示例#1
0
        private void ExecuteTestsWithTestRunner(
            IEnumerable <TestCase> tests,
            IRunContext runContext,
            ITestExecutionRecorder testExecutionRecorder,
            string source,
            IDictionary <string, object> sourceLevelParameters,
            UnitTestRunner testRunner)
        {
            foreach (var currentTest in tests)
            {
                if (this.cancellationToken != null && this.cancellationToken.Canceled)
                {
                    break;
                }

                var unitTestElement = currentTest.ToUnitTestElement(source);
                testExecutionRecorder.RecordStart(currentTest);

                var startTime = DateTimeOffset.Now;

                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo("Executing test {0}", unitTestElement.TestMethod.Name);

                // Run single test passing test context properties to it.
                var tcmProperties         = TcmTestPropertiesProvider.GetTcmProperties(currentTest);
                var testContextProperties = this.GetTestContextProperties(tcmProperties, sourceLevelParameters);
                var unitTestResult        = testRunner.RunSingleTest(unitTestElement.TestMethod, testContextProperties);

                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo("Executed test {0}", unitTestElement.TestMethod.Name);

                var endTime = DateTimeOffset.Now;

                this.SendTestResults(currentTest, unitTestResult, startTime, endTime, testExecutionRecorder);
            }
        }
示例#2
0
        private void ExecuteTestsWithTestRunner(
            IEnumerable <TestCase> tests,
            IRunContext runContext,
            ITestExecutionRecorder testExecutionRecorder,
            string source,
            IDictionary <string, object> sourceLevelParameters,
            UnitTestRunner testRunner)
        {
            var testExecutionRecorderWrapper = new TestExecutionRecorderWrapper(testExecutionRecorder);

            foreach (var currentTest in tests)
            {
                if (this.cancellationToken != null && this.cancellationToken.Canceled)
                {
                    break;
                }

                var unitTestElement = currentTest.ToUnitTestElement(source);

                // Fire a RecordStart here even though we also fire RecordStart inside TestMethodInfo
                // this is to ensure we fire start events for error cases. This is acceptable because
                // vstest ignores multiple start events.
                testExecutionRecorder.RecordStart(currentTest);

                var startTime = DateTimeOffset.Now;

                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
                    "Executing test {0}",
                    unitTestElement.TestMethod.Name);

                // Run single test passing test context properties to it.
                var tcmProperties         = TcmTestPropertiesProvider.GetTcmProperties(currentTest);
                var testContextProperties = this.GetTestContextProperties(tcmProperties, sourceLevelParameters);
                var unitTestResult        = testRunner.RunSingleTest(unitTestElement.TestMethod, testExecutionRecorderWrapper, testContextProperties);

                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
                    "Executed test {0}",
                    unitTestElement.TestMethod.Name);

                var endTime = DateTimeOffset.Now;

                this.SendTestResults(currentTest, unitTestResult, startTime, endTime, testExecutionRecorder);
            }
        }
示例#3
0
        private void ExecuteTestsWithTestRunner(
            IEnumerable <TestCase> tests,
            IRunContext runContext,
            ITestExecutionRecorder testExecutionRecorder,
            string source,
            UnitTestRunner testRunner)
        {
            TestCase test = null;

            UnitTestResult[] unitTestResult = null;

            var startTime = DateTimeOffset.MinValue;
            var endTime   = DateTimeOffset.MinValue;

            bool filterHasError;
            var  filterExpression = this.TestMethodFilter.GetFilterExpression(
                runContext,
                testExecutionRecorder,
                out filterHasError);

            if (!filterHasError)
            {
                foreach (var currentTest in tests)
                {
                    // Skip test if not fitting filter criteria.
                    if (filterExpression != null && filterExpression.MatchTestCase(
                            currentTest,
                            (p) => this.TestMethodFilter.PropertyValueProvider(currentTest, p)) == false)
                    {
                        continue;
                    }

                    // Send previous test result.
                    this.SendTestResults(test, unitTestResult, startTime, endTime, testExecutionRecorder);

                    if (this.cancellationToken != null && this.cancellationToken.Canceled)
                    {
                        break;
                    }

                    var unitTestElement = currentTest.ToUnitTestElement(source);
                    testExecutionRecorder.RecordStart(currentTest);

                    startTime = DateTimeOffset.Now;

                    PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
                        "Executing test {0}",
                        unitTestElement.TestMethod.Name);

                    if (unitTestElement.Ignored)
                    {
                        unitTestResult = new[] { new UnitTestResult(UnitTestOutcome.Ignored, null) };
                    }
                    else
                    {
                        // this is done so that appropriate values of testcontext properties are set at source level
                        // and are merged with session level parameters
                        var sourceLevelParameters = PlatformServiceProvider.Instance.SettingsProvider.GetProperties(source);

                        if (this.sessionParameters != null && this.sessionParameters.Count > 0)
                        {
                            sourceLevelParameters = sourceLevelParameters.Concat(this.sessionParameters).ToDictionary(x => x.Key, x => x.Value);
                        }

                        unitTestResult = testRunner.RunSingleTest(unitTestElement.TestMethod, sourceLevelParameters);
                    }

                    PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo(
                        "Executed test {0}",
                        unitTestElement.TestMethod.Name);

                    endTime = DateTimeOffset.Now;
                    test    = currentTest;
                }
            }

            IList <string> warnings = null;

            try
            {
                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo("Executing cleanup methods.");
                var cleanupResult = testRunner.RunCleanup();
                PlatformServiceProvider.Instance.AdapterTraceLogger.LogInfo("Executed cleanup methods.");

                if (cleanupResult != null)
                {
                    warnings = cleanupResult.Warnings;

                    if (unitTestResult?.Length > 0)
                    {
                        var lastResult = unitTestResult[unitTestResult.Length - 1];
                        lastResult.StandardOut   += cleanupResult.StandardOut;
                        lastResult.StandardError += cleanupResult.StandardError;
                        lastResult.DebugTrace    += cleanupResult.DebugTrace;
                    }
                }
            }
            finally
            {
                // Send last test result
                this.SendTestResults(test, unitTestResult, startTime, endTime, testExecutionRecorder);
            }

            this.LogWarnings(testExecutionRecorder, warnings);
        }