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'])
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)