예제 #1
0
 /// <summary>
 /// Used for unit testing only.
 /// </summary>
 /// <param name="testCases"></param>
 /// <param name="package">The user input test source(package) if it differ from actual test source otherwise null.</param>
 /// <param name="testRunCache"></param>
 /// <param name="runSettings"></param>
 /// <param name="testExecutionContext"></param>
 /// <param name="testCaseEventsHandler"></param>
 /// <param name="testRunEventsHandler"></param>
 /// <param name="executorUriVsTestList"></param>
 internal RunTestsWithTests(IRequestData requestData, IEnumerable <TestCase> testCases, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, List <TestCase> > executorUriVsTestList)
     : base(requestData, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, TestPlatformEventSource.Instance)
 {
     this.testCases             = testCases;
     this.executorUriVsTestList = executorUriVsTestList;
     this.testCaseEventsHandler = testCaseEventsHandler;
 }
예제 #2
0
        /// <inheritdoc/>
        public void RunTests(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler testRunEventsHandler)
        {
            var testCaseList = testCases.ToList();

            this.testPlatformEventSource.TranslationLayerExecutionStart(0, 0, testCaseList.Count, runSettings ?? string.Empty);

            this.EnsureInitialized();
            this.requestSender.StartTestRun(testCaseList, runSettings, options, testRunEventsHandler);
        }
예제 #3
0
        /// <inheritdoc/>
        public async Task RunTestsWithCustomTestHostAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher)
        {
            var testCaseList = testCases.ToList();

            this.testPlatformEventSource.TranslationLayerExecutionStart(1, 0, testCaseList.Count, runSettings ?? string.Empty);

            await this.EnsureInitializedAsync();

            await this.requestSender.StartTestRunWithCustomHostAsync(testCaseList, runSettings, options, testRunEventsHandler, customTestHostLauncher);
        }
예제 #4
0
 internal TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings,
                                      TestExecutionContext testExecutionContext,
                                      ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList, IRequestData requestData)
     : base(requestData, adapterSourceMap, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, executorUriVsSourceList)
 {
 }
 /// <summary>
 /// Cancels the test run.
 /// </summary>
 /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param>
 public void Cancel(ITestRunEventsHandler eventHandler)
 {
     Task.Run(() => this.testHostManagerFactory.GetExecutionManager().Cancel(eventHandler));
 }
예제 #6
0
        /// <inheritdoc/>
        public async Task RunTestsAsync(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler)
        {
            var testCaseList = testCases.ToList();

            this.testPlatformEventSource.TranslationLayerExecutionStart(0, 0, testCaseList.Count, runSettings ?? string.Empty);

            await this.EnsureInitializedAsync();

            await this.requestSender.StartTestRunAsync(testCaseList, runSettings, options : null, runEventsHandler : testRunEventsHandler);
        }
예제 #7
0
 /// <inheritdoc/>
 public async Task StartTestRunAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler)
 {
     await this.SendMessageAndListenAndReportTestResultsAsync(
         MessageType.TestRunAllSourcesWithDefaultHost,
         new TestRunRequestPayload()
     {
         TestCases = testCases.ToList(), RunSettings = runSettings, TestPlatformOptions = options
     },
         runEventsHandler,
         null);
 }
예제 #8
0
 /// <summary>
 /// Executes the specified tests with the criteria mentioned.
 /// </summary>
 /// <param name="runCriteria">The test run criteria.</param>
 /// <param name="eventHandler">The handler for execution events from the test host.</param>
 public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler)
 {
     this.StartTestRunAndListenAndReportTestResults(MessageType.StartTestExecutionWithTests, runCriteria, eventHandler);
 }
예제 #9
0
        /// <inheritdoc/>
        public void RunTestsWithCustomTestHost(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher)
        {
            var sourceList = sources.ToList();

            this.testPlatformEventSource.TranslationLayerExecutionStart(1, sourceList.Count, 0, runSettings ?? string.Empty);

            this.EnsureInitialized();
            this.requestSender.StartTestRunWithCustomHost(sourceList, runSettings, testRunEventsHandler, customTestHostLauncher);
        }
