// GET: Analyze
        public async Task <ActionResult> Index(string id = null)
        {
            ViewBag.ShowFlakyTests = true;

            if (id == null)
            {
                var latestTestRun = await TestResultRepoApiHelper.GetLatestTestRun();

                id = latestTestRun._Id;
                ViewBag.ShowFlakyTests = true;
            }

            var testRun = await TestResultRepoApiHelper.GetTestRunWithChildren(id);

            var failingSuites = testRun.TestSuites.FindAll(ts => ts.Result == Result.Failed).ToList();

            foreach (var suite in failingSuites)
            {
                var failingTestCases = suite.TestCases.FindAll(tc => tc.Result != Result.Failed);
                suite.TestCases.RemoveAll(tc => tc.Result != Result.Failed);
                foreach (var tc in failingTestCases)
                {
                    suite.TestCaseIds.Remove(tc._Id);
                }
            }

            ViewBag.failingTestSuites = failingSuites;

            ViewBag.testRun     = testRun;
            ViewBag.TestRunId   = testRun._Id;
            ViewBag.TestRunName = testRun.Name;

            return(View());
        }
        public ActionResult RenderViewFromId(string Id, bool showDate = true)
        {
            ViewBag.showDate = showDate;
            TestCase testCase = TestResultRepoApiHelper.GetTestCaseSync(Id);

            return(PartialView("TestCaseCard", testCase));
        }
Exemple #3
0
        public async Task <ActionResult> RenderTestSuiteCardList(string name)
        {
            var testSuites = await TestResultRepoApiHelper.GetTestSuitesByName(name);

            var orderedTestSuites = testSuites.OrderByDescending(ts => ts.EndTime);

            return(PartialView("TestSuiteCardList", orderedTestSuites));
        }
        public async Task <ActionResult> Latest(string category = null)
        {
            var latestTestRun = await TestResultRepoApiHelper.GetLatestTestRun(category);

            return(await Index(latestTestRun._Id));

            //return RedirectToAction("Index", "TestRuns", new {id = testRun._Id});
        }
        public async Task <ActionResult> Latest(string category = null)
        {
            var latestTestRun = await TestResultRepoApiHelper.GetLatestTestRun(category);

            var testRun = await TestResultRepoApiHelper.GetTestRunWithChildren(latestTestRun._Id);

            PopulateViewBag(testRun);
            return(View());
            //return RedirectToAction("Index", "TestRuns", new {id = testRun._Id});
        }
Exemple #6
0
        // GET: FlakyTests
        public ActionResult FlakyTests(TestRun testRun)
        {
            List <FlakyTestsGroup> flakyTestsGroups = new List <FlakyTestsGroup>();

            List <string> uniqueTestCaseNamesList = new List <string>();

            foreach (var suite in testRun.TestSuites)
            {
                foreach (var testCase in suite.TestCases)
                {
                    if (testCase.Result != Result.Skipped)
                    {
                        uniqueTestCaseNamesList.Add(testCase.Name);
                    }
                }
            }

            foreach (var uniqueName in uniqueTestCaseNamesList)
            {
                var testCases = TestResultRepoApiHelper.GetTestCasesByNameSync(uniqueName);

                testCases.RemoveAll(tc => DateTime.Parse(tc.EndTime) < DateTime.Now.AddDays(-21));

                if (testCases.Count == 0)
                {
                    continue;
                }

                // only use the last 20
                var orderedTestCases = testCases
                                       .OrderByDescending(tc => tc.EndTime)
                                       .Take(20);


                FlakyTestsGroup group = new FlakyTestsGroup(orderedTestCases.ToList());
                flakyTestsGroups.Add(group);
            }

            var orderedFlakyTestsGroups = flakyTestsGroups.OrderByDescending(g => g.FailureFactor).ToList();

            return(PartialView("FlakyTests", orderedFlakyTestsGroups));
        }
        // GET: TestCase
        public async Task <ActionResult> Index(string id)
        {
            // Return the listview if no id is provided
            if (id == null)
            {
                //var testCases = await HelperMethods.TestResultRepoApiHelper.GetAllTestCases();
                //var groupedTestCases = getGroupedTestCases(testCases);
                var uniqueNames = await HelperMethods.TestResultRepoApiHelper.GetUniqueTestCaseNames();

                if (uniqueNames == null)
                {
                    ViewBag.Message = "No such TestCase found.";
                }

                return(View("TestCaseGroupList", uniqueNames));
            }

            // Return the index view if id is provided
            var testCase = await HelperMethods.TestResultRepoApiHelper.GetTestCase(id);

            if (testCase != null)
            {
                ViewBag.testCase     = testCase;
                ViewBag.TestCaseName = testCase.Name;

                var testcases = await TestResultRepoApiHelper.GetTestCasesByName(testCase.Name);

                var orderedTestCases = testcases.OrderByDescending(tc => tc.EndTime);

                ViewBag.testCases = orderedTestCases;
            }
            else
            {
                ViewBag.Message = "No such TestCase found.";
            }

            return(View());
            //return View("TestCaseCard", testCase);
        }
        public async Task <ActionResult> Next(string id)
        {
            var testRuns = await TestResultRepoApiHelper.GetAllTestRuns();

            var orderedTestRuns = testRuns.OrderBy(tr => tr.EndTime).ToList();
            var indexOfCurrent  = orderedTestRuns.FindIndex(tr => tr._Id == id);

            string idOfNext;

            try
            {
                idOfNext = orderedTestRuns[indexOfCurrent + 1]._Id;
            }
            catch (ArgumentOutOfRangeException)
            {
                PopulateViewBag(await TestResultRepoApiHelper.GetTestRunWithChildren(id));
                return(View("Index"));
            }

            var testRun = await TestResultRepoApiHelper.GetTestRunWithChildren(idOfNext);

            PopulateViewBag(testRun);
            return(View("Index"));
        }
        public async Task <ActionResult> Index(string id)
        {
            // Return the listview if no id is provided
            if (id == null)
            {
                var testRuns = await TestResultRepoApiHelper.GetAllTestRuns();

                var orderedTestRuns = testRuns.OrderByDescending(run => run.EndTime).ToList();
                if (testRuns.Count != 0)
                {
                    ViewBag.Message  = "Here are the TestRuns you were looking for:";
                    ViewBag.testRuns = orderedTestRuns;
                }
                else
                {
                    ViewBag.Message = "No such TestRun found.";
                }

                return(View("All"));
            }

            // Return the index view if id is provided
            var testRun = await TestResultRepoApiHelper.GetTestRunWithChildren(id);

            if (testRun != null)
            {
                PopulateViewBag(testRun);
            }

            else
            {
                ViewBag.Message = "No such TestRun found.";
            }

            return(View());
        }
Exemple #10
0
        public async Task <ActionResult> Index(string Id)
        {
            TestSuite testSuite = await TestResultRepoApiHelper.GetTestSuite(Id);

            return(PartialView("TestSuiteCard", testSuite));
        }
Exemple #11
0
        public ActionResult RenderViewFromId(string Id)
        {
            TestSuite testSuite = TestResultRepoApiHelper.GetTestSuiteSync(Id);

            return(PartialView("TestSuiteCard", testSuite));
        }