Dynamic data display name

src/TestFramework/MSTest.Core/Attributes/DynamicDataAttribute.cs

@@ -56,7 +56,7 @@ public DynamicDataAttribute(string dynamicDataSourceName, DynamicDataSourceType
         /// Initializes a new instance of the <see cref="DynamicDataAttribute"/> class.
         /// </summary>
         /// <param name="dynamicDataSourceName">
-        /// The type in which the test data is declared (as property or in method).
+        /// The name of method or property having test data.
         /// </param>
         /// <param name="dynamicDataDeclaringType">
         /// The declaring type of property or method having data.
@@ -70,6 +70,16 @@ public DynamicDataAttribute(string dynamicDataSourceName, Type dynamicDataDeclar
             this.dynamicDataDeclaringType = dynamicDataDeclaringType;
         }
 
+        /// <summary>
+        /// Gets or sets the name of method used to customize the display name in test results.
+        /// </summary>
+        public string DynamicDisplayName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the declaring type used to customize the display name in test results.
+        /// </summary>
+        public Type DynamicDisplayNameDeclaringType { get; set; }
+
         /// <inheritdoc />
         public IEnumerable<object[]> GetData(MethodInfo methodInfo)
         {
@@ -131,7 +141,33 @@ public IEnumerable<object[]> GetData(MethodInfo methodInfo)
         /// <inheritdoc />
         public string GetDisplayName(MethodInfo methodInfo, object[] data)
         {
-            if (data != null)
+            if (this.DynamicDisplayName != null)
+            {
+                var dynamicDisplayNameDeclaringType = this.DynamicDisplayNameDeclaringType ?? methodInfo.DeclaringType;
+
+                var method = dynamicDisplayNameDeclaringType.GetTypeInfo().GetDeclaredMethod(this.DynamicDisplayName);
+                if (method == null)
+                {
+                    throw new ArgumentNullException(string.Format("{0} {1}", DynamicDataSourceType.Method, this.DynamicDisplayName));
+                }
+
+                var parameters = method.GetParameters();
+                if (parameters.Length != 2 ||
+                    parameters[0].ParameterType != typeof(MethodInfo) ||
+                    parameters[1].ParameterType != typeof(object[]) ||
+                    method.ReturnType != typeof(string))
+                {
+                    throw new ArgumentNullException(
+                        string.Format(
+                            FrameworkMessages.DynamicDataDisplayName,
+                            this.DynamicDisplayName,
+                            typeof(string).Name,
+                            string.Join(", ", typeof(MethodInfo).Name, typeof(object[]).Name)));
+                }
+
+                return method.Invoke(null, new object[] { methodInfo, data }) as string;
+            }
+            else if (data != null)
             {
                 return string.Format(CultureInfo.CurrentCulture, FrameworkMessages.DataDrivenResultDisplayName, methodInfo.Name, string.Join(",", data.AsEnumerable()));
             }

src/TestFramework/MSTest.Core/Interfaces/ITestDataSource.cs

@@ -26,7 +26,7 @@ public interface ITestDataSource
         /// Gets the display name corresponding to test data row for displaying in TestResults.
         /// </summary>
         /// <param name="methodInfo">
-        /// The method Info of test method.
+        /// The method info of test method.
         /// </param>
         /// <param name="data">
         /// The test data which is passed to test method.

src/TestFramework/MSTest.Core/Resources/FrameworkMessages.resx

@@ -283,4 +283,7 @@ Stack Trace: {4}</value>
   <data name="DynamicDataValueNull" xml:space="preserve">
     <value>Value returned by property or method {0} shouldn't be null.</value>
   </data>
+  <data name="DynamicDataDisplayName" xml:space="preserve">
+    <value>Method {0} must match the expected signature: {1} {0}({2}).</value>
+  </data>
 </root>

test/UnitTests/MSTest.Core.Unit.Tests/Attributes/DataRowAttributeTests.cs

@@ -81,5 +81,20 @@ public void GetDisplayNameShouldReturnAppropriateName()
             displayName = dataRowAttribute.GetDisplayName(this.testMethodInfo, data2);
             Assert.AreEqual("DataRowTestMethod (First,,Second)", displayName);
         }
+
+        [TestMethod]
+        public void GetDisplayNameShouldReturnAppropriateNameWithDataRowDisplayName()
+        {
+            var dataRowAttribute = new DataRowAttribute(null);
+            dataRowAttribute.DisplayName = "DataRowTestWithDisplayName";
+
+            this.dummyTestClass = new DummyTestClass();
+            this.testMethodInfo = this.dummyTestClass.GetType().GetTypeInfo().GetDeclaredMethod("DataRowTestMethod");
+
+            var data = new string[] { "First", "Second", null };
+
+            var displayName = dataRowAttribute.GetDisplayName(this.testMethodInfo, data);
+            Assert.AreEqual("DataRowTestWithDisplayName", displayName);
+        }
     }
 }

test/UnitTests/MSTest.Core.Unit.Tests/Attributes/DynamicDataAttributeTests.cs