예제 #10
0
 /// <inheritdoc/>
 public void StartTestRun(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler)
 {
     this.SendMessageAndListenAndReportTestResults(
         MessageType.TestRunAllSourcesWithDefaultHost,
         new TestRunRequestPayload()
     {
         Sources = sources.ToList(), RunSettings = runSettings, TestPlatformOptions = options
     },
         runEventsHandler,
         null);
 }
예제 #11
0
 internal TestableRunTestsWithTests(IEnumerable <TestCase> testCases, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, List <TestCase> > executorUriVsTestList, IRequestData requestData)
     : base(
         requestData, testCases, null, runSettings, testExecutionContext,
         testCaseEventsHandler, testRunEventsHandler, executorUriVsTestList)
 {
 }
예제 #12
0
 public TestableRunTestsWithTests(IEnumerable <TestCase> testCases,
                                  string runSettings, TestExecutionContext testExecutionContext,
                                  ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler,
                                  IRequestData requestData)
     : base(requestData, testCases, null, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler)
 {
 }
예제 #13
0
 /// <inheritdoc/>
 public void RunTestsWithCustomTestHost(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher)
 {
     this.RunTestsWithCustomTestHost(sources, runSettings, options: null, testRunEventsHandler: testRunEventsHandler, customTestHostLauncher: customTestHostLauncher);
 }
예제 #14
0
 /// <inheritdoc/>
 public void RunTests(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler)
 {
     this.EnsureInitialized();
     this.requestSender.StartTestRun(testCases, runSettings, testRunEventsHandler);
 }
예제 #15
0
 /// <inheritdoc/>
 public async Task StartTestRunWithCustomHostAsync(IEnumerable <TestCase> testCases, string runSettings, TestPlatformOptions options, ITestRunEventsHandler runEventsHandler, ITestHostLauncher customHostLauncher)
 {
     await this.SendMessageAndListenAndReportTestResultsAsync(
         MessageType.GetTestRunnerProcessStartInfoForRunSelected,
         new TestRunRequestPayload()
     {
         TestCases           = testCases.ToList(),
         RunSettings         = runSettings,
         DebuggingEnabled    = customHostLauncher.IsDebug,
         TestPlatformOptions = options
     },
         runEventsHandler,
         customHostLauncher);
 }
예제 #16
0
 /// <inheritdoc/>
 public void RunTestsWithCustomTestHost(IEnumerable <TestCase> testCases, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher)
 {
     this.EnsureInitialized();
     this.requestSender.StartTestRunWithCustomHost(testCases, runSettings, testRunEventsHandler, customTestHostLauncher);
 }
예제 #17
0
        private async Task SendMessageAndListenAndReportTestResultsAsync(string messageType, object payload, ITestRunEventsHandler eventHandler, ITestHostLauncher customHostLauncher)
        {
            try
            {
                this.communicationManager.SendMessage(messageType, payload, this.protocolVersion);
                var isTestRunComplete = false;

                // Cycle through the messages that the testhost sends.
                // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
                while (!isTestRunComplete)
                {
                    var message = await this.TryReceiveMessageAsync();

                    if (string.Equals(MessageType.TestRunStatsChange, message.MessageType))
                    {
                        var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(
                            message);
                        eventHandler.HandleTestRunStatsChange(testRunChangedArgs);
                    }
                    else if (string.Equals(MessageType.ExecutionComplete, message.MessageType))
                    {
                        var testRunCompletePayload =
                            this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);

                        eventHandler.HandleTestRunComplete(
                            testRunCompletePayload.TestRunCompleteArgs,
                            testRunCompletePayload.LastRunTests,
                            testRunCompletePayload.RunAttachments,
                            testRunCompletePayload.ExecutorUris);
                        isTestRunComplete = true;
                    }
                    else if (string.Equals(MessageType.TestMessage, message.MessageType))
                    {
                        var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
                        eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
                    }
                    else if (string.Equals(MessageType.CustomTestHostLaunch, message.MessageType))
                    {
                        HandleCustomHostLaunch(customHostLauncher, message);
                    }
                }
            }
            catch (Exception exception)
            {
                EqtTrace.Error("Aborting Test Run Operation: {0}", exception);
                eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsRun);
                var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero);
                eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
                this.CleanupCommunicationIfProcessExit();
            }

            this.testPlatformEventSource.TranslationLayerExecutionStop();
        }
