def test_filtered_none_components_deps(self):
     """
     Check that dependencies are not in the graph when they are filtered out.
     RuleSet: #root -> #deps (filter = NONE)
     Components: a#root
     Component a provides a depfinder that returns b#deps
     Expecting: a#root, b#deps (b#deps has no action, it has been filtered out)
     """
     rules = set()
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="R-root",
                                 action="Root Action",
                                 types=["root@cat"],
                                 depsfinder=tools.getMockDepsFinderCmd(["b#deps@cat"]),
                                 dependson=["R-Deps"]))
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="R-Deps",
                                 action="Deps Action",
                                 types=["deps@cat"],
                                 filter=NONE))
     ruleset = RuleSet(rules)
     depgraph = ruleset.get_depgraph([Component("a#root@cat")])
     components = depgraph.components_map
     self.assertTrue(components is not None)
     self.assertEquals(len(components), 2)
     self.assertTrue(depgraph.dag is not None)
     self.assertTrue("a#root@cat" in components)
     self.assertTrue("R-root" in components["a#root@cat"].actions)
     self.assertEquals("Root Action", components["a#root@cat"].actions["R-root"])
     self.assertTrue("b#deps@cat" in components)
     self.assertTrue(depgraph.dag.has_node("a#root@cat"))
     self.assertTrue(depgraph.dag.has_node("b#deps@cat"))
     self.assertTrue("Deps Action" not in components["b#deps@cat"].actions)
 def test_a_nop_b(self):
     """
     Check that action NONE are understood correctly.
     RuleSet: #root, #dep (filter = ALL),
     a#root -> b#dep (a.action=NONE)
     Expecting: a#root -> b#dep
     But a#root has no attribute in the xml graph.
     """
     rules = set()
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Root",
                                 types=["root@cat"],
                                 action=NONE,
                                 depsfinder=tools.getMockDepsFinderCmd(["b#dep@cat"]),
                                 dependson=['Dep']))
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Dep",
                                 types=["dep@cat"],
                                 action="Dep Action"))
     ruleset = RuleSet(rules)
     depgraph = ruleset.get_depgraph([Component("a#root@cat")])
     components = depgraph.components_map
     self.assertTrue(components is not None)
     self.assertEquals(len(components), 2)
     self.assertTrue("a#root@cat" in components)
     self.assertTrue("b#dep@cat" in components)
     self.assertTrue(depgraph.dag is not None)
     self.assertTrue(depgraph.dag.has_node("a#root@cat"))
     self.assertTrue(depgraph.dag.has_node("b#dep@cat"))
     self.assertFalse("Root" in components["a#root@cat"].actions, components)
     self.assertTrue("Dep" in components["b#dep@cat"].actions)
     attributes = depgraph.dag.node_attributes("a#root@cat")
     self.assertEquals(len(attributes), 0)
     attributes = depgraph.dag.node_attributes("b#dep@cat")
     self.assertEquals(len(attributes), 1)
Esempio n. 3
0
    def test_checksum_different_types(self):
        rule1 = tools.create_rule(self.__class__.__name__, "R1")
        rule2 = tools.create_rule(self.__class__.__name__, "R2")
        self.db.add_rule(rule1)
        self.db.add_rule(rule2)
        (orig_ruleset_h, orig_h_for) = self.db.checksum(rule1.ruleset)

        self.db.remove_rules(rule1.ruleset)
        rule2 = tools.create_rule(self.__class__.__name__, "R2", types=["type@cat"])
        self.db.add_rule(rule1)
        self.db.add_rule(rule2)
        (other_ruleset_h, other_h_for) = self.db.checksum(rule1.ruleset)
        self.assertNotEquals(orig_ruleset_h.hexdigest(),
                             other_ruleset_h.hexdigest())
        self.assertNotEquals(orig_h_for["R2"].hexdigest(),
                             other_h_for["R2"].hexdigest())

        self.db.remove_rules(rule1.ruleset)
        rule1 = tools.create_rule(self.__class__.__name__, "R1", types=["type@cat", "ALL"])
        self.db.add_rule(rule1)
        self.db.add_rule(rule2)
        (other_ruleset_h, other_h_for) = self.db.checksum(rule1.ruleset)
        self.assertNotEquals(orig_ruleset_h.hexdigest(),
                             other_ruleset_h.hexdigest())
        self.assertNotEquals(orig_h_for["R1"].hexdigest(),
                             other_h_for["R1"].hexdigest())
