NUnit3: change the way test name is created so that it doesn't change…

… between discovery and execution

Src/AutoFixture.NUnit3.UnitTest/AutoFixture.NUnit3.UnitTest.csproj

@@ -62,8 +62,12 @@
     <Compile Include="NoAutoPropertiesAttributeTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Scenario.cs" />
+    <Compile Include="TestNameStrategiesFixture.cs" />
+    <Compile Include="TestNameStrategiesTest.cs" />
     <Compile Include="ThrowingStubFixture.cs" />
     <Compile Include="TypeWithCustomizationAttributes.cs" />
+    <Compile Include="FixedNameTestMethodBuilderTest.cs" />
+    <Compile Include="VolatileNameTestMethodBuilderTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\AutoFixture.NUnit3\AutoFixture.NUnit3.csproj">

Src/AutoFixture.NUnit3.UnitTest/FixedNameTestMethodBuilderTest.cs

@@ -0,0 +1,25 @@
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Ploeh.AutoFixture.NUnit3.UnitTest
+{
+    public class FixedNameTestMethodBuilderTest
+    {
+        [Test]
+        public void FixedNameTestMethodBuilderIsResilientToFactoryException()
+        {
+            // Fixture setup
+            var method = new MethodWrapper(typeof(TestNameStrategiesFixture), nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod));
+            var sut = new FixedNameTestMethodBuilder();
+            // Exercise system
+            var testMethod = sut.Build(method, null, () => throw new Exception(), 0);
+            // Verify outcome
+            Assert.That(testMethod.Name, Is.EqualTo(nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod)));
+            // Teardown
+        }
+    }
+}

Src/AutoFixture.NUnit3.UnitTest/Scenario.cs

