private static TestDataNode AddMetadataNode(TestData testData, string metadataType, 
     TestTreeNode rootNode, Node parentNode)
 {
     var testDataNode = new TestDataNode(testData);
     
     var metadataList = testData.Metadata[metadataType];
     if (metadataList.Count > 0)
     {
         foreach (string metadata in metadataList)
         {
             var metadataNode = FindOrAddMetadataNode(metadataType, rootNode, metadata);
             metadataNode.Nodes.Add(testDataNode);
             testDataNode = new TestDataNode(testData); // can't re-use node
         }
     }
     else if (parentNode != null)
     {
         parentNode.Nodes.Add(testDataNode);
     }
     else
     {
         var metadataNode = FindOrAddMetadataNode(metadataType, rootNode, "None");
         metadataNode.Nodes.Add(testDataNode);
     }
     return testDataNode;
 }
        private static TestTreeNode AddNode(TestData testData, TestTreeNode parent,
            TreeBuilderOptions options)
        {
            var testTreeNode = new TestDataNode(testData);

            if (options.NamespaceHierarchy == NamespaceHierarchy.Flat)
            {
                if (FixtureNode(testData) && parent.TestKind != TestKinds.Namespace)
                {
                    var @namespace = testData.CodeReference.NamespaceName;
                    parent = FindOrAddNamespaceNode(parent, @namespace, @namespace);
                }
                else if (testTreeNode.TestKind == TestKinds.Namespace)
                {
                    return parent;
                }
            }

            if (FixtureNode(testData) && parent.TestKind != TestKinds.Namespace) 
            {
                parent = BuildNamespaceNode(testData, parent, options);
            }
            
            parent.Nodes.Add(testTreeNode);
         
            return testTreeNode;
        }
        public void Test_node_should_be_returned_if_status_is_not_filtered()
        {
            var node = new TestTreeNode("name", "text")
            {
                TestKind = TestKinds.Test,
                TestStatus = TestStatus.Failed
            };
            innerTreeModel.Stub(ttm => ttm.GetChildren(Arg<TreePath>.Is.Anything))
                .Return(new[] { node });
            treeModel.Handle(new FilterTestStatusEvent(TestStatus.Passed));

            var children = treeModel.GetChildren(new TreePath());

            bool foundNode = false;
            foreach (var child in children)
            {
                var testTreeNode = child as TestTreeNode;

                if (testTreeNode == null)
                    continue;

                if (testTreeNode != node) 
                    continue;
                
                foundNode = true;
                break;
            }
            Assert.IsTrue(foundNode);
        }
        public void Filtering_node()
        {
            var node = new TestTreeNode("id", "text");

            node.IsFiltered = true;

            Assert.IsTrue(node.IsFiltered);
        }
        public void Node_should_be_unchecked_when_filtered()
        {
            var node = new TestTreeNode("id", "text");

            node.IsFiltered = true;

            Assert.AreEqual(CheckState.Unchecked, node.CheckState);
        }
        public void If_applied_filter_set_is_none_filter_then_the_root_should_be_unchecked()
        {
            var testTreeNode = new TestTreeNode("root", "root");
            testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode);
            var filterSet = new FilterSet<ITestDescriptor>(new NoneFilter<ITestDescriptor>());

            filterService.ApplyFilterSet(filterSet);

            Assert.AreEqual(CheckState.Unchecked, testTreeNode.CheckState);
        }
        public void Node_check_status_should_be_unchanged_when_unfiltered()
        {
            var node = new TestTreeNode("id", "text")
            {
                CheckState = CheckState.Checked
            };

            node.IsFiltered = false;

            Assert.AreEqual(CheckState.Checked, node.CheckState);
        }
        public void If_applied_filter_set_is_empty_then_the_root_should_be_checked()
        {
            var testTreeNode = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Unchecked
            };
            testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode);

            filterService.ApplyFilterSet(FilterSet<ITestDescriptor>.Empty);

            Assert.AreEqual(CheckState.Checked, testTreeNode.CheckState);
        }
        public void When_a_nodes_test_status_is_updated_its_parent_should_be_too()
        {
            var parent = new TestTreeNode("parent", "parent");
            var child1 = new TestTreeNode("child1", "child1");
            var child2 = new TestTreeNode("child2", "child2");
            parent.Nodes.Add(child1);
            parent.Nodes.Add(child2);

            child1.TestStatus = TestStatus.Passed;

            Assert.AreEqual(TestStatus.Passed, parent.TestStatus);
        }
        private static void PopulateMetadataTree(IProgressMonitor progressMonitor, string metadataType,
            TestData testData, Node parentNode, TestTreeNode rootNode)
        {
            TestDataNode testDataNode = AddMetadataNode(testData, metadataType, 
                rootNode, parentNode);

            foreach (var childTestData in testData.Children)
            {
                PopulateMetadataTree(progressMonitor, metadataType, childTestData,
                    testDataNode, rootNode);
            }

            progressMonitor.Worked(1);
        }
        public void Alphanumeric_comparison()
        {
            var node1 = new TestTreeNode("id", "AAA");
            var node2 = new TestTreeNode("id", "10A");
            var node3 = new TestTreeNode("id", "1AA");
            var node4 = new TestTreeNode("id", "ABC");
            var list = new List<TestTreeNode> { node4, node2, node3, node1 };

            list.Sort();

            Assert.That(list[0], Is.EqualTo(node3));
            Assert.That(list[1], Is.EqualTo(node2));
            Assert.That(list[2], Is.EqualTo(node1));
            Assert.That(list[3], Is.EqualTo(node4));
        }
        private static void PopulateNamespaceTree(IProgressMonitor progressMonitor, IList<TestData> list,
            TestTreeNode parent, TreeBuilderOptions options)
        {
            for (var i = 0; i < list.Count; i++)
            {
                var testData = list[i];

                var testTreeNode = AddNode(testData, parent, 
                    options);

                // process child nodes
                PopulateNamespaceTree(progressMonitor, testData.Children, testTreeNode,
                    options);

                progressMonitor.Worked(1);
            }
        }
        public void If_test_status_is_Passed_text_should_be_passed_color()
        {
            var passedColor = Color.Firebrick;
            var nodeTextBox = new TestTestNodeTextBox
            {
                PassedColor = passedColor
            };
            var treeNode = new TestTreeNode("id", "text")
            {
                TestStatus = TestStatus.Passed
            };
            var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode), 
                nodeTextBox, new DrawContext(), "text");

            nodeTextBox.TestOnDrawText(eventArgs);

            Assert.AreEqual(passedColor, eventArgs.TextColor);
        }
        public void If_test_status_is_Skipped_text_should_be_failed_color()
        {
            var skippedColor = Color.Khaki;
            var nodeTextBox = new TestTestNodeTextBox
            {
                SkippedColor = skippedColor
            };
            var treeNode = new TestTreeNode("id", "text")
            {
                TestStatus = TestStatus.Skipped
            };
            var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode),
                nodeTextBox, new DrawContext(), "text");

            nodeTextBox.TestOnDrawText(eventArgs);

            Assert.AreEqual(skippedColor, eventArgs.TextColor);
        }
        public void Test_node_should_not_be_returned_if_status_is_filtered()
        {
            var node = new TestTreeNode("name", "text")
            {
                TestKind = TestKinds.Test,
                TestStatus = TestStatus.Passed
            };
            innerTreeModel.Stub(ttm => ttm.GetChildren(Arg<TreePath>.Is.Anything))
                .Return(new [] { node });
            treeModel.Handle(new FilterTestStatusEvent(TestStatus.Passed));

            var children = treeModel.GetChildren(new TreePath());

            foreach (var child in children)
            {
                var testTreeNode = child as TestTreeNode;

                if (testTreeNode == null)
                    continue;

                if (testTreeNode == node)
                    Assert.Fail("Node should have been filtered.");
            }
        }
        public void If_test_status_is_Inconclusive_text_should_be_inconclusive_color()
        {
            var inconclusiveColor = Color.Magenta;
            var nodeTextBox = new TestTestNodeTextBox
            {
                InconclusiveColor = inconclusiveColor
            };
            var treeNode = new TestTreeNode("id", "text")
            {
                TestStatus = TestStatus.Inconclusive
            };
            var eventArgs = new DrawEventArgs(new TreeNodeAdv(treeNode),
                nodeTextBox, new DrawContext(), "text");

            nodeTextBox.TestOnDrawText(eventArgs);

            Assert.AreEqual(inconclusiveColor, eventArgs.TextColor);
        }
        public void Generated_filter_should_be_empty_if_tree_model_root_is_checked()
        {
            var testTreeNode = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Checked
            };
            testTreeModel.Stub(ttm => ttm.Root).Return(testTreeNode);

            var filterSet = filterService.GenerateFilterSetFromSelectedTests();

            Assert.IsTrue(filterSet.IsEmpty);
        }
        private static IEnumerable<TestTreeNode> GetSelectedNodes(TestTreeNode testTreeNode)
        {
            var nodes = new List<TestTreeNode>();

            if (testTreeNode is NamespaceNode)
            {
                nodes.AddRange(((NamespaceNode)testTreeNode).GetChildren());
            }
            else
            {
                nodes.Add(testTreeNode);
            }
            return nodes;
        }
