Orderer() is now implemented based on may_run() instead of matches().

If the event is run with may_run() False, a nice assertion error is
raised with a nice debugging message. :-)

3 files changed, 70 insertions, 31 deletions

diff --git a/NEWS b/NEWS
index e735ebe..932b11c 100644
--- a/NEWS
+++ b/NEWS
@@ -1,6 +1,8 @@
 0.10 (2007-11-XX)
 ==================
 
+- Greatly improved error messages and logic for expression ordering!
+
 - Implemented MockerTestCase.addCleanup().  It allows one to
   register cleanup functions to be called after the test is
   complete.
@@ -16,11 +18,12 @@
 
 - Now when a spec is provided (or with proxy/replace/patch) the
   existence of the real method is checked even if the mocked
-  method doesn't have to execute (e.g. due to count(0)).
+  method doesn't execute.  This is useful to detect API expectation
+  errors even if count(0) is used (a negative assertion).
 
-- Implemented support for Deferred results as understood by
-  Twisted Trial's TestCase, so that coexistence by multiple
-  inheritance is possible and trivial.
+- Implemented in MockerTestCase support for Deferred results as
+  understood by Twisted Trial's TestCase, so that coexistence by
+  multiple inheritance is possible and trivial.
 
 - MockerTestCase.makeFile() with content=None (the default) now
   consistently returns an unexistent temporary filename which
diff --git a/mocker.py b/mocker.py
index da411ec..cbc457f 100644
--- a/mocker.py
+++ b/mocker.py
@@ -471,7 +471,7 @@ class MockerBase(object):
         """
         self._events.append(event)
         if self._ordering:
-            orderer = event.add_task(Orderer())
+            orderer = event.add_task(Orderer(event.path))
             if self._last_orderer:
                 orderer.add_dependency(self._last_orderer)
             self._last_orderer = orderer
@@ -865,7 +865,7 @@ class MockerBase(object):
                             orderer = task
                             break
                     else:
-                        orderer = Orderer()
+                        orderer = Orderer(path)
                         event.add_task(orderer)
                     if last_orderer:
                         orderer.add_dependency(last_orderer)
@@ -1790,31 +1790,35 @@ class Orderer(Task):
     been run.
     """
 
-    def __init__(self):
+    def __init__(self, path):
+        self.path = path
         self._run = False 
         self._dependencies = []
 
     def replay(self):
         self._run = False
 
-    def run(self, path):
-        self._run = True
-
     def has_run(self):
         return self._run
 
+    def may_run(self, path):
+        for dependency in self._dependencies:
+            if not dependency.has_run():
+                return False
+        return True
+
+    def run(self, path):
+        for dependency in self._dependencies:
+            if not dependency.has_run():
+                raise AssertionError("Should be after: %s" % dependency.path)
+        self._run = True
+
     def add_dependency(self, orderer):
         self._dependencies.append(orderer)
 
     def get_dependencies(self):
         return self._dependencies
 
