예제 #1
0
        internal static void StopAllureLogging(TestContext.ResultAdapter testResult, string testUuid,
                                               string testContainerUuid, ITest suite, bool updateStopTime, string ignoreReason)
        {
            var result         = testResult;
            var testMsg        = result.Message;
            var testStackTrace = result.StackTrace;

            Logger.LogInProgress(
                $"Entering stop allure logging for \"{testUuid}\"");

            if (!string.IsNullOrEmpty(ignoreReason))
            {
                testMsg = ignoreReason;
            }
            AllureLifecycle.Instance.UpdateTestCase(testUuid, x =>
            {
                x.statusDetails.message = MakeGoodErrorMsg(testMsg);
                x.statusDetails.trace   = testStackTrace;
                x.status = GetNUnitStatus(result.Outcome.Status);
            });
            AllureLifecycle.Instance.StopTestCase(testUuid,
                                                  updateStopTime);
            AllureLifecycle.Instance.WriteTestCase(testUuid);
            AllureLifecycle.Instance.UpdateTestContainer(
                testContainerUuid,
                q => q.children.Add(testUuid));
            AllureLifecycle.Instance.StopTestContainer(
                testContainerUuid, updateStopTime);
            AllureLifecycle.Instance.WriteTestContainer(testContainerUuid);
            Logger.LogInProgress($"Stopped allure logging for test {testUuid}, {testContainerUuid}, {ignoreReason}");
        }
예제 #2
0
        public void AllureOneTimeSetUp()
        {
            Logger.LogInProgress(
                $"Entering OneTimeSetup for \"{TestContext.CurrentContext.Test.Properties.Get(AllureConstants.FixtureUuid)}\"");
            AllureStorage.MainThreadId = Thread.CurrentThread.ManagedThreadId;
            _currentSuite = (TestFixture)TestExecutionContext.CurrentContext.CurrentTest;
            var allTests = ReportHelper.GetAllTestsInSuite(_currentSuite);

            _currentSuiteTests = allTests;
            Logger.LogInProgress(
                $"Exiting OneTimeSetup for \"{_currentSuite.GetProp(AllureConstants.FixtureUuid)}\"");
        }
예제 #3
0
        internal static void StartTestAndAddPropertiesInside(ITest test, TestFixture suite, int countRun)
        {
            var uuid          = $"{test.Id}_{Guid.NewGuid():N}";
            var testUuid      = $"{uuid}-{suite.Id}-test-run{countRun}";
            var containerUuid = $"{uuid}-{suite.Id}-run{countRun}-container";
            var fixtureUuid   = suite.GetPropAsString(AllureConstants.FixtureUuid);

            test.SetProp(AllureConstants.TestContainerUuid, containerUuid);
            test.SetProp(AllureConstants.TestUuid, testUuid);
            test.SetProp(AllureConstants.FixtureUuid, fixtureUuid);
            test.SetProp(AllureConstants.TestAsserts, new List <Exception>());
            ReportHelper.StartAllureLogging(test, testUuid, containerUuid, suite);
            Logger.LogInProgress(
                $"Started allure logging for \"{test.FullName}\", run #{countRun}\n\"{testUuid}\"\n\"{containerUuid}\"\n\"{fixtureUuid}\"");

            suite.GetAllTestsInFixture()
            .Add((testUuid, containerUuid, fixtureUuid));
            suite.GetCountTestInFixture()
            .Add((testUuid, containerUuid, fixtureUuid));
        }
예제 #4
0
        internal static Dictionary <MethodType, string> GetTypeOfCurrentMethodInTest()
        {
            var dict    = new Dictionary <MethodType, string>();
            var methods = GetCallStackMethods().ToList();

            if (AllureLifecycle.Instance.Config.Allure.DebugMode)
            {
                var sb = new StringBuilder();
                methods.ForEach(m => sb.AppendLine(m.Name));
                Logger.LogInProgress(
                    $"Test ID {TestExecutionContext.CurrentContext.CurrentTest.Id}, Thread ID {Thread.CurrentThread.ManagedThreadId}, call stack at this moment\n {sb}");
                sb.Clear();
            }

            var method = methods.FirstOrDefault(sMethod =>
            {
                try
                {
                    _ = sMethod.CustomAttributes;
                }
                catch (Exception)
                {
                    return(false);
                }

                var result = sMethod.DeclaringType != typeof(AllureReport);
                if (!result)
                {
                    return(false);
                }
                var result2 = sMethod.GetCustomAttribute <SetUpAttribute>();
                if (result2 != null)
                {
                    return(true);
                }
                var result3 = sMethod.GetCustomAttribute <OneTimeSetUpAttribute>();
                if (result3 != null)
                {
                    return(true);
                }
                var result4 = sMethod.GetCustomAttribute <TearDownAttribute>();
                if (result4 != null)
                {
                    return(true);
                }
                var result5 = sMethod.GetCustomAttribute <OneTimeTearDownAttribute>();
                return(result5 != null);
            });

            if (method == null)
            {
                dict.Add(MethodType.TestBody, "");
                return(dict);
            }

            var methodName = method.Name;
            var attrs      = method.GetCustomAttributes();
            var methodType = MethodType.TestBody;

            foreach (var attribute in attrs)
            {
                switch (attribute)
                {
                case SetUpAttribute _:
                    methodType = MethodType.Setup;
                    break;

                case OneTimeSetUpAttribute _:
                    methodType = MethodType.OneTimeSetup;
                    break;

                case TearDownAttribute _:
                    methodType = MethodType.Teardown;
                    break;

                case OneTimeTearDownAttribute _:
                    methodType = MethodType.OneTimeTearDown;
                    break;
                }
            }
            dict.Add(methodType, methodName);
            return(dict);
        }
