Full english test names by default in IDE and full class name with field name in runner output display name by default. Can be disabled through configuration.

ivanz · ivanz · commit 8e2ea4eb3aeb · 2016-03-11T19:01:55.000Z
diff --git a/Source/Machine.VSTestAdapter.Specs/Configuration/When_adapter_runs_tests.cs b/Source/Machine.VSTestAdapter.Specs/Configuration/When_adapter_runs_tests.cs
@@ -9,15 +9,15 @@
 
 namespace Machine.VSTestAdapter.Specs.Configuration
 {
-       [Subject(typeof(Settings), "Configuration")]
     public class When_adapter_runs_tests : WithFakes
     {
         static string ConfigurationXml = @"<RunSettings>
   <RunConfiguration>
     <MaxCpuCount>0</MaxCpuCount>
   </RunConfiguration>
   <MSpec>
-    <DisplayFullTestNameInOutput>true</DisplayFullTestNameInOutput>
+    <DisableFullTestNameInIDE>true</DisableFullTestNameInIDE>
+    <DisableFullTestNameInOutput>true</DisableFullTestNameInOutput>
   </MSpec>
 </RunSettings>";
 
@@ -36,9 +36,16 @@ public class When_adapter_runs_tests : WithFakes
         };
 
 
-        It should_pick_up_DisplayFullTestName = () => {
+        It should_pick_up_DisableFullTestNameInIDE = () => {
             The<ISpecificationExecutor>().WasToldTo(d => d.RunAssembly("dll",
-                                                                       Param<Settings>.Matches(s => s.DisplayFullTestNameInOutput == true),
+                                                                       Param<Settings>.Matches(s => s.DisableFullTestNameInIDE == true),
+                                                                       Param<Uri>.IsAnything,
+                                                                       Param<IFrameworkHandle>.IsAnything));
+        };
+
+        It should_pick_up_DisableFullTestNameInOutput = () => {
+            The<ISpecificationExecutor>().WasToldTo(d => d.RunAssembly("dll",
+                                                                       Param<Settings>.Matches(s => s.DisableFullTestNameInOutput == true),
                                                                        Param<Uri>.IsAnything,
                                                                        Param<IFrameworkHandle>.IsAnything));
         };
diff --git a/Source/Machine.VSTestAdapter.Specs/Configuration/When_parsing_configuration_and_mspec_section_is_missing.cs b/Source/Machine.VSTestAdapter.Specs/Configuration/When_parsing_configuration_and_mspec_section_is_missing.cs
@@ -16,7 +16,7 @@ public class When_parsing_configuration_and_mspec_section_is_missing
         };
 
         It should_default_to_DisplayFullTestName_off = () => {
-            Settings.DisplayFullTestNameInOutput.ShouldBeFalse();
+            Settings.DisableFullTestNameInOutput.ShouldBeFalse();
         };
         
     }
diff --git a/Source/Machine.VSTestAdapter.Specs/Configuration/When_parsing_valid_configuration.cs b/Source/Machine.VSTestAdapter.Specs/Configuration/When_parsing_valid_configuration.cs
diff --git a/Source/Machine.VSTestAdapter.Specs/Discovery/BuiltIn/When_discovering_specs.cs b/Source/Machine.VSTestAdapter.Specs/Discovery/BuiltIn/When_discovering_specs.cs
@@ -14,7 +14,6 @@ public class When_discovering_specs : With_DiscoverySetup<BuiltInSpecificationDi
                                                                           "StandardSpec".Equals(x.ClassName, StringComparison.Ordinal));
             discoveredSpec.ShouldNotBeNull();
 
-            discoveredSpec.SpecificationDisplayName.ShouldEqual("should pass");
             discoveredSpec.LineNumber.ShouldEqual(14);
             discoveredSpec.CodeFilePath.EndsWith("StandardSpec.cs", StringComparison.Ordinal);
         };
@@ -24,7 +23,6 @@ public class When_discovering_specs : With_DiscoverySetup<BuiltInSpecificationDi
                                                                           "StandardSpec".Equals(x.ClassName, StringComparison.Ordinal));
             discoveredSpec.ShouldNotBeNull();
 
-            discoveredSpec.SpecificationDisplayName.ShouldEqual("should be ignored");
             discoveredSpec.LineNumber.ShouldEqual(20);
             discoveredSpec.CodeFilePath.EndsWith("StandardSpec.cs", StringComparison.Ordinal);
         };
