Use MockCreatedContext for MockHandler (#59)

Author: twsouthwick

AutofacContrib.NSubstitute/MockHandlers/AutoPropertyInjectorMockHandler.cs

@@ -12,11 +12,11 @@ private AutoPropertyInjectorMockHandler()
         {
         }
 
-        protected internal override void OnMockCreated(object instance, Type type, IComponentContext context, ISubstitutionContext substitutionContext)
+        protected internal override void OnMockCreated(MockCreatedContext context)
         {
-            var router = substitutionContext.GetCallRouterFor(instance);
+            var router = context.SubstitutionContext.GetCallRouterFor(context.Instance);
 
-            router.RegisterCustomCallHandlerFactory(_ => new AutoPropertyInjectorCallHandler(context));
+            router.RegisterCustomCallHandlerFactory(_ => new AutoPropertyInjectorCallHandler(context.Context));
         }
 
         private class AutoPropertyInjectorCallHandler : ICallHandler

AutofacContrib.NSubstitute/MockHandlers/MockCreatedContext.cs

@@ -0,0 +1,40 @@
+using Autofac;
+using NSubstitute.Core;
+using System;
+
+namespace AutofacContrib.NSubstitute.MockHandlers
+{
+    /// <summary>
+    /// Context for a mock that has been created.
+    /// </summary>
+    public class MockCreatedContext
+    {
+        internal MockCreatedContext(object instance, Type type, IComponentContext context, ISubstitutionContext substitutionContext)
+        {
+            Instance = instance;
+            Type = type;
+            Context = context;
+            SubstitutionContext = substitutionContext;
+        }
+
+        /// <summary>
+        /// Gets the created mock instance.
+        /// </summary>
+        public object Instance { get; }
+
+        /// <summary>
+        /// Gets the type that the mock is being used for.
+        /// </summary>
+        public Type Type { get; }
+
+        /// <summary>
+        /// Gets the current resolve context.
+        /// </summary>
+        public IComponentContext Context { get; }
+
+        /// <summary>
+        /// Gets the NSubstitute substitution context.
+        /// </summary>
+        public ISubstitutionContext SubstitutionContext { get; }
+    }
+}

AutofacContrib.NSubstitute/MockHandler.cs renamed to AutofacContrib.NSubstitute/MockHandlers/MockHandler.cs

@@ -2,6 +2,7 @@
 using AutofacContrib.NSubstitute.MockHandlers;
 using NSubstitute.Core;
 using System;
+using System.ComponentModel;
 
 namespace AutofacContrib.NSubstitute
 {
@@ -21,10 +22,23 @@ protected MockHandler()
         /// <param name="type">The type the mock was created for.</param>
         /// <param name="context">The current component context.</param>
         /// <param name="substitutionContext">The current substitution context.</param>
-        protected internal virtual void OnMockCreated(object instance, Type type, IComponentContext context, ISubstitutionContext substitutionContext)
+        [Obsolete]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        protected virtual void OnMockCreated(object instance, Type type, IComponentContext context, ISubstitutionContext substitutionContext)
         {
         }
 
+        /// <summary>
+        /// Provides a way to manage mocks after creation but before returned from the container registry.
+        /// </summary>
+        /// <param name="context">Created context.</param>
+        protected internal virtual void OnMockCreated(MockCreatedContext context)
+        {
+#pragma warning disable CS0612 // Type or member is obsolete
+            OnMockCreated(context.Instance, context.Type, context.Context, context.SubstitutionContext);
+#pragma warning restore CS0612 // Type or member is obsolete
+        }
+
         /// <summary>
         /// Provides a way to manage the initial creation of mocks. Defaults to creating for all types.
         /// </summary>
@@ -33,4 +47,4 @@ protected internal virtual void OnMockCreating(MockCreatingContext context)
         {
         }
     }
-}
+}

AutofacContrib.NSubstitute/MockHandler{T}.cs renamed to AutofacContrib.NSubstitute/MockHandlers/MockHandler{T}.cs

@@ -1,4 +1,5 @@
 using Autofac;
+using AutofacContrib.NSubstitute.MockHandlers;
 using NSubstitute.Core;
 using System;
 
@@ -11,11 +12,11 @@ public abstract class MockHandler<T> : MockHandler
         where T : class
     {
         /// <inheritdoc />
-        protected internal sealed override void OnMockCreated(object instance, Type type, IComponentContext context, ISubstitutionContext substitutionContext)
+        protected internal sealed override void OnMockCreated(MockCreatedContext context)
         {
-            if (typeof(T) == type && instance is T t)
+            if (typeof(T) == context.Type && context.Instance is T t)
             {
-                OnMockCreated(t, context, substitutionContext);
+                OnMockCreated(t, context.Context, context.SubstitutionContext);
             }
         }
 

AutofacContrib.NSubstitute/NSubstituteRegistrationHandler.cs

@@ -79,9 +79,11 @@ public IEnumerable<IComponentRegistration> RegistrationsFor
                     var instance = Substitute.For(new[] { typedService.ServiceType }, null);
                     var ctx = c.Resolve<IComponentContext>();
 
+                    var mockCreatedContext = new MockCreatedContext(instance, typedService.ServiceType, ctx, SubstitutionContext.Current);
+
                     foreach (var handler in _options.MockHandlers)
                     {
-                        handler.OnMockCreated(instance, typedService.ServiceType, ctx, SubstitutionContext.Current);
+                        handler.OnMockCreated(mockCreatedContext);
                     }
 
                     return instance;

AutofacContrib.NSubstitute/SubstituteForBuilderExtensions.cs

@@ -26,7 +26,8 @@ public static SubstituteForBuilder<T> InjectProperties<T>(this SubstituteForBuil
             => builder.ConfigureSubstitute((t, ctx) =>
             {
                 ctx.InjectUnsetProperties(t);
-                AutoPropertyInjectorMockHandler.Instance.OnMockCreated(t, typeof(T), ctx, builder.Context);
+                var mockCtx = new MockCreatedContext(t, typeof(T), ctx, builder.Context);
+                AutoPropertyInjectorMockHandler.Instance.OnMockCreated(mockCtx);
             });
     }
 }