-    def matches(self, path):
-        for dependency in self._dependencies:
-            if not dependency.has_run():
-                return False
-        return True
-
 
 class SpecChecker(Task):
     """Task to check if arguments of the last action conform to a real method.
diff --git a/test.py b/test.py
index 9318633..77454e9 100755
--- a/test.py
+++ b/test.py
@@ -72,11 +72,15 @@ class IntegrationTest(TestCase):
         with_manager.__exit__(None, None, None)
 
         self.mocker.replay()
-
         self.assertRaises(AssertionError, getattr, obj, "y")
         self.assertRaises(AssertionError, getattr, obj, "z")
+
+        self.mocker.replay()
         obj.x
         self.assertRaises(AssertionError, getattr, obj, "z")
+
+        self.mocker.replay()
+        obj.x
         obj.y
         obj.z
 
@@ -1498,24 +1502,28 @@ class MockerTest(TestCase):
         self.assertEquals(events[0].get_tasks(), [other_task])
         other_task_, task1 = events[1].get_tasks()
         self.assertEquals(type(task1), Orderer)
+        self.assertEquals(task1.path, events[1].path)
         self.assertEquals(task1.get_dependencies(), [])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[2].get_tasks(), [other_task])
         other_task_, task3 = events[3].get_tasks()
         self.assertEquals(type(task3), Orderer)
+        self.assertEquals(task3.path, events[3].path)
         self.assertEquals(task3.get_dependencies(), [task1])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[4].get_tasks(), [other_task])
         other_task_, task5 = events[5].get_tasks()
         self.assertEquals(type(task5), Orderer)
+        self.assertEquals(task5.path, events[5].path)
         self.assertEquals(task5.get_dependencies(), [task3])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[6].get_tasks(), [other_task])
         other_task_, task7 = events[7].get_tasks()
         self.assertEquals(type(task7), Orderer)
+        self.assertEquals(task7.path, events[7].path)
         self.assertEquals(task7.get_dependencies(), [task1, task3])
         self.assertEquals(other_task_, other_task)
 
@@ -1540,18 +1548,21 @@ class MockerTest(TestCase):
         self.assertEquals(events[0].get_tasks(), [other_task])
         other_task_, task1 = events[1].get_tasks()
         self.assertEquals(type(task1), Orderer)
+        self.assertEquals(task1.path, events[1].path)
         self.assertEquals(task1.get_dependencies(), [])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[2].get_tasks(), [other_task])
         other_task_, task3 = events[3].get_tasks()
         self.assertEquals(type(task3), Orderer)
+        self.assertEquals(task3.path, events[3].path)
         self.assertEquals(task3.get_dependencies(), [])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[4].get_tasks(), [other_task])
         other_task_, task5 = events[5].get_tasks()
         self.assertEquals(type(task5), Orderer)
+        self.assertEquals(task5.path, events[5].path)
         self.assertEquals(task5.get_dependencies(), [task1, task3])
         self.assertEquals(other_task_, other_task)
 
@@ -1576,18 +1587,21 @@ class MockerTest(TestCase):
         self.assertEquals(events[4].get_tasks(), [other_task])
         other_task_, task5 = events[5].get_tasks()
         self.assertEquals(type(task5), Orderer)
+        self.assertEquals(task5.path, events[5].path)
         self.assertEquals(task5.get_dependencies(), [])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[0].get_tasks(), [other_task])
         other_task_, task1 = events[1].get_tasks()
         self.assertEquals(type(task1), Orderer)
+        self.assertEquals(task1.path, events[1].path)
         self.assertEquals(task1.get_dependencies(), [task5])
         self.assertEquals(other_task_, other_task)
 
         self.assertEquals(events[2].get_tasks(), [other_task])
         other_task_, task3 = events[3].get_tasks()
         self.assertEquals(type(task3), Orderer)
+        self.assertEquals(task3.path, events[3].path)
         self.assertEquals(task3.get_dependencies(), [task5])
         self.assertEquals(other_task_, other_task)
 
@@ -1635,6 +1649,10 @@ class MockerTest(TestCase):
         self.assertEquals(type(task2), Orderer)
         self.assertEquals(type(task3), Orderer)
 
+        self.assertEquals(task1.path, events[1].path)
+        self.assertEquals(task2.path, events[2].path)
+        self.assertEquals(task3.path, events[3].path)
+
         self.assertEquals(task1.get_dependencies(), [])
         self.assertEquals(task2.get_dependencies(), [task1])
         self.assertEquals(task3.get_dependencies(), [task2])
@@ -3191,16 +3209,19 @@ class OrdererTest(TestCase):
         self.path = Path(self.mock, [self.action])
 
     def test_is_task(self):
-        self.assertTrue(isinstance(Orderer(), Task))
+        self.assertTrue(isinstance(Orderer(self.path), Task))
+
+    def test_path(self):
+        self.assertEquals(Orderer(self.path).path, self.path)
 
     def test_has_run(self):
-        orderer = Orderer()
+        orderer = Orderer(self.path)
         self.assertFalse(orderer.has_run())
         orderer.run(self.path)
         self.assertTrue(orderer.has_run())
 
     def test_reset_on_replay(self):
-        orderer = Orderer()
+        orderer = Orderer(self.path)
         orderer.run(self.path)
         orderer.replay()
         self.assertFalse(orderer.has_run())
@@ -3215,21 +3236,32 @@ class OrdererTest(TestCase):
         self.mocker.replay()
         self.assertRaises(AssertionError, mock, 2)
 
-    def test_add_dependency_and_match(self):
-        orderer1 = Orderer()
-        orderer2 = Orderer()
-        orderer2.add_dependency(orderer1)
-        self.assertFalse(orderer2.matches(None))
-        self.assertTrue(orderer1.matches(None))
-        orderer1.run(self.path)
-        self.assertTrue(orderer2.matches(None))
-
-    def test_get_dependencies(self):
-        orderer = Orderer()
+    def test_add_and_get_dependencies(self):
+        orderer = Orderer(self.path)
         orderer.add_dependency(1)
         orderer.add_dependency(2)
         self.assertEquals(orderer.get_dependencies(), [1, 2])
 
+    def test_may_run(self):
+        orderer1 = Orderer(self.path)
+        orderer2 = Orderer(self.path)
+        orderer2.add_dependency(orderer1)
+        self.assertFalse(orderer2.may_run(None))
+        self.assertTrue(orderer1.may_run(None))
+        orderer1.run(self.path)
+        self.assertTrue(orderer2.may_run(None))
+
+    def test_run_with_missing_dependency(self):
+        orderer1 = Orderer("path1")
+        orderer2 = Orderer("path2")
+        orderer2.add_dependency(orderer1)
+        try:
+            orderer2.run(None)
+        except AssertionError, e:
+            self.assertEquals(str(e), "Should be after: path1")
+        else:
+            self.fail("AssertionError not raised")
+
 
 class SpecCheckerTest(TestCase):