internal UseVsixExtensionsArgumentExecutor(CommandLineOptions commandLineOptions, ITestRequestManager testRequestManager, IVSExtensionManager extensionManager, IOutput output)
 {
     this.commandLineOptions = commandLineOptions;
     this.testRequestManager = testRequestManager;
     this.extensionManager   = extensionManager;
     this.output             = output;
 }
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="options">
 /// The options.
 /// </param>
 public ListFullyQualifiedTestsArgumentExecutor(
     CommandLineOptions options,
     IRunSettingsProvider runSettingsProvider,
     ITestRequestManager testRequestManager) :
     this(options, runSettingsProvider, testRequestManager, ConsoleOutput.Instance)
 {
 }
        private void StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
        {
            Task.Run(
                delegate
            {
                try
                {
                    testRequestManager.ResetOptions();
                    testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);

                    // If there is an exception during test discovery request creation or some time during the process
                    // In such cases, TestPlatform will never send a DiscoveryComplete event and IDE need to be sent a discovery 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 payload = new DiscoveryCompletePayload()
                    {
                        IsAborted           = true,
                        LastDiscoveredTests = null,
                        TotalTests          = -1
                    };

                    // Send run complete to translation layer
                    this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
                }
            });
        }
        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 RunSpecificTestsArgumentExecutor GetExecutor(ITestRequestManager testRequestManager)
        {
            var runSettingsProvider = new TestableRunSettingsProvider();

            runSettingsProvider.AddDefaultRunSettings();
            return(new RunSpecificTestsArgumentExecutor(CommandLineOptions.Instance, runSettingsProvider, testRequestManager, this.mockOutput.Object));
        }
Exemple #6
0
        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 StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
        {
            Task.Run(
                delegate
            {
                try
                {
                    testRequestManager.ResetOptions();
                    testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);

                    var testMessagePayload = new TestMessagePayload {
                        MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
                    };
                    this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);

                    var payload = new DiscoveryCompletePayload()
                    {
                        IsAborted           = true,
                        LastDiscoveredTests = null,
                        TotalTests          = -1
                    };

                    // Send run complete to translation layer
                    this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
                }
            });
        }
        /// <summary>
        /// Creates a client and waits for server to accept connection asynchronously
        /// </summary>
        /// <param name="port">
        /// Port number to connect
        /// </param>
        /// <param name="testRequestManager">
        /// The test Request Manager.
        /// </param>
        public void ConnectToClientAndProcessRequests(int port, ITestRequestManager testRequestManager)
        {
            EqtTrace.Info("Trying to connect to server on port : {0}", port);
            this.communicationManager.SetupClientAsync(new IPEndPoint(IPAddress.Loopback, port));

            var connectionTimeoutInSecs = EnvironmentHelper.GetConnectionTimeout();

            // Wait for the connection to the server and listen for requests.
            if (this.communicationManager.WaitForServerConnection(connectionTimeoutInSecs * 1000))
            {
                this.communicationManager.SendMessage(MessageType.SessionConnected);
                this.ProcessRequests(testRequestManager);
            }
            else
            {
                EqtTrace.Error("DesignModeClient : ConnectToClientAndProcessRequests : Client timed out while connecting to the server.");
                this.Dispose();
                throw new TimeoutException(
                          string.Format(
                              CultureInfo.CurrentUICulture,
                              CommunicationUtilitiesResources.ConnectionTimeoutErrorMessage,
                              CoreUtilitiesConstants.VstestConsoleProcessName,
                              "translation layer",
                              connectionTimeoutInSecs,
                              EnvironmentHelper.VstestConnectionTimeout)
                          );
            }
        }
