Пример #1
0
        public void GetSelfAndAncestorIds()
        {
            TestStepRunNode tree     = BuildFakeTree();
            var             child321 = tree.Children[2].Children[1].Children[0];

            Assert.AreElementsEqual(new[] { "Test-321", "Test-32", "Test-3", "Test-Root" }, child321.GetSelfAndAncestorIds());
        }
Пример #2
0
        public void GetNavigatorChildren()
        {
            TestStepRunNode tree = BuildFakeTree();
            IEnumerable <TestStepRunNode> nodes = tree.GetNavigatorChildren();

            Assert.AreElementsEqual(new[] { "321", "323", "324", "332" }, nodes.Select(x => x.Run.Step.Id));
        }
Пример #3
0
        private TestStepRunNode BuildFakeTree()
        {
            // Root
            //   +- Child1
            //   +- Child2
            //   +- Child3
            //       +- Child31
            //       +- Child32
            //           +- Child321
            //           +- Child322
            //           +- Child323
            //           +- Child324
            //       +- Child33
            //           +- Child331
            //           +- Child332
            //           +- Child333

            var child1   = CreateFakeTestStepRun("1", true, TestOutcome.Passed);
            var child2   = CreateFakeTestStepRun("2", true, TestOutcome.Passed);
            var child331 = CreateFakeTestStepRun("331", true, TestOutcome.Passed);
            var child332 = CreateFakeTestStepRun("332", true, TestOutcome.Pending);
            var child333 = CreateFakeTestStepRun("333", true, TestOutcome.Passed);
            var child33  = CreateFakeTestStepRun("33", false, TestOutcome.Passed, child331, child332, child333);
            var child321 = CreateFakeTestStepRun("321", true, TestOutcome.Inconclusive);
            var child322 = CreateFakeTestStepRun("322", true, TestOutcome.Passed);
            var child323 = CreateFakeTestStepRun("323", true, TestOutcome.Failed);
            var child324 = CreateFakeTestStepRun("324", true, TestOutcome.Ignored);
            var child32  = CreateFakeTestStepRun("32", false, TestOutcome.Failed, child321, child322, child323, child324);
            var child31  = CreateFakeTestStepRun("31", true, TestOutcome.Passed);
            var child3   = CreateFakeTestStepRun("3", false, TestOutcome.Failed, child31, child32, child33);
            var root     = CreateFakeTestStepRun("Root", false, TestOutcome.Failed, child1, child2, child3);

            return(TestStepRunNode.BuildTreeFromRoot(root));
        }
Пример #4
0
        public void IsVisibleInPage(int index, int pageIndex, bool expectedVisible)
        {
            var  run           = CreateFakeTestStepRun("123", true, TestOutcome.Passed);
            var  node          = new TestStepRunNode(run, null, index);
            bool actualVisible = node.IsVisibleInPage(pageIndex, 1000);

            Assert.AreEqual(expectedVisible, actualVisible);
        }
Пример #5
0
        public void Constructs_root_element() // i.e. without any parent
        {
            var run  = CreateFakeTestStepRun("123", true, TestOutcome.Passed);
            var node = new TestStepRunNode(run, null, 0);

            Assert.AreSame(run, node.Run);
            Assert.IsNull(node.Parent);
            Assert.AreEqual(0, node.Index);
            Assert.IsEmpty(node.Children);
            Assert.AreEqual(1, node.Count);
        }
Пример #6
0
        public void GetDetailsChildren_not_condensed()
        {
            TestStepRunNode tree = BuildFakeTree();
            IEnumerable <TestStepRunNode> nodes = tree.GetDetailsChildren(false);

            Assert.AreElementsEqual(new[] { "1", "2", "3" }, nodes.Select(x => x.Run.Step.Id));
            nodes = nodes.ElementAt(2).GetDetailsChildren(false);
            Assert.AreElementsEqual(new[] { "31", "32", "33" }, nodes.Select(x => x.Run.Step.Id));
            nodes = nodes.ElementAt(1).GetDetailsChildren(false);
            Assert.AreElementsEqual(new[] { "321", "322", "323", "324" }, nodes.Select(x => x.Run.Step.Id));
        }
Пример #7
0
        public void GetSummaryChildren_not_condensed()
        {
            TestStepRunNode tree = BuildFakeTree();
            IEnumerable <TestStepRunNode> nodes = tree.GetSummaryChildren(false);

            Assert.AreElementsEqual(new[] { "3" }, nodes.Select(x => x.Run.Step.Id));
            nodes = nodes.ElementAt(0).GetSummaryChildren(false);
            Assert.AreElementsEqual(new[] { "32", "33" }, nodes.Select(x => x.Run.Step.Id));
            nodes = nodes.ElementAt(0).GetSummaryChildren(false);
            Assert.IsEmpty(nodes);
        }
Пример #8
0
        public void Constructs_not_root_element()
        {
            var runParent = CreateFakeTestStepRun("123", false, TestOutcome.Passed);
            var parent    = new TestStepRunNode(runParent, null, 0);
            var run       = CreateFakeTestStepRun("456", true, TestOutcome.Passed);
            var node      = new TestStepRunNode(run, parent, 1);

            Assert.AreSame(run, node.Run);
            Assert.AreSame(parent, node.Parent);
            Assert.AreEqual(1, node.Index);
            Assert.IsEmpty(node.Children);
            Assert.AreEqual(1, node.Count);
        }
Пример #9
0
        public void BuildTreeFromRoot_with_null_root()
        {
            var tree = TestStepRunNode.BuildTreeFromRoot(null);

            Assert.AreEqual(1, tree.Count);
        }
Пример #10
0
        public void Count()
        {
            TestStepRunNode tree = BuildFakeTree();

            Assert.AreEqual(14, tree.Count);
        }