Esempio n. 4
0
 def test_none_rulename_forbidden(self):
     try:
         tools.create_rule(self.__class__.__name__,
                           None)
         self.fail("Setting rule name to None should raise an exception!")
     except ValueError:
         pass
    def test_multiple_actions_cycle(self):
        """
        Check that a given component can contain multiple actions.
        RuleSet: R1:#ta, R2:#ta->R1
        Components: a#ta (R1 depsfinder returns itself: a#ta)
        Expecting: a#ta with 2 actions and a cycle.
        """
        rules = set()
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="R1",
                                    action="Action for a",
                                    types=["ta@cat"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="R2",
                                    action="Action for a",
                                    types=["ta@cat"],
                                    depsfinder=tools.getMockDepsFinderCmd(["a#ta@cat"]),
                                    dependson=["R1"]))
        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("a#ta@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 1, "Map: %s" % components)
        self.assertTrue("a#ta@cat" in components)
        self.assertTrue("R1" in components["a#ta@cat"].actions)
        self.assertTrue("R2" in components["a#ta@cat"].actions)
        self.assertEquals(len(components["a#ta@cat"].actions), 2)
        self.assertEquals(len(depgraph.dag.node_attributes("a#ta@cat")), 2)
        self.assertTrue(depgraph.dag.has_edge(("a#ta@cat", "a#ta@cat")))
 def test_simple_deps_ta_tb_b_a_nodepsfinder(self):
     """
     RuleSet: #ta->#tb,
     Components: b#tb, a#ta (reverse than test_simple_deps_ta_tb_a_b_nodepsfinder)
     Expecting: a#ta, b#tb (order does not count)
     """
     rules = set()
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Ra",
                                 action="Action for a",
                                 types=["ta@cat"],
                                 dependson=["Rb"]))
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Rb",
                                 action="Action for b",
                                 types=["tb@cat"]))
     ruleset = RuleSet(rules)
     depgraph = ruleset.get_depgraph([Component("b#tb@cat"),
                                      Component("a#ta@cat")])
     components = depgraph.components_map
     self.assertTrue(components is not None)
     self.assertEquals(len(components), 2)
     self.assertTrue("a#ta@cat" in components)
     self.assertTrue("b#tb@cat" in components)
     self.assertTrue(depgraph.dag is not None)
     self.assertTrue(depgraph.dag.has_node("a#ta@cat"))
     self.assertTrue(depgraph.dag.has_node("b#tb@cat"))
     self.assertNoEdgeBetween(depgraph.dag, "a#ta@cat", "b#tb@cat")
 def test_simple_nodeps_ta_tb_a_b(self):
     """
     RuleSet: #ta, #tb,
     Components: a#ta, b#tb
     Expecting: a#ta, b#tb
     """
     rules = set()
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Ra",
                                 action="Action for a",
                                 types=["ta@cat"]))
     rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                 name="Rb",
                                 action="Action for b",
                                 types=["tb@cat"]))
     ruleset = RuleSet(rules)
     depgraph = ruleset.get_depgraph([Component("a#ta@cat"),
                                      Component("b#tb@cat")])
     components = depgraph.components_map
     self.assertTrue(components is not None)
     self.assertEquals(len(components), 2)
     self.assertTrue("a#ta@cat" in components)
     self.assertTrue("b#tb@cat" in components)
     self.assertTrue(depgraph.dag is not None)
     self.assertTrue(depgraph.dag.has_node("a#ta@cat"))
     self.assertTrue(depgraph.dag.has_node("b#tb@cat"))
     self.assertTrue("Ra" in components["a#ta@cat"].actions)
     self.assertEquals("Action for a", components["a#ta@cat"].actions["Ra"])
     self.assertTrue("Rb" in components["b#tb@cat"].actions)
     self.assertEquals("Action for b", components["b#tb@cat"].actions["Rb"])
     self.assertNoEdgeBetween(depgraph.dag, "a#ta@cat", "b#tb@cat")
    def test_multiple_actions_nodeps(self):
        """
        Check that a given component can contain multiple actions.
        RuleSet: #ta, #ta
        Components: a#ta
        Expecting: a#ta with 2 actions.
        """
        rules = set()
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="R1",
                                    action="Action for a",
                                    types=["ta@cat"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="R2",
                                    action="Action for a",
                                    types=["ta@cat"]))
        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("a#ta@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 1, "Map: %s" % components)
        self.assertTrue("a#ta@cat" in components)
        self.assertTrue("R1" in components["a#ta@cat"].actions)
        self.assertTrue("R2" in components["a#ta@cat"].actions)
        self.assertEquals(len(components["a#ta@cat"].actions), 2)
        self.assertEquals(len(depgraph.dag.node_attributes("a#ta@cat")), 2)
    def test_root_in_simple_cycle(self):
        """
        The root is in a simple cycle.
        RuleSet: #ta->#tb, #tb->#tc, #tc->#ta (triangle)
        Components: b#tb
        Expecting: b#tb
        """
        rules = set()
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Ra",
                                    action="Action for a",
                                    types=["ta@cat"],
                                    dependson=["Rb"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Rb",
                                    action="Action for b",
                                    types=["tb@cat"],
                                    dependson=["Rc"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Rc",
                                    action="Action for c",
                                    dependson=["Ra"],
                                    types=["tc@cat"]))
        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("b#tb@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 1, "Map: %s" % components)
        self.assertTrue("b#tb@cat" in components)
        self.assertTrue(depgraph.dag is not None)
        self.assertTrue(depgraph.dag.has_node("b#tb@cat"))
Esempio n. 10
0
    def test_no_root_with_cycle_in_graph_rules(self):
        """
        There are no match in the given component list.
        RuleSet: #ta->#tb->#ta
        Components: c#tc
        Expecting: c#tc.
        """
        rules = set()
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Ra",
                                    action="Action for a",
                                    types=["ta@cat"],
                                    depsfinder=tools.getMockDepsFinderCmd(["foo#bar@cat"]),
                                    dependson=["Rb"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Rb",
                                    action="Action for b",
                                    types=["tb@cat"],
                                    depsfinder=tools.getMockDepsFinderCmd(["foo#bar@cat"]),
                                    dependson=["Ra"]))

        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("c#tc@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 1, "Map: %s" % components)
        self.assertTrue("c#tc@cat" in components)
        self.assertTrue(depgraph.dag is not None)
        self.assertEquals(len(depgraph.dag.nodes()), 1)
        self.assertTrue(depgraph.dag.has_node("c#tc@cat"))
Esempio n. 11
0
    def test_simple_deps_ta_tb_b_a_withdepsfinder(self):
        """
        RuleSet: #ta->#tb,
        Components: b#tb, a#ta (reverse)
        Component a does provide a depfinder that returns b#tb
        Expecting: a#ta -> b#tb
        """
        rules = set()
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Ra",
                                    action="Action for a",
                                    types=["ta@cat"],
                                    depsfinder=tools.getMockDepsFinderCmd(["b#tb@cat"]),
                                    dependson=["Rb"]))
        rules.add(tools.create_rule(ruleset=self.__class__.__name__,
                                    name="Rb",
                                    action="Action for b",
                                    types=["tb@cat"]))
        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("b#tb@cat"),
                                         Component("a#ta@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 2, "Map: %s" % components)
        self.assertTrue("a#ta@cat" in components)
        self.assertTrue("b#tb@cat" in components)
        self.assertTrue(depgraph.dag is not None)
        self.assertTrue(depgraph.dag.has_node("a#ta@cat"))
        self.assertTrue(depgraph.dag.has_node("b#tb@cat"))
        self.assertTrue(depgraph.dag.has_edge(("a#ta@cat", "b#tb@cat")))
Esempio n. 12
0
 def test_empty_depsfinder_forbidden(self):
     try:
         tools.create_rule(self.__class__.__name__,
                           "EmptyDepsFinderForbidden",
                           depsfinder="")
         self.fail("Setting an empty depsfinder should raise an exception!")
     except ValueError:
         pass
Esempio n. 13
0
    def test_rule_pass_filter_re_category(self):
        rule = tools.create_rule("RS", "RN", filter="%category =~ cat")
        self.assertTrue(rule.pass_filter(Component("foo#bar@cat")))
        self.assertFalse(rule.pass_filter(Component("bar#foo@baz")))

        rule = tools.create_rule("RS", "RN", filter="%category !~ cat")
        self.assertFalse(rule.pass_filter(Component("foo#bar@cat")))
        self.assertTrue(rule.pass_filter(Component("bar#foo@baz")))
Esempio n. 14
0
    def test_rule_pass_filter_re_type(self):
        rule = tools.create_rule("RS", "RN", filter="%type =~ bar")
        self.assertTrue(rule.pass_filter(Component("foo#bar@cat")))
        self.assertFalse(rule.pass_filter(Component("bar#foo@cat")))

        rule = tools.create_rule("RS", "RN", filter="%type !~ bar")
        self.assertFalse(rule.pass_filter(Component("foo#bar@cat")))
        self.assertTrue(rule.pass_filter(Component("bar#foo@cat")))
Esempio n. 15
0
 def test_empty_types_forbidden(self):
     try:
         tools.create_rule(self.__class__.__name__,
                           "EmptyTypesForbidden",
                           types=set())
         self.fail("Setting an empty set should raise an exception!")
     except ValueError:
         pass
Esempio n. 16
0
 def test_baddep2(self):
     rule1 = tools.create_rule(self.__class__.__name__, "BadDep2-1")
     rule2 = tools.create_rule(self.__class__.__name__, "BadDep2-2", dependson="Unknown")
     rules = set([rule1, rule2])
     try:
         RuleSet(rules)
         self.fail("Unknown Dependency should be raised: %s" % rule2)
     except UnknownDepError as ude:
         print "Exception is: %s" % ude
Esempio n. 17
0
 def test_update_name_deps_simple(self):
     self.db.add_rule(tools.create_rule("RS", "r1"))
     self.db.add_rule(tools.create_rule("RS", "r2", dependson=set(['r1'])))
     self.db.update_rule("RS", "r1", [("name", "foo")])
     rules = self.db.get_rules_for("RS")
     self.assertTrue(rules is not None)
     self.assertEquals(len(rules), 2)
     self.assertEquals(len(rules["r2"].dependson), 1)
     self.assertTrue("foo" in rules["r2"].dependson)
Esempio n. 18
0
 def test_update_ruleset(self):
     rule = tools.create_rule(self.__class__.__name__, "update")
     self.db.add_rule(rule)
     self.db.update_rule(rule.ruleset, rule.name, [("ruleset", "NewRS")])
     rules_for = self.db.get_rules_map()
     self.assertTrue(rules_for is not None)
     self.assertEquals(len(rules_for), 1, str(rules_for))
     self.assertRuleInMap(tools.create_rule("NewRS", "update"),
                          rules_for)
Esempio n. 19
0
 def test_dup_forbidden(self):
     rule1 = tools.create_rule(self.__class__.__name__, "DupForbidden")
     rule2 = tools.create_rule(self.__class__.__name__, "DupForbidden")
     self.assertEquals(rule1, rule2)
     self.db.add_rule(rule1)
     try:
         self.db.add_rule(rule2)
         self.fail("Duplicate rules are forbidden in the DB")
     except Exception as e:
         print "Exception is: %s" % e
Esempio n. 20
0
    def test_rule_match_type_multiple(self):
        rule = tools.create_rule("RS", "RN", types=["bar@cat", "baz@cat"])
        self.assertTrue(rule.match_type(Component("foo#bar@cat")))
        self.assertTrue(rule.match_type(Component("foo#baz@cat")))
        self.assertFalse(rule.match_type(Component("bar#foo@cat")))

        rule = tools.create_rule("RS", "RN", types=["bar@cat1", "baz@cat2"])
        self.assertTrue(rule.match_type(Component("foo#bar@cat1")))
        self.assertTrue(rule.match_type(Component("foo#baz@cat2")))
        self.assertFalse(rule.match_type(Component("foo#bar@cat2")))
        self.assertFalse(rule.match_type(Component("foo#baz@cat1")))
Esempio n. 21
0
 def test_dup_forbidden(self):
     rule1 = tools.create_rule(self.__class__.__name__, "DupForbidden")
     rule2 = tools.create_rule(self.__class__.__name__, "DupForbidden")
     self.assertEquals(rule1, rule2)
     self.db.add_rule(rule1)
     try:
         self.db.add_rule(rule2)
         self.fail("Duplicate rules are forbidden in the DB")
     except DuplicateRuleError as dre:
         self.assertEquals(dre.ruleset, self.__class__.__name__)
         self.assertEquals(dre.name, "DupForbidden")
Esempio n. 22
0
 def test_cycles_simple(self):
     """Cycles are allowed in the graph rules"""
     rules = set()
     rules.add(tools.create_rule(self.__class__.__name__,
                                 "nocycles_simple1",
                                 dependson=["nocycles_simple2"]))
     rules.add(tools.create_rule(self.__class__.__name__,
                                 "nocycles_simple2",
                                 dependson=["nocycles_simple1"]))
     # This should not raise an exception
     RuleSet(rules)
Esempio n. 23
0
 def test_ruleset_different(self):
     rules = set()
     rules.add(tools.create_rule(self.__class__.__name__,
                                 "ruleset_different"))
     rules.add(tools.create_rule(self.__class__.__name__ + "-2",
                                 "ruleset_different"))
     try:
         RuleSet(rules)
         self.fail("Creating a RuleSet with different " + \
                       "ruleset should raise an exception")
     except ValueError:
         pass
Esempio n. 24
0
    def test_remove_ref_deps_single(self):
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "r1"))
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "r2",
                                           dependson=set(['r1'])))

        remaining = self.db.remove_rules(self.__class__.__name__, ("r1",))
        self.assertEquals(len(remaining), 0)
        rules = self.db.get_rules_for(self.__class__.__name__)
        self.assertTrue(rules is not None)
        self.assertEquals(len(rules), 1)
        self.assertTrue("r2" in rules)
        self.assertEquals(len(rules["r2"].dependson), 0)
