From 57d0b22b665c0fff6f6ecf320e2229de1ff2cb6b Mon Sep 17 00:00:00 2001
From: dee-see <dc@doum.ca>
Date: Sun, 28 Dec 2014 10:47:46 -0500
Subject: [PATCH 1/4] Added support for abstract classes that don't have a
 parameterless constructor

---
 src/UnityAutoMoq.Tests/AbstractService.cs              | 7 +++++++
 src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj       | 5 +++++
 src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs | 9 +++++++++
 src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs        | 8 +++++---
 4 files changed, 26 insertions(+), 3 deletions(-)
 create mode 100644 src/UnityAutoMoq.Tests/AbstractService.cs

diff --git a/src/UnityAutoMoq.Tests/AbstractService.cs b/src/UnityAutoMoq.Tests/AbstractService.cs
new file mode 100644
index 0000000..1c991f9
--- /dev/null
+++ b/src/UnityAutoMoq.Tests/AbstractService.cs
@@ -0,0 +1,7 @@
+namespace UnityAutoMoq.Tests
+{
+    public abstract class AbstractService
+    {
+        public AbstractService(IService service) { }
+    }
+}
diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
index 52e3a2b..09f8148 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
@@ -86,12 +86,14 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\packages\NUnit.2.5.10.11092\lib\pnunit.framework.dll</HintPath>
     </Reference>
+    <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
     <Reference Include="System.Web" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AbstractService.cs" />
     <Compile Include="AnotherService.cs" />
     <Compile Include="CoreTdd.cs" />
     <Compile Include="IAnotherService.cs" />
@@ -133,6 +135,9 @@
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
index 8041ce9..d187cc3 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
@@ -146,5 +146,14 @@ public void Can_get_registered_implementation()
 
             real.ShouldBeOfType<AnotherService>();
         }
+
+        [Test]
+        public void Can_mock_abstract_classes_without_parameterless_constructor()
+        {
+            var real = container.Resolve<AbstractService>();
+            var mock = container.GetMock<AbstractService>();
+
+            real.ShouldBeSameAs(mock.Object);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
index 09b4140..bd9e4a2 100644
--- a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
+++ b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
@@ -24,7 +24,7 @@ public override void PreBuildUp(IBuilderContext context)
 
             if (autoMoqContainer.Registrations.Any(r => r.RegisteredType == type))
                 return;
-            
+
             if (type.IsInterface || type.IsAbstract)
             {
                 context.Existing = GetOrCreateMock(type);
@@ -39,10 +39,12 @@ private object GetOrCreateMock(Type t)
 
             Type genericType = typeof(Mock<>).MakeGenericType(new[] { t });
 
-            object mock = Activator.CreateInstance(genericType);
+            var constructor = t.GetConstructors().OrderByDescending(c => c.GetParameters().Length).FirstOrDefault(); // Constructor with most arguments to follow Unity convention
+            object[] arguments = constructor == null ? new object[0] : constructor.GetParameters().Select(x => autoMoqContainer.Resolve(x.ParameterType, null)).ToArray();
+            object mock = Activator.CreateInstance(genericType, arguments);
 
             AsExpression interfaceImplementations = autoMoqContainer.GetInterfaceImplementations(t);
-            if(interfaceImplementations != null)
+            if (interfaceImplementations != null)
                 interfaceImplementations.GetImplementations().Each(type => genericType.GetMethod("As").MakeGenericMethod(type).Invoke(mock, null));
 
             genericType.InvokeMember("DefaultValue", BindingFlags.SetProperty, null, mock, new object[] { autoMoqContainer.DefaultValue });

From 2ac2264801acf8d1e18b540c46d95a92a1e48eb5 Mon Sep 17 00:00:00 2001
From: dee-see <dc@doum.ca>
Date: Sun, 28 Dec 2014 11:21:45 -0500
Subject: [PATCH 2/4] Test for constructor injection

---
 src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj |  1 +
 .../UnityAutoMoqContainerFixture.cs              | 16 ++++++++++++----
 src/UnityAutoMoq.Tests/YetAnotherService.cs      | 12 ++++++++++++
 3 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 src/UnityAutoMoq.Tests/YetAnotherService.cs

diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
index 09f8148..c1e4458 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
@@ -103,6 +103,7 @@
     <Compile Include="Service.cs" />
     <Compile Include="ServiceWithAbstractDependency.cs" />
     <Compile Include="UnityAutoMoqContainerFixture.cs" />
+    <Compile Include="YetAnotherService.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\UnityAutoMoq\UnityAutoMoq.csproj">
diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
index d187cc3..adb7a76 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
@@ -148,12 +148,20 @@ public void Can_get_registered_implementation()
         }
 
         [Test]
-        public void Can_mock_abstract_classes_without_parameterless_constructor()
+        public void Can_get_abstract_class_without_parameterless_constructor_without_registering_it_first()
         {
-            var real = container.Resolve<AbstractService>();
-            var mock = container.GetMock<AbstractService>();
+            var mocked = container.Resolve<AbstractService>();
 
-            real.ShouldBeSameAs(mock.Object);
+            mocked.ShouldNotBeNull();
+        }
+
+        [Test]
+        public void Can_resolve_concrete_type_with_abstract_dependency_that_does_not_have_a_parameterless_constructor()
+        {
+            var mocked = container.Resolve<YetAnotherService>();
+
+            mocked.ShouldNotBeNull();
+            mocked.AbstractService.ShouldNotBeNull();
         }
     }
 }
