public void StartTestRunShouldCallHandleTestRunCompleteOnRunCompletion() { var mockHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new TestRunCriteriaWithTests(null, null, null); var rawMessage = "ExecComplete"; var message = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; var payload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(message)).Returns(payload); var waitHandle = new AutoResetEvent(false); mockHandler.Setup(mh => mh.HandleTestRunComplete( It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set()); this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object); waitHandle.WaitOne(); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithTests, runCriteria, this.protocolConfig.Version), Times.Once); this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Once); mockHandler.Verify(mh => mh.HandleTestRunComplete(null, null, null, null), Times.Once); mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Once); }
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch) { Task.Run( delegate { try { testRequestManager.ResetOptions(); var customLauncher = skipTestHostLaunch ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }
private void OnTestRunAbort(ITestRunEventsHandler testRunEventsHandler, Exception exception) { EqtTrace.Error("Server: TestExecution: Aborting test run because {0}", exception); // log console message to vstest console testRunEventsHandler.HandleLogMessage(TestMessageLevel.Error, CommonResources.AbortedTestRun); // log console message to vstest console wrapper var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = CommonResources.AbortedTestRun }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload); testRunEventsHandler.HandleRawMessage(rawMessage); // notify test run abort to vstest console wrapper var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero); var payload = new TestRunCompletePayload { TestRunCompleteArgs = completeArgs }; rawMessage = this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, payload); testRunEventsHandler.HandleRawMessage(rawMessage); // notify of a test run complete and bail out. testRunEventsHandler.HandleTestRunComplete(completeArgs, null, null, null); this.CleanupCommunicationIfProcessExit(); }
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch) { Task.Run( delegate { try { testRequestManager.ResetOptions(); var customLauncher = skipTestHostLaunch ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); // If there is an exception during test run request creation or some time during the process // In such cases, TestPlatform will never send a TestRunComplete event and IDE need to be sent a run complete message // We need recoverability in translationlayer-designmode scenarios var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }
private void OnTestRunAbort(ITestRunEventsHandler testRunEventsHandler, Exception exception, bool getClientError) { if (this.IsOperationComplete()) { EqtTrace.Verbose("TestRequestSender: OnTestRunAbort: Operation is already complete. Skip error message."); return; } EqtTrace.Verbose("TestRequestSender: OnTestRunAbort: Set operation complete."); this.SetOperationComplete(); var reason = this.GetAbortErrorMessage(exception, getClientError); EqtTrace.Error("TestRequestSender: Aborting test run because {0}", reason); this.LogErrorMessage(string.Format(CommonResources.AbortedTestRun, reason)); // notify test run abort to vstest console wrapper. var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero); var payload = new TestRunCompletePayload { TestRunCompleteArgs = completeArgs }; var rawMessage = this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, payload); testRunEventsHandler.HandleRawMessage(rawMessage); // notify of a test run complete and bail out. testRunEventsHandler.HandleTestRunComplete(completeArgs, null, null, null); }
public void OnTestRunComplete(TestRunCompletePayload testRunComplete) { if (testRunComplete.TestRunCompleteArgs.IsAborted || testRunComplete.TestRunCompleteArgs.IsCanceled) { return; } if (testRunComplete.LastRunTests != null) { OnTestRunChanged(testRunComplete.LastRunTests); } }
public void ExecutionManagerShouldPassOnLaunchProcessWithDebuggerAttached() { Mock <ITestRunEventsHandler> mockTestRunEventsHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new Mock <TestRunCriteria>( new List <TestCase> { new TestCase("A.C.M", new System.Uri("executor://dummy"), "source.dll") }, 10); var rawMessage = "LaunchProcessWithDebugger"; var message = new Message() { MessageType = MessageType.LaunchAdapterProcessWithDebuggerAttached, Payload = null }; var payload = new TestProcessStartInfo(); this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestProcessStartInfo>(message)).Returns(payload); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; mockTestRunEventsHandler.Setup(mh => mh.LaunchProcessWithDebuggerAttached(payload)).Callback( () => { this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload); }); var waitHandle = new AutoResetEvent(false); mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunComplete( It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set()); this.testExecutionManager.StartTestRun(runCriteria.Object, mockTestRunEventsHandler.Object); waitHandle.WaitOne(); // Verify mockTestRunEventsHandler.Verify(mtdeh => mtdeh.LaunchProcessWithDebuggerAttached(It.IsAny <TestProcessStartInfo>()), Times.Once); }
public void StartTestRunShouldCallLaunchProcessWithDebuggerAndWaitForCallback() { var mockHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new TestRunCriteriaWithSources(null, null, null); var rawMessage = "LaunchProcessWithDebugger"; var message = new Message() { MessageType = MessageType.LaunchAdapterProcessWithDebuggerAttached, Payload = null }; var payload = new TestProcessStartInfo(); this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestProcessStartInfo>(message)).Returns(payload); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; mockHandler.Setup(mh => mh.LaunchProcessWithDebuggerAttached(payload)).Callback( () => { this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload); }); var waitHandle = new AutoResetEvent(false); mockHandler.Setup(mh => mh.HandleTestRunComplete( It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set()); this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object); waitHandle.WaitOne(); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria, this.protocolConfig.Version), Times.Once); this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(It.IsAny <string>()), Times.Exactly(2)); mockHandler.Verify(mh => mh.LaunchProcessWithDebuggerAttached(payload), Times.Once); mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2)); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback, It.IsAny <object>(), this.protocolConfig.Version), Times.Once); }
public void ExecutionManagerShouldPassOnTestRunStatsChange() { this.mockFileHelper.Setup(fh => fh.Exists(It.IsAny <string>())).Returns(true); Mock <ITestRunEventsHandler> mockTestRunEventsHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new Mock <TestRunCriteria>( new List <TestCase> { new TestCase("A.C.M", new System.Uri("executor://dummy"), "source.dll") }, 10); var testRunChangedArgs = new TestRunChangedEventArgs(null, null, null); this.testExecutionManager = this.GetProxyExecutionManager(); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; this.SetupChannelMessage(MessageType.StartTestExecutionWithTests, MessageType.TestRunStatsChange, testRunChangedArgs); mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunStatsChange(It.IsAny <TestRunChangedEventArgs>())).Callback( () => { this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload); this.mockDataSerializer.Setup(ds => ds.SerializeMessage(It.IsAny <string>())) .Returns(MessageType.SessionEnd); this.RaiseMessageReceived(MessageType.ExecutionComplete); }); var waitHandle = new AutoResetEvent(false); mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunComplete( It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set()); // Act. this.testExecutionManager.StartTestRun(runCriteria.Object, mockTestRunEventsHandler.Object); waitHandle.WaitOne(); // Verify mockTestRunEventsHandler.Verify(mtdeh => mtdeh.HandleTestRunStatsChange(It.IsAny <TestRunChangedEventArgs>()), Times.Once); }
public void StartTestRunWithSourcesShouldCallHandleTestRunStatsChange() { var mockHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new TestRunCriteriaWithSources(null, null, null); var testRunChangedArgs = new TestRunChangedEventArgs(null, null, null); var rawMessage = "OnTestRunStatsChange"; var message = new Message() { MessageType = MessageType.TestRunStatsChange, Payload = null }; this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunChangedEventArgs>(message)).Returns(testRunChangedArgs); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; mockHandler.Setup(mh => mh.HandleTestRunStatsChange(testRunChangedArgs)).Callback( () => { this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload); }); var waitHandle = new AutoResetEvent(false); mockHandler.Setup(mh => mh.HandleTestRunComplete(It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback (() => waitHandle.Set()); this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object); waitHandle.WaitOne(); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria), Times.Once); // One for run stats and another for runcomplete this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Exactly(2)); mockHandler.Verify(mh => mh.HandleTestRunStatsChange(testRunChangedArgs), Times.Once); mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2)); }
/// <inheritdoc/> public void SendExecutionComplete( TestRunCompleteEventArgs testRunCompleteArgs, TestRunChangedEventArgs lastChunkArgs, ICollection <AttachmentSet> runContextAttachments, ICollection <string> executorUris) { var payload = new TestRunCompletePayload { TestRunCompleteArgs = testRunCompleteArgs, LastRunTests = lastChunkArgs, RunAttachments = runContextAttachments, ExecutorUris = executorUris }; this.communicationManager.SendMessage(MessageType.ExecutionComplete, payload, this.protocolVersion); }
public void StartTestRunShouldCallHandleLogMessageOnTestMessage() { var mockHandler = new Mock <ITestRunEventsHandler>(); var runCriteria = new TestRunCriteriaWithSources(null, null, null, null); var rawMessage = "OnLogMessage"; var message = new Message() { MessageType = MessageType.TestMessage, Payload = null }; var payload = new TestMessagePayload() { MessageLevel = TestMessageLevel.Error, Message = rawMessage }; this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestMessagePayload>(message)).Returns(payload); var completePayload = new TestRunCompletePayload() { ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null }; var completeMessage = new Message() { MessageType = MessageType.ExecutionComplete, Payload = null }; var waitHandle = new AutoResetEvent(false); mockHandler.Setup(mh => mh.HandleLogMessage(TestMessageLevel.Error, rawMessage)).Callback( () => { this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage); this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Callback(() => { waitHandle.Set(); }) .Returns(completePayload); }); this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object); waitHandle.WaitOne(); this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria, this.protocolConfig.Version), Times.Once); this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(It.IsAny <string>()), Times.AtLeast(2)); // Asserting that 'StartTestRun" should have been completed, & invoked only once this.mockDataSerializer.Verify(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage), Times.Exactly(1)); mockHandler.Verify(mh => mh.HandleLogMessage(payload.MessageLevel, payload.Message), Times.Once); mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.AtLeastOnce); }
public void StartTestRunShouldStopServerOnRunCompleteMessageReceived() { var testRunCompletePayload = new TestRunCompletePayload { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue), LastRunTests = new TestRunChangedEventArgs(null, null, null), RunAttachments = new List <AttachmentSet>() }; this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload); this.SetupFakeCommunicationChannel(); this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object); this.RaiseMessageReceivedEvent(); this.mockServer.Verify(ms => ms.Stop()); }
/// <summary> /// Update raw message with telemetry info. /// </summary> /// <param name="testRunCompletePayload">Test run complete payload.</param> /// <param name="message">Updated rawMessage.</param> /// <returns></returns> private string UpdateRawMessageWithTelemetryInfo(TestRunCompletePayload testRunCompletePayload, Message message) { var rawMessage = default(string); if (this.requestData.IsTelemetryOptedIn) { if (testRunCompletePayload?.TestRunCompleteArgs != null) { if (testRunCompletePayload.TestRunCompleteArgs.Metrics == null) { testRunCompletePayload.TestRunCompleteArgs.Metrics = this.requestData.MetricsCollection.Metrics; } else { foreach (var kvp in this.requestData.MetricsCollection.Metrics) { testRunCompletePayload.TestRunCompleteArgs.Metrics[kvp.Key] = kvp.Value; } } // Fill in the time taken to complete the run var executionTotalTimeTakenForDesignMode = DateTime.UtcNow - this.executionStartTime; testRunCompletePayload.TestRunCompleteArgs.Metrics[TelemetryDataConstants.TimeTakenInSecForRun] = executionTotalTimeTakenForDesignMode.TotalSeconds; } if (message is VersionedMessage message1) { var version = message1.Version; rawMessage = this.dataSerializer.SerializePayload( MessageType.ExecutionComplete, testRunCompletePayload, version); } else { rawMessage = this.dataSerializer.SerializePayload( MessageType.ExecutionComplete, testRunCompletePayload); } } return(rawMessage); }
public void StartTestRunShouldNotNotifyExecutionCompleteIfClientDisconnectedAndOperationComplete() { var testRunCompletePayload = new TestRunCompletePayload { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue), LastRunTests = new TestRunChangedEventArgs(null, null, null), RunAttachments = new List <AttachmentSet>() }; this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload); this.SetupFakeCommunicationChannel(); this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object); this.RaiseMessageReceivedEvent(); // Raise test run complete this.RaiseClientDisconnectedEvent(); this.mockExecutionEventsHandler.Verify(eh => eh.HandleTestRunComplete(It.Is <TestRunCompleteEventArgs>(t => t.IsAborted), null, null, null), Times.Never); this.mockExecutionEventsHandler.Verify(eh => eh.HandleRawMessage("SerializedAbortedPayload"), Times.Never); }
protected void HandleParallelTestRunComplete(TestRunCompleteEventArgs completedArgs) { // In case of sequential execution - RawMessage would have contained a 'TestRunCompletePayload' object // To send a rawmessge - we need to create rawmessage from an aggregated payload object var testRunCompletePayload = new TestRunCompletePayload() { ExecutorUris = this.runDataAggregator.ExecutorUris, LastRunTests = null, RunAttachments = this.runDataAggregator.RunContextAttachments, TestRunCompleteArgs = completedArgs }; // we have to send rawmessages as we block the runcomplete actual raw messages ConvertToRawMessageAndSend(MessageType.ExecutionComplete, testRunCompletePayload); // send actual test runcomplete to clients this.actualRunEventsHandler.HandleTestRunComplete( completedArgs, null, this.runDataAggregator.RunContextAttachments, this.runDataAggregator.ExecutorUris); }
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool shouldLaunchTesthost) { Task.Run( () => { try { testRequestManager.ResetOptions(); // We must avoid re-launching the test host if the test run payload already // contains test session info. Test session info being present is an indicative // of an already running test host spawned by a start test session call. var customLauncher = shouldLaunchTesthost && testRunPayload.TestSessionInfo == null ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun( this, testRunPayload.DebuggingEnabled) : null; testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig); } catch (Exception ex) { EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex); var testMessagePayload = new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = ex.ToString() }; this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue), LastRunTests = null }; // Send run complete to translation layer this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload); } }); }
public void StartTestRunShouldNotifyExecutionCompleteOnRunCompleteMessageReceived() { var testRunCompletePayload = new TestRunCompletePayload { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue), LastRunTests = new TestRunChangedEventArgs(null, null, null), RunAttachments = new List <AttachmentSet>() }; this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload); this.SetupFakeCommunicationChannel(); this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object); this.RaiseMessageReceivedEvent(); this.mockExecutionEventsHandler.Verify( eh => eh.HandleTestRunComplete( testRunCompletePayload.TestRunCompleteArgs, testRunCompletePayload.LastRunTests, testRunCompletePayload.RunAttachments, It.IsAny <ICollection <string> >()), Times.Once); }
/// <summary> /// Handles LoggerManager's TestRunComplete. /// </summary> /// <param name="testRunCompletePayload">TestRun complete payload.</param> private void HandleLoggerManagerTestRunComplete(TestRunCompletePayload testRunCompletePayload) { if (this.LoggerManager.LoggersInitialized && testRunCompletePayload != null) { // Send last chunk to logger manager. if (testRunCompletePayload.LastRunTests != null) { this.LoggerManager.HandleTestRunStatsChange(testRunCompletePayload.LastRunTests); } // Note: In HandleRawMessage attachments are considered from TestRunCompleteArgs, while in HandleTestRunComplete attachments are considered directly from testRunCompletePayload. // Ideally we should have attachmentSets at one place only. // Send test run complete to logger manager. TestRunCompleteEventArgs testRunCompleteArgs = new TestRunCompleteEventArgs( testRunCompletePayload.TestRunCompleteArgs.TestRunStatistics, testRunCompletePayload.TestRunCompleteArgs.IsCanceled, testRunCompletePayload.TestRunCompleteArgs.IsAborted, testRunCompletePayload.TestRunCompleteArgs.Error, testRunCompletePayload.TestRunCompleteArgs.AttachmentSets, this.runRequestTimeTracker.Elapsed); this.LoggerManager.HandleTestRunComplete(testRunCompleteArgs); } }
private async void StartMessageLoop(TaskCompletionSource <object> tcs) { while (isConnected) { var message = await ReceiveMessageAsync(); if (message != null) { if (message.MessageType == MessageType.SessionConnected) { // Version Check comm.SendMessage(MessageType.VersionCheck, 1); tcs.TrySetResult(null); SendTestHostLaunched(); isConnected = true; } else if (!isConnected) { continue; } else if (message.MessageType == MessageType.StartDiscovery) { var req = comm.DeserializePayload <DiscoveryRequestPayload>(message); comm.SendMessage(MessageType.DiscoveryInitialize); var tests = ViewModels.TestRunnerVM.Instance.Tests; comm.SendMessage(MessageType.DiscoveryComplete, new DiscoveryCompletePayload() { LastDiscoveredTests = tests.Select(t => t.Test), TotalTests = tests.Count() }); } else if (message.MessageType == MessageType.TestRunSelectedTestCasesDefaultHost || message.MessageType == MessageType.TestRunAllSourcesWithDefaultHost) { var trr = comm.DeserializePayload <TestRunRequestPayload>(message); if (trr.TestCases != null) { var testsToRun = ViewModels.TestRunnerVM.Instance.Tests.Select(t => t.Test).Where(t => trr.TestCases.Any(t2 => t2.Id == t.Id)).ToList(); DateTime start = DateTime.Now; var _ = ViewModels.TestRunnerVM.Instance.Run(testsToRun, new SettingsXmlImpl(ViewModels.TestRunnerVM.Instance.Settings.AppendParameters(trr.RunSettings))).ContinueWith(task => { TimeSpan elapsedTime = DateTime.Now - start; if (task.IsCanceled) { SendMessage(MessageType.CancelTestRun); } else if (task.Exception != null) { SendMessage(MessageType.TestMessage, new TestMessagePayload { MessageLevel = TestMessageLevel.Error, Message = task.Exception.ToString() }); var runCompletePayload = new TestRunCompletePayload() { TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, task.Exception, null, TimeSpan.MinValue), LastRunTests = null }; SendMessage(MessageType.ExecutionComplete, runCompletePayload); } else { var results = task.Result; var stats = new Dictionary <TestOutcome, long>() { { TestOutcome.Passed, results.Where(t => t.Outcome == TestOutcome.Passed).Count() }, { TestOutcome.Failed, results.Where(t => t.Outcome == TestOutcome.Failed).Count() }, { TestOutcome.Skipped, results.Where(t => t.Outcome == TestOutcome.Skipped).Count() }, { TestOutcome.NotFound, results.Where(t => t.Outcome == TestOutcome.NotFound).Count() }, { TestOutcome.None, results.Where(t => t.Outcome == TestOutcome.None).Count() } }; var testRunStats = new TestRunStatistics(results.Count(), stats); var payload = new TestRunCompletePayload() { LastRunTests = new TestRunChangedEventArgs(testRunStats, results, testsToRun), RunAttachments = new List <AttachmentSet>(), TestRunCompleteArgs = new TestRunCompleteEventArgs(testRunStats, false, false, null, new System.Collections.ObjectModel.Collection <AttachmentSet>(), elapsedTime) }; SendMessage(MessageType.ExecutionComplete, payload); } }); } } else { System.Diagnostics.Debug.WriteLine($"Got message: {message.MessageType}, Payload={message.Payload}"); } } } comm.StopServer(); _ = StartAsync(); }
/// <summary> /// Handles the Run Complete event from a parallel proxy manager /// </summary> public void HandleTestRunComplete( TestRunCompleteEventArgs testRunCompleteArgs, TestRunChangedEventArgs lastChunkArgs, ICollection <AttachmentSet> runContextAttachments, ICollection <string> executorUris) { // we get run complete events from each executor process // so we cannot "complete" the actual executor operation until all sources/testcases are consumed // We should not block last chunk results while we aggregate overall run data if (lastChunkArgs != null) { ConvertToRawMessageAndSend(MessageType.TestRunStatsChange, lastChunkArgs); HandleTestRunStatsChange(lastChunkArgs); } // Update runstats, executorUris, etc. // we need this data when we send the final runcomplete runDataAggregator.Aggregate( testRunCompleteArgs.TestRunStatistics, executorUris, testRunCompleteArgs.Error, testRunCompleteArgs.ElapsedTimeInRunningTests, testRunCompleteArgs.IsAborted, testRunCompleteArgs.IsCanceled, runContextAttachments, testRunCompleteArgs.AttachmentSets); // Do not send TestRunComplete to actual test run handler // We need to see if there are still sources to execute - let the parallel manager decide var parallelRunComplete = this.parallelProxyExecutionManager.HandlePartialRunComplete( this.proxyExecutionManager, testRunCompleteArgs, null, // lastChunk should be null as we already sent this data above runContextAttachments, executorUris); if (parallelRunComplete) { // todo : Merge Code Coverage files here var completedArgs = new TestRunCompleteEventArgs(runDataAggregator.GetAggregatedRunStats(), runDataAggregator.IsCanceled, runDataAggregator.IsAborted, runDataAggregator.GetAggregatedException(), new Collection <AttachmentSet>(runDataAggregator.RunCompleteArgsAttachments), runDataAggregator.ElapsedTime); // In case of sequential execution - RawMessage would have contained a 'TestRunCompletePayload' object // To send a rawmessge - we need to create rawmessage from an aggregated payload object var testRunCompletePayload = new TestRunCompletePayload() { ExecutorUris = runDataAggregator.ExecutorUris, LastRunTests = null, RunAttachments = runDataAggregator.RunContextAttachments, TestRunCompleteArgs = completedArgs }; // we have to send rawmessages as we block the runcomplete actual raw messages ConvertToRawMessageAndSend(MessageType.ExecutionComplete, testRunCompletePayload); // send actual test runcomplete to clients this.actualRunEventsHandler.HandleTestRunComplete( completedArgs, null, runDataAggregator.RunContextAttachments, runDataAggregator.ExecutorUris); } }
/// <inheritdoc/> public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler) { this.baseTestRunEventsHandler = eventHandler; try { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize."); } var testSources = new List <string>( testRunCriteria.HasSpecificSources ? testRunCriteria.Sources // If the test execution is with a test filter, group them by sources. : testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key)); this.isCommunicationEstablished = this.ProxyOperationManager.SetupChannel( testSources, testRunCriteria.TestRunSettings); if (this.isCommunicationEstablished) { this.ProxyOperationManager.CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested(); this.InitializeExtensions(testSources); // This code should be in sync with InProcessProxyExecutionManager.StartTestRun // execution context. var executionContext = new TestExecutionContext( testRunCriteria.FrequencyOfRunStatsChangeEvent, testRunCriteria.RunStatsChangeEventTimeout, inIsolation: false, keepAlive: testRunCriteria.KeepAlive, isDataCollectionEnabled: false, areTestCaseLevelEventsRequired: false, hasTestRun: true, // Debugging should happen if there's a custom test host launcher present // and is in debugging mode, or if the debugging is enabled in case the // test session info is present. isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug) || this.debugEnabledForTestSession, testCaseFilter: testRunCriteria.TestCaseFilter, filterOptions: testRunCriteria.FilterOptions); // This is workaround for the bug https://github.com/Microsoft/vstest/issues/970 var runsettings = this.ProxyOperationManager.RemoveNodesFromRunsettingsIfRequired( testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message); }); if (testRunCriteria.HasSpecificSources) { var runRequest = testRunCriteria.CreateTestRunCriteriaForSources( testHostManager, runsettings, executionContext, testSources); this.ProxyOperationManager.RequestSender.StartTestRun(runRequest, this); } else { var runRequest = testRunCriteria.CreateTestRunCriteriaForTests( testHostManager, runsettings, executionContext, testSources); this.ProxyOperationManager.RequestSender.StartTestRun(runRequest, this); } } } catch (Exception exception) { EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception); // Log error message to design mode and CLI. // TestPlatformException is expected exception, log only the message. // For other exceptions, log the stacktrace as well. var errorMessage = exception is TestPlatformException ? exception.Message : exception.ToString(); var testMessagePayload = new TestMessagePayload() { MessageLevel = TestMessageLevel.Error, Message = errorMessage }; this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload)); this.LogMessage(TestMessageLevel.Error, errorMessage); // Send a run complete to caller. Similar logic is also used in // ParallelProxyExecutionManager.StartTestRunOnConcurrentManager. // // Aborted is `true`: in case of parallel run (or non shared host), an aborted // message ensures another execution manager created to replace the current one. // This will help if the current execution manager is aborted due to irreparable // error and the test host is lost as well. var completeArgs = new TestRunCompleteEventArgs(null, false, true, null, new Collection <AttachmentSet>(), TimeSpan.Zero); var testRunCompletePayload = new TestRunCompletePayload { TestRunCompleteArgs = completeArgs }; this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, testRunCompletePayload)); this.HandleTestRunComplete(completeArgs, null, null, null); } return(0); }