Example #19
0
        private Filter<ITestDescriptor> GetNamespaceFilter(TestTreeNode namespaceNode)
        {
            var equalityFilter = new EqualityFilter<string>(namespaceNode.Id);
            var namespaceFilter = new NamespaceFilter<ITestDescriptor>(equalityFilter);
            
            if (optionsController.NamespaceHierarchy == NamespaceHierarchy.Flat)
                return namespaceFilter;

            var filters = new List<Filter<ITestDescriptor>> { namespaceFilter };

            foreach (var n in namespaceNode.Nodes)
            {
                var node = n as NamespaceNode;

                if (node == null)
                    continue;

                var filter = GetNamespaceFilter(node);

                if (filter != null)
                {
                    filters.Add(filter);
                }
            }

            return filters.Count > 1 ? new OrFilter<ITestDescriptor>(filters)
                : filters[0];
        }
 public TestNodeNamespace(TestTreeNode parent, string name)
     : base(parent, name, true)
 {
 }
Example #21
0
 private Filter<ITestDescriptor> CreateFilterForNode(TestTreeNode node)
 {
     Filter<ITestDescriptor> filter = null;
     switch (node.CheckState)
     {
         case CheckState.Checked:
             {
                 filter = GenerateFilter(node);
                 break;
             }
         case CheckState.Indeterminate:
             {
                 filter = CreateFilter(node.Nodes);
                 break;
             }
     }
     return filter;
 }
