Add DefaultStateMachine to implement a basic create_states

malcolm/core/controller.py

@@ -2,14 +2,14 @@
 from collections import OrderedDict
 
 from malcolm.core.loggable import Loggable
-from malcolm.core.statemachine import StateMachine
+from malcolm.core.defaultstatemachine import DefaultStateMachine
 from malcolm.core.attribute import Attribute
 from malcolm.core.enummeta import EnumMeta
 from malcolm.core.stringmeta import StringMeta
 from malcolm.core.booleanmeta import BooleanMeta
 
 
-@StateMachine.insert
+@DefaultStateMachine.insert
 class Controller(Loggable):
     """Implement the logic that takes a Block through its statemachine"""
 

malcolm/core/defaultstatemachine.py

@@ -0,0 +1,8 @@
+from malcolm.core.statemachine import StateMachine
+
+class DefaultStateMachine(StateMachine):
+
+    READY = "Ready"
+
+    def create_states(self):
+        self.set_allowed(self.RESETTING, self.READY)

tests/test_core/test_defaultstatemachine.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import unittest
+from collections import OrderedDict
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
+import setup_malcolm_paths
+from mock import Mock
+
+from malcolm.core.defaultstatemachine import DefaultStateMachine
+
+
+class TestDefaultStateMachine(unittest.TestCase):
+
+    def setUp(self):
+        self.SM = DefaultStateMachine("test_state_machine")
+
+    def test_init(self):
+        default_allowed_transitions = OrderedDict()
+        default_allowed_transitions['Resetting'] = {'Ready', 'Fault',
+                                                    'Disabled'}
+        default_allowed_transitions['Fault'] = {"Resetting", "Disabled"}
+        default_allowed_transitions['Disabled'] = {"Resetting"}
+        self.assertEqual("test_state_machine", self.SM.name)
+        self.assertEqual(default_allowed_transitions,
+                         self.SM.allowed_transitions)
+        self.assertEqual([], self.SM.busy_states)
+
+    def test_is_allowed(self):
+        self.SM.allowed_transitions.update(dict(Ready={"Resetting",
+                                                       "Rewinding"}))
+
+        response = self.SM.is_allowed("Ready", "Resetting")
+        self.assertTrue(response)
+        response = self.SM.is_allowed("Ready", "Paused")
+        self.assertFalse(response)
+
+    def test_set_allowed(self):
+        self.SM.set_allowed("Ready", "Prerun")
+        self.assertEqual({"Prerun"}, self.SM.allowed_transitions['Ready'])
+        self.SM.set_allowed("Ready", "Resetting")
+        self.assertEqual({"Prerun", "Resetting"},
+                         self.SM.allowed_transitions['Ready'])
+
+    def test_set_busy(self):
+        self.SM.set_busy("Ready", busy=False)
+        self.assertEqual([], self.SM.busy_states)
+        self.SM.set_busy("Ready", busy=True)
+        self.assertEqual(["Ready"], self.SM.busy_states)
+        self.SM.set_busy("Ready", busy=False)
+        self.assertEqual([], self.SM.busy_states)
+
+    def test_is_busy(self):
+        self.assertEqual([], self.SM.busy_states)
+        self.SM.set_busy("Resetting", busy=True)
+
+        response = self.SM.is_busy("Resetting")
+        self.assertTrue(response)
+
+        response = self.SM.is_busy("Ready")
+        self.assertFalse(response)
+
+    def test_insert(self):
+
+        @DefaultStateMachine.insert
+        class DummyController(object):
+            pass
+
+        d = DummyController()
+
+        self.assertIsInstance(d.stateMachine, DefaultStateMachine)
+        self.assertEqual("DefaultStateMachine", d.stateMachine.name)
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)