\ No newline at end of file
diff --git a/src/UnityAutoMoq.Tests/YetAnotherService.cs b/src/UnityAutoMoq.Tests/YetAnotherService.cs
new file mode 100644
index 0000000..0a7dd76
--- /dev/null
+++ b/src/UnityAutoMoq.Tests/YetAnotherService.cs
@@ -0,0 +1,12 @@
+namespace UnityAutoMoq.Tests
+{
+    class YetAnotherService : IAnotherService
+    {
+        public AbstractService AbstractService { get; private set; }
+
+        public YetAnotherService(AbstractService service)
+        {
+            AbstractService = service;
+        }
+    }
+}

From 1d70dc843858d1c73f440d4e500b619545a3fe54 Mon Sep 17 00:00:00 2001
From: dee-see <dc@doum.ca>
Date: Sun, 28 Dec 2014 18:47:33 -0500
Subject: [PATCH 3/4] Make behavior similar to Unity's

Throws an exception if constructor is ambiguous
---
 ...AbstractServiceWithAmbiguousConstructor.cs |  8 ++++++
 .../UnityAutoMoq.Tests.csproj                 |  1 +
 .../UnityAutoMoqContainerFixture.cs           | 10 ++++++-
 .../UnityAutoMoqBuilderStrategy.cs            | 27 ++++++++++++++++---
 4 files changed, 42 insertions(+), 4 deletions(-)
 create mode 100644 src/UnityAutoMoq.Tests/AbstractServiceWithAmbiguousConstructor.cs

diff --git a/src/UnityAutoMoq.Tests/AbstractServiceWithAmbiguousConstructor.cs b/src/UnityAutoMoq.Tests/AbstractServiceWithAmbiguousConstructor.cs
new file mode 100644
index 0000000..7f6d00b
--- /dev/null
+++ b/src/UnityAutoMoq.Tests/AbstractServiceWithAmbiguousConstructor.cs
@@ -0,0 +1,8 @@
+namespace UnityAutoMoq.Tests
+{
+    public abstract class AbstractServiceWithAmbiguousConstructor
+    {
+        public AbstractServiceWithAmbiguousConstructor(IService service) { }
+        public AbstractServiceWithAmbiguousConstructor(IAnotherService service) { }
+    }
+}
diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
index c1e4458..05b3c67 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoq.Tests.csproj
@@ -94,6 +94,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AbstractService.cs" />
+    <Compile Include="AbstractServiceWithAmbiguousConstructor.cs" />
     <Compile Include="AnotherService.cs" />
     <Compile Include="CoreTdd.cs" />
     <Compile Include="IAnotherService.cs" />
diff --git a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
index adb7a76..805f393 100644
--- a/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
+++ b/src/UnityAutoMoq.Tests/UnityAutoMoqContainerFixture.cs
@@ -72,7 +72,7 @@ public void Should_apply_specified_default_value_when_specified()
         [Test]
         public void Should_apply_specified_default_value_when_specified_2()
         {
-            container = new UnityAutoMoqContainer{DefaultValue = DefaultValue.Empty};
+            container = new UnityAutoMoqContainer { DefaultValue = DefaultValue.Empty };
             var mocked = container.GetMock<IService>();
 
             mocked.DefaultValue.ShouldEqual(DefaultValue.Empty);
@@ -163,5 +163,13 @@ public void Can_resolve_concrete_type_with_abstract_dependency_that_does_not_hav
             mocked.ShouldNotBeNull();
             mocked.AbstractService.ShouldNotBeNull();
         }