@@ -34,7 +32,6 @@ public class When_discovering_specs : With_DiscoverySetup<BuiltInSpecificationDi
                                                                           "StandardSpec".Equals(x.ClassName, StringComparison.Ordinal));
             discoveredSpec.ShouldNotBeNull();
 
-            discoveredSpec.SpecificationDisplayName.ShouldEqual("not implemented");
             discoveredSpec.LineNumber.ShouldEqual(0);
             discoveredSpec.CodeFilePath.ShouldBeNull();
         };
diff --git a/Source/Machine.VSTestAdapter.Specs/Discovery/When_DisableFullTestNameInIDE_is_off.cs b/Source/Machine.VSTestAdapter.Specs/Discovery/When_DisableFullTestNameInIDE_is_off.cs
@@ -0,0 +1,32 @@
+﻿using System;
+using System.Linq;
+using Machine.Fakes;
+using Machine.Specifications;
+using Machine.VSTestAdapter.Configuration;
+using Machine.VSTestAdapter.Discovery;
+using Machine.VSTestAdapter.Execution;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
+using SampleSpecs;
+
+namespace Machine.VSTestAdapter.Specs.Discovery
+{
+    public class When_DisableFullTestNameInIDE_is_off : WithFakes
+    {
+
+        Because of = () => {
+            The<MSpecTestAdapter>().DiscoverTests(new[] { typeof(When_something).Assembly.Location },
+                                                      An<IDiscoveryContext>(),
+                                                      An<IMessageLogger>(),
+                                                      The<ITestCaseDiscoverySink>());
+        };
+
+
+        It should_use_full_type_and_field_name_for_display_name = () => {
+            The<ITestCaseDiscoverySink>()
+                .WasToldTo(d => d.SendTestCase(Param<TestCase>.Matches(t => t.DisplayName.Equals("When something should pass", StringComparison.Ordinal))))
+                .OnlyOnce();
+        };        
+    }
+}
diff --git a/Source/Machine.VSTestAdapter.Specs/Discovery/When_DisableFullTestNameInIDE_is_on.cs b/Source/Machine.VSTestAdapter.Specs/Discovery/When_DisableFullTestNameInIDE_is_on.cs
@@ -0,0 +1,47 @@
+﻿using System;
+using System.Linq;
+using Machine.Fakes;
+using Machine.Specifications;
+using Machine.VSTestAdapter.Helpers;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
+using SampleSpecs;
+
+namespace Machine.VSTestAdapter.Specs.Discovery
+{
+    public class When_DisableFullTestNameInIDE_is_on : WithFakes
+    {
+        static string ConfigurationXml = @"<RunSettings>
+  <RunConfiguration>
+    <MaxCpuCount>0</MaxCpuCount>
+  </RunConfiguration>
+  <MSpec>
+    <DisableFullTestNameInIDE>true</DisableFullTestNameInIDE>
+  </MSpec>
+</RunSettings>";
+
+        Establish establish = () => {
+            The<IRunSettings>().WhenToldTo(runSettings => runSettings.SettingsXml).Return(ConfigurationXml);
+            The<IDiscoveryContext>().WhenToldTo(context => context.RunSettings).Return(The<IRunSettings>());
+        };
+
+
+        Because of = () => {
+            The<MSpecTestAdapter>().DiscoverTests(new[] { typeof(StandardSpec).Assembly.Location },
+                                  The<IDiscoveryContext>(),
+                                  An<IMessageLogger>(),
+                                  The<ITestCaseDiscoverySink>());
+        };
+
+
+        It should_use_test_name_as_display_name = () => {
+            var specId = new VisualStudioTestIdentifier("SampleSpecs.StandardSpec", "should_pass");
+
+            The<ITestCaseDiscoverySink>()
+                .WasToldTo(d => d.SendTestCase(Param<TestCase>.Matches(t => t.ToVisualStudioTestIdentifier().Equals(specId) && 
+                                                                       t.DisplayName.Equals("should pass", StringComparison.Ordinal))))
+                .OnlyOnce();
+        };        
+    }
+}
diff --git a/Source/Machine.VSTestAdapter.Specs/Execution/RunListener/TestCaseMapperBehavior.cs b/Source/Machine.VSTestAdapter.Specs/Execution/RunListener/TestCaseMapperBehavior.cs
@@ -14,7 +14,6 @@ public class TestCaseMapperBehavior
 
         It should_provide_correct_details_to_visual_studio = () => {
             TestCase.FullyQualifiedName.ShouldEqual("ContainingType::field_name");
-            TestCase.DisplayName.ShouldEqual("field name");
             TestCase.ExecutorUri.ShouldEqual(new Uri("bla://executorUri"));
             TestCase.Source.ShouldEqual("assemblyPath");
         };