Esempio n. 25
0
 def test_root_rules_for_a_a(self):
     rules = set()
     r1 = tools.create_rule(
         ruleset=self.__class__.__name__, name="R1", action="A1", types=["ta@cat"], dependson=["R2"]
     )
     r2 = tools.create_rule(ruleset=self.__class__.__name__, name="R2", action="A2", types=["ta@cat"])
     rules.add(r1)
     rules.add(r2)
     ruleset = RuleSet(rules)
     types = ruleset.root_rules_for
     self.assertTrue(len(types) == 1, types)
     self.assertTrue(r1 in types["ta@cat"], types)
Esempio n. 26
0
    def test_remove_whole_ruleset(self):
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove1"))
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove2"))
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove3"))
        self.db.add_rule(tools.create_rule("other_ruleset", "a_rule"))

        remaining = self.db.remove_rules(self.__class__.__name__)
        self.assertEquals(len(remaining), 0)
        rules_for = self.db.get_rules_map()
        self.assertTrue(rules_for is not None)
        self.assertEquals(len(rules_for), 1)
        self.assertTrue(self.__class__.__name__ not in rules_for)
        self.assertEquals(len(rules_for["other_ruleset"]), 1)
Esempio n. 27
0
    def test_multiple_removal(self):
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove1"))
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove2"))
        self.db.add_rule(tools.create_rule(self.__class__.__name__, "remove3"))

        remaining = self.db.remove_rules(self.__class__.__name__,
                                        ("remove1", "remove2", "unknown"))
        self.assertEquals(len(remaining), 1)
        self.assertTrue("unknown" in remaining)
        rules = self.db.get_rules_for(self.__class__.__name__)
        self.assertTrue(rules is not None)
        self.assertEquals(len(rules), 1)
        self.assertTrue("remove3" in rules)