예제 #18
0
        private void ListenAndReportTestResults(ITestRunEventsHandler testRunEventsHandler)
        {
            var isTestRunComplete = false;

            // Cycle through the messages that the testhost sends.
            // Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
            while (!isTestRunComplete)
            {
                try
                {
                    var rawMessage = this.TryReceiveRawMessage();

                    // Send raw message first to unblock handlers waiting to send message to IDEs
                    testRunEventsHandler.HandleRawMessage(rawMessage);

                    var message = this.dataSerializer.DeserializeMessage(rawMessage);
                    if (string.Equals(MessageType.TestRunStatsChange, message.MessageType))
                    {
                        var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(
                            message);
                        testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs);
                    }
                    else if (string.Equals(MessageType.ExecutionComplete, message.MessageType))
                    {
                        var testRunCompletePayload =
                            this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);

                        testRunEventsHandler.HandleTestRunComplete(
                            testRunCompletePayload.TestRunCompleteArgs,
                            testRunCompletePayload.LastRunTests,
                            testRunCompletePayload.RunAttachments,
                            testRunCompletePayload.ExecutorUris);
                        isTestRunComplete = true;
                    }
                    else if (string.Equals(MessageType.TestMessage, message.MessageType))
                    {
                        var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
                        testRunEventsHandler.HandleLogMessage(
                            testMessagePayload.MessageLevel,
                            testMessagePayload.Message);
                    }
                    else if (string.Equals(MessageType.LaunchAdapterProcessWithDebuggerAttached, message.MessageType))
                    {
                        var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message);
                        int processId            = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);

                        this.communicationManager.SendMessage(
                            MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback,
                            processId,
                            version: this.protocolVersion);
                    }
                }
                catch (IOException exception)
                {
                    // To avoid further communication with remote host
                    this.sendMessagesToRemoteHost = false;

                    this.OnTestRunAbort(testRunEventsHandler, exception);
                    isTestRunComplete = true;
                }
                catch (Exception exception)
                {
                    this.OnTestRunAbort(testRunEventsHandler, exception);
                    isTestRunComplete = true;
                }
            }
        }
예제 #19
0
        private void OnExecutionMessageReceived(object sender, MessageReceivedEventArgs messageReceived, ITestRunEventsHandler testRunEventsHandler)
        {
            try
            {
                var rawMessage = messageReceived.Data;
                if (EqtTrace.IsVerboseEnabled)
                {
                    EqtTrace.Verbose("TestRequestSender.OnExecutionMessageReceived: Received message: {0}", rawMessage);
                }

                // Send raw message first to unblock handlers waiting to send message to IDEs
                testRunEventsHandler.HandleRawMessage(rawMessage);

                var message = this.dataSerializer.DeserializeMessage(rawMessage);
                switch (message.MessageType)
                {
                case MessageType.TestRunStatsChange:
                    var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(message);
                    testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs);
                    break;

                case MessageType.ExecutionComplete:
                    var testRunCompletePayload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);

                    testRunEventsHandler.HandleTestRunComplete(
                        testRunCompletePayload.TestRunCompleteArgs,
                        testRunCompletePayload.LastRunTests,
                        testRunCompletePayload.RunAttachments,
                        testRunCompletePayload.ExecutorUris);

                    this.SetOperationComplete();
                    break;

                case MessageType.TestMessage:
                    var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
                    testRunEventsHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
                    break;

                case MessageType.LaunchAdapterProcessWithDebuggerAttached:
                    var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message);
                    int processId            = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);

                    var data =
                        this.dataSerializer.SerializePayload(
                            MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback,
                            processId,
                            this.protocolVersion);
                    if (EqtTrace.IsVerboseEnabled)
                    {
                        EqtTrace.Verbose("TestRequestSender.OnExecutionMessageReceived: Sending LaunchAdapterProcessWithDebuggerAttachedCallback message: {0}", data);
                    }

                    this.channel.Send(data);
                    break;
                }
            }
            catch (Exception exception)
            {
                this.OnTestRunAbort(testRunEventsHandler, exception, false);
            }
        }
