Esempio n. 1
0
    def handle(self, *args, **options):
        rule_set = RuleSet.factory('My Rules', rules.A)

        flow = Flow.factory('Simple Flow', rule_set)
        root = flow.root_data
        root.add_child_rule(rules.B)

        flow = Flow.factory('Branching, Looping Flow', rule_set)
        root = flow.root_data
        node = root.add_child_rule(rules.C)
        node.add_child_rule(rules.D)
        node = node.add_child_rule(rules.E)
        node.connect_child(root)
Esempio n. 2
0
    def test_flow2(self):
        """Tests multipath, looping flow:
                   A
                   |
                   C
                  / \
                 D   E
                      \
                       A (loops)
        """
        flow = Flow.factory(name='Flow', rule_set=self.rule_set)
        root = flow.root_data
        node = root.add_child_rule(rules.C)
        node.add_child_rule(rules.D)

        # should not be able to add D a second time
        with self.assertRaises(AttributeError):
            node.add_child_rule(rules.D)

        node = node.add_child_rule(rules.E)
        node.connect_child(root)

        # -- start testing the flow
        rules.done_enter = []
        rules.done_leave = []
        state = State.start(flow=flow)
        self.assertEqual(rules.done_enter, ['A'])
        self.assertEqual(rules.done_leave, [])

        state.next_state()
        self.assertEqual(rules.done_enter, ['A', 'C'])
        self.assertEqual(rules.done_leave, ['A'])

        # next step requires a choice, can't use parameterless call
        with self.assertRaises(AttributeError):
            state.next_state()

        # next step must be D or E
        with self.assertRaises(AttributeError):
            state.next_state(rules.A)

        state.next_state(rules.E)
        state.next_state(rules.A)
        self.assertEqual(rules.done_enter, ['A', 'C', 'E', 'A'])
        self.assertEqual(rules.done_leave, ['A', 'C', 'E'])
Esempio n. 3
0
    def test_flow1(self):
        """Tests a simple flow:
                    A
                    |
                    B
        """
        flow = Flow.factory('Flow', self.rule_set)
        self.assertFalse(flow.in_use())
        root = flow.root_data

        # should not be able to add D as it is against the rules
        with self.assertRaises(AttributeError):
            root.add_child_rule(rules.D)

        # should be able to add B
        root.add_child_rule(rules.B)

        # should not be able to add B again as A isn't multipath
        with self.assertRaises(AttributeError):
            root.add_child_rule(rules.B)

        # --- State testing
        rules.done_enter = []
        rules.done_leave = []

        # starting should call A's on_enter
        state = State.start(flow)
        self.assertEqual(rules.done_enter, ['A'])
        self.assertEqual(rules.done_leave, [])

        # next step
        state.next_state()
        self.assertEqual(rules.done_leave, ['A'])
        self.assertEqual(rules.done_enter, ['A', 'B'])

        # no next step in Flow
        with self.assertRaises(AttributeError):
            state.next_state()

        # force __str__ calls for coverage
        str(flow)
        str(root)
        str(state)
Esempio n. 4
0
    def test_delete(self):
        flow = Flow.factory(name='Flow', rule_set=self.rule_set)
        flow.delete()

        self.assertEqual(Flow.objects.count(), 0)
        self.assertEqual(DCCGraph.objects.count(), 0)
Esempio n. 5
0
def create_flow(request, rule_set_id):
    rule_set = get_object_or_404(RuleSet, id=rule_set_id)
    flow = Flow.factory('New Flow', rule_set)
    return edit_flow(request, flow.id)