#24: add UnitTestResolveCallback and needed registration

LightweightIocContainer/Interfaces/IIocContainer.cs

@@ -79,6 +79,13 @@ namespace LightweightIocContainer.Interfaces
         /// <param name="tFactory">The abstract typed factory to register</param>
         void RegisterFactory(Type tFactory);
 
+        /// <summary>
+        /// Register an Interface with an <see cref="ResolveCallback{T}"/> as a callback that is called when <see cref="Resolve{T}()"/> is called
+        /// </summary>
+        /// <typeparam name="TInterface">The Interface to register</typeparam>
+        /// <param name="unitTestCallback">The <see cref="ResolveCallback{T}"/> for the callback</param>
+        void RegisterUnitTestCallback<TInterface>(ResolveCallback<TInterface> unitTestCallback);
+
         /// <summary>
         /// Gets an instance of the given <see cref="Type"/>
         /// </summary>

LightweightIocContainer/Interfaces/Registrations/IUnitTestCallbackRegistration.cs

@@ -0,0 +1,18 @@
+// Author: Gockner, Simon
+// Created: 2019-10-15
+// Copyright(c) 2019 SimonG. All Rights Reserved.
+
+namespace LightweightIocContainer.Interfaces.Registrations
+{
+    /// <summary>
+    /// A special <see cref="IDefaultRegistration{TInterface}"/> that allows to set an <see cref="ResolveCallback{T}"/> as a callback that is called on <see cref="IIocContainer.Resolve{T}()"/>
+    /// </summary>
+    /// <typeparam name="TInterface"></typeparam>
+    public interface IUnitTestCallbackRegistration<out TInterface> : IRegistrationBase
+    {
+        /// <summary>
+        /// An <see cref="ResolveCallback{T}"/> that is set as a callback that is called on <see cref="IIocContainer.Resolve{T}()"/>
+        /// </summary>
+        ResolveCallback<TInterface> UnitTestResolveCallback { get; }
+    }
+}

LightweightIocContainer/IocContainer.cs

@@ -29,7 +29,7 @@ namespace LightweightIocContainer
 
 
         /// <summary>
-        /// The constructor of the <see cref="IocContainer"/>
+        /// The main container that carries all the <see cref="IRegistrationBase"/>s and can resolve all the types you'll ever want
         /// </summary>
         public IocContainer()
         {
@@ -134,6 +134,16 @@ namespace LightweightIocContainer
             Register(_registrationFactory.RegisterFactory(tFactory));
         }
 
+        /// <summary>
+        /// Register an Interface with an <see cref="ResolveCallback{T}"/> as a callback that is called when <see cref="Resolve{T}()"/> is called
+        /// </summary>
+        /// <typeparam name="TInterface">The Interface to register</typeparam>
+        /// <param name="unitTestCallback">The <see cref="ResolveCallback{T}"/> for the callback</param>
+        public void RegisterUnitTestCallback<TInterface>(ResolveCallback<TInterface> unitTestCallback)
+        {
+            Register(_registrationFactory.RegisterUnitTestCallback(unitTestCallback));
+        }
+
         /// <summary>
         /// Add the <see cref="IRegistrationBase"/> to the the <see cref="IocContainer"/>
         /// </summary>
@@ -201,7 +211,11 @@ namespace LightweightIocContainer
             if (registration == null)
                 throw new TypeNotRegisteredException(typeof(T));
 