Exemple #9
0
 /// <summary>
 /// For Unit testing only
 /// </summary>
 internal PortArgumentExecutor(CommandLineOptions options, ITestRequestManager testRequestManager, Func <int, IDesignModeClient> designModeInitializer)
 {
     Contract.Requires(options != null);
     this.commandLineOptions    = options;
     this.testRequestManager    = testRequestManager;
     this.designModeInitializer = designModeInitializer;
 }
 public void TestInit()
 {
     this.mockTestPlatform            = new Mock <ITestPlatform>();
     this.mockTestPlatformEventSource = new Mock <ITestPlatformEventSource>();
     this.testRequestManager          = new TestRequestManager(CommandLineOptions.Instance,
                                                               this.mockTestPlatform.Object,
                                                               TestLoggerManager.Instance,
                                                               TestRunResultAggregator.Instance,
                                                               this.mockTestPlatformEventSource.Object);
 }
Exemple #11
0
        public void RunTestsWithSourcesShouldCallTestPlatformAndSucceed()
        {
            var payload = new TestRunRequestPayload()
            {
                Sources = new List <string>()
                {
                    "a", "b"
                }
            };

            var             createRunRequestCalled = 0;
            TestRunCriteria observedCriteria       = null;
            var             mockRunRequest         = new Mock <ITestRunRequest>();

            this.mockTestPlatform.Setup(mt => mt.CreateTestRunRequest(It.IsAny <TestRunCriteria>())).Callback <TestRunCriteria>(
                (runCriteria) =>
            {
                createRunRequestCalled++;
                observedCriteria = runCriteria;
            }).Returns(mockRunRequest.Object);

            var mockRunEventsRegistrar = new Mock <ITestRunEventsRegistrar>();
            var mockCustomlauncher     = new Mock <ITestHostLauncher>();

            string testCaseFilterValue = "TestFilter";

            CommandLineOptions.Instance.TestCaseFilterValue = testCaseFilterValue;
            this.testRequestManager = new TestRequestManager(CommandLineOptions.Instance,
                                                             this.mockTestPlatform.Object,
                                                             TestLoggerManager.Instance,
                                                             TestRunResultAggregator.Instance,
                                                             this.mockTestPlatformEventSource.Object);

            var success = this.testRequestManager.RunTests(payload, mockCustomlauncher.Object, mockRunEventsRegistrar.Object);

            Assert.IsTrue(success, "RunTests call must succeed");

            Assert.AreEqual(testCaseFilterValue, observedCriteria.TestCaseFilter, "TestCaseFilter must be set");

            Assert.AreEqual(createRunRequestCalled, 1, "CreateRunRequest must be invoked only once.");
            Assert.AreEqual(2, observedCriteria.Sources.Count(), "All Sources must be used for discovery request");
            Assert.AreEqual("a", observedCriteria.Sources.First(), "First Source in list is incorrect");
            Assert.AreEqual("b", observedCriteria.Sources.ElementAt(1), "Second Source in list is incorrect");

            // Check for the default value for the frequency
            Assert.AreEqual(10, observedCriteria.FrequencyOfRunStatsChangeEvent);
            mockRunEventsRegistrar.Verify(md => md.RegisterTestRunEvents(It.IsAny <ITestRunRequest>()), Times.Once);
            mockRunEventsRegistrar.Verify(md => md.UnregisterTestRunEvents(It.IsAny <ITestRunRequest>()), Times.Once);

            mockRunRequest.Verify(md => md.ExecuteAsync(), Times.Once);

            mockTestPlatformEventSource.Verify(mt => mt.ExecutionRequestStart(), Times.Once);
            mockTestPlatformEventSource.Verify(mt => mt.ExecutionRequestStop(), Times.Once);
        }
