Merge 49de734 into 962e1bb

Author: twsouthwick

AutofacContrib.NSubstitute.Tests/ExampleFixture.cs

@@ -138,7 +138,7 @@ public void Example_test_with_concrete_type_provided()
             const int val = 3;
 
             using var mock = AutoSubstitute.Configure()
-                .Provide<IDependency2, Dependency2>(out _)
+                .Provide<IDependency2, Dependency2>()
                 .Build();
 
             mock.Resolve<IDependency2>().SomeOtherMethod().Returns(val); // This shouldn't do anything because of the next line
@@ -210,8 +210,10 @@ public void Example_test_with_substitute_for_concrete_resolved_from_autofac()
             const int val2 = 3;
             const int val3 = 4;
 
+#pragma warning disable CS0618 // Type or member is obsolete
             using var mock = AutoSubstitute.Configure()
                 .ResolveAndSubstituteFor<ConcreteClassWithDependency>(new TypedParameter(typeof(int), val1))
+#pragma warning restore CS0618 // Type or member is obsolete
                 .Build();
 
             mock.Resolve<IDependency2>().SomeOtherMethod().Returns(val2);
@@ -221,5 +223,38 @@ public void Example_test_with_substitute_for_concrete_resolved_from_autofac()
 
             Assert.That(result, Is.EqualTo(val2 * val3 * 2));
         }
+
+        [Test]
+        public void Example_provide_service()
+        {
+            const int val1 = 2;
+            const int val2 = 3;
+            const int val3 = 4;
+
+            using var mock = AutoSubstitute.Configure()
+                .Provide<ConcreteClassWithDependency>(new TypedParameter(typeof(int), val1))
+                .Build();
+
+            mock.Resolve<IDependency2>().SomeOtherMethod().Returns(val2);
+            mock.Resolve<IDependency1>().SomeMethod(val1).Returns(val3);
+
+            var result = mock.Resolve<MyClassWithConcreteDependencyThatHasDependencies>().AMethod();
+
+            Assert.That(result, Is.EqualTo(val2 * val3 * 2));
+        }
+
+        [Test]
+        public void Example_provide_service_with_out_param()
+        {
+            const int val1 = 2;
+
+            using var mock = AutoSubstitute.Configure()
+                .Provide<ConcreteClassWithDependency>(out var c, new TypedParameter(typeof(int), val1))
+                .Build();
+
+            var result = mock.Resolve<ConcreteClassWithDependency>();
+
+            Assert.AreSame(result, c.Value);
+        }
     }
 }

AutofacContrib.NSubstitute/AutoMock.cs

@@ -0,0 +1,14 @@
+using System;
+using System.ComponentModel;
+
+namespace AutofacContrib.NSubstitute
+{
+    /// <summary>
+    /// Deprecated auto mocking container. Use <see cref="AutoSubstitute"/> instead.
+    /// </summary>
+    [Obsolete("AutoMock has been deprecated in favour of AutoSubstitute.")]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public class AutoMock : AutoSubstitute
+    {
+    }
+}

AutofacContrib.NSubstitute/AutoSubstitute.cs

@@ -4,12 +4,6 @@
 
 namespace AutofacContrib.NSubstitute
 {
-    /// <summary>
-    /// Deprecated auto mocking container. Use <see cref="AutoSubstitute"/> instead.
-    /// </summary>
-    [Obsolete("AutoMock has been deprecated in favour of AutoSubstitute.")]
-    public class AutoMock : AutoSubstitute { }
-
     /// <summary>
     /// Auto mocking container using <see cref="Autofac"/> and <see cref="NSubstitute"/>.
     /// </summary>

AutofacContrib.NSubstitute/AutoSubstituteBuilder.cs

@@ -50,7 +50,38 @@ public AutoSubstituteBuilder ConfigureBuilder(Action<ContainerBuilder> action)
         }
 
         /// <summary>