-            if (registration is IDefaultRegistration<T> defaultRegistration)
+            if (registration is IUnitTestCallbackRegistration<T> unitTestCallbackRegistration)
+            {
+                return unitTestCallbackRegistration.UnitTestResolveCallback.Invoke(arguments);
+            }
+            else if (registration is IDefaultRegistration<T> defaultRegistration)
             {
                 if (defaultRegistration.Lifestyle == Lifestyle.Singleton)
                     return GetOrCreateSingletonInstance(defaultRegistration, arguments);

LightweightIocContainer/LightweightIocContainer.xml

@@ -275,6 +275,13 @@
             </summary>
             <param name="tFactory">The abstract typed factory to register</param>
         </member>
+        <member name="M:LightweightIocContainer.Interfaces.IIocContainer.RegisterUnitTestCallback``1(LightweightIocContainer.ResolveCallback{``0})">
+            <summary>
+            Register an Interface with an <see cref="T:LightweightIocContainer.ResolveCallback`1"/> as a callback that is called when <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/> is called
+            </summary>
+            <typeparam name="TInterface">The Interface to register</typeparam>
+            <param name="unitTestCallback">The <see cref="T:LightweightIocContainer.ResolveCallback`1"/> for the callback</param>
+        </member>
         <member name="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1">
             <summary>
             Gets an instance of the given <see cref="T:System.Type"/>
@@ -399,6 +406,17 @@
             The class that contains the implemented abstract factory of this <see cref="T:LightweightIocContainer.Interfaces.Registrations.ITypedFactoryRegistration`1"/>
             </summary>
         </member>
+        <member name="T:LightweightIocContainer.Interfaces.Registrations.IUnitTestCallbackRegistration`1">
+            <summary>
+            A special <see cref="T:LightweightIocContainer.Interfaces.Registrations.IDefaultRegistration`1"/> that allows to set an <see cref="T:LightweightIocContainer.ResolveCallback`1"/> as a callback that is called on <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/>
+            </summary>
+            <typeparam name="TInterface"></typeparam>
+        </member>
+        <member name="P:LightweightIocContainer.Interfaces.Registrations.IUnitTestCallbackRegistration`1.UnitTestResolveCallback">
+            <summary>
+            An <see cref="T:LightweightIocContainer.ResolveCallback`1"/> that is set as a callback that is called on <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/>
+            </summary>
+        </member>
         <member name="T:LightweightIocContainer.IocContainer">
             <summary>
             The main container that carries all the <see cref="T:LightweightIocContainer.Interfaces.Registrations.IRegistrationBase"/>s and can resolve all the types you'll ever want
@@ -406,7 +424,7 @@
         </member>
         <member name="M:LightweightIocContainer.IocContainer.#ctor">
             <summary>
-            The constructor of the <see cref="T:LightweightIocContainer.IocContainer"/>
+            The main container that carries all the <see cref="T:LightweightIocContainer.Interfaces.Registrations.IRegistrationBase"/>s and can resolve all the types you'll ever want
             </summary>
         </member>
         <member name="M:LightweightIocContainer.IocContainer.Install(LightweightIocContainer.Interfaces.Installers.IIocInstaller[])">
@@ -474,6 +492,13 @@
             </summary>
             <param name="tFactory">The abstract typed factory to register</param>
         </member>
+        <member name="M:LightweightIocContainer.IocContainer.RegisterUnitTestCallback``1(LightweightIocContainer.ResolveCallback{``0})">
+            <summary>
+            Register an Interface with an <see cref="T:LightweightIocContainer.ResolveCallback`1"/> as a callback that is called when <see cref="M:LightweightIocContainer.IocContainer.Resolve``1"/> is called
+            </summary>
+            <typeparam name="TInterface">The Interface to register</typeparam>
+            <param name="unitTestCallback">The <see cref="T:LightweightIocContainer.ResolveCallback`1"/> for the callback</param>
+        </member>
         <member name="M:LightweightIocContainer.IocContainer.Register(LightweightIocContainer.Interfaces.Registrations.IRegistrationBase)">
             <summary>
             Add the <see cref="T:LightweightIocContainer.Interfaces.Registrations.IRegistrationBase"/> to the the <see cref="T:LightweightIocContainer.IocContainer"/>
@@ -767,6 +792,39 @@
             <exception cref="T:LightweightIocContainer.Exceptions.InvalidFactoryRegistrationException">Factory registration is invalid</exception>
             <exception cref="T:LightweightIocContainer.Exceptions.IllegalAbstractMethodCreationException">Creation of abstract methods are illegal in their current state</exception>
         </member>
+        <member name="T:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1">
+            <summary>
+            A special <see cref="T:LightweightIocContainer.Interfaces.Registrations.IDefaultRegistration`1"/> that allows to set an <see cref="T:LightweightIocContainer.ResolveCallback`1"/> as a callback that is called on <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/>
+            </summary>
+            <typeparam name="TInterface"></typeparam>
+        </member>
+        <member name="M:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1.#ctor(System.Type,LightweightIocContainer.ResolveCallback{`0})">
+            <summary>
+            A special <see cref="T:LightweightIocContainer.Interfaces.Registrations.IDefaultRegistration`1"/> that allows to set an <see cref="T:LightweightIocContainer.ResolveCallback`1"/> as a callback that is called on <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/>
+            </summary>
+            <param name="interfaceType">The <see cref="T:System.Type"/> of the interface</param>
+            <param name="unitTestResolveCallback">The <see cref="T:LightweightIocContainer.ResolveCallback`1"/> that is set as a callback</param>
+        </member>
+        <member name="P:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1.Name">
+            <summary>
+            The name of the <see cref="T:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1"/>
+            </summary>
+        </member>
+        <member name="P:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1.InterfaceType">
+            <summary>
+            The <see cref="T:System.Type"/> of the Interface that is registered with this <see cref="T:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1"/>
+            </summary>
+        </member>
+        <member name="P:LightweightIocContainer.Registrations.UnitTestCallbackRegistration`1.UnitTestResolveCallback">
+            <summary>
+            An <see cref="T:LightweightIocContainer.ResolveCallback`1"/> that is set as a callback that is called on <see cref="M:LightweightIocContainer.Interfaces.IIocContainer.Resolve``1"/>
+            </summary>
+        </member>
+        <member name="T:LightweightIocContainer.ResolveCallback`1">
+            <summary>
+            The resolve callback delegate
+            </summary>
+        </member>
         <member name="M:LightweightIocContainer.TypeExtension.GetDefault(System.Type)">
             <summary>
             Returns the default value for a given <see cref="T:System.Type"/>

LightweightIocContainer/Registrations/RegistrationFactory.cs

@@ -42,7 +42,7 @@ namespace LightweightIocContainer.Registrations
         /// <returns>A new created <see cref="IDefaultRegistration{TInterface}"/> with the given parameters</returns>
         public IDefaultRegistration<TImplementation> Register<TImplementation>(Lifestyle lifestyle)
         {
-            if (typeof(TImplementation).IsInterface) //TODO: handle `Instance` case when an instance is given
+            if (typeof(TImplementation).IsInterface)
                 throw new InvalidRegistrationException("Can't register an interface without its implementation type.");
 
             return Register<TImplementation, TImplementation>(lifestyle);
@@ -81,7 +81,7 @@ namespace LightweightIocContainer.Registrations
         /// <returns>A new created <see cref="IDefaultRegistration{TInterface}"/> with the given parameters</returns>
         public IRegistrationBase Register(Type tImplementation, Lifestyle lifestyle)
         {
-            if (tImplementation.IsInterface) //TODO: handle `Instance` case when an instance is given
+            if (tImplementation.IsInterface)
                 throw new InvalidRegistrationException("Can't register an interface without its implementation type.");
 
             return Register(tImplementation, tImplementation, lifestyle);
@@ -120,5 +120,10 @@ namespace LightweightIocContainer.Registrations
             Type factoryRegistrationType = typeof(TypedFactoryRegistration<>).MakeGenericType(tFactory);
             return (IRegistrationBase)Activator.CreateInstance(factoryRegistrationType, tFactory, _iocContainer);
         }
+
+        public IUnitTestCallbackRegistration<TInterface> RegisterUnitTestCallback<TInterface>(ResolveCallback<TInterface> unitTestResolveCallback)
+        {
+            return new UnitTestCallbackRegistration<TInterface>(typeof(TInterface), unitTestResolveCallback);
+        }
     }
 }

