#58: fix double wrapped constructorNotMatchingExceptions

LightweightIocContainer/IocContainer.cs

@@ -140,6 +140,7 @@ namespace LightweightIocContainer
         /// <typeparam name="T">The registered <see cref="Type"/></typeparam>
         /// <returns>An instance of the given registered <see cref="Type"/>, an <see cref="InternalToBeResolvedPlaceholder"/> if parameters need to be resolved or an <see cref="InternalFactoryMethodPlaceholder{T}"/> if a factory method is used to create an instance</returns>
         /// <exception cref="TypeNotRegisteredException">The given <see cref="Type"/> is not registered</exception>
+        /// <exception cref="DirectResolveWithRegisteredFactoryNotAllowed">A direct resolve with a registered factory is not allowed</exception>
         /// <exception cref="InvalidRegistrationException">An interface was registered without an implementation or factory method</exception>
         /// <exception cref="MultitonResolveException">Tried resolving a multiton without scope argument</exception>
         /// <exception cref="NoMatchingConstructorFoundException">No matching constructor for the given <see cref="Type"/> found</exception>
@@ -201,6 +202,7 @@ namespace LightweightIocContainer
         /// <param name="isFactoryResolve"></param>
         /// <returns>An instance of the given registered <see cref="Type"/>, an <see cref="InternalToBeResolvedPlaceholder"/> if parameters need to be resolved or an <see cref="InternalFactoryMethodPlaceholder{T}"/> if a factory method is used to create an instance</returns>
         /// <exception cref="TypeNotRegisteredException">The given <see cref="Type"/> is not registered</exception>
+        /// <exception cref="DirectResolveWithRegisteredFactoryNotAllowed">A direct resolve with a registered factory is not allowed</exception>
         /// <exception cref="InvalidRegistrationException">An interface was registered without an implementation or factory method</exception>
         /// <exception cref="MultitonResolveException">Tried resolving a multiton without scope argument</exception>
         /// <exception cref="NoMatchingConstructorFoundException">No matching constructor for the given <see cref="Type"/> found</exception>
@@ -464,8 +466,7 @@ namespace LightweightIocContainer
                     return (true, parameters, null);
                 
                 noMatchingConstructorFoundException ??= new NoMatchingConstructorFoundException(type);
-                exceptions?.ForEach(e => 
+                exceptions?.ForEach(e => noMatchingConstructorFoundException.AddInnerException(e));
-                    noMatchingConstructorFoundException.AddInnerException(new ConstructorNotMatchingException(constructor, e)));
             }
 
             return (false, null, noMatchingConstructorFoundException);

Test.LightweightIocContainer/FluentFactoryRegistrationTest.cs

@@ -113,9 +113,18 @@ namespace Test.LightweightIocContainer
 
             ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
             ITest test = factory.Create();
+            ITest test2 = factory.CreateTest();
             
             Assert.IsInstanceOf<ITestFactory>(factory);
             Assert.IsInstanceOf<ITest>(test);
+            Assert.IsInstanceOf<ITest>(test2);
+        }
+        
+        [Test]
+        public void TestFluentFactoryRegistrationResolveWithoutFactoryFails()
+        {
+            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
+            Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
         }
         
         [Test]
@@ -130,6 +139,14 @@ namespace Test.LightweightIocContainer
             Assert.IsInstanceOf<ITest>(test);
         }
         
+        [Test]
+        public void TestFluentFactoryRegistration_WithoutFactoryFails()
+        {
+            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory, TestFactory>());
+            Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
+        }
+
+        
         [Test]
         public void TestRegisterFactoryWithoutCreate() => Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryNoCreate>()));
         

Test.LightweightIocContainer/IocContainerRecursionTest.cs

@@ -115,12 +115,10 @@ namespace Test.LightweightIocContainer
 
             NoMatchingConstructorFoundException noMatchingConstructorFoundException = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<IFoo>());
             ConstructorNotMatchingException fooConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingConstructorFoundException?.InnerExceptions[0];
