[Repoze-checkins] r656 - repoze.retry/trunk/repoze/retry

[Tres Seaver]

Author: Tres Seaver <tseaver at palladion.com>
Date: Sun Feb  3 16:24:11 2008
New Revision: 656

Log:
Make ZODB dependency vanish.

Modified:
   repoze.retry/trunk/repoze/retry/tests.py

Modified: repoze.retry/trunk/repoze/retry/tests.py
==============================================================================
--- repoze.retry/trunk/repoze/retry/tests.py	(original)
+++ repoze.retry/trunk/repoze/retry/tests.py	Sun Feb  3 16:24:11 2008
@@ -1,7 +1,15 @@
 import unittest
 import sys
 
-class TestRetry(unittest.TestCase):
+class CEBase:
+
+    def _getConflictError(self):
+        from repoze.retry import ConflictError
+        return ConflictError
+
+    ConflictError = property(_getConflictError,)
+
+class TestRetry(unittest.TestCase, CEBase):
     def _getTargetClass(self):
         from repoze.retry import Retry
         return Retry
@@ -13,36 +21,36 @@
         self._dummy_start_response_result = None
 
     def test_conflict_not_raised_start_response_not_called(self):
-        from ZODB.POSException import ConflictError
         application = DummyApplication(conflicts=1)
-        retry = self._makeOne(application, tries=4, retryable=(ConflictError,))
+        retry = self._makeOne(application, tries=4,
+                              retryable=(self.ConflictError,))
         result = retry({}, None)
         self.assertEqual(result, ['hello'])
         self.assertEqual(application.called, 1)
 
     def test_conflict_raised_start_response_not_called(self):
-        from ZODB.POSException import ConflictError
         application = DummyApplication(conflicts=5)
-        retry = self._makeOne(application, tries=4, retryable=(ConflictError,))
-        self.failUnlessRaises(ConflictError, retry, {}, None)
+        retry = self._makeOne(application, tries=4,
+                              retryable=(self.ConflictError,))
+        self.failUnlessRaises(self.ConflictError, retry, {}, None)
         self.assertEqual(application.called, 4)
 
     def _dummy_start_response(self, *arg):
         self._dummy_start_response_result = arg
 
     def test_conflict_raised_start_response_called(self):
-        from ZODB.POSException import ConflictError
         application = DummyApplication(conflicts=5, call_start_response=True)
-        retry = self._makeOne(application, tries=4, retryable=(ConflictError,))
-        self.failUnlessRaises(ConflictError, retry, {},
+        retry = self._makeOne(application, tries=4,
+                              retryable=(self.ConflictError,))
+        self.failUnlessRaises(self.ConflictError, retry, {},
                               self._dummy_start_response)
         self.assertEqual(application.called, 4)
         self.assertEqual(self._dummy_start_response_result, ('200 OK', {}))
 
     def test_conflict_not_raised_start_response_called(self):
-        from ZODB.POSException import ConflictError
         application = DummyApplication(conflicts=1, call_start_response=True)
-        retry = self._makeOne(application, tries=4, retryable=(ConflictError,))
+        retry = self._makeOne(application, tries=4,
+                              retryable=(self.ConflictError,))
         result = retry({}, self._dummy_start_response)
         self.assertEqual(application.called, 1)
         self.assertEqual(self._dummy_start_response_result, ('200 OK', {}))
@@ -56,42 +64,39 @@
         self.assertEqual(application.called, 1)
 
     def test_alternate_retryble_exceptions(self):
-        from ZODB.POSException import ConflictError
         app1 = DummyApplication(conflicts=1)
         app2 = DummyApplication(conflicts=1, exception=Retryable)
 
         retry1 = self._makeOne(app1, tries=4,
-                               retryable=(ConflictError, Retryable,))
+                               retryable=(self.ConflictError, Retryable,))
         result = retry1({}, None)
         self.assertEqual(result, ['hello'])
         self.assertEqual(app1.called, 1)
 
         retry2 = self._makeOne(app2, tries=4,
-                               retryable=(ConflictError, Retryable,))
+                               retryable=(self.ConflictError, Retryable,))
         result = retry2({}, None)
         self.assertEqual(result, ['hello'])
         self.assertEqual(app2.called, 1)
 
-class FactoryTests(unittest.TestCase):
+class FactoryTests(unittest.TestCase, CEBase):
 
     def test_make_retry_defaults(self):
-        from ZODB.POSException import ConflictError
         from repoze.retry import make_retry #FUT
         app = object()
         middleware = make_retry(app, {})
         self.failUnless(middleware.application is app)
         self.assertEqual(middleware.tries, 3)
         self.assertEqual(middleware.tries, 3)
-        self.assertEqual(middleware.retryable, (ConflictError,))
+        self.assertEqual(middleware.retryable, (self.ConflictError,))
 
     def test_make_retry_override_tries(self):
-        from ZODB.POSException import ConflictError
         from repoze.retry import make_retry #FUT
         app = object()
         middleware = make_retry(app, {}, tries=4)
         self.failUnless(middleware.application is app)
         self.assertEqual(middleware.tries, 4)
-        self.assertEqual(middleware.retryable, (ConflictError,))
+        self.assertEqual(middleware.retryable, (self.ConflictError,))
 
     def test_make_retry_override_retryable_one(self):
         from repoze.retry import make_retry #FUT
@@ -117,13 +122,14 @@
 class AnotherRetryable(Exception):
     pass
 
-class DummyApplication:
-    def __init__(self, conflicts, call_start_response=False, exception=None):
+class DummyApplication(CEBase):
+    def __init__(self, conflicts, call_start_response=False,
+                 exception=None):
         self.called = 0
         self.conflicts = conflicts
         self.call_start_response = call_start_response
         if exception is None:
-            from ZODB.POSException import ConflictError as exception
+            exception = self.ConflictError
         self.exception = exception
 
     def __call__(self, environ, start_response):