@@ -378,7 +378,7 @@ public void InlineAutoDataCanBeUsedWithFrozen(int p1, int p2, [Frozen]string p3,
 
         [Theory, AutoData]
         public void NoAutoPropertiesAttributeLeavesPropertiesUnset(
-            [NoAutoProperties]PropertyHolder<object> ph1, 
+            [NoAutoProperties]PropertyHolder<object> ph1,
             [NoAutoProperties]PropertyHolder<string> ph2,
             [NoAutoProperties]PropertyHolder<int> ph3
             )

Src/AutoFixture.NUnit3.UnitTest/TestNameStrategiesFixture.cs

@@ -0,0 +1,79 @@
+using NUnit.Framework.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Ploeh.AutoFixture.NUnit3.UnitTest
+{
+    public class TestNameStrategiesFixture
+    {
+        #region Custom attribute definitions
+        public const int InjectedIntValue = 42;
+        public const string InjectedStringValue = "foo";
+
+        private static IFixture CreateFixtureWithInjectedValues()
+        {
+            var result = new Fixture();
+            // Make so that fixed values will be returned
+            result.Inject(InjectedIntValue);
+            result.Inject(InjectedStringValue);
+            return result;
+        }
+
+        public class AutoDataFixedNameAttribute : AutoDataAttribute
+        {
+            public AutoDataFixedNameAttribute()
+            {
+                TestMethodBuilder = new FixedNameTestMethodBuilder();
+            }
+        }
+
+        public class AutoDataVolatileNameAttributeAttribute : AutoDataAttribute
+        {
+            public AutoDataVolatileNameAttributeAttribute() : base(CreateFixtureWithInjectedValues())
+            {
+                TestMethodBuilder = new VolatileNameTestMethodBuilder();
+            }
+        }
+
+        public class InlineAutoDataFixedNameAttribute : InlineAutoDataAttribute
+        {
+            public InlineAutoDataFixedNameAttribute(params object[] arguments) : base(arguments)
+            {
+                TestMethodBuilder = new FixedNameTestMethodBuilder();
+            }
+        }
+
+        public class InlineAutoDataVolatileNameAttribute : InlineAutoDataAttribute
+        {
+            public InlineAutoDataVolatileNameAttribute(params object[] arguments) : base(CreateFixtureWithInjectedValues(), arguments)
+            {
+                TestMethodBuilder = new VolatileNameTestMethodBuilder();
+            }
+        }
+        #endregion
+
+        [AutoDataFixedName]
+        public void FixedNameDecoratedMethod(
+            int expectedNumber, MyClass sut)
+        {
+        }
+
+        [AutoDataVolatileNameAttribute]
+        public void VolatileNameDecoratedMethod(
+            int expectedNumber, string value)
+        {
+        }
+
+        [InlineAutoDataFixedName("alpha", "beta")]
+        public void InlineFixedNameDecoratedMethod(string p1, string p2, string p3)
+        {
+        }
+
+        [InlineAutoDataVolatileNameAttribute("alpha", "beta")]
+        public void InlineVolatileNameDecoratedMethod(string p1, string p2, string p3)
+        {
+        }
+    }
+}

Src/AutoFixture.NUnit3.UnitTest/TestNameStrategiesTest.cs

@@ -0,0 +1,141 @@
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using static Ploeh.AutoFixture.NUnit3.UnitTest.TestNameStrategiesFixture;
+
+namespace Ploeh.AutoFixture.NUnit3.UnitTest
+{
+    public class TestNameStrategiesTest
+    {
+        [Test]
+        public void AutoDataAttributeUsesRealValueByDefault()
+        {
+            // Fixture setup
+            // Exercise system
+            var sut = new AutoDataAttribute();
+            // Verify outcome
+            Assert.That(sut.TestMethodBuilder,
+                Is.TypeOf<VolatileNameTestMethodBuilder>());
+            // Teardown
+        }
+
+        [Test]
+        public void InlineAutoDataAttributeUsesRealValueByDefault()
+        {
+            // Fixture setup
+            // Exercise system
+            var sut = new InlineAutoDataAttribute();
+            // Verify outcome
+            Assert.That(sut.TestMethodBuilder,
+                Is.TypeOf<VolatileNameTestMethodBuilder>());
+            // Teardown
+        }
+
+        [Test]
+        public void AutoDataUsesFixedValuesForTestName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<AutoDataFixedNameAttribute>(nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.Name,
+                Is.EqualTo(@"FixedNameDecoratedMethod(auto<Int32>,auto<MyClass>)"));
+            // Teardown
+        }
+
+        [Test]
+        public void AutoDataFixedNameUsesFixedValuesForTestFullName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<AutoDataFixedNameAttribute>(nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.FullName,
+                Is.EqualTo(@"Ploeh.AutoFixture.NUnit3.UnitTest.TestNameStrategiesFixture.FixedNameDecoratedMethod(auto<Int32>,auto<MyClass>)"));
+            // Teardown
+        }
+
+        [Test]
+        public void AutoDataVolatileNameUsesRealValuesForTestName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<AutoDataVolatileNameAttributeAttribute>(nameof(TestNameStrategiesFixture.VolatileNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.Name,
+                Is.EqualTo(@"VolatileNameDecoratedMethod(42,""foo"")"));
+            // Teardown
+        }
+
+        [Test]
+        public void AutoDataVolatileNameUsesRealValuesForTestFullName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<AutoDataVolatileNameAttributeAttribute>(nameof(TestNameStrategiesFixture.VolatileNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.FullName,
+                Is.EqualTo(@"Ploeh.AutoFixture.NUnit3.UnitTest.TestNameStrategiesFixture.VolatileNameDecoratedMethod(42,""foo"")"));
+            // Teardown
+        }
+
+        [Test]
+        public void InlineAutoDataUsesFixedValuesForTestName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<InlineAutoDataFixedNameAttribute>(nameof(TestNameStrategiesFixture.InlineFixedNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.Name,
+                Is.EqualTo(@"InlineFixedNameDecoratedMethod(""alpha"",""beta"",auto<String>)"));
+            // Teardown
+        }
+
+        [Test]
+        public void InlineAutoDataFixedNameUsesFixedValuesForTestFullName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<InlineAutoDataFixedNameAttribute>(nameof(TestNameStrategiesFixture.InlineFixedNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.FullName,
+                Is.EqualTo(@"Ploeh.AutoFixture.NUnit3.UnitTest.TestNameStrategiesFixture.InlineFixedNameDecoratedMethod(""alpha"",""beta"",auto<String>)"));
+            // Teardown
+        }
+
+        [Test]
+        public void InlineAutoDataVolatileNameUsesRealValuesForTestName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<InlineAutoDataVolatileNameAttribute>(nameof(TestNameStrategiesFixture.InlineVolatileNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.Name,
+                Is.EqualTo(@"InlineVolatileNameDecoratedMethod(""alpha"",""beta"",""foo"")"));
+            // Teardown
+        }
+
+        [Test]
+        public void InlineAutoDataVolatileNameUsesRealValuesForFullName()
+        {
+            // Fixture setup
+            // Exercise system
+            var testMethod = GetTestMethod<InlineAutoDataVolatileNameAttribute>(nameof(TestNameStrategiesFixture.InlineVolatileNameDecoratedMethod));
+            // Verify outcome
+            Assert.That(testMethod.FullName,
+                Is.EqualTo(@"Ploeh.AutoFixture.NUnit3.UnitTest.TestNameStrategiesFixture.InlineVolatileNameDecoratedMethod(""alpha"",""beta"",""foo"")"));
+            // Teardown
+        }
+
+        private static TestMethod GetTestMethod<TAttribute>(string testName) where TAttribute : Attribute, NUnit.Framework.Interfaces.ITestBuilder
+        {
+            var method = new MethodWrapper(typeof(TestNameStrategiesFixture), testName);
+            var inlineAttribute = (TAttribute)Attribute.GetCustomAttribute(method.MethodInfo, typeof(TAttribute));
+            var testMethod = inlineAttribute.BuildFrom(method, null).Single();
+            return testMethod;
+        }
+    }
+}