Exemple #12
0
        public void DiscoverTestsShouldCallTestPlatformAndSucceed()
        {
            var payload = new DiscoveryRequestPayload()
            {
                Sources = new List <string>()
                {
                    "a", "b"
                }
            };

            var createDiscoveryRequestCalled          = 0;
            DiscoveryCriteria actualDiscoveryCriteria = null;
            var mockDiscoveryRequest = new Mock <IDiscoveryRequest>();

            this.mockTestPlatform.Setup(mt => mt.CreateDiscoveryRequest(It.IsAny <IRequestData>(), It.IsAny <DiscoveryCriteria>())).Callback(
                (IRequestData requestData, DiscoveryCriteria discoveryCriteria) =>
            {
                createDiscoveryRequestCalled++;
                actualDiscoveryCriteria = discoveryCriteria;
            }).Returns(mockDiscoveryRequest.Object);

            var mockDiscoveryRegistrar = new Mock <ITestDiscoveryEventsRegistrar>();

            string testCaseFilterValue = "TestFilter";

            CommandLineOptions.Instance.TestCaseFilterValue = testCaseFilterValue;
            this.testRequestManager = new TestRequestManager(CommandLineOptions.Instance,
                                                             this.mockTestPlatform.Object,
                                                             TestLoggerManager.Instance,
                                                             TestRunResultAggregator.Instance,
                                                             this.mockTestPlatformEventSource.Object);

            var success = this.testRequestManager.DiscoverTests(payload, mockDiscoveryRegistrar.Object, this.protocolConfig);

            Assert.IsTrue(success, "DiscoverTests call must succeed");
            Assert.AreEqual(testCaseFilterValue, actualDiscoveryCriteria.TestCaseFilter, "TestCaseFilter must be set");

            Assert.AreEqual(createDiscoveryRequestCalled, 1, "CreateDiscoveryRequest must be invoked only once.");
            Assert.AreEqual(2, actualDiscoveryCriteria.Sources.Count(), "All Sources must be used for discovery request");
            Assert.AreEqual("a", actualDiscoveryCriteria.Sources.First(), "First Source in list is incorrect");
            Assert.AreEqual("b", actualDiscoveryCriteria.Sources.ElementAt(1), "Second Source in list is incorrect");

            // Default frequency is set to 10, unless specified in runsettings.
            Assert.AreEqual(10, actualDiscoveryCriteria.FrequencyOfDiscoveredTestsEvent);

            mockDiscoveryRegistrar.Verify(md => md.RegisterDiscoveryEvents(It.IsAny <IDiscoveryRequest>()), Times.Once);
            mockDiscoveryRegistrar.Verify(md => md.UnregisterDiscoveryEvents(It.IsAny <IDiscoveryRequest>()), Times.Once);

            mockDiscoveryRequest.Verify(md => md.DiscoverAsync(), Times.Once);

            mockTestPlatformEventSource.Verify(mt => mt.DiscoveryRequestStart(), Times.Once);
            mockTestPlatformEventSource.Verify(mt => mt.DiscoveryRequestStop(), Times.Once);
        }
        private static RunTestsArgumentExecutor GetExecutor(ITestRequestManager testRequestManager)
        {
            var runSettingsProvider = new TestableRunSettingsProvider();

            runSettingsProvider.AddDefaultRunSettings();
            var executor = new RunTestsArgumentExecutor(
                CommandLineOptions.Instance,
                runSettingsProvider,
                testRequestManager);

            return(executor);
        }
        private static ListFullyQualifiedTestsArgumentExecutor GetExecutor(ITestRequestManager testRequestManager, IOutput output)
        {
            var runSettingsProvider = new TestableRunSettingsProvider();

            runSettingsProvider.AddDefaultRunSettings();
            var listFullyQualifiedTestsArgumentExecutor =
                new ListFullyQualifiedTestsArgumentExecutor(
                    CommandLineOptions.Instance,
                    runSettingsProvider,
                    testRequestManager,
                    output ?? ConsoleOutput.Instance);

            return(listFullyQualifiedTestsArgumentExecutor);
        }