LightweightIocContainer/Registrations/UnitTestCallbackRegistration.cs

@@ -0,0 +1,45 @@
+// Author: Gockner, Simon
+// Created: 2019-10-15
+// Copyright(c) 2019 SimonG. All Rights Reserved.
+
+using System;
+using LightweightIocContainer.Interfaces;
+using LightweightIocContainer.Interfaces.Registrations;
+
+namespace LightweightIocContainer.Registrations
+{
+    /// <summary>
+    /// A special <see cref="IDefaultRegistration{TInterface}"/> that allows to set an <see cref="ResolveCallback{T}"/> as a callback that is called on <see cref="IIocContainer.Resolve{T}()"/>
+    /// </summary>
+    /// <typeparam name="TInterface"></typeparam>
+    public class UnitTestCallbackRegistration<TInterface> : IUnitTestCallbackRegistration<TInterface>
+    {
+        /// <summary>
+        /// A special <see cref="IDefaultRegistration{TInterface}"/> that allows to set an <see cref="ResolveCallback{T}"/> as a callback that is called on <see cref="IIocContainer.Resolve{T}()"/>
+        /// </summary>
+        /// <param name="interfaceType">The <see cref="Type"/> of the interface</param>
+        /// <param name="unitTestResolveCallback">The <see cref="ResolveCallback{T}"/> that is set as a callback</param>
+        public UnitTestCallbackRegistration(Type interfaceType, ResolveCallback<TInterface> unitTestResolveCallback)
+        {
+            InterfaceType = interfaceType;
+            UnitTestResolveCallback = unitTestResolveCallback;
+
+            Name = InterfaceType.Name;
+        }
+
+        /// <summary>
+        /// The name of the <see cref="UnitTestCallbackRegistration{TInterface}"/>
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// The <see cref="Type"/> of the Interface that is registered with this <see cref="UnitTestCallbackRegistration{TInterface}"/>
+        /// </summary>
+        public Type InterfaceType { get; }
+
+        /// <summary>
+        /// An <see cref="ResolveCallback{T}"/> that is set as a callback that is called on <see cref="IIocContainer.Resolve{T}()"/>
+        /// </summary>
+        public ResolveCallback<TInterface> UnitTestResolveCallback { get; }
+    }
+}