diff --git a/Source/Machine.VSTestAdapter.Specs/Execution/When_DisableFullTestNameInOutput_is_off.cs b/Source/Machine.VSTestAdapter.Specs/Execution/When_DisableFullTestNameInOutput_is_off.cs
@@ -1,8 +1,5 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Machine.Fakes;
 using Machine.Specifications;
 using Machine.VSTestAdapter.Configuration;
@@ -12,15 +9,17 @@
 
 namespace Machine.VSTestAdapter.Specs.Execution
 {
-    public class When_using_displayfulltestname_setting : With_SingleSpecExecutionSetup
+
+
+     public class When_DisableFullTestNameInOutput_is_off : With_SingleSpecExecutionSetup
     {
         static TestCase RecordStartTestCase;
         static TestCase RecordEndTestCase;
 
         Establish context = () => {
             SpecificationToRun = new VisualStudioTestIdentifier("SampleSpecs.When_something", "should_pass");
 
-            The<Settings>().DisplayFullTestNameInOutput = true;
+            The<Settings>().DisableFullTestNameInOutput = false;
 
             The<IFrameworkHandle>()
                 .WhenToldTo(handle => 
@@ -37,8 +36,8 @@ public class When_using_displayfulltestname_setting : With_SingleSpecExecutionSe
         };
 
         It should_display_both_the_context_name_and_specification_name_on_a_single_line = () => {
-            RecordStartTestCase.DisplayName.ShouldEqual("SampleSpecs.When_something: should_pass");
-            RecordEndTestCase.DisplayName.ShouldEqual("SampleSpecs.When_something: should_pass");
+            RecordStartTestCase.DisplayName.ShouldEqual("SampleSpecs.When_something.should_pass");
+            RecordEndTestCase.DisplayName.ShouldEqual("SampleSpecs.When_something.should_pass");
         };
     }
 }
diff --git a/Source/Machine.VSTestAdapter.Specs/Execution/When_DisableFullTestNameInOutput_is_on.cs b/Source/Machine.VSTestAdapter.Specs/Execution/When_DisableFullTestNameInOutput_is_on.cs
@@ -0,0 +1,44 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Machine.Fakes;
+using Machine.Specifications;
+using Machine.VSTestAdapter.Configuration;
+using Machine.VSTestAdapter.Helpers;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Adapter;
+
+namespace Machine.VSTestAdapter.Specs.Execution
+{
+    public class When_DisableFullTestNameInOutput_is_on : With_SingleSpecExecutionSetup
+    {
+        static TestCase RecordStartTestCase;
+        static TestCase RecordEndTestCase;
+
+        Establish context = () => {
+            SpecificationToRun = new VisualStudioTestIdentifier("SampleSpecs.When_something", "should_pass");
+
+            The<Settings>().DisableFullTestNameInOutput = true;
+
+            The<IFrameworkHandle>()
+                .WhenToldTo(handle => 
+                    handle.RecordStart(Param<TestCase>.Matches(testCase => testCase.ToVisualStudioTestIdentifier().Equals(SpecificationToRun)))
+                )
+                .Callback((TestCase testCase) => RecordStartTestCase = testCase);
+
+            The<IFrameworkHandle>()
+                .WhenToldTo(handle => 
+                    handle.RecordEnd(Param<TestCase>.Matches(testCase => testCase.ToVisualStudioTestIdentifier().Equals(SpecificationToRun)),
+                                     Param<TestOutcome>.Matches(outcome => outcome == TestOutcome.Passed))
+                )
+                .Callback((TestCase testCase) => RecordEndTestCase = testCase);
+        };
+
+        It should_display_both_the_context_name_and_specification_name_on_a_single_line = () => {
+            RecordStartTestCase.DisplayName.ShouldEqual("should pass");
+            RecordEndTestCase.DisplayName.ShouldEqual("should pass");
+        };
+    }
+}
diff --git a/Source/Machine.VSTestAdapter.Specs/Machine.VSTestAdapter.Specs.csproj b/Source/Machine.VSTestAdapter.Specs/Machine.VSTestAdapter.Specs.csproj
@@ -84,9 +84,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Discovery\When_DisableFullTestNameInIDE_is_off.cs" />
     <Compile Include="Configuration\When_adapter_runs_tests.cs" />
     <Compile Include="Configuration\When_parsing_configuration_and_mspec_section_is_missing.cs" />
-    <Compile Include="Configuration\When_parsing_valid_configuration.cs" />
     <Compile Include="Discovery\BuiltIn\When_discovering_specs.cs" />
     <Compile Include="Discovery\BuiltIn\When_discovering_behaviors.cs" />
     <Compile Include="Discovery\BuiltIn\When_discovering_specs_in_nested_types.cs" />
@@ -101,6 +101,7 @@
     <Compile Include="Execution\RunListener\When_specification_ends_with_a_fail.cs" />
     <Compile Include="Execution\RunListener\When_specification_ends_with_a_pass.cs" />
     <Compile Include="Execution\RunListener\When_specification_starts.cs" />
+    <Compile Include="Execution\When_DisableFullTestNameInOutput_is_off.cs" />
     <Compile Include="Execution\When_running_a_nested_spec_passes.cs" />
     <Compile Include="Execution\When_running_a_single_behavior_passes.cs" />
     <Compile Include="Execution\When_running_a_spec_that_fails.cs" />
@@ -111,11 +112,12 @@
     <Compile Include="Execution\When_running_a_spec_that_throws.cs" />
     <Compile Include="Execution\When_running_a_spec_with_custom_act_assert_delegates_passes.cs" />
     <Compile Include="Execution\When_running_an_assembly_with_behaviors.cs" />
-    <Compile Include="Execution\When_using_displayfulltestname_setting.cs" />
+    <Compile Include="Execution\When_DisableFullTestNameInOutput_is_on.cs" />
     <Compile Include="Execution\With_AssemblyExecutionSetup.cs" />
     <Compile Include="Execution\With_SingleSpecExecutionSetup.cs" />
     <Compile Include="Helper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Discovery\When_DisableFullTestNameInIDE_is_on.cs" />
     <Compile Include="When_there_is_an_unhandled_error_during_test_discovery.cs" />
     <Compile Include="When_there_is_an_unhandled_error_during_test_execution.cs" />
   </ItemGroup>
diff --git a/Source/Machine.VSTestAdapter/Configuration/Settings.cs b/Source/Machine.VSTestAdapter/Configuration/Settings.cs
@@ -10,8 +10,8 @@ namespace Machine.VSTestAdapter.Configuration
 {
     public class Settings
     {
-
-        public bool DisplayFullTestNameInOutput { get; set; }
+        public bool DisableFullTestNameInIDE { get; set; }
+        public bool DisableFullTestNameInOutput { get; set; }
 
         public static Settings Parse(string xml)
         {
@@ -25,7 +25,8 @@ public static Settings Parse(string xml)
             if (mspecConfig == null)
                 return config;
 
-            config.DisplayFullTestNameInOutput = "true".Equals(mspecConfig.Element("DisplayFullTestNameInOutput")?.Value ?? "false", StringComparison.InvariantCultureIgnoreCase);
+            config.DisableFullTestNameInOutput = "true".Equals(mspecConfig.Element("DisableFullTestNameInOutput")?.Value ?? "false", StringComparison.InvariantCultureIgnoreCase);
+            config.DisableFullTestNameInIDE = "true".Equals(mspecConfig.Element("DisableFullTestNameInIDE")?.Value ?? "false", StringComparison.InvariantCultureIgnoreCase);
 
             return config;
         }
diff --git a/Source/Machine.VSTestAdapter/Discovery/BuiltIn/TestDiscoverer.cs b/Source/Machine.VSTestAdapter/Discovery/BuiltIn/TestDiscoverer.cs
@@ -33,6 +33,7 @@ private IEnumerable<MSpecTestCase> CreateTestCase(Context context, string assemb
 
                 testCase.ClassName = context.Type.Name;
                 testCase.ContextFullType = context.Type.FullName;
+                testCase.ContextDisplayName = context.Type.Name.Replace("_", " ");
                 testCase.SpecificationName = spec.FieldInfo.Name;
                 testCase.SpecificationDisplayName = spec.Name;
 
diff --git a/Source/Machine.VSTestAdapter/Discovery/Cecil/CecilSpecificationDiscoverer.cs b/Source/Machine.VSTestAdapter/Discovery/Cecil/CecilSpecificationDiscoverer.cs
@@ -68,6 +68,7 @@ public IEnumerable<MSpecTestCase> DiscoverSpecs(string assemblyFilePath)
                                 ClassName = typeName,
                                 ContextFullType = typeFullName,
                                 SpecificationName = fieldDefinition.Name,
+                                ContextDisplayName = typeName.Replace("_", " "),
                                 SpecificationDisplayName = fieldDefinition.Name.Replace("_", " "),
                             };
 
diff --git a/Source/Machine.VSTestAdapter/Discovery/MSpecTestCase.cs b/Source/Machine.VSTestAdapter/Discovery/MSpecTestCase.cs
@@ -8,6 +8,7 @@ public class MSpecTestCase
         public string Subject { get; set; }
 
         public string ContextFullType { get; set; }
+        public object ContextDisplayName { get; set; }
 
         public string ClassName { get; set; }
 
diff --git a/Source/Machine.VSTestAdapter/Execution/VSProxyAssemblySpecificationRunListener.cs b/Source/Machine.VSTestAdapter/Execution/VSProxyAssemblySpecificationRunListener.cs
@@ -82,7 +82,7 @@ private TestCase ConvertSpecificationToTestCase(SpecificationInfo specification,
             VisualStudioTestIdentifier vsTestId = specification.ToVisualStudioTestIdentifier(currentContext);
 
             return new TestCase(vsTestId.FullyQualifiedName, this.executorUri, this.assemblyPath) {
-                DisplayName = settings.DisplayFullTestNameInOutput ? $"{this.currentContext?.TypeName}: {specification.FieldName}" : specification.Name,
+                DisplayName = settings.DisableFullTestNameInOutput ? specification.Name : $"{this.currentContext?.TypeName}.{specification.FieldName}",
             };
         }
 
diff --git a/Source/Machine.VSTestAdapter/Helpers/SpecTestHelper.cs b/Source/Machine.VSTestAdapter/Helpers/SpecTestHelper.cs
@@ -7,13 +7,13 @@ namespace Machine.VSTestAdapter.Helpers
 {
     public static class SpecTestHelper
     {
-        public static TestCase GetVSTestCaseFromMSpecTestCase(string source, MSpecTestCase mspecTestCase, Uri uri, Func<string, string, dynamic> traitCreator)
+        public static TestCase GetVSTestCaseFromMSpecTestCase(string source, MSpecTestCase mspecTestCase, bool disableFullTestNames, Uri testRunnerUri, Func<string, string, dynamic> traitCreator)
         {
             VisualStudioTestIdentifier vsTest = mspecTestCase.ToVisualStudioTestIdentifier();
 
-            TestCase testCase = new TestCase(vsTest.FullyQualifiedName, uri, source)
+            TestCase testCase = new TestCase(vsTest.FullyQualifiedName, testRunnerUri, source)
             {
-                DisplayName = mspecTestCase.SpecificationDisplayName,
+                DisplayName = disableFullTestNames ? mspecTestCase.SpecificationDisplayName : $"{mspecTestCase.ContextDisplayName} {mspecTestCase.SpecificationDisplayName}",
                 CodeFilePath = mspecTestCase.CodeFilePath,
                 LineNumber = mspecTestCase.LineNumber
             };
diff --git a/Source/Machine.VSTestAdapter/MSpecTestAdapterDiscoverer.cs b/Source/Machine.VSTestAdapter/MSpecTestAdapterDiscoverer.cs
diff --git a/Source/Machine.VSTestAdapter/MspecTestAdapterExecutor.cs b/Source/Machine.VSTestAdapter/MspecTestAdapterExecutor.cs

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class When_parsing_configuration_and_mspec_section_is_missing`
`16`	`16`	`};`
`17`	`17`
`18`	`18`	`It should_default_to_DisplayFullTestName_off = () => {`
`19`		`- Settings.DisplayFullTestNameInOutput.ShouldBeFalse();`
	`19`	`+ Settings.DisableFullTestNameInOutput.ShouldBeFalse();`
`20`	`20`	`};`
`21`	`21`
`22`	`22`	`}`