-        /// Register the specified implementation type to the container as the specified service type and resolve it using the given parameters.
+        /// Register the specified implementation type to the container as itself with the given parameterst.
+        /// </summary>
+        /// <typeparam name="TService">The type to register the implementation as</typeparam>
+        /// <typeparam name="TImplementation">The implementation type</typeparam>
+        /// <param name="parameters">Optional constructor parameters</param>
+        /// <returns>The current <see cref="AutoSubstituteBuilder"/>.</returns>
+        public AutoSubstituteBuilder Provide<TService>(params Parameter[] parameters)
+            => Provide<TService, TService>(out _, parameters);
+
+        /// <summary>
+        /// Register the specified implementation type to the container as itself with the given parameterst.
+        /// </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>(out IProvidedValue<TService> providedValue, params Parameter[] parameters)
+            => Provide<TService, TService>(out providedValue, parameters);
+
+        /// <summary>
+        /// Register the specified implementation type to the container as the specified service type with the given parameterst.
+        /// </summary>
+        /// <typeparam name="TService">The type to register the implementation as</typeparam>
+        /// <typeparam name="TImplementation">The implementation type</typeparam>
+        /// <param name="parameters">Optional constructor parameters</param>
+        /// <returns>The current <see cref="AutoSubstituteBuilder"/>.</returns>
+        public AutoSubstituteBuilder Provide<TService, TImplementation>(params Parameter[] parameters)
+            => Provide<TService, TImplementation>(out _, parameters);
+
+        /// <summary>
+        /// Register the specified implementation type to the container as the specified service type with the given parameterst.
         /// </summary>
         /// <typeparam name="TService">The type to register the implementation as</typeparam>
         /// <typeparam name="TImplementation">The implementation type</typeparam>
@@ -137,6 +168,8 @@ public SubstituteForBuilder<TService> SubstituteFor<TService>(params object[] pa
         /// <typeparam name="TService">The type to register and return a substitute for</typeparam>
         /// <param name="parameters">Any constructor parameters that Autofac can't resolve automatically</param>
         /// <returns>The current <see cref="AutoSubstituteBuilder"/>.</returns>
+        [Obsolete("Use a Provide method instead")]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
         public AutoSubstituteBuilder ResolveAndSubstituteFor<TService>(params Parameter[] parameters) where TService : class
         {
             _builder.RegisterType<TService>()

README.md

@@ -118,7 +118,7 @@ public void Example_test_with_concrete_type_provided()
 {
     const int val = 3;
     using var autoSubstitute = AutoSubstitute.Configure()
-        .Provide<IDependency2, Dependency2>(out _)
+        .Provide<IDependency2, Dependency2>()
         .Build();
     autoSubstitute.Resolve<IDependency2>().SomeOtherMethod().Returns(val); // This shouldn't do anything because of the next line
     autoSubstitute.Resolve<IDependency1>().SomeMethod(Arg.Any<int>()).Returns(c => c.Arg<int>());
@@ -128,6 +128,15 @@ public void Example_test_with_concrete_type_provided()
     Assert.That(result, Is.EqualTo(Dependency2.Value));
 }
 
+[Test]
+public void Example_test_with_concrete_object_provide()
+{
+    using var mock = AutoSubstitute.Configure()
+        .Provide<ConcreteClassWithDependency>(new TypedParameter(typeof(int), 5))
+        .Build();
+}
+```
+
 [Test]
 public void Example_test_with_concrete_object_provide()
 {
@@ -187,63 +196,6 @@ 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:
-
-```c#
-public class ConcreteClassWithDependency
-{
-    private readonly IDependency1 _dependency;
-    private readonly int _i;
-
-    public ConcreteClassWithDependency(IDependency1 dependency, int i)
-    {
-        _dependency = dependency;
-        _i = i;
-    }
-
-    public int Double()
-    {
-        return _dependency.SomeMethod(_i)*2;
-    }
-}
-
-public class MyClassWithConcreteDependencyThatHasDependencies
-{
-    private readonly ConcreteClassWithDependency _c;
-    private readonly IDependency2 _d2;
-
-    public MyClassWithConcreteDependencyThatHasDependencies(ConcreteClassWithDependency c, IDependency2 d2)
-    {
-        _c = c;
-        _d2 = d2;
-    }
-
-    public int AMethod()
-    {
-        return _d2.SomeOtherMethod() * _c.Double();
-    }
-}
-
-...
-
-[Test]
-public void Example_test_with_substitute_for_concrete_resolved_from_autofac()
-{
-    const int val1 = 2;
-    const int val2 = 3;
-    const int val3 = 4;
-    using var AutoSubstitute = AutoSubstitute.Configure()
-        .ResolveAndSubstituteFor<ConcreteClassWithDependency>(new TypedParameter(typeof(int), val1))
-        .Build();
-    AutoSubstitute.Resolve<IDependency2>().SomeOtherMethod().Returns(val2);
-    AutoSubstitute.Resolve<IDependency1>().SomeMethod(val1).Returns(val3);
-
-    var result = AutoSubstitute.Resolve<MyClassWithConcreteDependencyThatHasDependencies>().AMethod();
-
-    Assert.That(result, Is.EqualTo(val2*val3*2));
-}
-```
-
 If you need to access the underlying Autofac container for some reason then you use the `Container` property on the `AutoSubstitute` object.
 
 If you want to make modifications to the container builder before the container is build from it there is a second constructor parameter you can use, for example: