diff --git a/eng/Versions.props b/eng/Versions.props
index 2365d69146..c563f7e964 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -84,6 +84,8 @@
8.1.0
2.1.0
+
+ 2.4.0-preview.26410.1
4.16.1
18.3.0
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientHelpers.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientHelpers.cs
deleted file mode 100644
index 83ef3bdcef..0000000000
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientHelpers.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-using Jsonite;
-
-using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
-
-namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
-
-///
-/// Shared helpers for the MTP proxies.
-///
-internal static class MtpClientHelpers
-{
- public static Dictionary InitializeParameters()
- => new()
- {
- ["processId"] = GetCurrentProcessId(),
- ["clientInfo"] = new Dictionary
- {
- ["name"] = "vstest",
- ["version"] = "1.0.0",
- },
- ["capabilities"] = new Dictionary
- {
- ["testing"] = new Dictionary
- {
- ["debuggerProvider"] = false,
- },
- },
- };
-
- public static TestMessageLevel MapLevel(string level)
- => level switch
- {
- "Error" or "Critical" => TestMessageLevel.Error,
- "Warning" => TestMessageLevel.Warning,
- _ => TestMessageLevel.Informational,
- };
-
- public static TimeSpan GetConnectionTimeout()
- {
- // Reuse vstest's connection timeout knob so users can extend it in slow environments.
- string? value = Environment.GetEnvironmentVariable("VSTEST_CONNECTION_TIMEOUT");
- if (!string.IsNullOrEmpty(value) && int.TryParse(value, out int seconds) && seconds > 0)
- {
- return TimeSpan.FromSeconds(seconds);
- }
-
- return TimeSpan.FromSeconds(90);
- }
-
- private static int GetCurrentProcessId()
- {
- using var process = Process.GetCurrentProcess();
- return process.Id;
- }
-
- ///
- /// Returns true when a testing/testUpdates/tests notification is the completion sentinel
- /// (its changes array is null or absent).
- ///
- public static bool IsCompletionSentinel(object? parameters)
- {
- JsonObject? node = MtpJson.AsObject(parameters);
- return node is null
- || !node.TryGetValue(MtpConstants.ChangesProperty, out object? changes)
- || changes is null;
- }
-
- ///
- /// Enumerates the node objects carried by a testing/testUpdates/tests notification.
- ///
- public static IEnumerable EnumerateNodes(object? parameters)
- {
- if (MtpJson.AsObject(parameters) is not JsonObject node
- || !node.TryGetValue(MtpConstants.ChangesProperty, out object? changesValue)
- || changesValue is not JsonArray changes)
- {
- yield break;
- }
-
- foreach (object? changeObject in changes)
- {
- if (changeObject is JsonObject change
- && change.TryGetValue(MtpConstants.NodeProperty, out object? nodeValue)
- && nodeValue is JsonObject testNode)
- {
- yield return testNode;
- }
- }
- }
-}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientOptionsFactory.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientOptionsFactory.cs
new file mode 100644
index 0000000000..f22df6af07
--- /dev/null
+++ b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpClientOptionsFactory.cs
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+
+using Microsoft.Testing.Platform.ServerMode.Client;
+using Microsoft.VisualStudio.TestPlatform.CoreUtilities.Helpers;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Logging;
+
+namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
+
+///
+/// vstest-side glue for the source-only Microsoft.Testing.Platform (MTP) server client: builds the
+/// that identify vstest to the MTP application, bridge the client's
+/// own diagnostics to , and map the server's client/log levels onto vstest's
+/// .
+///
+internal static class MtpClientOptionsFactory
+{
+ ///
+ /// Builds the options used to launch an MTP application: vstest's client identity, a single
+ /// discover-or-run session (not stateful), the vstest connection timeout, the EqtTrace diagnostics
+ /// bridge, and any environment variables to inject into the launched process.
+ ///
+ public static MtpServerClientOptions CreateOptions(IDictionary? environmentVariables = null)
+ {
+ var options = new MtpServerClientOptions
+ {
+ ClientName = "vstest",
+ ClientVersion = "1.0.0",
+ DebuggerProvider = false,
+ IsStateful = false,
+ ConnectionTimeout = GetConnectionTimeout(),
+ Logger = new DelegateMtpClientLogger(Trace),
+ };
+
+ if (environmentVariables is not null)
+ {
+ foreach (KeyValuePair variable in environmentVariables)
+ {
+ options.EnvironmentVariables[variable.Key] = variable.Value;
+ }
+ }
+
+ return options;
+ }
+
+ ///
+ /// Maps a server client/log level string onto the vstest .
+ ///
+ public static TestMessageLevel MapServerLogLevel(string level)
+ => level switch
+ {
+ "Error" or "Critical" => TestMessageLevel.Error,
+ "Warning" => TestMessageLevel.Warning,
+ _ => TestMessageLevel.Informational,
+ };
+
+ private static TimeSpan GetConnectionTimeout()
+ // Reuse vstest's shared connection-timeout knob (VSTEST_CONNECTION_TIMEOUT) rather than
+ // re-reading the environment variable here, so the MTP path honours exactly the same
+ // override, default and diagnostics as every other vstest connection.
+ => TimeSpan.FromSeconds(EnvironmentHelper.GetConnectionTimeout());
+
+ private static void Trace(MtpClientLogLevel level, string message)
+ {
+ switch (level)
+ {
+ case MtpClientLogLevel.Error:
+ EqtTrace.Error(message);
+ break;
+
+ case MtpClientLogLevel.Warning:
+ EqtTrace.Warning(message);
+ break;
+
+ case MtpClientLogLevel.Information:
+ EqtTrace.Info(message);
+ break;
+
+ default:
+ EqtTrace.Verbose(message);
+ break;
+ }
+ }
+}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpConstants.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpConstants.cs
deleted file mode 100644
index 0e43f0a5ca..0000000000
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpConstants.cs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
-
-///
-/// Constants for the Microsoft.Testing.Platform (MTP) server-mode JSON-RPC protocol.
-/// See the MTP protocol docs in microsoft/testfx (ServerMode/JsonRpc).
-///
-internal static class MtpConstants
-{
- // Command line used to start an MTP application in JSON-RPC server mode. vstest opens a TCP
- // listener and the application connects back to it (the application dials out to us).
- public const string ServerArgument = "--server";
- public const string ClientPortArgument = "--client-port";
- public const string NoBannerArgument = "--no-banner";
-
- // JSON-RPC method names.
- public const string InitializeMethod = "initialize";
- public const string DiscoverTestsMethod = "testing/discoverTests";
- public const string RunTestsMethod = "testing/runTests";
- public const string TestUpdatesTestsMethod = "testing/testUpdates/tests";
- public const string TestUpdatesAttachmentsMethod = "testing/testUpdates/attachments";
- public const string ClientLogMethod = "client/log";
- public const string ExitMethod = "exit";
-
- // Framing (LSP-like headers).
- public const string ContentLengthHeader = "Content-Length:";
- public const string ContentType = "application/testingplatform";
-
- // Request/notification parameter keys.
- public const string RunIdParameter = "runId";
- public const string TestsParameter = "tests";
- public const string ChangesProperty = "changes";
- public const string NodeProperty = "node";
- public const string AttachmentsProperty = "attachments";
- public const string AttachmentUriProperty = "uri";
- public const string AttachmentPathProperty = "path";
-
- // TestNode wire property keys (pure MTP shape).
- public const string Uid = "uid";
- public const string DisplayName = "display-name";
- public const string NodeType = "node-type";
- public const string ExecutionState = "execution-state";
- public const string TimeDurationMs = "time.duration-ms";
- public const string ErrorMessage = "error.message";
- public const string ErrorStackTrace = "error.stacktrace";
- public const string StandardOutput = "standardOutput";
- public const string StandardError = "standardError";
- public const string LocationFile = "location.file";
- public const string LocationLineStart = "location.line-start";
- public const string Traits = "traits";
-
- // Execution states.
- public const string StateDiscovered = "discovered";
- public const string StateInProgress = "in-progress";
- public const string StatePassed = "passed";
- public const string StateSkipped = "skipped";
- public const string StateFailed = "failed";
- public const string StateError = "error";
- public const string StateTimedOut = "timed-out";
- public const string StateCanceled = "canceled";
-
- // Optional VSTest-provider properties (present only when the app still runs on the VSTestBridge).
- // The converter treats these as best-effort enrichment and never requires them, so that a pure
- // MTP app with no vstest dependency at all still converts correctly.
- public const string VsTestFullyQualifiedName = "vstest.TestCase.FullyQualifiedName";
- public const string VsTestId = "vstest.TestCase.Id";
- public const string VsTestExecutorUri = "vstest.original-executor-uri";
-
- // Synthetic executor URI used when the app does not expose the vstest provider properties.
- public const string DefaultExecutorUri = "executor://MicrosoftTestingPlatform/v1";
-
- // Property used to round-trip the MTP node uid on a vstest TestCase so we can request a
- // filtered run by uid after discovery.
- public const string MtpUidPropertyId = "MTP.TestNode.Uid";
-}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpJson.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpJson.cs
deleted file mode 100644
index 038a77b397..0000000000
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpJson.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using Jsonite;
-
-namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
-
-///
-/// Small accessors over the Jsonite JSON object model used by the MTP JSON-RPC client.
-///
-/// The MTP wire is serialized with Jsonite (not System.Text.Json) so that the client works on every
-/// framework we ship — including the .NET Framework runner, where taking a dependency on
-/// System.Text.Json would introduce binding-redirect fallout in hosts that run without them. Parsed
-/// JSON is a plain object graph: objects are (a
-/// Dictionary<string, object>), arrays are (a
-/// List<object>), numbers are int/long/double, and everything else
-/// is string/bool/null.
-///
-internal static class MtpJson
-{
- public static JsonObject? AsObject(object? node) => node as JsonObject;
-
- public static JsonArray? AsArray(object? node) => node as JsonArray;
-
- public static object? GetValue(JsonObject? node, string key)
- => node is not null && node.TryGetValue(key, out object? value) ? value : null;
-
- public static string? GetString(JsonObject? node, string key)
- => GetValue(node, key) as string;
-
- public static bool TryGetInt(JsonObject? node, string key, out int result)
- => TryToInt(GetValue(node, key), out result);
-
- public static bool TryGetDouble(JsonObject? node, string key, out double result)
- {
- switch (GetValue(node, key))
- {
- case double d: result = d; return true;
- case int i: result = i; return true;
- case long l: result = l; return true;
- case decimal m: result = (double)m; return true;
- default: result = 0; return false;
- }
- }
-
- public static bool TryToInt(object? value, out int result)
- {
- switch (value)
- {
- case int i: result = i; return true;
- case long l: result = unchecked((int)l); return true;
- case double d: result = (int)d; return true;
- case decimal m: result = (int)m; return true;
- default: result = 0; return false;
- }
- }
-}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyDiscoveryManager.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyDiscoveryManager.cs
index 07a36ed168..5d9e5f00f2 100644
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyDiscoveryManager.cs
+++ b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyDiscoveryManager.cs
@@ -6,8 +6,7 @@
using System.Linq;
using System.Threading;
-using Jsonite;
-
+using Microsoft.Testing.Platform.ServerMode.Client;
using Microsoft.VisualStudio.TestPlatform.ObjectModel;
using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client;
using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine;
@@ -85,44 +84,37 @@ public void Dispose()
private int DiscoverSource(string source, ITestDiscoveryEventsHandler2 eventHandler)
{
var discovered = new List();
- var completed = new ManualResetEventSlim(false);
- using var connection = new MtpServerConnection();
- connection.LogReceived += (level, message) => eventHandler.HandleLogMessage(MtpClientHelpers.MapLevel(level), message);
- connection.TestNodesUpdated += parameters =>
+ MtpServerClientOptions options = MtpClientOptionsFactory.CreateOptions();
+ using IMtpServerClient client = MtpServerClientFactory.Launch(source, options);
+ client.LogReceived += (_, e) => eventHandler.HandleLogMessage(MtpClientOptionsFactory.MapServerLogLevel(e.Level), e.Message);
+ client.TestNodesUpdated += (_, e) =>
{
- if (MtpClientHelpers.IsCompletionSentinel(parameters))
+ foreach (MtpTestNodeUpdate change in e.Changes)
{
- completed.Set();
- return;
- }
-
- foreach (JsonObject node in MtpClientHelpers.EnumerateNodes(parameters))
- {
- if (MtpTestNodeConverter.IsActionNode(node))
+ if (MtpTestNodeConverter.IsActionNode(change))
{
lock (discovered)
{
- discovered.Add(MtpTestNodeConverter.ToTestCase(node, source));
+ discovered.Add(MtpTestNodeConverter.ToTestCase(change, source));
}
}
}
};
- connection.Start(source, environmentVariables: null, MtpClientHelpers.GetConnectionTimeout());
- connection.InvokeAsync(MtpConstants.InitializeMethod, MtpClientHelpers.InitializeParameters(), _cancellationTokenSource.Token).GetAwaiter().GetResult();
-
- var runId = Guid.NewGuid();
- var discoverTask = connection.InvokeAsync(
- MtpConstants.DiscoverTestsMethod,
- new Dictionary { [MtpConstants.RunIdParameter] = runId.ToString() },
- _cancellationTokenSource.Token);
+ try
+ {
+ client.InitializeAsync(_cancellationTokenSource.Token).GetAwaiter().GetResult();
- // The response indicates the server has finished discovery. Because messages arrive on a
- // single ordered stream that we read sequentially, every node notification sent before the
- // response has already been dispatched by the time the response completes.
- discoverTask.GetAwaiter().GetResult();
- completed.Wait(TimeSpan.FromSeconds(3));
+ // Awaiting the discover request is sufficient: server-to-client messages arrive on a single
+ // ordered stream that the client reads sequentially and dispatches synchronously, so every
+ // node notification has already been delivered by the time the request completes.
+ client.DiscoverTestsAsync(_cancellationTokenSource.Token).GetAwaiter().GetResult();
+ }
+ finally
+ {
+ MtpServerClientFactory.TryExit(client);
+ }
List chunk;
lock (discovered)
@@ -135,7 +127,6 @@ private int DiscoverSource(string source, ITestDiscoveryEventsHandler2 eventHand
eventHandler.HandleDiscoveredTests(chunk);
}
- connection.SendNotification(MtpConstants.ExitMethod, null);
return chunk.Count;
}
}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyExecutionManager.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyExecutionManager.cs
index 0fe50c394e..6da0a1dd90 100644
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyExecutionManager.cs
+++ b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpProxyExecutionManager.cs
@@ -4,11 +4,12 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
+using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
-using Jsonite;
+using Microsoft.Testing.Platform.ServerMode.Client;
using Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client;
using Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.DataCollection;
@@ -18,6 +19,8 @@
using Microsoft.VisualStudio.TestPlatform.ObjectModel.Engine;
using Microsoft.VisualStudio.TestPlatform.Utilities;
+using CrossPlatEngineResources = Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Resources.Resources;
+
namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
///
@@ -169,7 +172,7 @@ private void BeforeTestRun(IInternalTestRunEventsHandler eventHandler)
if (parameters?.EnvironmentVariables is { } dataCollectionEnvironmentVariables)
{
- EnvironmentVariables ??= new Dictionary();
+ EnvironmentVariables ??= CreateEnvironmentVariablesDictionary();
foreach (KeyValuePair variable in dataCollectionEnvironmentVariables)
{
EnvironmentVariables[variable.Key] = variable.Value;
@@ -311,39 +314,32 @@ private int RunSource(
List attachments,
HashSet executorUris)
{
- var completed = new ManualResetEventSlim(false);
-
- using var connection = new MtpServerConnection();
- connection.LogReceived += (level, message) => eventHandler.HandleLogMessage(MtpClientHelpers.MapLevel(level), message);
- connection.TestNodesUpdated += parameters =>
+ MtpServerClientOptions options = MtpClientOptionsFactory.CreateOptions(EnvironmentVariables);
+ using IMtpServerClient client = MtpServerClientFactory.Launch(source, options);
+ client.LogReceived += (_, e) => eventHandler.HandleLogMessage(MtpClientOptionsFactory.MapServerLogLevel(e.Level), e.Message);
+ client.TestNodesUpdated += (_, e) =>
{
- if (MtpClientHelpers.IsCompletionSentinel(parameters))
- {
- completed.Set();
- return;
- }
-
var results = new List();
- foreach (JsonObject node in MtpClientHelpers.EnumerateNodes(parameters))
+ foreach (MtpTestNodeUpdate change in e.Changes)
{
- if (!MtpTestNodeConverter.IsActionNode(node))
+ if (!MtpTestNodeConverter.IsActionNode(change))
{
continue;
}
- string? state = MtpTestNodeConverter.GetExecutionState(node);
+ string? state = change.ExecutionState;
if (EqtTrace.IsVerboseEnabled)
{
- EqtTrace.Verbose("MtpProxyExecutionManager: node update uid={0} state={1}", MtpJson.GetString(node, MtpConstants.Uid), state ?? "(none)");
+ EqtTrace.Verbose("MtpProxyExecutionManager: node update uid={0} state={1}", change.Uid, state ?? "(none)");
}
// A test entering the in-progress state is our "test started" signal. Forwarding it
// lets per-test-case collectors (e.g. Blame) know which test is in flight, which is
// what makes crash attribution work when the test never reaches a terminal state.
- if (_testCaseEventForwarder is { } forwarder && state == MtpConstants.StateInProgress)
+ if (_testCaseEventForwarder is { } forwarder && MtpTestNodeConverter.IsInProgressState(state))
{
- forwarder.NotifyTestCaseStart(MtpTestNodeConverter.ToTestCase(node, source));
+ forwarder.NotifyTestCaseStart(MtpTestNodeConverter.ToTestCase(change, source));
continue;
}
@@ -352,7 +348,7 @@ private int RunSource(
continue;
}
- TestResult result = MtpTestNodeConverter.ToTestResult(node, source);
+ TestResult result = MtpTestNodeConverter.ToTestResult(change, source);
_testCaseEventForwarder?.NotifyTestCaseEnd(result);
results.Add(result);
}
@@ -380,28 +376,31 @@ private int RunSource(
eventHandler.HandleTestRunStatsChange(new TestRunChangedEventArgs(snapshot, results, null));
};
- connection.Start(source, EnvironmentVariables, MtpClientHelpers.GetConnectionTimeout());
-
// Let the data collector (e.g. code coverage) know the process it should track. The profiler
- // env vars were already injected via EnvironmentVariables above.
- _dataCollectionManager?.TestHostLaunched(connection.ProcessId);
+ // env vars were already injected via the launch options above. Capture the id here rather than
+ // reading it again after the exit handshake, when the process may already be gone.
+ int processId = client.ProcessId;
+ _dataCollectionManager?.TestHostLaunched(processId);
- connection.InvokeAsync(MtpConstants.InitializeMethod, MtpClientHelpers.InitializeParameters(), _cancellationTokenSource.Token).GetAwaiter().GetResult();
+ try
+ {
+ client.InitializeAsync(_cancellationTokenSource.Token).GetAwaiter().GetResult();
+
+ // Awaiting the run request is sufficient: server-to-client messages arrive on a single ordered
+ // stream that the client reads sequentially and dispatches synchronously, so every node update
+ // has already been delivered by the time the request completes.
+ MtpRunResult runResult = (tests is { Count: > 0 }
+ ? client.RunTestsAsync(BuildUids(tests), _cancellationTokenSource.Token)
+ : client.RunTestsAsync(_cancellationTokenSource.Token)).GetAwaiter().GetResult();
- var runId = Guid.NewGuid();
- var runParameters = new Dictionary { [MtpConstants.RunIdParameter] = runId.ToString() };
- if (tests is { Count: > 0 })
+ CollectAttachments(runResult, attachments);
+ }
+ finally
{
- runParameters[MtpConstants.TestsParameter] = BuildTestsFilter(tests);
+ MtpServerClientFactory.TryExit(client);
}
- var runTask = connection.InvokeAsync(MtpConstants.RunTestsMethod, runParameters, _cancellationTokenSource.Token);
- object? response = runTask.GetAwaiter().GetResult();
- completed.Wait(TimeSpan.FromSeconds(3));
-
- CollectAttachments(response, attachments);
- connection.SendNotification(MtpConstants.ExitMethod, null);
- return connection.ProcessId;
+ return processId;
}
private static IEnumerable<(string Source, List? Tests)> BuildWork(TestRunCriteria criteria)
@@ -430,42 +429,74 @@ private void ApplyRunSettingsEnvironmentVariables(string? runSettings)
return;
}
- EnvironmentVariables ??= new Dictionary(
- Environment.OSVersion.Platform == PlatformID.Win32NT ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
+ EnvironmentVariables ??= CreateEnvironmentVariablesDictionary();
foreach (KeyValuePair variable in runSettingsEnvironmentVariables)
{
EnvironmentVariables[variable.Key] = variable.Value;
}
}
- private static List> BuildTestsFilter(List tests)
- => tests
- .Select(test => new Dictionary
+ ///
+ /// Creates the dictionary used to collect environment variables for the MTP application launch,
+ /// keyed case-insensitively on Windows (matching the classic testhost path) and case-sensitively
+ /// elsewhere, so callers that pass case-variant duplicate keys collapse the same way the classic
+ /// path did before the values reach the ordinal-keyed
+ /// .
+ ///
+ private static Dictionary CreateEnvironmentVariablesDictionary()
+ => new(Environment.OSVersion.Platform == PlatformID.Win32NT ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
+
+ ///
+ /// Projects the tests selected for a filtered run onto the MTP node uids the server matches on.
+ ///
+ ///
+ /// A selected test carries no MTP node uid, so the run cannot be expressed.
+ ///
+ private static IReadOnlyCollection BuildUids(List tests)
+ {
+ var uids = new List(tests.Count);
+ foreach (TestCase test in tests)
+ {
+ string? uid = test.GetPropertyValue(MtpTestNodeConverter.MtpUidProperty, null);
+
+ // The MTP server projects node.Uid alone when it builds a run filter and never reads
+ // DisplayName or any other field, so a TestCase without MTP.TestNode.Uid simply cannot be
+ // addressed. Substituting FullyQualifiedName here (as this method previously did) produces
+ // a filter the server matches nothing against: the run completes "successfully" having
+ // executed zero of the tests the user selected, with no error anywhere. Failing here turns
+ // that invisible wrong answer into a visible, actionable one. Do not reintroduce a
+ // fallback - there is no value that works other than the uid the server itself issued.
+ //
+ // This aborts the whole source rather than skipping the offending test: the caller reports
+ // the failure and marks the run aborted, which is deliberate. Silently running the
+ // addressable subset would recreate the same class of bug in a smaller form, reporting a
+ // partial run as if it were the run the user asked for.
+ if (uid.IsNullOrEmpty())
{
- [MtpConstants.Uid] = test.GetPropertyValue(MtpTestNodeConverter.MtpUidProperty, test.FullyQualifiedName),
- [MtpConstants.DisplayName] = test.DisplayName,
- })
- .ToList();
+ throw new TestPlatformException(
+ string.Format(
+ CultureInfo.CurrentCulture,
+ CrossPlatEngineResources.MtpTestCaseMissingNodeUid,
+ test.DisplayName ?? test.FullyQualifiedName));
+ }
+
+ uids.Add(uid);
+ }
- private static void CollectAttachments(object? response, List attachments)
+ return uids;
+ }
+
+ private static void CollectAttachments(MtpRunResult runResult, List attachments)
{
- if (MtpJson.AsObject(response) is not JsonObject responseObject
- || !responseObject.TryGetValue(MtpConstants.AttachmentsProperty, out object? attachmentsValue)
- || attachmentsValue is not JsonArray attachmentArray)
+ if (runResult.Artifacts.Count == 0)
{
return;
}
- var set = new AttachmentSet(new Uri(MtpConstants.DefaultExecutorUri), "Microsoft.Testing.Platform");
- foreach (object? attachmentObject in attachmentArray)
+ var set = new AttachmentSet(new Uri(MtpTestNodeConverter.DefaultExecutorUri), "Microsoft.Testing.Platform");
+ foreach (MtpAttachment artifact in runResult.Artifacts)
{
- if (attachmentObject is not JsonObject attachment)
- {
- continue;
- }
-
- string? path = GetStringProperty(attachment, MtpConstants.AttachmentUriProperty)
- ?? GetStringProperty(attachment, MtpConstants.AttachmentPathProperty);
+ string? path = artifact.Uri;
if (string.IsNullOrEmpty(path))
{
continue;
@@ -476,7 +507,7 @@ private static void CollectAttachments(object? response, List att
continue;
}
- string display = GetStringProperty(attachment, MtpConstants.DisplayName) ?? Path.GetFileName(path!);
+ string display = artifact.DisplayName ?? Path.GetFileName(path!);
set.Attachments.Add(new UriDataAttachment(fileUri!, display));
}
@@ -489,9 +520,6 @@ private static void CollectAttachments(object? response, List att
}
}
- private static string? GetStringProperty(JsonObject element, string name)
- => element.TryGetValue(name, out object? value) && value is string text ? text : null;
-
private static bool TryCreateFileUri(string path, out Uri? uri)
{
try
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerClientFactory.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerClientFactory.cs
new file mode 100644
index 0000000000..25fe1ae120
--- /dev/null
+++ b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerClientFactory.cs
@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Threading;
+
+using Microsoft.Testing.Platform.ServerMode.Client;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+
+namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
+
+///
+/// Creates the the MTP proxy managers drive, and shuts it down.
+///
+/// The launch is behind a replaceable delegate purely so the proxy managers can be unit tested
+/// without starting a real test application; production code always uses
+/// .
+///
+internal static class MtpServerClientFactory
+{
+ ///
+ /// How long to wait for the server to acknowledge exit before abandoning the graceful
+ /// shutdown and falling back to disposing the client (which terminates the process).
+ ///
+ private static readonly TimeSpan ExitTimeout = TimeSpan.FromSeconds(10);
+
+ ///
+ /// Launches an MTP application in server mode. Replaceable for testing only.
+ ///
+ internal static Func Launch { get; set; }
+ = static (source, options) => MtpServerClient.Launch(source, options);
+
+ ///
+ /// Asks the server to exit, on a best-effort basis.
+ ///
+ /// Two things matter here and neither is served by passing the run's own cancellation token.
+ /// First, shutdown must still happen when the run was cancelled or aborted - that is precisely
+ /// when the token is already cancelled, so using it would make exit throw immediately and
+ /// skip the handshake entirely. Second, exit is a request/response call rather than the
+ /// fire-and-forget notification it replaced, so an unresponsive test application would otherwise
+ /// block the run forever; it is bounded here instead.
+ ///
+ /// Failing to exit cleanly is never fatal: the caller disposes the client afterwards, which
+ /// tears the process down regardless.
+ ///
+ internal static void TryExit(IMtpServerClient client)
+ {
+ try
+ {
+ using var timeout = new CancellationTokenSource(ExitTimeout);
+ client.ExitAsync(timeout.Token).GetAwaiter().GetResult();
+ }
+ catch (Exception ex)
+ {
+ EqtTrace.Warning("MtpServerClientFactory.TryExit: graceful exit failed, disposing instead. {0}", ex);
+ }
+ }
+}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerConnection.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerConnection.cs
deleted file mode 100644
index 8f2d7a0781..0000000000
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpServerConnection.cs
+++ /dev/null
@@ -1,532 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Net;
-using System.Net.Sockets;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-
-using Jsonite;
-
-using Microsoft.VisualStudio.TestPlatform.ObjectModel;
-
-namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
-
-///
-/// Manages a single Microsoft.Testing.Platform (MTP) application running in JSON-RPC server mode.
-///
-/// vstest is the JSON-RPC client here: it opens a loopback TCP listener, launches the MTP
-/// application with --server --client-port <port>, and the application connects back to
-/// the listener. Messages are framed with LSP-style Content-Length headers.
-///
-/// The wire is serialized with Jsonite rather than System.Text.Json so this client works on every
-/// framework we ship, including the .NET Framework runner (no System.Text.Json dependency and thus
-/// no binding-redirect fallout). Parsed messages are plain / object graphs.
-///
-internal sealed class MtpServerConnection : IDisposable
-{
- private readonly TcpListener _listener;
- private readonly int _port;
- private readonly ConcurrentDictionary> _pending = new();
- private readonly object _writeLock = new();
- private readonly CancellationTokenSource _cts = new();
- private readonly StringBuilder _standardError = new();
-
- private TcpClient? _client;
- private Stream? _stream;
- private Process? _process;
- private Task? _readLoop;
- private int _nextId;
- private bool _disposed;
-
- ///
- /// Raised for each testing/testUpdates/tests notification. The argument is the parsed
- /// notification params value (a ), or null when absent.
- ///
- public event Action? TestNodesUpdated;
-
- ///
- /// Raised for each client/log notification with (level, message).
- ///
- public event Action? LogReceived;
-
- public MtpServerConnection()
- {
- _listener = new TcpListener(IPAddress.Loopback, 0);
- _listener.Start();
- _port = ((IPEndPoint)_listener.LocalEndpoint).Port;
- }
-
- ///
- /// Gets the process id of the launched MTP application, or 0 if it has not been launched.
- ///
- public int ProcessId => _process?.Id ?? 0;
-
- ///
- /// Launches the MTP application in server mode and waits for it to connect back.
- ///
- public void Start(string source, IDictionary? environmentVariables, TimeSpan connectionTimeout)
- {
- var (fileName, arguments, workingDirectory) = BuildLaunch(source, _port);
- EqtTrace.Info("MtpServerConnection.Start: launching '{0} {1}' (cwd '{2}') listening on port {3}.", fileName, arguments, workingDirectory, _port);
-
- var startInfo = new ProcessStartInfo
- {
- FileName = fileName,
- Arguments = arguments,
- WorkingDirectory = workingDirectory,
- UseShellExecute = false,
- RedirectStandardError = true,
- RedirectStandardOutput = true,
- };
-
- if (environmentVariables != null)
- {
- foreach (var kvp in environmentVariables)
- {
- startInfo.Environment[kvp.Key] = kvp.Value;
- }
- }
-
- _process = new Process { StartInfo = startInfo, EnableRaisingEvents = true };
- _process.ErrorDataReceived += (_, e) =>
- {
- if (e.Data != null)
- {
- lock (_standardError)
- {
- _standardError.AppendLine(e.Data);
- }
- }
- };
- _process.Start();
- _process.BeginErrorReadLine();
- // Drain stdout so the child never blocks on a full pipe (banner, diagnostics).
- _process.BeginOutputReadLine();
-
- var acceptTask = _listener.AcceptTcpClientAsync();
- if (!acceptTask.Wait(connectionTimeout))
- {
- throw new TimeoutException($"The Microsoft.Testing.Platform application '{source}' did not connect back within {connectionTimeout.TotalSeconds:N0}s. {GetStandardError()}");
- }
-
- _client = acceptTask.GetAwaiter().GetResult();
- _client.NoDelay = true;
- _stream = _client.GetStream();
- _readLoop = Task.Run(() => ReadLoopAsync(_cts.Token));
- }
-
- ///
- /// Sends a JSON-RPC request and awaits the response.
- ///
- public async Task InvokeAsync(string method, object? parameters, CancellationToken cancellationToken)
- {
- int id = Interlocked.Increment(ref _nextId);
- var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
- _pending[id] = tcs;
-
- var envelope = new Dictionary
- {
- ["jsonrpc"] = "2.0",
- ["id"] = id,
- ["method"] = method,
- ["params"] = parameters ?? new Dictionary(),
- };
-
- WriteMessage(envelope);
-
- using var registration = cancellationToken.Register(static state => ((TaskCompletionSource)state!).TrySetCanceled(), tcs);
- try
- {
- return await tcs.Task.ConfigureAwait(false);
- }
- finally
- {
- _pending.TryRemove(id, out _);
- }
- }
-
- ///
- /// Sends a JSON-RPC notification (no response expected).
- ///
- public void SendNotification(string method, object? parameters)
- {
- var envelope = new Dictionary
- {
- ["jsonrpc"] = "2.0",
- ["method"] = method,
- ["params"] = parameters ?? new Dictionary(),
- };
- WriteMessage(envelope);
- }
-
- public string GetStandardError()
- {
- lock (_standardError)
- {
- var text = _standardError.ToString().Trim();
- return text.Length == 0 ? string.Empty : $"Standard error: {text}";
- }
- }
-
- private void WriteMessage(Dictionary envelope)
- {
- if (_stream is null)
- {
- throw new InvalidOperationException("MTP connection has not been established.");
- }
-
- string json = Json.Serialize(envelope);
- byte[] body = Encoding.UTF8.GetBytes(json);
- byte[] header = Encoding.ASCII.GetBytes($"{MtpConstants.ContentLengthHeader} {body.Length}\r\nContent-Type: {MtpConstants.ContentType}\r\n\r\n");
-
- lock (_writeLock)
- {
- _stream.Write(header, 0, header.Length);
- _stream.Write(body, 0, body.Length);
- _stream.Flush();
- }
- }
-
- private async Task ReadLoopAsync(CancellationToken cancellationToken)
- {
- Debug.Assert(_stream != null, "Stream must be set before the read loop starts.");
- try
- {
- while (!cancellationToken.IsCancellationRequested)
- {
- int contentLength = await ReadHeadersAsync(_stream!, cancellationToken).ConfigureAwait(false);
- if (contentLength < 0)
- {
- break; // stream closed
- }
-
- byte[] body = await ReadExactlyAsync(_stream!, contentLength, cancellationToken).ConfigureAwait(false);
- if (body.Length < contentLength)
- {
- break; // stream closed mid-message
- }
-
- Dispatch(body);
- }
- }
- catch (OperationCanceledException)
- {
- }
- catch (Exception ex) when (ex is IOException or ObjectDisposedException or SocketException)
- {
- // Connection closed; fail any pending requests below.
- }
- catch (Exception ex)
- {
- EqtTrace.Error("MtpServerConnection.ReadLoopAsync: unexpected error: {0}", ex);
- }
- finally
- {
- FailPending(new IOException($"The MTP connection was closed. {GetStandardError()}"));
- }
- }
-
- private void Dispatch(byte[] body)
- {
- object? parsed;
- try
- {
- parsed = Json.Deserialize(Encoding.UTF8.GetString(body));
- }
- catch (JsonException ex)
- {
- EqtTrace.Error("MtpServerConnection.Dispatch: failed to parse message: {0}", ex);
- return;
- }
-
- if (parsed is not JsonObject root)
- {
- return;
- }
-
- int? id = root.TryGetValue("id", out object? idValue) && MtpJson.TryToInt(idValue, out int parsedId)
- ? parsedId
- : (int?)null;
-
- if (root.TryGetValue("method", out object? methodValue) && methodValue is string method)
- {
- object? parameters = root.TryGetValue("params", out object? p) ? p : null;
- HandleServerMessage(method, parameters, id);
- return;
- }
-
- if (id is int responseId && _pending.TryGetValue(responseId, out var tcs))
- {
- if (root.TryGetValue("error", out object? errorValue) && errorValue is JsonObject error)
- {
- string message = error.TryGetValue("message", out object? m) && m is string ms ? ms : "unknown error";
- tcs.TrySetException(new InvalidOperationException($"MTP request '{responseId}' failed: {message}"));
- }
- else
- {
- object? result = root.TryGetValue("result", out object? r) ? r : null;
- tcs.TrySetResult(result);
- }
- }
- }
-
- private void HandleServerMessage(string method, object? parameters, int? id)
- {
- switch (method)
- {
- case MtpConstants.TestUpdatesTestsMethod:
- TestNodesUpdated?.Invoke(parameters);
- break;
-
- case MtpConstants.ClientLogMethod:
- JsonObject? logParams = MtpJson.AsObject(parameters);
- string level = MtpJson.GetString(logParams, "level") ?? "Information";
- string message = MtpJson.GetString(logParams, "message") ?? string.Empty;
- LogReceived?.Invoke(level, message);
- break;
-
- default:
- // Requests from the server (e.g. client/attachDebugger, client/launchDebugger) must be
- // answered so the server does not block. We never request debugging, so decline.
- if (id.HasValue)
- {
- var response = new Dictionary
- {
- ["jsonrpc"] = "2.0",
- ["id"] = id.Value,
- ["result"] = new Dictionary { ["success"] = false },
- };
- try
- {
- WriteMessage(response);
- }
- catch (Exception ex)
- {
- EqtTrace.Warning("MtpServerConnection.HandleServerMessage: failed to answer '{0}': {1}", method, ex);
- }
- }
-
- break;
- }
- }
-
- private static async Task ReadHeadersAsync(Stream stream, CancellationToken cancellationToken)
- {
- int contentLength = -1;
- while (true)
- {
- string? line = await ReadAsciiLineAsync(stream, cancellationToken).ConfigureAwait(false);
- if (line is null)
- {
- return -1; // stream closed
- }
-
- if (line.Length == 0)
- {
- return contentLength; // blank line terminates headers
- }
-
- if (line.StartsWith(MtpConstants.ContentLengthHeader, StringComparison.OrdinalIgnoreCase))
- {
- _ = int.TryParse(line.Substring(MtpConstants.ContentLengthHeader.Length).Trim(), out contentLength);
- }
- }
- }
-
- private static async Task ReadAsciiLineAsync(Stream stream, CancellationToken cancellationToken)
- {
- var bytes = new List(64);
- var one = new byte[1];
- while (true)
- {
- int read = await stream.ReadAsync(one, 0, 1, cancellationToken).ConfigureAwait(false);
- if (read == 0)
- {
- return bytes.Count == 0 ? null : Encoding.ASCII.GetString(bytes.ToArray());
- }
-
- if (one[0] == (byte)'\n')
- {
- if (bytes.Count > 0 && bytes[bytes.Count - 1] == (byte)'\r')
- {
- bytes.RemoveAt(bytes.Count - 1);
- }
-
- return Encoding.ASCII.GetString(bytes.ToArray());
- }
-
- bytes.Add(one[0]);
- }
- }
-
- private static async Task ReadExactlyAsync(Stream stream, int count, CancellationToken cancellationToken)
- {
- var buffer = new byte[count];
- int offset = 0;
- while (offset < count)
- {
- int read = await stream.ReadAsync(buffer, offset, count - offset, cancellationToken).ConfigureAwait(false);
- if (read == 0)
- {
- Array.Resize(ref buffer, offset);
- break;
- }
-
- offset += read;
- }
-
- return buffer;
- }
-
- private void FailPending(Exception exception)
- {
- foreach (var kvp in _pending)
- {
- kvp.Value.TrySetException(exception);
- }
-
- _pending.Clear();
- }
-
- internal static (string fileName, string arguments, string workingDirectory) BuildLaunch(string source, int port)
- {
- string serverArgs = $"{MtpConstants.ServerArgument} {MtpConstants.ClientPortArgument} {port} {MtpConstants.NoBannerArgument}";
- string workingDirectory = Path.GetDirectoryName(source) ?? Directory.GetCurrentDirectory();
- string extension = Path.GetExtension(source);
-
- if (extension.Equals(".exe", StringComparison.OrdinalIgnoreCase))
- {
- return (source, serverArgs, workingDirectory);
- }
-
- // A .NET MTP app is typically shipped as a dll with a sibling native apphost. Prefer the
- // apphost if it is a usable executable for this platform, otherwise fall back to
- // `dotnet `. The apphost file name is OS-specific: `Foo.exe` on Windows, but an
- // extension-less `Foo` on Unix. Probing for `.exe` unconditionally is wrong on Unix: a
- // payload built on Windows and run on Unix (for example tests built on a Windows agent and
- // executed on a Linux Helix machine) can drag a Windows PE `Foo.exe` next to the dll.
- // Launching that yields "Permission denied" (or "Exec format error" once it is +x), so the
- // probe must be OS-aware and, on Unix, insist the candidate is actually executable.
-#if NETFRAMEWORK
- // .NET Framework only runs on Windows, where the apphost is .exe.
- string apphost = Path.ChangeExtension(source, ".exe");
-#else
- string apphost = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
- ? Path.ChangeExtension(source, ".exe")
- : Path.ChangeExtension(source, null);
-#endif
-
- return IsUsableApphost(apphost)
- ? (apphost, serverArgs, workingDirectory)
- : ("dotnet", $"\"{source}\" {serverArgs}", workingDirectory);
- }
-
- ///
- /// Determines whether can be launched directly as a native executable
- /// on the current platform. On Windows, presence is sufficient. On Unix, when built for a target
- /// framework that exposes File.GetUnixFileMode (.NET 7+), the file must also
- /// carry an execute bit; a file that merely exists (for example a Windows PE copied onto Unix) is
- /// not a usable apphost and the caller should fall back to dotnet <dll>. On target
- /// frameworks without that API (e.g. netstandard2.0) this degrades to an existence-only check —
- /// the OS-aware probe in already avoids the Windows-.exe-on-Unix
- /// case, so the execute-bit check is defence-in-depth rather than the primary guard.
- ///
- internal static bool IsUsableApphost(string apphost)
- {
- if (!File.Exists(apphost))
- {
- return false;
- }
-
-#if NET
- if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
- {
- const UnixFileMode executeBits = UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute;
- return (File.GetUnixFileMode(apphost) & executeBits) != 0;
- }
-#endif
- return true;
- }
-
- public void Dispose()
- {
- if (_disposed)
- {
- return;
- }
-
- _disposed = true;
-
- try
- {
- _cts.Cancel();
- }
- catch
- {
- // ignore
- }
-
- try
- {
- _stream?.Dispose();
- }
- catch
- {
- // ignore
- }
-
- try
- {
- _client?.Dispose();
- }
- catch
- {
- // ignore
- }
-
- try
- {
- _listener.Stop();
- }
- catch
- {
- // ignore
- }
-
- try
- {
- if (_process is { HasExited: false })
- {
-#if NETCOREAPP
- _process.Kill(entireProcessTree: true);
-#else
- _process.Kill();
-#endif
- }
- }
- catch
- {
- // ignore
- }
-
- try
- {
- _process?.Dispose();
- }
- catch
- {
- // ignore
- }
-
- _cts.Dispose();
- }
-}
diff --git a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpTestNodeConverter.cs b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpTestNodeConverter.cs
index d84b11c4d2..865f369681 100644
--- a/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpTestNodeConverter.cs
+++ b/src/Microsoft.TestPlatform.CrossPlatEngine/Client/MTP/MtpTestNodeConverter.cs
@@ -3,26 +3,57 @@
using System;
using System.Collections.Generic;
+using System.Globalization;
-using Jsonite;
-
+using Microsoft.Testing.Platform.ServerMode.Client;
using Microsoft.VisualStudio.TestPlatform.ObjectModel;
namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.MTP;
///
-/// Converts Microsoft.Testing.Platform (MTP) test nodes into vstest ObjectModel
+/// Converts Microsoft.Testing.Platform (MTP) test-node updates into vstest ObjectModel
/// and instances.
///
-/// The converter works purely off the MTP node shape (uid, display-name,
-/// execution-state, time.duration-ms, error.*, location.*, traits)
-/// so that an MTP application with no dependency on vstest at all still converts correctly. When the
-/// optional vstest.* bridge properties are present they are used purely as enrichment.
+/// The typed accessors cover the common fields (uid, display name,
+/// node type, execution state, error, duration). The remaining MTP node fields that vstest surfaces
+/// (standardOutput/standardError, location.*, traits, and the optional
+/// vstest.* bridge properties) are read from the raw
+/// property bag by key, so an MTP application with no dependency on vstest at all still converts
+/// correctly and the bridge properties are used purely as enrichment when present.
///
internal static class MtpTestNodeConverter
{
+ // Property used to round-trip the MTP node uid on a vstest TestCase so we can request a
+ // filtered run by uid after discovery.
+ private const string MtpUidPropertyId = "MTP.TestNode.Uid";
+
+ // Synthetic executor URI used when the app does not expose the vstest provider properties.
+ internal const string DefaultExecutorUri = "executor://MicrosoftTestingPlatform/v1";
+
+ // Raw TestNode wire keys not covered by the package's typed accessors.
+ private const string StandardOutputKey = "standardOutput";
+ private const string StandardErrorKey = "standardError";
+ private const string LocationFileKey = "location.file";
+ private const string LocationLineStartKey = "location.line-start";
+ private const string TraitsKey = "traits";
+
+ // Optional VSTest-provider properties (present only when the app still runs on the VSTestBridge).
+ private const string VsTestFullyQualifiedNameKey = "vstest.TestCase.FullyQualifiedName";
+ private const string VsTestExecutorUriKey = "vstest.original-executor-uri";
+
+ // Execution states (MTP wire values).
+ private const string StateInProgress = "in-progress";
+ private const string StatePassed = "passed";
+ private const string StateSkipped = "skipped";
+ private const string StateFailed = "failed";
+ private const string StateError = "error";
+ private const string StateTimedOut = "timed-out";
+
+ // Node type of a runnable test (leaf) as opposed to a grouping node.
+ private const string ActionNodeType = "action";
+
internal static readonly TestProperty MtpUidProperty = TestProperty.Register(
- MtpConstants.MtpUidPropertyId,
+ MtpUidPropertyId,
"MTP Uid",
typeof(string),
typeof(TestCase));
@@ -31,53 +62,53 @@ internal static class MtpTestNodeConverter
/// Returns true when the node represents a runnable test (a leaf "action" node) rather than a
/// grouping node (namespace/class/suite).
///
- public static bool IsActionNode(JsonObject node)
- => MtpJson.GetString(node, MtpConstants.NodeType) is "action";
-
- public static string? GetExecutionState(JsonObject node)
- => MtpJson.GetString(node, MtpConstants.ExecutionState);
+ public static bool IsActionNode(MtpTestNodeUpdate update)
+ => update.NodeType is ActionNodeType;
- public static TestCase ToTestCase(JsonObject node, string source)
+ public static TestCase ToTestCase(MtpTestNodeUpdate update, string source)
{
- string uid = MtpJson.GetString(node, MtpConstants.Uid) ?? Guid.NewGuid().ToString();
- string fullyQualifiedName = MtpJson.GetString(node, MtpConstants.VsTestFullyQualifiedName) ?? uid;
- string executorUri = MtpJson.GetString(node, MtpConstants.VsTestExecutorUri) ?? MtpConstants.DefaultExecutorUri;
+ string? uid = update.Uid;
+ string fullyQualifiedName = GetRawString(update, VsTestFullyQualifiedNameKey)
+ ?? (uid is { Length: > 0 } ? uid : Guid.NewGuid().ToString());
+ string executorUri = GetRawString(update, VsTestExecutorUriKey) ?? DefaultExecutorUri;
var testCase = new TestCase(fullyQualifiedName, new Uri(executorUri), source)
{
- DisplayName = MtpJson.GetString(node, MtpConstants.DisplayName) ?? fullyQualifiedName,
+ DisplayName = update.DisplayName ?? fullyQualifiedName,
};
- testCase.SetPropertyValue(MtpUidProperty, uid);
+ if (uid is { Length: > 0 })
+ {
+ testCase.SetPropertyValue(MtpUidProperty, uid);
+ }
- string? file = MtpJson.GetString(node, MtpConstants.LocationFile);
+ string? file = GetRawString(update, LocationFileKey);
if (!string.IsNullOrEmpty(file))
{
testCase.CodeFilePath = file;
- if (MtpJson.TryGetInt(node, MtpConstants.LocationLineStart, out int line))
+ if (TryGetRawInt(update, LocationLineStartKey, out int line))
{
testCase.LineNumber = line;
}
}
- AddTraits(node, testCase);
+ AddTraits(update, testCase);
return testCase;
}
- public static TestResult ToTestResult(JsonObject node, string source)
+ public static TestResult ToTestResult(MtpTestNodeUpdate update, string source)
{
- var testCase = ToTestCase(node, source);
- string? state = GetExecutionState(node);
+ var testCase = ToTestCase(update, source);
var result = new TestResult(testCase)
{
- Outcome = ToOutcome(state),
+ Outcome = ToOutcome(update.ExecutionState),
DisplayName = testCase.DisplayName,
- ErrorMessage = MtpJson.GetString(node, MtpConstants.ErrorMessage),
- ErrorStackTrace = MtpJson.GetString(node, MtpConstants.ErrorStackTrace),
+ ErrorMessage = update.ErrorMessage,
+ ErrorStackTrace = update.ErrorStackTrace,
};
- if (MtpJson.TryGetDouble(node, MtpConstants.TimeDurationMs, out double durationMs))
+ if (update.DurationInMilliseconds is { } durationMs)
{
result.Duration = TimeSpan.FromMilliseconds(durationMs);
}
@@ -85,13 +116,13 @@ public static TestResult ToTestResult(JsonObject node, string source)
// Surface the test's captured standard output/error (when the MTP node carries it) as result
// messages so the console and TRX loggers show it, matching the classic path where a test's
// stdout/stderr is attached to its result.
- string? standardOutput = MtpJson.GetString(node, MtpConstants.StandardOutput);
+ string? standardOutput = GetRawString(update, StandardOutputKey);
if (!string.IsNullOrEmpty(standardOutput))
{
result.Messages.Add(new TestResultMessage(TestResultMessage.StandardOutCategory, standardOutput));
}
- string? standardError = MtpJson.GetString(node, MtpConstants.StandardError);
+ string? standardError = GetRawString(update, StandardErrorKey);
if (!string.IsNullOrEmpty(standardError))
{
result.Messages.Add(new TestResultMessage(TestResultMessage.StandardErrorCategory, standardError));
@@ -101,42 +132,109 @@ public static TestResult ToTestResult(JsonObject node, string source)
}
public static bool IsTerminalState(string? state)
- => state is MtpConstants.StatePassed
- or MtpConstants.StateFailed
- or MtpConstants.StateSkipped
- or MtpConstants.StateError
- or MtpConstants.StateTimedOut;
+ => state is StatePassed
+ or StateFailed
+ or StateSkipped
+ or StateError
+ or StateTimedOut;
+
+ public static bool IsInProgressState(string? state)
+ => state is StateInProgress;
private static TestOutcome ToOutcome(string? state)
=> state switch
{
- MtpConstants.StatePassed => TestOutcome.Passed,
- MtpConstants.StateFailed => TestOutcome.Failed,
- MtpConstants.StateError => TestOutcome.Failed,
- MtpConstants.StateTimedOut => TestOutcome.Failed,
- MtpConstants.StateSkipped => TestOutcome.Skipped,
+ StatePassed => TestOutcome.Passed,
+ StateFailed => TestOutcome.Failed,
+ StateError => TestOutcome.Failed,
+ StateTimedOut => TestOutcome.Failed,
+ StateSkipped => TestOutcome.Skipped,
_ => TestOutcome.None,
};
- private static void AddTraits(JsonObject node, TestCase testCase)
+ private static void AddTraits(MtpTestNodeUpdate update, TestCase testCase)
{
- if (MtpJson.GetValue(node, MtpConstants.Traits) is not JsonArray traits)
+ if (!update.Node.TryGetValue(TraitsKey, out object? traitsValue) || traitsValue is not IEnumerable