def test_register_module_custom_name(self):
smc = StateMachineCrawler(None, InitialState)
smc.register_collection(
StateCollection.from_module(non_tpl_cases, "FooBar"))
rval = self._get_raw_state(smc)
print_struct(rval)
self.assertEqual(
rval, {
"FooBar.TplStateTwo": {
"transitions": {
"tests.cases.StateTwo": {
"name": "to_another_unknown_target"
}
}
},
"FooBar.TplStateOne": {
"transitions": {
"FooBar.TplStateTwo": {
"name": "from_one"
},
"tests.cases.StateOne": {
"name": "to_unknown_target"
}
}
},
"tests.cases.InitialState": {
"transitions": {
"FooBar.TplStateOne": {
"name": "from_root"
},
"tests.cases.StateOne": {
"name": "from_initial_state"
}
}
},
"tests.cases.StateTwo": {
"transitions": {}
},
"state_machine_crawler.state_machine_crawler.EntryPoint": {
"transitions": {
"tests.cases.InitialState": {
"name": "init"
}
}
},
"tests.cases.StateOne": {
"transitions": {
"tests.cases.StateTwo": {
"name": "from_state_one"
},
"tests.cases.StateOne": {
"name": "reset"
}
}
}
})
def test_duplicated_collection(self):
smc = StateMachineCrawler(mock.Mock(), InitialState)
collection_one = StateCollection("foobar")
collection_two = StateCollection("foobar")
smc.register_collection(collection_one)
self.assertRaisesRegexp(
DeclarationError,
"Collection called 'foobar' was already registred.",
smc.register_collection, collection_two)
def test_register_module(self):
smc = StateMachineCrawler(mock.Mock(), InitialState)
smc.register_module(non_tpl_cases)
states = sorted([src.full_name for src in smc._state_graph])
self.assertEqual(states, [
'state_machine_crawler.state_machine_crawler.EntryPoint',
'tests.cases.InitialState', 'tests.cases.StateOne',
'tests.cases.StateTwo', 'tests.non_tpl_cases.TplStateOne',
'tests.non_tpl_cases.TplStateTwo'
])
def test_register_not_a_state(self):
class NotAState:
pass
smc = StateMachineCrawler(mock.Mock(), InitialState)
self.assertRaisesRegexp(DeclarationError,
"state .* must be a subclass of State",
smc.register_state, NotAState)
def setUpClass(cls):
cls.target = mock.Mock()
cls.smc = StateMachineCrawler(cls.target, InitialState)
for state in ALL_STATES:
cls.smc.register_state(state)
if EXEC_TIME:
cls.viewer = WebView(cls.smc)
cls.viewer.start()
class NegativeTestCases(unittest.TestCase):
def setUp(self):
self.target = mock.Mock()
self.smc = StateMachineCrawler(self.target, InitialState)
for state in ALL_STATES:
self.smc.register_state(state)
def test_multiple_found_states(self):
self.assertRaises(MultipleStatesError, self.smc.move, "State")
def test_not_found_state(self):
self.assertRaises(NonExistentStateError, self.smc.move, "FooBar")
def test_unknown_state(self):
self.assertRaises(NonExistentStateError, self.smc.move, UnknownState)
def test_initial_state_verification_failure(self):
self.target.enter.side_effect = Exception
self.assertRaisesRegexp(TransitionError,
"Move from state .+ to state .+ has failed",
self.smc.move, InitialState)
self.assertRaisesRegexp(
UnreachableStateError,
"There is no way to achieve state %r" % StateOne, self.smc.move,
StateOne)
def test_verification_error(self):
self.target.ok.side_effect = Exception
self.assertRaisesRegexp(TransitionError,
"Move from state .+ to state .+ has failed",
self.smc.move, InitialState)
def test_not_all_reachable(self):
self.target.last_verify.side_effect = Exception
self.assertRaisesRegexp(
TransitionError,
"Failed to visit the following states: %s" % StateFour,
self.smc.verify_all_states)
def test_base_state_registration(self):
self.smc.register_state(BaseState)
self.assertFalse(BaseState in self.smc._registered_states)
def tearDown(self):
self.target.reset_mock()
def test_repr(self):
smc = StateMachineCrawler(mock.Mock(), InitialState)
for state in ALL_STATES:
smc.register_state(state)
smc.move(StateTwo)
# print_struct(create_hierarchy(smc.as_graph()))
value = repr(Serializer(smc))
target_lines = DOT_GRAPH.replace("\n", "").replace(" ", "").replace(
"}", "};").replace("{", "{;").split(";")
real_lines = value.replace("}", "};").replace("{", "{;").split(";")
target_lines = map(str.strip, target_lines)
real_lines = map(str.strip, real_lines)
not_expected = []
for i in real_lines:
if i not in target_lines:
not_expected.append(i)
not_in_target = []
for i in target_lines:
if i not in real_lines:
not_in_target.append(i)
print "NOT IN RELITY ************"
print_struct(sorted(not_in_target))
print "NOT EXPECTED ************"
print_struct(sorted(not_expected))
self.assertEqual(sorted(real_lines), sorted(target_lines))
def setUp(self):
self.target = mock.Mock()
self.smc = StateMachineCrawler(self.target, InitialState)
for state in ALL_STATES:
self.smc.register_state(state)
def test_dict(self):
smc = StateMachineCrawler(None, InitialState)
for state in ALL_STATES:
smc.register_state(state)
rval = self._get_raw_state(smc)
print_struct(rval)
self.assertEqual(
rval, {
"tests.cases.StateThreeVariantTwo": {
"transitions": {
"tests.cases.StateFour": {
"name": "from_v2"
}
}
},
"tests.cases.InitialState": {
"transitions": {
"tests.cases.StateOne": {
"name": "from_initial_state"
}
}
},
"tests.cases.StateTwo": {
"transitions": {
"tests.cases.StateThreeVariantOne": {
"name": "move"
},
"tests.cases.StateThreeVariantTwo": {
"name": "from_state_two"
}
}
},
"tests.cases.StateFour": {
"transitions": {}
},
"state_machine_crawler.state_machine_crawler.EntryPoint": {
"transitions": {
"tests.cases.InitialState": {
"name": "init"
}
}
},
"tests.cases.StateOne": {
"transitions": {
"tests.cases.StateTwo": {
"name": "from_state_one"
},
"tests.cases.StateOne": {
"name": "reset"
}
}
},
"tests.cases.StateThreeVariantOne": {
"transitions": {
"tests.cases.StateFour": {
"name": "from_v1"
}
}
}
})
def test_passing_context_through_layer(self):
smc = StateMachineCrawler(None, InitialState)
top_collection = StateCollection(
"top", {
"LaunchedState": StateOne,
"unknown_target": StateTwo,
"another_unknown_target": StateOne
})
top_collection.register_collection(
StateCollection.from_module(solo_tpl_state, "SOLO"))
top_collection.register_collection(
StateCollection.from_module(tpl_cases, "TPL"))
smc.register_collection(top_collection)
rval = self._get_raw_state(smc)
print_struct(rval)
self.assertEqual(
rval, {
"top.SOLO.SoloTplState": {
"transitions": {
"tests.cases.StateOne": {
"name": "back"
}
}
},
"tests.cases.InitialState": {
"transitions": {
"top.TPL.TplStateOne": {
"name": "from_root"
},
"tests.cases.StateOne": {
"name": "from_initial_state"
}
}
},
"tests.cases.StateTwo": {
"transitions": {}
},
"top.TPL.TplStateTwo": {
"transitions": {
"tests.cases.StateOne": {
"name": "to_another_unknown_target"
}
}
},
"top.TPL.TplStateOne": {
"transitions": {
"top.TPL.TplStateTwo": {
"name": "from_one"
},
"tests.cases.StateTwo": {
"name": "to_unknown_target"
}
}
},
"state_machine_crawler.state_machine_crawler.EntryPoint": {
"transitions": {
"tests.cases.InitialState": {
"name": "init"
}
}
},
"tests.cases.StateOne": {
"transitions": {
"tests.cases.StateTwo": {
"name": "from_state_one"
},
"tests.cases.StateOne": {
"name": "reset"
},
"top.SOLO.SoloTplState": {
"name": "there"
}
}
}
})
def test_multilayer_collection(self):
sub_collection = StateCollection("sub_collection", {
"unknown_target": StateOne,
"another_unknown_target": StateTwo
})
sub_collection.register_state(TplStateOne)
sub_collection.register_state(TplStateTwo)
another_sub_collection = StateCollection(
"another_sub_collection", {
"unknown_target": StateTwo,
"another_unknown_target": StateOne
})
another_sub_collection.register_state(TplStateOne)
another_sub_collection.register_state(TplStateTwo)
collection = StateCollection("collection")
collection.register_collection(sub_collection)
collection.register_collection(another_sub_collection)
smc = StateMachineCrawler(None, InitialState)
smc.register_collection(collection)
rval = self._get_raw_state(smc)
print_struct(rval)
self.assertEqual(
rval, {
"tests.cases.InitialState": {
"transitions": {
"collection.another_sub_collection.TplStateOne": {
"name": "from_root"
},
"tests.cases.StateOne": {
"name": "from_initial_state"
},
"collection.sub_collection.TplStateOne": {
"name": "from_root"
}
}
},
"collection.another_sub_collection.TplStateOne": {
"transitions": {
"tests.cases.StateTwo": {
"name": "to_unknown_target"
},
"collection.another_sub_collection.TplStateTwo": {
"name": "from_one"
}
}
},
"tests.cases.StateTwo": {
"transitions": {}
},
"collection.sub_collection.TplStateTwo": {
"transitions": {
"tests.cases.StateTwo": {
"name": "to_another_unknown_target"
}
}
},
"state_machine_crawler.state_machine_crawler.EntryPoint": {
"transitions": {
"tests.cases.InitialState": {
"name": "init"
}
}
},
"tests.cases.StateOne": {
"transitions": {
"tests.cases.StateTwo": {
"name": "from_state_one"
},
"tests.cases.StateOne": {
"name": "reset"
}
}
},
"collection.another_sub_collection.TplStateTwo": {
"transitions": {
"tests.cases.StateOne": {
"name": "to_another_unknown_target"
}
}
},
"collection.sub_collection.TplStateOne": {
"transitions": {
"tests.cases.StateOne": {
"name": "to_unknown_target"
},
"collection.sub_collection.TplStateTwo": {
"name": "from_one"
}
}
}
})