+
+        [Test]
+        public void Abstract_class_with_ambiguous_constructor_throws_exception()
+        {
+            typeof(ResolutionFailedException).ShouldBeThrownBy(
+                () => container.Resolve<AbstractServiceWithAmbiguousConstructor>(), 
+                e => e.InnerException is InvalidOperationException);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
index bd9e4a2..551fd53 100644
--- a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
+++ b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
@@ -39,9 +39,7 @@ private object GetOrCreateMock(Type t)
 
             Type genericType = typeof(Mock<>).MakeGenericType(new[] { t });
 
-            var constructor = t.GetConstructors().OrderByDescending(c => c.GetParameters().Length).FirstOrDefault(); // Constructor with most arguments to follow Unity convention
-            object[] arguments = constructor == null ? new object[0] : constructor.GetParameters().Select(x => autoMoqContainer.Resolve(x.ParameterType, null)).ToArray();
-            object mock = Activator.CreateInstance(genericType, arguments);
+            object mock = Activator.CreateInstance(genericType, GetConstructorArguments(t));
 
             AsExpression interfaceImplementations = autoMoqContainer.GetInterfaceImplementations(t);
             if (interfaceImplementations != null)
@@ -54,5 +52,28 @@ private object GetOrCreateMock(Type t)
 
             return mockedInstance;
         }
+
+        /// <summary>
+        /// Get the arguments for the constructor with the most parameters following Unity convention.
+        /// </summary>
+        /// <exception cref="System.InvalidOperationException">
+        /// There are more than one constructors with the same (max) amount of parameters. Unity throws the same exception where resolving a concrete type.
+        /// </exception>
+        private object[] GetConstructorArguments(Type t)
+        {
+            var constructors = (from c in t.GetConstructors()
+                                let numberOfParameters = c.GetParameters().Length
+                                group c by numberOfParameters into x
+                                orderby x.Key descending
+                                select x).ToList();
+
+            if (constructors.Count == 0)
+                return new object[0];
+            if (constructors[0].Count() > 1)
+                throw new InvalidOperationException(string.Format("The type {0} has multiple constructor of length {1}. Unable to disambiguate.", t.Name, constructors[0].Key));
+
+            // Constructor with most arguments to follow Unity convention
+            return constructors[0].First().GetParameters().Select(x => autoMoqContainer.Resolve(x.ParameterType, null)).ToArray();
+        }
     }
 }
\ No newline at end of file

From a5366d394c1a392a0817de32e55d74899dc29287 Mon Sep 17 00:00:00 2001
From: dee-see <dc@doum.ca>
Date: Mon, 29 Dec 2014 21:17:39 -0500
Subject: [PATCH 4/4] minor clean up

---
 src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
index 551fd53..fdd5730 100644
--- a/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
+++ b/src/UnityAutoMoq/UnityAutoMoqBuilderStrategy.cs
@@ -65,15 +65,15 @@ private object[] GetConstructorArguments(Type t)
                                 let numberOfParameters = c.GetParameters().Length
                                 group c by numberOfParameters into x
                                 orderby x.Key descending
-                                select x).ToList();
+                                select x).FirstOrDefault();
 
-            if (constructors.Count == 0)
+            if (constructors == null)
                 return new object[0];
-            if (constructors[0].Count() > 1)
-                throw new InvalidOperationException(string.Format("The type {0} has multiple constructor of length {1}. Unable to disambiguate.", t.Name, constructors[0].Key));
+            if (constructors.Count() > 1)
+                throw new InvalidOperationException(string.Format("The type {0} has multiple constructor of length {1}. Unable to disambiguate.", t.Name, constructors.Key));
 
             // Constructor with most arguments to follow Unity convention
-            return constructors[0].First().GetParameters().Select(x => autoMoqContainer.Resolve(x.ParameterType, null)).ToArray();
+            return constructors.First().GetParameters().Select(x => autoMoqContainer.Resolve(x.ParameterType, null)).ToArray();
         }
     }
 }
\ No newline at end of file