-            ConstructorNotMatchingException barConstructorNotMatchingException = (ConstructorNotMatchingException) fooConstructorNotMatchingException?.InnerExceptions[0];
+            NoMatchingConstructorFoundException noMatchingBarConstructorFoundException = (NoMatchingConstructorFoundException) fooConstructorNotMatchingException?.InnerExceptions[0]; 
-            NoMatchingConstructorFoundException noMatchingBarConstructorFoundException = (NoMatchingConstructorFoundException) barConstructorNotMatchingException?.InnerExceptions[0]; 
+            ConstructorNotMatchingException barConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingBarConstructorFoundException?.InnerExceptions[0];
-            ConstructorNotMatchingException secondFooConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingBarConstructorFoundException?.InnerExceptions[0];
-            ConstructorNotMatchingException secondBarConstructorNotMatchingException = (ConstructorNotMatchingException) secondFooConstructorNotMatchingException?.InnerExceptions[0];
             
-            CircularDependencyException exception = (CircularDependencyException) secondBarConstructorNotMatchingException?.InnerExceptions[0];
+            CircularDependencyException exception = (CircularDependencyException) barConstructorNotMatchingException?.InnerExceptions[0];
             
             Assert.AreEqual(typeof(IFoo), exception?.ResolvingType);
             Assert.AreEqual(2, exception.ResolveStack.Count);

Test.LightweightIocContainer/IocValidatorTest.cs

@@ -22,6 +22,11 @@ namespace Test.LightweightIocContainer
             
         }
         
+        public interface ITest2
+        {
+            
+        }
+        
         [UsedImplicitly]
         public interface IParameter
         {
@@ -33,12 +38,30 @@ namespace Test.LightweightIocContainer
             public Test(IParameter parameter) => parameter.Method();
         }
         
+        
+        
         [UsedImplicitly]
         public interface ITestFactory
         {
             ITest Create(IParameter parameter);
         }
         
+        [UsedImplicitly]
+        public interface ITest2Factory
+        {
+            ITest2 InvalidCreate();
+            ITest2 Create(ITest test);
+        }
+
+
+        private class Test2 : ITest2
+        {
+            public Test2(ITest parameter)
+            {
+                
+            }
+        }
+        
         [UsedImplicitly]
         public interface IInvalidFactory
         {
@@ -60,6 +83,15 @@ namespace Test.LightweightIocContainer
             public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<IInvalidFactory>();
         }
         
+        private class InvalidTestClassInstaller : IIocInstaller
+        {
+            public void Install(IRegistrationCollector registration)
+            {
+                registration.Add<ITest, Test>().WithFactory<ITestFactory>();
+                registration.Add<ITest2, Test2>().WithFactory<ITest2Factory>();
+            }
+        }
+        
         [Test]
         public void TestValidateWithoutFactory()
         {
@@ -102,6 +134,35 @@ namespace Test.LightweightIocContainer
             parameterMock.Verify(p => p.Method(), Times.Never);
         }
         
+           
+        [Test]
+        public void TestValidateWithInvalidParameterWithFactory()
+        {
+            IocContainer iocContainer = new();
+            iocContainer.Install(new InvalidTestClassInstaller());
+            
+            IocValidator validator = new(iocContainer);
+
+            Mock<IParameter> parameterMock = new();
+            validator.AddParameter<ITest, IParameter>(parameterMock.Object);
+            
+            AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+
+            if (aggregateException?.InnerExceptions[0] is not NoMatchingConstructorFoundException noMatchingConstructorFoundException)
+            {
+                Assert.Fail();
+                return;
+            }
+            
+            if (noMatchingConstructorFoundException.InnerExceptions[0] is not ConstructorNotMatchingException iTest2CtorNotMatchingException)
+            {
+                Assert.Fail();
+                return;
+            }
+            
+            Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+        }
+        
         [Test]
         public void TestValidateInvalidFactory()
         {