Src/AutoFixture.NUnit3.UnitTest/VolatileNameTestMethodBuilderTest.cs

@@ -0,0 +1,25 @@
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Ploeh.AutoFixture.NUnit3.UnitTest
+{
+    public class VolatileNameTestMethodBuilderTest
+    {
+        [Test]
+        public void VolatileNameTestMethodBuilderIsResilientToFactoryException()
+        {
+            // Fixture setup
+            var method = new MethodWrapper(typeof(TestNameStrategiesFixture), nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod));
+            var sut = new VolatileNameTestMethodBuilder();
+            // Exercise system
+            var testMethod = sut.Build(method, null, () => throw new Exception(), 0);
+            // Verify outcome
+            Assert.That(testMethod.Name, Is.EqualTo(nameof(TestNameStrategiesFixture.FixedNameDecoratedMethod)));
+            // Teardown
+        }
+    }
+}

Src/AutoFixture.NUnit3/AutoDataAttribute.cs

@@ -5,6 +5,7 @@
 using NUnit.Framework.Internal;
 using NUnit.Framework.Internal.Builders;
 using Ploeh.AutoFixture.Kernel;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Ploeh.AutoFixture.NUnit3
 {
@@ -13,11 +14,21 @@ namespace Ploeh.AutoFixture.NUnit3
     /// This implementation is based on TestCaseAttribute of NUnit3
     /// </summary>
     [AttributeUsage(AttributeTargets.Method)]
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is the root of a potential attribute hierarchy.")]
+    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is the root of a potential attribute hierarchy.")]
     public class AutoDataAttribute : Attribute, ITestBuilder
     {
         private readonly IFixture _fixture;
 
+        private ITestMethodBuilder _testMethodBuilder = new VolatileNameTestMethodBuilder();
+        /// <summary>
+        /// Gets or sets the current <see cref="ITestMethodBuilder"/> strategy.
+        /// </summary>
+        public ITestMethodBuilder TestMethodBuilder
+        {
+            get => _testMethodBuilder;
+            set => _testMethodBuilder = value ?? throw new ArgumentNullException(nameof(value));
+        }
+
         /// <summary>
         /// Construct a <see cref="AutoDataAttribute"/>
         /// </summary>
@@ -49,28 +60,11 @@ protected AutoDataAttribute(IFixture fixture)
         /// <returns>One or more TestMethods</returns>
         public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
         {
-            var test = new NUnitTestCaseBuilder().BuildTestMethod(method, suite, this.GetParametersForMethod(method));
+            var test = TestMethodBuilder.Build(method, suite, () => GetParameterValues(method.GetParameters()).ToArray(), 0);
 
             yield return test;
         }
 
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method is always expected to return an instance of the TestCaseParameters class.")]
-        private TestCaseParameters GetParametersForMethod(IMethodInfo method)
-        {
-            try
-            {
-                var parameters = method.GetParameters();
-
-                var parameterValues = this.GetParameterValues(parameters);
-
-                return new TestCaseParameters(parameterValues.ToArray());
-            }
-            catch (Exception ex)
-            {
-                return new TestCaseParameters(ex);
-            }
-        }
-
         private IEnumerable<object> GetParameterValues(IEnumerable<IParameterInfo> parameters)
         {
             return parameters.Select(Resolve);

Src/AutoFixture.NUnit3/AutoFixture.NUnit3.csproj

@@ -71,6 +71,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="FixedNameTestMethodBuilder.cs" />
     <Compile Include="InlineAutoDataAttribute.cs" />
     <Compile Include="AutoDataAttribute.cs" />
     <Compile Include="CustomizeAttribute.cs" />
@@ -84,6 +85,8 @@
     <Compile Include="ModestAttribute.cs" />
     <Compile Include="NoAutoPropertiesAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="VolatileNameTestMethodBuilder.cs" />
+    <Compile Include="ITestMethodBuilder.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\AutoFixture\AutoFixture.csproj">