@@ -60,7 +60,7 @@ public void GetDataShouldReadDataFromProperty()
         public void GetDataShouldReadDataFromPropertyInDifferntClass()
         {
             var methodInfo = this.dummyTestClass.GetType().GetTypeInfo().GetDeclaredMethod("TestMethod1");
-            this.dynamicDataAttribute = new DynamicDataAttribute("ReusableTestDataProperty", typeof(DummyTestClass));
+            this.dynamicDataAttribute = new DynamicDataAttribute("ReusableTestDataProperty2", typeof(DummyTestClass2));
             var data = this.dynamicDataAttribute.GetData(methodInfo);
             Assert.IsTrue(data is IEnumerable<object[]>);
             Assert.IsTrue(data.ToList().Count == 2);
@@ -80,7 +80,7 @@ public void GetDataShouldReadDataFromMethod()
         public void GetDataShouldReadDataFromMethodInDifferentClass()
         {
             var methodInfo = this.dummyTestClass.GetType().GetTypeInfo().GetDeclaredMethod("TestMethod2");
-            this.dynamicDataAttribute = new DynamicDataAttribute("ReusableTestDataMethod", typeof(DummyTestClass), DynamicDataSourceType.Method);
+            this.dynamicDataAttribute = new DynamicDataAttribute("ReusableTestDataMethod2", typeof(DummyTestClass2), DynamicDataSourceType.Method);
             var data = this.dynamicDataAttribute.GetData(methodInfo);
             Assert.IsTrue(data is IEnumerable<object[]>);
             Assert.IsTrue(data.ToList().Count == 2);
@@ -121,6 +121,41 @@ public void GetDisplayNameShouldReturnDisplayName()
             Assert.AreEqual("TestMethod1 (1,2,3)", displayName);
         }
 
+        [TestFrameworkV1.TestMethod]
+        public void GetDisplayNameShouldReturnDisplayNameWithDataRowDisplayName()
+        {
+            var data = new object[] { 1, 2, 3 };
+
+            this.dynamicDataAttribute.DynamicDisplayName = "GetCustomDynamicDataDisplayName";
+            var displayName = this.dynamicDataAttribute.GetDisplayName(this.testMethodInfo, data);
+            Assert.AreEqual("DynamicDataTestWithDisplayName TestMethod1 with 3 parameters", displayName);
+        }
+
+        [TestFrameworkV1.TestMethod]
+        public void GetDisplayNameShouldReturnDisplayNameWithDataRowDisplayNameInDifferentClass()
+        {
+            var data = new object[] { 1, 2, 3 };
+
+            this.dynamicDataAttribute.DynamicDisplayName = "GetCustomDynamicDataDisplayName2";
+            this.dynamicDataAttribute.DynamicDisplayNameDeclaringType = typeof(DummyTestClass2);
+            var displayName = this.dynamicDataAttribute.GetDisplayName(this.testMethodInfo, data);
+            Assert.AreEqual("DynamicDataTestWithDisplayName TestMethod1 with 3 parameters", displayName);
+        }
+
+        [TestFrameworkV1.TestMethod]
+        public void GetDisplayNameShouldThrowExceptionIfMethodDoesNotMatchExpectedSignature()
+        {
+            Action action = () =>
+            {
+                var data = new object[] { 1, 2, 3 };
+
+                this.dynamicDataAttribute.DynamicDisplayName = "InvalidCustomDynamicDataDisplayName";
+                var displayName = this.dynamicDataAttribute.GetDisplayName(this.testMethodInfo, data);
+            };
+
+            ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(ArgumentNullException));
+        }
+
         [TestFrameworkV1.TestMethod]
         public void GetDisplayNameShouldReturnEmptyStringIfDataIsNull()
         {
@@ -195,6 +230,30 @@ public static IEnumerable<object[]> ReusableTestDataMethod()
             return new[] { new object[] { 1, 2, 3 }, new object[] { 4, 5, 6 } };
         }
 
+        /// <summary>
+        /// The custom display name method.
+        /// </summary>
+        /// <param name="methodInfo">
+        /// The method info of test method.
+        /// </param>
+        /// <param name="data">
+        /// The test data which is passed to test method.
+        /// </param>
+        /// <returns>
+        /// The <see cref="string"/>.
+        /// </returns>
+        public static string GetCustomDynamicDataDisplayName(MethodInfo methodInfo, object[] data)
+        {
+            return string.Format("DynamicDataTestWithDisplayName {0} with {1} parameters", methodInfo.Name, data.Length);
+        }
+
+        /// <summary>
+        /// Invalid custom display name method.
+        /// </summary>
+        public static void InvalidCustomDynamicDataDisplayName()
+        {
+        }
+
         /// <summary>
         /// The test method 1.
         /// </summary>
@@ -242,4 +301,46 @@ public void DataRowTestMethod()
         {
         }
     }
+
+    public class DummyTestClass2
+    {
+        /// <summary>
+        /// Gets the reusable test data property.
+        /// </summary>
+        public static IEnumerable<object[]> ReusableTestDataProperty2
+        {
+            get
+            {
+                return new[] { new object[] { 1, 2, 3 }, new object[] { 4, 5, 6 } };
+            }
+        }
+
+        /// <summary>
+        /// The reusable test data method.
+        /// </summary>
+        /// <returns>
+        /// The <see cref="IEnumerable"/>.
+        /// </returns>
+        public static IEnumerable<object[]> ReusableTestDataMethod2()
+        {
+            return new[] { new object[] { 1, 2, 3 }, new object[] { 4, 5, 6 } };
+        }
+
+        /// <summary>
+        /// The custom display name method.
+        /// </summary>
+        /// <param name="methodInfo">
+        /// The method info of test method.
+        /// </param>
+        /// <param name="data">
+        /// The test data which is passed to test method.
+        /// </param>
+        /// <returns>
+        /// The <see cref="string"/>.
+        /// </returns>
+        public static string GetCustomDynamicDataDisplayName2(MethodInfo methodInfo, object[] data)
+        {
+            return string.Format("DynamicDataTestWithDisplayName {0} with {1} parameters", methodInfo.Name, data.Length);
+        }
+    }
 }