Exemple #15
0
        /// <summary>
        /// Default constructor.
        /// </summary>
        public RunTestsArgumentExecutor(
            CommandLineOptions commandLineOptions,
            IRunSettingsProvider runSettingsProvider,
            ITestRequestManager testRequestManager,
            IOutput output)
        {
            Contract.Requires(commandLineOptions != null);

            this.commandLineOptions     = commandLineOptions;
            this.runSettingsManager     = runSettingsProvider;
            this.testRequestManager     = testRequestManager;
            this.output                 = output;
            this.testRunEventsRegistrar = new TestRunRequestEventsRegistrar(this.output);
        }
        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="options">
        /// The options.
        /// </param>
        internal ListTestsArgumentExecutor(
            CommandLineOptions options,
            IRunSettingsProvider runSettingsProvider,
            ITestRequestManager testRequestManager,
            IOutput output)
        {
            Contract.Requires(options != null);

            this.commandLineOptions = options;
            this.output             = output;
            this.testRequestManager = testRequestManager;

            this.runSettingsManager       = runSettingsProvider;
            this.discoveryEventsRegistrar = new DiscoveryEventsRegistrar(output);
        }
        /// <summary>
        /// Default constructor.
        /// </summary>
        public RunSpecificTestsArgumentExecutor(
            CommandLineOptions options,
            IRunSettingsProvider runSettingsProvider,
            ITestRequestManager testRequestManager)
        {
            Contract.Requires(options != null);
            Contract.Requires(testRequestManager != null);

            this.commandLineOptions = options;
            this.testRequestManager = testRequestManager;

            this.runSettingsManager       = runSettingsProvider;
            this.output                   = ConsoleOutput.Instance;
            this.discoveryEventsRegistrar = new DiscoveryEventsRegistrar(this.discoveryRequest_OnDiscoveredTests);
        }
Exemple #18
0
        /// <summary>
        /// Creates a client and waits for server to accept connection asynchronously
        /// </summary>
        /// <param name="port">
        /// Port number to connect
        /// </param>
        /// <param name="testRequestManager">
        /// The test Request Manager.
        /// </param>
        public void ConnectToClientAndProcessRequests(int port, ITestRequestManager testRequestManager)
        {
            EqtTrace.Info("Trying to connect to server on port : {0}", port);
            this.communicationManager.SetupClientAsync(new IPEndPoint(IPAddress.Loopback, port));

            // Wait for the connection to the server and listen for requests.
            if (this.communicationManager.WaitForServerConnection(ClientListenTimeOut))
            {
                this.communicationManager.SendMessage(MessageType.SessionConnected);
                this.ProcessRequests(testRequestManager);
            }
            else
            {
                EqtTrace.Info("Client timed out while connecting to the server.");
                this.Dispose();
                throw new TimeoutException();
            }
        }
        public TestRequestManagerTests()
        {
            this.mockLoggerEvents            = new DummyLoggerEvents(TestSessionMessageLogger.Instance);
            this.mockLoggerManager           = new DummyTestLoggerManager(this.mockLoggerEvents);
            this.commandLineOptions          = new DummyCommandLineOptions();
            this.mockTestPlatform            = new Mock <ITestPlatform>();
            this.mockDiscoveryRequest        = new Mock <IDiscoveryRequest>();
            this.mockRunRequest              = new Mock <ITestRunRequest>();
            this.mockTestPlatformEventSource = new Mock <ITestPlatformEventSource>();
            var testRunResultAggregator = new DummyTestRunResultAggregator();

            this.testRequestManager = new TestRequestManager(this.commandLineOptions, this.mockTestPlatform.Object,
                                                             mockLoggerManager, testRunResultAggregator, mockTestPlatformEventSource.Object);
            this.mockTestPlatform.Setup(tp => tp.CreateDiscoveryRequest(It.IsAny <DiscoveryCriteria>(), It.IsAny <ProtocolConfig>()))
            .Returns(this.mockDiscoveryRequest.Object);
            this.mockTestPlatform.Setup(tp => tp.CreateTestRunRequest(It.IsAny <TestRunCriteria>(), It.IsAny <ProtocolConfig>()))
            .Returns(this.mockRunRequest.Object);
        }
        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);
                }
            });
        }