Esempio n. 28
0
    def test_only_root_rules_applied(self):
        """
        Check that a rule is applied on a parameter only if it is a
        potential root.

        RuleSet: #t(action1)->#t(action2)
        Components: a#t, b#t (a#t depsfinder returns b#t)
        Expecting: a#t contains only 1 action while b#t contains two actions.
        """
        rules = set()
        rules.add(
            tools.create_rule(
                ruleset=self.__class__.__name__,
                name="Ra",
                action="Action for a",
                types=["t@cat"],
                filter="%name =~ a",
                depsfinder=tools.getMockDepsFinderCmd(["b#t@cat"]),
                dependson=["Rdep"],
            )
        )
        rules.add(
            tools.create_rule(
                ruleset=self.__class__.__name__,
                name="Rb",
                action="Action for b",
                types=["t@cat"],
                filter="%name =~ b",
                dependson=["Rdep"],
            )
        )
        rules.add(
            tools.create_rule(ruleset=self.__class__.__name__, name="Rdep", action="Action for dep", types=["t@cat"])
        )

        ruleset = RuleSet(rules)
        depgraph = ruleset.get_depgraph([Component("a#t@cat"), Component("b#t@cat")])
        components = depgraph.components_map

        self.assertTrue(components is not None)
        self.assertEquals(len(components), 2, "Map: %s" % components)
        self.assertTrue("a#t@cat" in components)
        self.assertTrue("b#t@cat" in components)
        self.assertEquals(len(components["a#t@cat"].actions), 1)
        self.assertTrue("Ra" in components["a#t@cat"].actions)
        self.assertEquals(len(components["b#t@cat"].actions), 2)
        self.assertTrue("Rb" in components["b#t@cat"].actions)
        self.assertTrue("Rdep" in components["b#t@cat"].actions)

        self.assertEquals(len(depgraph.dag.node_attributes("a#t@cat")), 1)
        self.assertEquals(len(depgraph.dag.node_attributes("b#t@cat")), 2)
