add SequenceDispatcher

Author: radix

effect/test_testing.py

@@ -18,6 +18,8 @@
     ESFunc,
     EQDispatcher,
     EQFDispatcher,
+    IntentMismatchError,
+    SequenceDispatcher,
     fail_effect,
     resolve_effect,
     resolve_stubs)
@@ -276,3 +278,30 @@ def test_perform(self):
         """When an intent matches, performing it returns the canned result."""
         d = EQFDispatcher([('hello', lambda i: (i, 'there'))])
         self.assertEqual(sync_perform(d, Effect('hello')), ('hello', 'there'))
+
+
+class SequenceDispatcherTests(TestCase):
+    """Tests for :obj:`SequenceDispatcher`."""
+
+    def test_mismatch(self):
+        """
+        When an intent isn't expected, a :obj:`IntentMismatchError` is raised.
+        """
+        d = SequenceDispatcher([('foo', lambda i: 1 / 0)])
+        e = self.assertRaises(IntentMismatchError, lambda: sync_perform(d, Effect('hello')))
+        self.assertEqual(e.expected_intent, 'foo')
+        self.assertEqual(e.got_intent, 'hello')
+
+    def test_success(self):
+        """
+        Each intent is performed in sequence with the provided functions, as
+        long as the intents match.
+        """
+        d = SequenceDispatcher([
+            ('foo', lambda i: ('performfoo', i)),
+            ('bar', lambda i: ('performbar', i)),
+        ])
+        eff = Effect('foo').on(lambda r: Effect('bar').on(lambda r2: (r, r2)))
+        self.assertEqual(
+            sync_perform(d, eff),
+            (('performfoo', 'foo'), ('performbar', 'bar')))

effect/testing.py

@@ -243,3 +243,43 @@ def __call__(self, intent):
         for k, v in self.mapping:
             if k == intent:
                 return sync_performer(lambda d, i: v(i))
+
+
+
+class IntentMismatchError(Exception):
+    def __init__(self, expected_intent, got_intent):
+        self.expected_intent = expected_intent
+        self.got_intent = got_intent
+        super(IntentMismatchError, self).__init__(
+            'Expected intent %r, got %r' % (expected_intent, got_intent))
+
+
+class SequenceDispatcher(object):
+    """
+    A dispatcher which steps through a sequence of (intent, func) tuples and
+    runs ``func`` to perform intents in strict sequence.
+
+    So, if you expect to first perform an intent like ``MyIntent('a')`` and
+    then an intent like ``OtherIntent('b')``, you can create a dispatcher like
+    this::
+
+        SequenceDispatcher([
+            (MyIntent('a'), lambda i: 'my-intent-result'),
+            (OtherIntent('b'), lambda i: 'other-intent-result')
+        ])
+
+    Unlike most dispatchers, this one raises an exception
+    (:obj:`IntentMismatchError`) when an intent is not found, in the order
+    expected.
+    """
+    def __init__(self, sequence):
+        """:param list sequence: Sequence of (intent, fn)."""
+        self.sequence = sequence
+
+    def __call__(self, intent):
+        exp_intent, func = self.sequence[0]
+        if intent == exp_intent:
+            self.sequence = self.sequence[1:]
+            return sync_performer(lambda d, i: func(i))
+        else:
+            raise IntentMismatchError(exp_intent, intent)