Merge pull request #57 from JCH2k/master

Fixed validation with parameter for registrations without factory

LightweightIocContainer/Validation/IocValidator.cs

@@ -47,12 +47,13 @@ namespace LightweightIocContainer.Validation
             
             foreach (IRegistration registration in _iocContainer.Registrations)
             {
+                var definedParameters = _parameters.Where(p => p.type == registration.InterfaceType);
+                
                 if (registration is IWithFactoryInternal { Factory: { } } withFactoryRegistration)
                 {
                     (from createMethod in withFactoryRegistration.Factory.CreateMethods
                         select createMethod.GetParameters().Select(p => p.ParameterType)
                         into parameterTypes 
-                        let definedParameters = _parameters.Where(p => p.type == registration.InterfaceType)
                         select (from parameterType in parameterTypes
                             let definedParameter = definedParameters
                                 .FirstOrDefault(p => parameterType.IsInstanceOfType(p.parameter))
@@ -61,7 +62,10 @@ namespace LightweightIocContainer.Validation
                         .ForEach(p => TryResolve(registration.InterfaceType, p, validationExceptions, true));
                 }
                 else
-                    TryResolve(registration.InterfaceType, null, validationExceptions);
+                {
+                    var arguments = definedParameters.Select(p => p.parameter).ToArray();
+                    TryResolve(registration.InterfaceType, arguments, validationExceptions);
+                }
             }
 
             if (validationExceptions.Any())

Test.LightweightIocContainer/IocValidatorTest.cs

@@ -45,12 +45,17 @@ namespace Test.LightweightIocContainer
             ITest Create();
         }
         
-        private class TestInstaller : IIocInstaller
+        private class TestInstallerNoFactory : IIocInstaller
+        {
+            public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>();
+        }
+        
+        private class TestInstallerWithFactory : IIocInstaller
         {
             public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<ITestFactory>();
         }
         
-        private class InvalidTestInstaller : IIocInstaller
+        private class TestInstallerWithInvalidFactory : IIocInstaller
         {
             public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<IInvalidFactory>();
         }
@@ -59,7 +64,20 @@ namespace Test.LightweightIocContainer
         public void TestValidate()
         {
             IocContainer iocContainer = new();
-            iocContainer.Install(new TestInstaller());
+            iocContainer.Install(new TestInstallerNoFactory());
+            
+            IocValidator validator = new(iocContainer);
+            
+            var aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+            
+            AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
+        }
+        
+        [Test]
+        public void TestValidateWithFactory()
+        {
+            IocContainer iocContainer = new();
+            iocContainer.Install(new TestInstallerWithFactory());
             
             IocValidator validator = new(iocContainer);
             
@@ -70,7 +88,7 @@ namespace Test.LightweightIocContainer
         public void TestValidateWithParameter()
         {
             IocContainer iocContainer = new();
-            iocContainer.Install(new TestInstaller());
+            iocContainer.Install(new TestInstallerNoFactory());
             
             IocValidator validator = new(iocContainer);
 
@@ -88,17 +106,22 @@ namespace Test.LightweightIocContainer
         public void TestValidateInvalidFactory()
         {
             IocContainer iocContainer = new();
-            iocContainer.Install(new InvalidTestInstaller());
+            iocContainer.Install(new TestInstallerWithInvalidFactory());
             
             IocValidator validator = new(iocContainer);
             
-            AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+            var aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
             
-            Exception exception =  aggregateException?.InnerExceptions[0];
+            AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
+        }
+
+        private static void AssertNoMatchingConstructorFoundForType<T>(AggregateException aggregateException)
+        {
+            Exception exception = aggregateException?.InnerExceptions[0];
             Assert.IsInstanceOf<NoMatchingConstructorFoundException>(exception);
-            
+
-            NoMatchingConstructorFoundException noMatchingConstructorFoundException = (NoMatchingConstructorFoundException) exception;
+            NoMatchingConstructorFoundException noMatchingConstructorFoundException = (NoMatchingConstructorFoundException)exception;
-            Assert.AreEqual(typeof(Test), noMatchingConstructorFoundException?.Type);
+            Assert.AreEqual(typeof(T), noMatchingConstructorFoundException?.Type);
         }
     }
 }