Add support for Substitute.ForPartsOf to AutoSubstituteBuilder (#43)

Fixes #19

Author: twsouthwick

AutofacContrib.NSubstitute.Tests/ExampleFixture.cs

@@ -166,43 +166,6 @@ public void Example_test_with_concrete_object_provided()
             Assert.That(result, Is.EqualTo(val1 + val2));
         }
 
-        [Test]
-        public void Example_test_with_substitute_for_concrete()
-        {
-            const int val1 = 3;
-            const int val2 = 2;
-            const int val3 = 10;
-
-            using var utoSubstitute = AutoSubstitute.Configure()
-                .SubstituteFor<ConcreteClass>(val2).Configure(c => c.Add(Arg.Any<int>()).Returns(val3))
-                .Build();
-
-            utoSubstitute.Resolve<IDependency2>().SomeOtherMethod().Returns(val1);
-
-            var result = utoSubstitute.Resolve<MyClassWithConcreteDependency>().AMethod();
-
-            Assert.That(result, Is.EqualTo(val3));
-        }
-
-        [Test]
-        public void SubstituteForConfigureWithContext()
-        {
-            const int val = 2;
-
-            using var utoSubstitute = AutoSubstitute.Configure()
-                .SubstituteFor<ConcreteClass>(val).Configured()
-                .SubstituteFor<ConcreteClassWithObject>().Configure((s, ctx) =>
-                {
-                    s.Configure().GetResult().Returns(ctx.Resolve<ConcreteClass>());
-                })
-                .Build()
-                .Container;
-
-            var result = utoSubstitute.Resolve<ConcreteClassWithObject>().GetResult();
-
-            Assert.AreSame(result, utoSubstitute.Resolve<ConcreteClass>());
-        }
-
         [Test]
         public void Example_test_with_substitute_for_concrete_resolved_from_autofac()
         {

AutofacContrib.NSubstitute.Tests/NSubstituteExtensions.cs

@@ -0,0 +1,33 @@
+using NSubstitute.Core;
+using NSubstitute.Exceptions;
+using NUnit.Framework.Constraints;
+
+namespace AutofacContrib.NSubstitute.Tests
+{
+    internal class NSubstituteConstraint : Constraint
+    {
+        public NSubstituteConstraint()
+        {
+            Description = "Object expected to be NSubstitute mock";
+        }
+
+        public override ConstraintResult ApplyTo<TActual>(TActual actual)
+        {
+            try
+            {
+                var router = SubstitutionContext.Current.GetCallRouterFor(actual);
+
+                return new ConstraintResult(this, actual, router != null);
+            }
+            catch (NotASubstituteException)
+            {
+                return new ConstraintResult(this, actual, false);
+            }
+        }
+    }
+
+    internal class Is : NUnit.Framework.Is
+    {
+        public static NSubstituteConstraint NSubstituteMock { get; } = new NSubstituteConstraint();
+    }
+}

AutofacContrib.NSubstitute.Tests/NSubstituteTestExtensions.cs

@@ -0,0 +1,100 @@
+using Autofac;
+using NSubstitute;
+using NSubstitute.Extensions;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace AutofacContrib.NSubstitute.Tests
+{
+    [TestFixture]
+    public class SubstituteForFixture
+    {
+        [Test]
+        public void Example_test_with_substitute_for_concrete()
+        {
+            const int val1 = 3;
+            const int val2 = 2;
+            const int val3 = 10;
+
+            using var utoSubstitute = AutoSubstitute.Configure()
+                .SubstituteFor<ConcreteClass>(val2).Configure(c => c.Add(Arg.Any<int>()).Returns(val3))
+                .Build();
+
+            utoSubstitute.Resolve<IDependency2>().SomeOtherMethod().Returns(val1);
+
+            var result = utoSubstitute.Resolve<MyClassWithConcreteDependency>().AMethod();
+
+            Assert.That(result, Is.EqualTo(val3));
+        }
+
+        [Test]
+        public void SubstituteForConfigureWithContext()
+        {
+            const int val = 2;
+
+            using var utoSubstitute = AutoSubstitute.Configure()
+                .SubstituteFor<ConcreteClass>(val).Configured()
+                .SubstituteFor<ConcreteClassWithObject>().Configure((s, ctx) =>
+                {
+                    s.Configure().GetResult().Returns(ctx.Resolve<ConcreteClass>());
+                })
+                .Build()
+                .Container;
+
+            var result = utoSubstitute.Resolve<ConcreteClassWithObject>().GetResult();
+
+            Assert.AreSame(result, utoSubstitute.Resolve<ConcreteClass>());
+        }
+
+        [Test]
+        public void BaseCalledOnSubstituteForPartsOf()
+        {
+            using var mock = AutoSubstitute.Configure()
+                .SubstituteForPartsOf<Test1>().Configured()
+                .Build();
+
+            var test1 = mock.Resolve<Test1>();
+
+            Assert.That(test1, Is.NSubstituteMock);
+            Assert.Throws<InvalidOperationException>(() => test1.Throws());
+        }
+
+        [Test]
+        public void BaseNotCalledOnSubstituteFor()
+        {
+            using var mock = AutoSubstitute.Configure()
+                .SubstituteFor<Test1>().Configured()
+                .Build();
+
+            var test1 = mock.Resolve<Test1>();
+
+            Assert.That(test1, Is.NSubstituteMock);
+            Assert.Null(test1.Throws());
+        }
+
+        [Test]
+        public void FailsIfSubstituteTypeIsChanged()
+        {
+            var builder = AutoSubstitute.Configure()
+                .SubstituteFor<Test1>().Configured();
+
+            Assert.Throws<InvalidOperationException>(() => builder.SubstituteForPartsOf<Test1>());
+        }
+
+        [Test]
+        public void FailsIfSubstituteTypeIsChanged2()
+        {
+            var builder = AutoSubstitute.Configure()
+                .SubstituteForPartsOf<Test1>().Configured();
+
+            Assert.Throws<InvalidOperationException>(() => builder.SubstituteFor<Test1>());
+        }
+
+        public abstract class Test1
+        {
+            public virtual object Throws() => throw new InvalidOperationException();
+        }
+    }
+}

AutofacContrib.NSubstitute.Tests/SubstituteForFixture.cs

@@ -126,30 +126,26 @@ public AutoSubstituteBuilder Provide<TService>(TService instance, object service
         }
 
         /// <summary>
-        /// Registers to the container and returns a substitute for a given concrete class given the explicit constructor parameters.
+        /// Registers a substitute to the container a given concrete class given the explicit constructor parameters using <see cref="Substitute.For{TService}(object[])"/>.
         /// This is used for concrete classes where NSubstitutes won't be created by default by the container when using Resolve.
-        /// For advanced uses consider using directly <see cref="Substitute.For{TService}"/> and then calling <see cref="Provide{TService}(TService)"/> so that type is used on dependencies for other Resolved types.
         /// </summary>
         /// <typeparam name="TService">The type to register and return a substitute for</typeparam>
         /// <param name="parameters">Optional constructor parameters</param>
         /// <returns>An instance to help configure the substitution.</returns>
         public SubstituteForBuilder<TService> SubstituteFor<TService>(params object[] parameters)
             where TService : class
-        {
-            if (_substituteForRegistrations.TryGetValue(typeof(TService), out var result))
-            {
-                return (SubstituteForBuilder<TService>)result;
-            }
-
-            var registration = _builder.Register(_ => Substitute.For<TService>(parameters))
-                .As<TService>()
-                .InstancePerLifetimeScope();
-            var builder = new SubstituteForBuilder<TService>(this, registration);
-
-            _substituteForRegistrations.Add(typeof(TService), builder);
+            => CreateSubstituteForBuilder<TService>(() => Substitute.For<TService>(parameters), true);
 
-            return builder;
-        }
+        /// <summary>
+        /// Registers a substitute to the container a given concrete class given the explicit constructor parameters using <see cref="Substitute.ForPartsOf{TService}(object[])"/>.
+        /// This is used for concrete classes where NSubstitutes won't be created by default by the container when using Resolve.
+        /// </summary>
+        /// <typeparam name="TService">The type to register and return a substitute for</typeparam>
+        /// <param name="parameters">Optional constructor parameters</param>
+        /// <returns>An instance to help configure the substitution.</returns>
+        public SubstituteForBuilder<TService> SubstituteForPartsOf<TService>(params object[] parameters)
+            where TService : class
+            => CreateSubstituteForBuilder(() => Substitute.ForPartsOf<TService>(parameters), false);
 
         /// <summary>
         /// Registers to the container and returns a substitute for a given concrete class using autofac to resolve the constructor parameters.
@@ -168,6 +164,31 @@ public AutoSubstituteBuilder ResolveAndSubstituteFor<TService>(params Parameter[
             return this;
         }
 
+        private SubstituteForBuilder<TService> CreateSubstituteForBuilder<TService>(Func<TService> factory, bool isSubstituteFor)
+            where TService : class
+        {
+            if (_substituteForRegistrations.TryGetValue(typeof(TService), out var result))
+            {
+                var previousBuilder = (SubstituteForBuilder<TService>)result;
+
+                if (previousBuilder.IsSubstituteFor != isSubstituteFor)
+                {
+                    throw new InvalidOperationException("Cannot change a service registration between SubstituteFor and SubstituteForPartsOf");
+                }
+
+                return previousBuilder;
+            }
+
+            var registration = _builder.Register(_ => factory())
+                .As<TService>()
+                .InstancePerLifetimeScope();
+            var builder = new SubstituteForBuilder<TService>(this, registration, isSubstituteFor);
+
+            _substituteForRegistrations.Add(typeof(TService), builder);
+
+            return builder;
+        }
+
         internal IProvidedValue<TService> CreateProvidedValue<TService>(Func<IContainer, TService> factory)
         {
             var value = new ProvidedValue<TService>(factory);

AutofacContrib.NSubstitute/AutoSubstituteBuilder.cs

@@ -14,12 +14,21 @@ public class SubstituteForBuilder<TService>
         private readonly AutoSubstituteBuilder _builder;
         private readonly IRegistrationBuilder<TService, SimpleActivatorData, SingleRegistrationStyle> _registration;
 
-        internal SubstituteForBuilder(AutoSubstituteBuilder builder, IRegistrationBuilder<TService, SimpleActivatorData, SingleRegistrationStyle> registration)
+        internal SubstituteForBuilder(
+            AutoSubstituteBuilder builder,
+            IRegistrationBuilder<TService, SimpleActivatorData, SingleRegistrationStyle> registration,
+            bool isSubstituteFor)
         {
             _builder = builder;
             _registration = registration;
+            IsSubstituteFor = isSubstituteFor;
         }
 
+        /// <summary>
+        /// Used to identify if a builder was created by <see cref="AutoSubstituteBuilder.SubstituteFor{TService}(object[])"/> or <see cref="AutoSubstituteBuilder.SubstituteForPartsOf{TService}(object[])"/>.
+        /// </summary>
+        internal bool IsSubstituteFor { get; }
+
         /// <summary>
         /// Allows for configuration of the service.
         /// </summary>

AutofacContrib.NSubstitute/SubstituteForBuilder.cs

@@ -187,7 +187,28 @@ public void SubstituteForConfigureWithContext()
 }
 ```
 
-Similarly, you can resolve a concrete type from the autosubstitute container and register that with the underlying container using the `ResolveAndSubstituteFor` method:
+If you would rather register it using NSubstitute's `SubstituteForPartsOf` method, you may use the following:
+
+```c#
+public abstract class Test1
+{
+	public virtual object Throws() => throw new InvalidOperationException();
+}
+
+[Test]
+public void BaseCalledOnSubstituteForPartsOf()
+{
+    using var mock = AutoSubstitute.Configure()
+        .SubstituteForPartsOf<Test1>().Configured()
+        .Build();
+
+    var test1 = mock.Resolve<Test1>();
+
+    Assert.Throws<InvalidOperationException>(() => test1.Throws());
+}
+```
+
+Similarly, you can resolve a concrete type from the AutoSubstitute container and register that with the underlying container using the `ResolveAndSubstituteFor` method:
 
 ```c#
 public class ConcreteClassWithDependency