예제 #20
0
 /// <inheritdoc/>
 public async Task RunTestsAsync(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler)
 {
     await RunTestsAsync(sources, runSettings, null, testRunEventsHandler);
 }
예제 #21
0
 public RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler)
     : this(requestData, adapterSourceMap, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, null)
 {
 }
예제 #22
0
 /// <inheritdoc/>
 public async Task RunTestsWithCustomTestHostAsync(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler, ITestHostLauncher customTestHostLauncher)
 {
     await RunTestsWithCustomTestHostAsync(sources, runSettings, null, testRunEventsHandler, customTestHostLauncher);
 }
예제 #23
0
 /// <summary>
 /// Used for unit testing only.
 /// </summary>
 /// <param name="requestData"></param>
 /// <param name="adapterSourceMap"></param>
 /// <param name="package">The user input test source(package) if it differ from actual test source otherwise null.</param>
 /// <param name="runSettings"></param>
 /// <param name="testExecutionContext"></param>
 /// <param name="testCaseEventsHandler"></param>
 /// <param name="testRunEventsHandler"></param>
 /// <param name="executorUriVsSourceList"></param>
 /// <param name="testRunCache"></param>
 internal RunTestsWithSources(IRequestData requestData, Dictionary <string, IEnumerable <string> > adapterSourceMap, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, Dictionary <Tuple <Uri, string>, IEnumerable <string> > executorUriVsSourceList)
     : base(requestData, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, TestPlatformEventSource.Instance)
 {
     this.adapterSourceMap        = adapterSourceMap;
     this.executorUriVsSourceList = executorUriVsSourceList;
     this.testCaseEventsHandler   = testCaseEventsHandler;
 }
예제 #24
0
        /// <summary>
        /// Starts the test run
        /// </summary>
        /// <param name="testRunCriteria"> The settings/options for the test run. </param>
        /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param>
        /// <returns> The process id of the runner executing tests. </returns>
        public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler)
        {
            try
            {
                var executionEngineStartTime = DateTime.UtcNow;

                if (EqtTrace.IsVerboseEnabled)
                {
                    EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize.");
                }

                var testPackages = 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.SetupChannel(testPackages, this.cancellationTokenSource.Token);

                if (this.isCommunicationEstablished)
                {
                    if (this.cancellationTokenSource.IsCancellationRequested)
                    {
                        if (EqtTrace.IsVerboseEnabled)
                        {
                            EqtTrace.Verbose("ProxyExecutionManager.StartTestRun: Canceling the current run after getting cancelation request.");
                        }
                        throw new TestPlatformException(Resources.Resources.CancelationRequested);
                    }

                    this.InitializeExtensions(testPackages);

                    // Collecting Time Taken to Start Discovery Engine
                    var executionEngineTotalTime = DateTime.UtcNow - executionEngineStartTime;

                    // Collecting Data Point for Time taken to start Execution Engine. In case of Parallel, it will be maximum time taken.
                    this.requestData.MetricsCollection.Add(TelemetryDataConstants.TimeTakenToStartExecutionEngineExe, executionEngineTotalTime.TotalSeconds.ToString());

                    // This code should be in sync with InProcessProxyExecutionManager.StartTestRun executionContext
                    var executionContext = new TestExecutionContext(
                        testRunCriteria.FrequencyOfRunStatsChangeEvent,
                        testRunCriteria.RunStatsChangeEventTimeout,
                        inIsolation: false,
                        keepAlive: testRunCriteria.KeepAlive,
                        isDataCollectionEnabled: false,
                        areTestCaseLevelEventsRequired: false,
                        hasTestRun: true,
                        isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug),
                        testCaseFilter: testRunCriteria.TestCaseFilter);

                    // This is workaround for the bug https://github.com/Microsoft/vstest/issues/970
                    var runsettings = this.RemoveNodesFromRunsettingsIfRequired(testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message, eventHandler); });

                    if (testRunCriteria.HasSpecificSources)
                    {
                        var runRequest = testRunCriteria.CreateTestRunCriteriaForSources(testHostManager, runsettings, executionContext, testPackages);

                        this.RequestSender.StartTestRun(runRequest, eventHandler);
                    }
                    else
                    {
                        var runRequest = testRunCriteria.CreateTestRunCriteriaForTests(testHostManager, runsettings, executionContext, testPackages);

                        this.RequestSender.StartTestRun(runRequest, eventHandler);
                    }
                }
            }
            catch (Exception exception)
            {
                EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception);
                this.LogMessage(TestMessageLevel.Error, exception.Message, eventHandler);

                // 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, exception, new Collection <AttachmentSet>(), TimeSpan.Zero);
                eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
            }

            return(0);
        }