예제 #5
0
        public void AllureOneTimeTearDown()
        {
            Logger.LogInProgress(
                $"Entering OneTimeTearDown for \"{_currentSuite.GetProp(AllureConstants.FixtureUuid)}\"");

            if (_currentSuite.GetCurrentOneTimeTearDownFixture() != null)
            {
                string testMsg        = null;
                string testStackTrace = null;
                var    status         = ReportHelper.GetNUnitStatus(TestContext.CurrentContext.Result.Outcome.Status);

                if (TestContext.CurrentContext.Result.Outcome.Site == FailureSite.TearDown)
                {
                    testStackTrace = TestContext.CurrentContext.Result.StackTrace;
                    testMsg        = TestContext.CurrentContext.Result.Message;
                }

                AllureLifecycle.Instance.StopFixture(
                    _currentSuite.GetCurrentOneTimeTearDownFixture().suiteUuid + "-onetimeteardown",
                    q =>
                {
                    q.status = status;
                    q.statusDetails.message = testMsg;
                    q.statusDetails.trace   = testStackTrace;
                });
                TestExecutionContext.CurrentContext.CurrentTest.SetCurrentOneTimeTearDownFixture(new FixtureResult
                {
                    suiteUuid = "null"
                });
            }

            foreach (var testTupleInfo in TestExecutionContext.CurrentContext.CurrentTest.GetCompletedTestsInFixture())
            {
                AllureLifecycle.Instance.Storage.ClearStepContext();
                AllureLifecycle.Instance.Storage.CurrentThreadStepContext.AddLast(testTupleInfo.TestUuid);
                ReportHelper.StopAllureLogging(testTupleInfo.testResult,
                                               testTupleInfo.TestUuid, testTupleInfo.TestContainerUuid, _currentSuite, false, null);
            }

            if (string.IsNullOrEmpty(TestContext.CurrentContext.Test.MethodName) &&
                TestContext.CurrentContext.Result.Outcome.Site == FailureSite.SetUp &&
                AllureLifecycle.Instance.Config.Allure.AllowEmptySuites &&
                TestContext.CurrentContext.Result.Outcome.Status == TestStatus.Failed)
            {
                lock (ReportHelper.Locker)
                {
                    AllureStorage.MainThreadId = Thread.CurrentThread.ManagedThreadId;
                    foreach (var test in _currentSuiteTests)
                    {
                        test.Properties.Set(AllureConstants.TestResult, TestContext.CurrentContext.Result);
                        AllureLifecycle.Instance.UpdateTestContainer(
                            test.Properties.Get(AllureConstants.TestContainerUuid)
                            .ToString(),
                            x => x.start = AllureLifecycle.ToUnixTimestamp());
                        AllureLifecycle.Instance.UpdateTestCase(test.Properties
                                                                .Get(AllureConstants.TestUuid).ToString(),
                                                                x => { x.start = AllureLifecycle.ToUnixTimestamp(); });
                        Thread.Sleep(5);
                        AllureLifecycle.Instance.Storage.ClearStepContext();
                        AllureLifecycle.Instance.Storage.CurrentThreadStepContext.AddLast(test.Properties
                                                                                          .Get(AllureConstants.TestUuid).ToString());
                        AllureLifecycle.Instance.StartStepAndStopIt(null, "The test was not started",
                                                                    Status.failed);
                        AllureLifecycle.Instance.UpdateTestCase(
                            test.Properties.Get(AllureConstants.TestUuid).ToString(),
                            x =>
                        {
                            x.labels.RemoveAll(q => q.name == "thread");
                            x.labels.Add(Label.Thread());
                        });
                        ReportHelper.StopAllureLogging(TestContext.CurrentContext.Result, test.Properties
                                                       .Get(AllureConstants.TestUuid).ToString(), test.Properties
                                                       .Get(AllureConstants.TestContainerUuid).ToString(), _currentSuite, true, null);
                    }
                }
            }

            else
            {
                ReportHelper.AddIgnoredTestsToReport(_currentSuite);
            }

            lock (ReportHelper.Locker)
            {
                EnvironmentBuilder.BuildEnvFile(new DirectoryInfo(AllureLifecycle.Instance.ResultsDirectory));
            }

            Logger.LogInProgress(
                $"Exiting OneTimeTearDown for \"{TestContext.CurrentContext.Test.Properties.Get(AllureConstants.FixtureUuid)}\"");
        }