Exemple #21
0
        public void DiscoverTestsShouldPassSameProtocolConfigInRequestData()
        {
            var payload = new DiscoveryRequestPayload()
            {
                Sources = new List <string>()
                {
                    "a", "b"
                }
            };

            var mockProtocolConfig = new ProtocolConfig {
                Version = 4
            };

            IRequestData actualRequestData    = null;
            var          mockDiscoveryRequest = new Mock <IDiscoveryRequest>();

            this.mockTestPlatform.Setup(mt => mt.CreateDiscoveryRequest(It.IsAny <IRequestData>(), It.IsAny <DiscoveryCriteria>())).Callback(
                (IRequestData requestData, DiscoveryCriteria discoveryCriteria) => { actualRequestData = requestData; }).Returns(mockDiscoveryRequest.Object);

            var mockDiscoveryRegistrar = new Mock <ITestDiscoveryEventsRegistrar>();

            string testCaseFilterValue = "TestFilter";

            CommandLineOptions.Instance.TestCaseFilterValue = testCaseFilterValue;
            this.testRequestManager = new TestRequestManager(CommandLineOptions.Instance,
                                                             this.mockTestPlatform.Object,
                                                             TestLoggerManager.Instance,
                                                             TestRunResultAggregator.Instance,
                                                             this.mockTestPlatformEventSource.Object);

            // Act
            this.testRequestManager.DiscoverTests(payload, mockDiscoveryRegistrar.Object, mockProtocolConfig);

            // Verify.
            Assert.AreEqual(4, actualRequestData.ProtocolConfig.Version);
        }
        private void StartTestSession(StartTestSessionPayload payload, ITestRequestManager requestManager)
        {
            Task.Run(() =>
            {
                var eventsHandler = new TestSessionEventsHandler(this.communicationManager);

                try
                {
                    var customLauncher = payload.HasCustomHostLauncher
                        ? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, payload.IsDebuggingEnabled)
                        : null;

                    requestManager.ResetOptions();
                    requestManager.StartTestSession(payload, customLauncher, eventsHandler, this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartTestSession: " + ex);

                    eventsHandler.HandleLogMessage(TestMessageLevel.Error, ex.ToString());
                    eventsHandler.HandleStartTestSessionComplete(null);
                }
            });
        }
        /// <summary>
        /// Process Requests from the IDE
        /// </summary>
        /// <param name="testRequestManager">
        /// The test Request Manager.
        /// </param>
        private void ProcessRequests(ITestRequestManager testRequestManager)
        {
            var isSessionEnd = false;

            do
            {
                try
                {
                    var message = this.communicationManager.ReceiveMessage();

                    if (EqtTrace.IsInfoEnabled)
                    {
                        EqtTrace.Info("DesignModeClient.ProcessRequests: Processing Message: {0}", message);
                    }

                    switch (message.MessageType)
                    {
                    case MessageType.VersionCheck:
                    {
                        var version = this.dataSerializer.DeserializePayload <int>(message);
                        this.protocolConfig.Version = Math.Min(version, this.protocolConfig.Version);
                        this.communicationManager.SendMessage(MessageType.VersionCheck, this.protocolConfig.Version);
                        break;
                    }

                    case MessageType.ExtensionsInitialize:
                    {
                        // Do not filter the Editor/IDE provided extensions by name
                        var extensionPaths = this.communicationManager.DeserializePayload <IEnumerable <string> >(message);
                        testRequestManager.InitializeExtensions(extensionPaths, skipExtensionFilters: true);
                        break;
                    }

                    case MessageType.StartDiscovery:
                    {
                        var discoveryPayload = this.dataSerializer.DeserializePayload <DiscoveryRequestPayload>(message);
                        this.StartDiscovery(discoveryPayload, testRequestManager);
                        break;
                    }

                    case MessageType.GetTestRunnerProcessStartInfoForRunAll:
                    case MessageType.GetTestRunnerProcessStartInfoForRunSelected:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: true);
                        break;
                    }

                    case MessageType.TestRunAllSourcesWithDefaultHost:
                    case MessageType.TestRunSelectedTestCasesDefaultHost:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: false);
                        break;
                    }

                    case MessageType.CancelDiscovery:
                    {
                        testRequestManager.CancelDiscovery();
                        break;
                    }

                    case MessageType.CancelTestRun:
                    {
                        testRequestManager.CancelTestRun();
                        break;
                    }

                    case MessageType.AbortTestRun:
                    {
                        testRequestManager.AbortTestRun();
                        break;
                    }

                    case MessageType.CustomTestHostLaunchCallback:
                    {
                        this.onCustomTestHostLaunchAckReceived?.Invoke(message);
                        break;
                    }

                    case MessageType.EditorAttachDebuggerCallback:
                    {
                        this.onAttachDebuggerAckRecieved?.Invoke(message);
                        break;
                    }

                    case MessageType.SessionEnd:
                    {
                        EqtTrace.Info("DesignModeClient: Session End message received from server. Closing the connection.");
                        isSessionEnd = true;
                        this.Dispose();
                        break;
                    }

                    default:
                    {
                        EqtTrace.Info("DesignModeClient: Invalid Message received: {0}", message);
                        break;
                    }
                    }
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Error processing request: {0}", ex);
                    isSessionEnd = true;
                    this.Dispose();
                }
            }while (!isSessionEnd);
        }