Example #22
0
        private Filter<ITestDescriptor> GenerateFilter(TestTreeNode node)
        {
            var equalityFilter = new EqualityFilter<string>(node.Id);

            if (node is NamespaceNode)
            {
                return GetNamespaceFilter(node);
            }

            if (node is TestDataNode)
            {
                return new IdFilter<ITestDescriptor>(equalityFilter);
            }

            if (node is MetadataNode && node.Id != "None")
            {
                return new MetadataFilter<ITestDescriptor>(node.TestKind, equalityFilter);
            }

            return CreateFilter(node.Nodes);
        }
        public void Generated_filter_should_be_none_if_tree_model_root_is_unchecked()
        {
            var root = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Unchecked
            };
            testTreeModel.Stub(ttm => ttm.Root).Return(root);

            var filterSet = filterService.GenerateFilterSetFromSelectedTests();

            Assert.IsInstanceOfType(typeof(NoneFilter<ITestDescriptor>), 
                filterSet.Rules[0].Filter);
        }
 private static TestTreeNode FindOrAddMetadataNode(string metadataType, 
     TestTreeNode rootTestDataNode, string metadata)
 {
     TestTreeNode metadataNode;
     var nodes = rootTestDataNode.Find(metadata, false);
     if (nodes.Count > 0)
     {
         metadataNode = nodes[0];
     }
     else
     {
         metadataNode = new MetadataNode(metadata, metadataType);
         rootTestDataNode.Nodes.Add(metadataNode);
     }
     return metadataNode;
 }
        public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_namespace_is_checked()
        {
            var root = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Indeterminate
            };
            var child = new TestTreeNode("child", "child")
            {
                CheckState = CheckState.Checked
            };
            root.Nodes.Add(child);
            const string @namespace = "Gallio.Icarus.Tests.Services";
            child.Nodes.Add(new NamespaceNode(@namespace, @namespace)
            {
                CheckState = CheckState.Checked
            });
            testTreeModel.Stub(ttm => ttm.Root).Return(root);

            var filterSet = filterService.GenerateFilterSetFromSelectedTests();

            var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter;
            Assert.IsInstanceOfType(typeof(NamespaceFilter<ITestDescriptor>),
                filter);
            Assert.AreEqual(true, filter.ValueFilter.IsMatch(@namespace));
        }
        public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_test_data_is_checked()
        {
            var root = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Indeterminate
            };
            var child = new TestTreeNode("child", "child")
            {
                CheckState = CheckState.Indeterminate
            };
            root.Nodes.Add(child);
            const string id = "id";
            child.Nodes.Add(new TestDataNode(new TestData(id, "name", "fullName"))
            {
                CheckState = CheckState.Checked
            });
            child.Nodes.Add(new Node());
            testTreeModel.Stub(ttm => ttm.Root).Return(root);

            var filterSet = filterService.GenerateFilterSetFromSelectedTests();

            var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter;
            Assert.IsInstanceOfType(typeof(IdFilter<ITestDescriptor>),
                filter);
            Assert.AreEqual(true, filter.ValueFilter.IsMatch(id));
        }
        public void Generated_filter_should_be_correct_if_root_is_indeterminate_and_metadata_is_checked()
        {
            var root = new TestTreeNode("root", "root")
            {
                CheckState = CheckState.Indeterminate
            };
            const string category = "blahblah";
            const string metadataType = MetadataKeys.Category;
            root.Nodes.Add(new MetadataNode(category, metadataType)
            {
                CheckState = CheckState.Checked
            });
            testTreeModel.Stub(ttm => ttm.Root).Return(root);

            var filterSet = filterService.GenerateFilterSetFromSelectedTests();

            var filter = (PropertyFilter<ITestDescriptor>)filterSet.Rules[0].Filter;
            Assert.IsInstanceOfType(typeof(MetadataFilter<ITestDescriptor>),
                filter);
            Assert.AreEqual(metadataType, filter.Key);
            Assert.AreEqual(true, filter.ValueFilter.IsMatch(category));
        }
        private static TestTreeNode FindOrAddNamespaceNode(TestTreeNode parent, string @namespace, string text)
        {
            var namespaceNode = FindNamespaceNode(parent, text) 
                ?? new NamespaceNode(@namespace, text);

            parent.Nodes.Add(namespaceNode);
            parent = namespaceNode;

            return parent;
        }
        private static TestTreeNode BuildNamespaceNode(TestComponentData testData, 
            TestTreeNode parent, TreeBuilderOptions options)
        {
            var @namespace = testData.CodeReference.NamespaceName;

            if (string.IsNullOrEmpty(@namespace))
                return parent;

            if (options.NamespaceHierarchy == NamespaceHierarchy.Flat)
            {
                parent = FindOrAddNamespaceNode(parent, @namespace, @namespace);
                return parent;
            }

            var namespaces = @namespace.Split('.');

            foreach (var namespaceSegment in namespaces)
            {
                if (namespaceSegment.Length == 0)
                    continue;

                parent = FindOrAddNamespaceNode(parent, @namespace, namespaceSegment);
            }

            return parent;
        }