dispatch: implement method of saving/restoring all steps scheduling.

Imagine this scenario, steps A, B and C are scheduled to be executed in
that order. Based on a user's choice A decides to skip_step(B) and then
the user presses "back" during C. This will take us back to A, but
previously the state of step B would stay 'skipped'. Instead, it is
desirable upon going back to have all the steps in the same scheduling
state as they were when the original step was first entered.

This patch addresses that by having each step store a dictionary of
scheduling changes that happened during that step (a mapping from a step
name to the tuple (from_state, to_state). It is therefore always possible
to reconstruct the original state.

Unittests included.

1 files changed, 83 insertions, 21 deletions

diff --git a/tests/pyanaconda_test/dispatch_test.py b/tests/pyanaconda_test/dispatch_test.py
index afb2e8849..61148f5be 100644
--- a/tests/pyanaconda_test/dispatch_test.py
+++ b/tests/pyanaconda_test/dispatch_test.py
@@ -15,11 +15,11 @@ class StepTest(mock.TestCase):
         from pyanaconda.dispatch import Step
         from pyanaconda.errors import DispatchError
         s = Step("a_step")
-        s.schedule()
-        s.request()
-        s.done()
+        s.schedule(None)
+        s.request(None)
+        s.done(None)
         self.assertEquals(s.sched, Step.SCHED_DONE)
-        self.assertRaises(DispatchError, s.skip)
+        self.assertRaises(DispatchError, s.skip, None)
 
     def instantiation_test(self):
         from pyanaconda.dispatch import Step
@@ -39,45 +39,84 @@ class StepTest(mock.TestCase):
         from pyanaconda.dispatch import Step
         from pyanaconda.errors import DispatchError
         s = Step("a_step")
-        s._reschedule(Step.SCHED_UNSCHEDULED)
+        s._reschedule(Step.SCHED_UNSCHEDULED, None)
         self.assertEqual(s.sched, Step.SCHED_UNSCHEDULED)
-        s._reschedule(Step.SCHED_SCHEDULED)
+        s._reschedule(Step.SCHED_SCHEDULED, None)
         self.assertEqual(s.sched, Step.SCHED_SCHEDULED)
-        s._reschedule(Step.SCHED_REQUESTED)
+        s._reschedule(Step.SCHED_REQUESTED, None)
         self.assertEqual(s.sched, Step.SCHED_REQUESTED)
-        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_SKIPPED)
-        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_UNSCHEDULED)
-        s._reschedule(Step.SCHED_DONE)
-        self.assertEqual(s.sched, Step.SCHED_DONE)
+        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_SKIPPED, None)
+        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_UNSCHEDULED, None)
+        s._reschedule(Step.SCHED_DONE, None)
+        self.assertEqual(s.sched, Step.SCHED_DONE, None)
 
         s = Step("another_step")
-        s._reschedule(Step.SCHED_SKIPPED)
+        s._reschedule(Step.SCHED_SKIPPED, None)
         self.assertEqual(s.sched, Step.SCHED_SKIPPED)
-        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_SCHEDULED)
-        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_REQUESTED)
-        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_DONE)
+        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_SCHEDULED, None)
+        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_REQUESTED, None)
+        self.assertRaises(DispatchError, s._reschedule, Step.SCHED_DONE, None)
 
     def request_test(self):
         from pyanaconda.dispatch import Step
         from pyanaconda.errors import DispatchError
         s = Step("a_step")
-        s.request()
-        self.assertRaises(DispatchError, s.skip)
+        s.request(None)
+        self.assertRaises(DispatchError, s.skip, None)
 
     def schedule_test(self):
         from pyanaconda.dispatch import Step
         s = Step("a_step")
-        s.schedule()
+        s.schedule(None)
         self.assertEquals(s.sched, Step.SCHED_SCHEDULED)
 
     def skip_test(self):
         from pyanaconda.dispatch import Step
         from pyanaconda.errors import DispatchError
         s = Step("a_step")
-        s.skip()
+        s.skip(None)
         self.assertEquals(s.sched, Step.SCHED_SKIPPED)
-        self.assertRaises(DispatchError, s.done)
-        self.assertRaises(DispatchError, s.request)
+        self.assertRaises(DispatchError, s.done, None)
+        self.assertRaises(DispatchError, s.request, None)
+
+    def record_history_test(self):
+        from pyanaconda.dispatch import Step
+        s = Step("first_step")
+        self.assertDictEqual(s.changes, {})
+
+        s2 = Step("second_step")
+        s.record_history(s2, Step.SCHED_UNSCHEDULED, Step.SCHED_SCHEDULED)
+        self.assertDictEqual(
+            s.changes,
+            {'second_step' : (Step.SCHED_UNSCHEDULED, Step.SCHED_SCHEDULED)})
+        s.record_history(s2, Step.SCHED_SCHEDULED, Step.SCHED_DONE)
+        self.assertDictEqual(
+            s.changes,
+            {'second_step' : (Step.SCHED_UNSCHEDULED, Step.SCHED_DONE)})
+
+    def revert_sched_test(self):
+        from pyanaconda.dispatch import Step
+        s = Step("first_step")
+        s.request(None)
+        s.revert_sched(Step.SCHED_UNSCHEDULED, Step.SCHED_REQUESTED)
+        self.assertEqual(s.sched, Step.SCHED_UNSCHEDULED)
+        s.request(None)
+        self.assertRaises(AssertionError, s.revert_sched, Step.SCHED_SKIPPED,
+                          Step.SCHED_UNSCHEDULED)
+
+    def tracking_test(self):
+        """ Tests that reschedule correctly registers steps to revert """
+        from pyanaconda.dispatch import Step
+        s1 = Step("first_step")
+        s2 = Step("second_step")
+        s = Step("current_step")
+        s1.schedule(s)
+        s2.schedule(s)
+        s2.request(s)
+        self.assertDictEqual(
+            s.changes,
+            {"first_step" : (Step.SCHED_UNSCHEDULED, Step.SCHED_SCHEDULED),
+             "second_step" : (Step.SCHED_UNSCHEDULED, Step.SCHED_REQUESTED)})
 
 class DispatchTest(mock.TestCase):
     def setUp(self):
@@ -131,3 +170,26 @@ class DispatchTest(mock.TestCase):
         self.assertFalse(d.step_enabled("betanag"))
         self.assertFalse(d.step_enabled("complete"))
         self.assertTrue(d.step_enabled("filtertype"))
+
+    def track_scheduling_test(self):
+        from pyanaconda.dispatch import Step
+        d = self._getDispatcher()
+        d.schedule_steps("betanag", "filtertype", "filter")
+        d.step = "betanag"
+        # tested through the request_steps
+        d.request_steps("filtertype", "filter")
+        self.assertDictEqual(
+            d.steps[d.step].changes,
+            {"filtertype" : (Step.SCHED_SCHEDULED, Step.SCHED_REQUESTED),
+             "filter" : (Step.SCHED_SCHEDULED, Step.SCHED_REQUESTED)})
+
+    def revert_scheduling_test(self):
+        from pyanaconda.dispatch import Step
+        d = self._getDispatcher()
+        d.schedule_steps("betanag", "filtertype", "filter")
+        d.step = "betanag"
+        d.request_steps("filtertype", "filter")
+        d._revert_scheduling("betanag")
+        self.assertEqual(d.steps["filtertype"].sched, Step.SCHED_SCHEDULED)
+        self.assertEqual(d.steps["filter"].sched, Step.SCHED_SCHEDULED)
+        self.assertDictEqual(d.steps[d.step].changes, {})