Exemple #24
0
 /// <summary>
 /// For Unit testing only
 /// </summary>
 internal PortArgumentExecutor(CommandLineOptions options, ITestRequestManager testRequestManager, IProcessHelper processHelper)
     : this(options, testRequestManager, InitializeDesignMode, processHelper)
 {
 }
Exemple #25
0
        /// <summary>
        /// Process Requests from the IDE
        /// </summary>
        /// <param name="testRequestManager">
        /// The test Request Manager.
        /// </param>
        private void ProcessRequests(ITestRequestManager testRequestManager)
        {
            var isSessionEnd = false;

            do
            {
                try
                {
                    var message = this.communicationManager.ReceiveMessage();

                    EqtTrace.Info("DesignModeClient: Processing Message of message type: {0}", message.MessageType);
                    switch (message.MessageType)
                    {
                    case MessageType.VersionCheck:
                    {
                        // At this point, we cannot add stuff to object model like "ProtocolVersionMessage"
                        // as that cannot be acessed from testwindow which still uses TP-V1
                        // we are sending a version number as an integer for now
                        // TODO: Find a better way without breaking TW which using TP-V1
                        var payload = 1;
                        this.communicationManager.SendMessage(MessageType.VersionCheck, payload);
                        break;
                    }

                    case MessageType.ExtensionsInitialize:
                    {
                        var extensionPaths = this.communicationManager.DeserializePayload <IEnumerable <string> >(message);
                        testRequestManager.InitializeExtensions(extensionPaths);
                        break;
                    }

                    case MessageType.StartDiscovery:
                    {
                        var discoveryPayload = message.Payload.ToObject <DiscoveryRequestPayload>();
                        testRequestManager.DiscoverTests(discoveryPayload, new DesignModeTestEventsRegistrar(this));
                        break;
                    }

                    case MessageType.GetTestRunnerProcessStartInfoForRunAll:
                    case MessageType.GetTestRunnerProcessStartInfoForRunSelected:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: true);
                        break;
                    }

                    case MessageType.TestRunAllSourcesWithDefaultHost:
                    case MessageType.TestRunSelectedTestCasesDefaultHost:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: false);
                        break;
                    }

                    case MessageType.CancelTestRun:
                    {
                        testRequestManager.CancelTestRun();
                        break;
                    }

                    case MessageType.AbortTestRun:
                    {
                        testRequestManager.AbortTestRun();
                        break;
                    }

                    case MessageType.CustomTestHostLaunchCallback:
                    {
                        this.onAckMessageReceived?.Invoke(message);
                        break;
                    }

                    case MessageType.SessionEnd:
                    {
                        EqtTrace.Info("DesignModeClient: Session End message received from server. Closing the connection.");
                        isSessionEnd = true;
                        this.Dispose();
                        break;
                    }

                    default:
                    {
                        EqtTrace.Info("DesignModeClient: Invalid Message received: {0}", message);
                        break;
                    }
                    }
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Error processing request: {0}", ex);
                    isSessionEnd = true;
                    this.Dispose();
                }
            }while (!isSessionEnd);
        }