LightweightIocContainer/ResolveCallback.cs

@@ -0,0 +1,11 @@
+// Author: Gockner, Simon
+// Created: 2019-10-15
+// Copyright(c) 2019 SimonG. All Rights Reserved.
+
+namespace LightweightIocContainer
+{
+    /// <summary>
+    /// The resolve callback delegate
+    /// </summary>
+    public delegate TInterface ResolveCallback<out TInterface>(params object[] parameters);
+}

Test.LightweightIocContainer/IocContainerTest.cs

@@ -163,6 +163,12 @@ namespace Test.LightweightIocContainer
             Assert.Throws<IllegalAbstractMethodCreationException>(() => _iocContainer.RegisterFactory<ITestFactoryNonGenericClear>());
         }
 
+        [Test]
+        public void TestRegisterUnitTestCallback()
+        {
+            Assert.DoesNotThrow(() => _iocContainer.RegisterUnitTestCallback<ITest>(delegate {return new Test(); }));
+        }
+
         [Test]
         public void TestResolveNotRegistered()
         {
@@ -389,6 +395,17 @@ namespace Test.LightweightIocContainer
             Assert.AreNotSame(resolvedTest3, resolvedTest5);
         }
 
+        [Test]
+        public void TestResolveUnitTestCallbackRegistration()
+        {
+            ITest callbackTest = new Test();
+
+            _iocContainer.RegisterUnitTestCallback(delegate { return callbackTest; });
+            ITest test = _iocContainer.Resolve<ITest>();
+
+            Assert.AreEqual(callbackTest, test);
+        }
+
         [Test]
         public void TestIsTypeRegistered()
         {

Test.LightweightIocContainer/UnitTestCallbackRegistrationTest.cs

@@ -0,0 +1,70 @@
+// Author: Gockner, Simon
+// Created: 2019-10-15
+// Copyright(c) 2019 SimonG. All Rights Reserved.
+
+using LightweightIocContainer;
+using LightweightIocContainer.Interfaces;
+using LightweightIocContainer.Interfaces.Registrations;
+using LightweightIocContainer.Registrations;
+using Moq;
+using NUnit.Framework;
+
+namespace Test.LightweightIocContainer
+{
+    [TestFixture]
+    public class UnitTestCallbackRegistrationTest
+    {
+        private interface ITest
+        {
+            int Count { get; }
+            string Name { get; }
+            bool Testing { get; }
+        }
+
+        private class Test : ITest
+        {
+            public Test()
+            {
+                Count = -1;
+                Name = "Test";
+                Testing = false;
+            }
+
+            public Test(int count, string name, bool testing)
+            {
+                Count = count;
+                Name = name;
+                Testing = testing;
+            }
+
+            public int Count { get; }
+            public string Name { get; }
+            public bool Testing { get; }
+        }
+
+        [Test]
+        public void TestUnitTestResolveCallback()
+        {
+            RegistrationFactory registrationFactory = new RegistrationFactory(new Mock<IIocContainer>().Object);
+
+            ITest test = new Test();
+            IUnitTestCallbackRegistration<ITest> testCallbackRegistration = registrationFactory.RegisterUnitTestCallback(delegate { return test; });
+
+            Assert.AreEqual(test, testCallbackRegistration.UnitTestResolveCallback.Invoke());
+        }
+
+        [Test]
+        public void TestUnitTestResolveCallbackWithParams()
+        {
+            RegistrationFactory registrationFactory = new RegistrationFactory(new Mock<IIocContainer>().Object);
+            IUnitTestCallbackRegistration<ITest> testCallbackRegistration =
+                registrationFactory.RegisterUnitTestCallback(new ResolveCallback<ITest>(parameters => new Test((int) parameters[0], (string) parameters[1], (bool) parameters[2])));
+
+            ITest test = testCallbackRegistration.UnitTestResolveCallback.Invoke(4, "SomeTest", true);
+
+            Assert.AreEqual(4, test.Count);
+            Assert.AreEqual("SomeTest", test.Name);
+            Assert.True(test.Testing);
+        }
+    }
+}