Merge pull request #41 from twsouthwick/substitute-provide

Add overload to SubstituteForBuilder<> that allows configuration of substitute with access to Autofac container

Author: robdmoore

AutofacContrib.NSubstitute.Tests/ExampleFixture.cs

@@ -1,5 +1,6 @@
 using Autofac;
 using NSubstitute;
+using NSubstitute.Extensions;
 using NUnit.Framework;
 
 namespace AutofacContrib.NSubstitute.Tests
@@ -41,6 +42,14 @@ public int AMethod()
         }
     }
 
+    public class ConcreteClassWithObject
+    {
+        public virtual object GetResult()
+        {
+            return new object();
+        }
+    }
+
     public class ConcreteClass
     {
         private readonly int _i;
@@ -175,6 +184,25 @@ public void Example_test_with_substitute_for_concrete()
             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,13 @@
+using NSubstitute.Extensions;
+
+namespace AutofacContrib.NSubstitute.Tests
+{
+    internal static class NSubstituteExtensions
+    {
+        public static void AssertIsNSubstituteMock(this object obj)
+        {
+            // This throws an exception if it is not an NSubstitute mock
+            obj.Configure();
+        }
+    }
+}

AutofacContrib.NSubstitute/AutoSubstituteBuilder.cs

@@ -9,6 +9,7 @@ namespace AutofacContrib.NSubstitute
 {
     public class AutoSubstituteBuilder
     {
+        private readonly Dictionary<Type, object> _substituteForRegistrations = new Dictionary<Type, object>();
         private readonly List<IProvidedValue> _providedValues;
         private readonly ContainerBuilder _builder;
 
@@ -53,6 +54,7 @@ public AutoSubstituteBuilder ConfigureBuilder(Action<ContainerBuilder> action)
         /// </summary>
         /// <typeparam name="TService">The type to register the implementation as</typeparam>
         /// <typeparam name="TImplementation">The implementation type</typeparam>
+        /// <param name="providedValue">Parameter to obtain a provided value.</param>
         /// <param name="parameters">Optional constructor parameters</param>
         /// <returns>The current <see cref="AutoSubstituteBuilder"/>.</returns>
         public AutoSubstituteBuilder Provide<TService, TImplementation>(out IProvidedValue<TService> providedValue, params Parameter[] parameters)
@@ -112,11 +114,19 @@ public AutoSubstituteBuilder Provide<TService>(TService instance, object service
         public SubstituteForBuilder<TService> SubstituteFor<TService>(params object[] parameters)
             where TService : class
         {
-            var substitute = Substitute.For<TService>(parameters);
+            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);
 
-            Provide(substitute);
+            _substituteForRegistrations.Add(typeof(TService), builder);
 
-            return new SubstituteForBuilder<TService>(this, substitute);
+            return builder;
         }
 
         /// <summary>
@@ -136,7 +146,7 @@ public AutoSubstituteBuilder ResolveAndSubstituteFor<TService>(params Parameter[
             return this;
         }
 
-        private IProvidedValue<TService> CreateProvidedValue<TService>(Func<IContainer, TService> factory)
+        internal IProvidedValue<TService> CreateProvidedValue<TService>(Func<IContainer, TService> factory)
         {
             var value = new ProvidedValue<TService>(factory);
 

AutofacContrib.NSubstitute/SubstituteForBuilder.cs

@@ -1,4 +1,6 @@
-using System;
+using Autofac;
+using Autofac.Builder;
+using System;
 
 namespace AutofacContrib.NSubstitute
 {
@@ -10,12 +12,12 @@ public class SubstituteForBuilder<TService>
         where TService : class
     {
         private readonly AutoSubstituteBuilder _builder;
-        private readonly TService _service;
+        private readonly IRegistrationBuilder<TService, SimpleActivatorData, SingleRegistrationStyle> _registration;
 
-        internal SubstituteForBuilder(AutoSubstituteBuilder builder, TService service)
+        internal SubstituteForBuilder(AutoSubstituteBuilder builder, IRegistrationBuilder<TService, SimpleActivatorData, SingleRegistrationStyle> registration)
         {
             _builder = builder;
-            _service = service;
+            _registration = registration;
         }
 
         /// <summary>
@@ -24,10 +26,27 @@ internal SubstituteForBuilder(AutoSubstituteBuilder builder, TService service)
         /// <param name="action">The delegate to configure the service.</param>
         /// <returns>The original <see cref="AutoSubstituteBuilder"/>.</returns>
         public AutoSubstituteBuilder Configure(Action<TService> action)
+            => Configure((s, _) => action(s));
+
+        /// <summary>
+        /// Allows for configuration of the service with access to the resolved components.
+        /// </summary>
+        /// <param name="action">The delegate to configure the service.</param>
+        /// <returns>The original <see cref="AutoSubstituteBuilder"/>.</returns>
+        public AutoSubstituteBuilder Configure(Action<TService, IComponentContext> action)
         {
-            action(_service);
+            _registration.OnActivated(args =>
+            {
+                action(args.Instance, args.Context);
+            });
+
             return _builder;
         }
-    }
 
+        /// <summary>
+        /// Completes the configuration of the substitute.
+        /// </summary>
+        /// <returns>The original <see cref="AutoSubstituteBuilder"/>.</returns>
+        public AutoSubstituteBuilder Configured() => _builder;
+    }
 }

README.md

@@ -164,6 +164,29 @@ public void Example_test_with_substitute_for_concrete()
 }
 ```
 
+If you want to configure it with a service from the container, you can use a separate overload:
+
+```c#
+[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>());
+}
+```
+
 Similarly, you can resolve a concrete type from the autosubstitute container and register that with the underlying container using the `ResolveAndSubstituteFor` method:
 
 ```c#