Exemple #26
0
        private void StartTestRunAttachmentsProcessing(TestRunAttachmentsProcessingPayload attachmentsProcessingPayload, ITestRequestManager testRequestManager)
        {
            Task.Run(
                () =>
            {
                try
                {
                    testRequestManager.ProcessTestRunAttachments(attachmentsProcessingPayload, new TestRunAttachmentsProcessingEventsHandler(this.communicationManager), this.protocolConfig);
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Exception in StartTestRunAttachmentsProcessing: " + ex);

                    var testMessagePayload = new TestMessagePayload {
                        MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
                    };
                    this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);

                    var payload = new TestRunAttachmentsProcessingCompletePayload()
                    {
                        Attachments = null
                    };

                    // Send run complete to translation layer
                    this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingComplete, payload);
                }
            });
        }
Exemple #27
0
        /// <summary>
        /// Process Requests from the IDE
        /// </summary>
        /// <param name="testRequestManager">
        /// The test Request Manager.
        /// </param>
        private void ProcessRequests(ITestRequestManager testRequestManager)
        {
            var isSessionEnd = false;

            do
            {
                try
                {
                    var message = this.communicationManager.ReceiveMessage();

                    EqtTrace.Info("DesignModeClient: Processing Message of message type: {0}", message.MessageType);
                    switch (message.MessageType)
                    {
                    case MessageType.VersionCheck:
                    {
                        var version = this.dataSerializer.DeserializePayload <int>(message);
                        this.protocolConfig.Version = Math.Min(version, this.protocolConfig.Version);
                        this.communicationManager.SendMessage(MessageType.VersionCheck, this.protocolConfig.Version);
                        break;
                    }

                    case MessageType.ExtensionsInitialize:
                    {
                        var extensionPaths = this.communicationManager.DeserializePayload <IEnumerable <string> >(message);
                        testRequestManager.InitializeExtensions(extensionPaths);
                        break;
                    }

                    case MessageType.StartDiscovery:
                    {
                        var discoveryPayload = message.Payload.ToObject <DiscoveryRequestPayload>();
                        testRequestManager.DiscoverTests(discoveryPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
                        break;
                    }

                    case MessageType.GetTestRunnerProcessStartInfoForRunAll:
                    case MessageType.GetTestRunnerProcessStartInfoForRunSelected:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: true);
                        break;
                    }

                    case MessageType.TestRunAllSourcesWithDefaultHost:
                    case MessageType.TestRunSelectedTestCasesDefaultHost:
                    {
                        var testRunPayload =
                            this.communicationManager.DeserializePayload <TestRunRequestPayload>(
                                message);
                        this.StartTestRun(testRunPayload, testRequestManager, skipTestHostLaunch: false);
                        break;
                    }

                    case MessageType.CancelTestRun:
                    {
                        testRequestManager.CancelTestRun();
                        break;
                    }

                    case MessageType.AbortTestRun:
                    {
                        testRequestManager.AbortTestRun();
                        break;
                    }

                    case MessageType.CustomTestHostLaunchCallback:
                    {
                        this.onAckMessageReceived?.Invoke(message);
                        break;
                    }

                    case MessageType.SessionEnd:
                    {
                        EqtTrace.Info("DesignModeClient: Session End message received from server. Closing the connection.");
                        isSessionEnd = true;
                        this.Dispose();
                        break;
                    }

                    default:
                    {
                        EqtTrace.Info("DesignModeClient: Invalid Message received: {0}", message);
                        break;
                    }
                    }
                }
                catch (Exception ex)
                {
                    EqtTrace.Error("DesignModeClient: Error processing request: {0}", ex);
                    isSessionEnd = true;
                    this.Dispose();
                }
            }while (!isSessionEnd);
        }
Exemple #28
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="options">
 /// The options.
 /// </param>
 /// <param name="testRequestManager"> Test request manager</param>
 public PortArgumentExecutor(CommandLineOptions options, ITestRequestManager testRequestManager)
     : this(options, testRequestManager, InitializeDesignMode)
 {
 }