예제 #25
0
        /// <summary>
        /// Starts the test run
        /// </summary>
        /// <param name="testRunCriteria"> The settings/options for the test run. </param>
        /// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param>
        /// <returns> The process id of the runner executing tests. </returns>
        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 testPackages = 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.SetupChannel(testPackages);

                if (this.isCommunicationEstablished)
                {
                    this.CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested();

                    this.InitializeExtensions(testPackages);

                    // This code should be in sync with InProcessProxyExecutionManager.StartTestRun executionContext
                    var executionContext = new TestExecutionContext(
                        testRunCriteria.FrequencyOfRunStatsChangeEvent,
                        testRunCriteria.RunStatsChangeEventTimeout,
                        inIsolation: false,
                        keepAlive: testRunCriteria.KeepAlive,
                        isDataCollectionEnabled: false,
                        areTestCaseLevelEventsRequired: false,
                        hasTestRun: true,
                        isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug),
                        testCaseFilter: testRunCriteria.TestCaseFilter,
                        filterOptions: testRunCriteria.FilterOptions);

                    // This is workaround for the bug https://github.com/Microsoft/vstest/issues/970
                    var runsettings = this.RemoveNodesFromRunsettingsIfRequired(testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message); });

                    if (testRunCriteria.HasSpecificSources)
                    {
                        var runRequest = testRunCriteria.CreateTestRunCriteriaForSources(testHostManager, runsettings, executionContext, testPackages);
                        this.RequestSender.StartTestRun(runRequest, this);
                    }
                    else
                    {
                        var runRequest = testRunCriteria.CreateTestRunCriteriaForTests(testHostManager, runsettings, executionContext, testPackages);
                        this.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);
        }
예제 #26
0
 public RunTestsWithTests(IRequestData requestData, IEnumerable <TestCase> testCases, string package, string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler)
     : this(requestData, testCases, package, runSettings, testExecutionContext, testCaseEventsHandler, testRunEventsHandler, null)
 {
 }
예제 #27
0
        /// <summary>
        /// Initializes a new instance of the <see cref="BaseRunTests"/> class.
        /// </summary>
        /// <param name="runSettings"> The run settings. </param>
        /// <param name="testExecutionContext"> The test execution context. </param>
        /// <param name="testCaseEventsHandler"> The test case events handler. </param>
        /// <param name="testRunEventsHandler"> The test run events handler. </param>
        /// <param name="testPlatformEventSource"></param>
        protected BaseRunTests(string runSettings, TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler, ITestPlatformEventSource testPlatformEventSource)
        {
            this.runSettings           = runSettings;
            this.testExecutionContext  = testExecutionContext;
            this.testCaseEventsHandler = testCaseEventsHandler;
            this.testRunEventsHandler  = testRunEventsHandler;

            this.isCancellationRequested = false;
            this.testPlatformEventSource = testPlatformEventSource;
            this.SetContext();
        }
예제 #28
0
 public TestableRunTestsWithSources(Dictionary <string, IEnumerable <string> > adapterSourceMap, string runSettings,
                                    TestExecutionContext testExecutionContext, ITestCaseEventsHandler testCaseEventsHandler, ITestRunEventsHandler testRunEventsHandler)
     : base(
         adapterSourceMap, runSettings, testExecutionContext, testCaseEventsHandler,
         testRunEventsHandler)
 {
 }
예제 #29
0
 /// <inheritdoc/>
 public void RunTests(IEnumerable <string> sources, string runSettings, ITestRunEventsHandler testRunEventsHandler)
 {
     this.RunTests(sources, runSettings, options: null, testRunEventsHandler: testRunEventsHandler);
 }