Esempio n. 29
0
 def test_update_normal_fields(self):
     rule = tools.create_rule(self.__class__.__name__, "update_normal")
     self.db.add_rule(rule)
     self.db.update_rule(rule.ruleset, rule.name, [("action", "NewAction"),
                                                   ("filter", "NewFilter")])
     rules_for = self.db.get_rules_map()
     self.assertTrue(rules_for is not None)
     self.assertEquals(len(rules_for), 1, str(rules_for))
     self.assertRuleInMap(tools.create_rule(self.__class__.__name__,
                                            "update_normal"),
                          rules_for)
     rule = rules_for[self.__class__.__name__]["update_normal"]
     self.assertEquals(rule.action, "NewAction")
     self.assertEquals(rule.filter, "NewFilter")
Esempio n. 30
0
 def test_update_ruleset_deps_multiple(self):
     self.db.add_rule(tools.create_rule("RS", "r1"))
     self.db.add_rule(tools.create_rule("RS", "r2", dependson=set(['r1'])))
     self.db.add_rule(tools.create_rule("RS", "r3", dependson=set(['r1', "r2"])))
     self.db.update_rule("RS", "r1", [("ruleset", "newRS")])
     rules = self.db.get_rules_for("RS")
     self.assertTrue(rules is not None)
     self.assertEquals(len(rules), 2)
     self.assertEquals(len(rules["r2"].dependson), 0)
     self.assertEquals(len(rules["r3"].dependson), 1)
     self.assertTrue("r2" in rules["r3"].dependson)
     rules = self.db.get_rules_for("newRS")
     self.assertTrue(rules is not None)
     self.assertEquals(len(rules), 1)
     self.assertTrue("r1" in rules)