1 files changed, 0 insertions, 156 deletions
diff --git a/nova/test.py b/nova/test.py
index 8ef7eca1a..5c2a72819 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -28,7 +28,6 @@ import time
 
 import mox
 import stubout
-from tornado import ioloop
 from twisted.internet import defer
 from twisted.trial import unittest
 
@@ -159,158 +158,3 @@ class TrialTestCase(unittest.TestCase):
 
         _wrapped.func_name = self.originalAttach.func_name
         rpc.Consumer.attach_to_twisted = _wrapped
-
-
-class BaseTestCase(TrialTestCase):
-    # TODO(jaypipes): Can this be moved into the TrialTestCase class?
-    """Base test case class for all unit tests.
-
-    DEPRECATED: This is being removed once Tornado is gone, use TrialTestCase.
-    """
-    def setUp(self):
-        """Run before each test method to initialize test environment"""
-        super(BaseTestCase, self).setUp()
-        # TODO(termie): we could possibly keep a more global registry of
-        #               the injected listeners... this is fine for now though
-        self.ioloop = ioloop.IOLoop.instance()
-
-        self._waiting = None
-        self._done_waiting = False
-        self._timed_out = False
-
-    def _wait_for_test(self, timeout=60):
-        """ Push the ioloop along to wait for our test to complete. """
-        self._waiting = self.ioloop.add_timeout(time.time() + timeout,
-                                                self._timeout)
-
-        def _wait():
-
-            """Wrapped wait function. Called on timeout."""
-            if self._timed_out:
-                self.fail('test timed out')
-                self._done()
-            if self._done_waiting:
-                self.ioloop.stop()
-                return
-            # we can use add_callback here but this uses less cpu when testing
-            self.ioloop.add_timeout(time.time() + 0.01, _wait)
-
-        self.ioloop.add_callback(_wait)
-        self.ioloop.start()
-
-    def _done(self):
-        """Callback used for cleaning up deferred test methods."""
-        if self._waiting:
-            try:
-                self.ioloop.remove_timeout(self._waiting)
-            except Exception:  # pylint: disable-msg=W0703
-                # TODO(jaypipes): This produces a pylint warning.  Should
-                # we really be catching Exception and then passing here?
-                pass
-            self._waiting = None
-        self._done_waiting = True
-
-    def _maybe_inline_callbacks(self, func):
-        """ If we're doing async calls in our tests, wait on them.
-
-        This is probably the most complicated hunk of code we have so far.
-
-        First up, if the function is normal (not async) we just act normal
-        and return.
-
-        Async tests will use the "Inline Callbacks" pattern, which means
-        you yield Deferreds at every "waiting" step of your code instead
-        of making epic callback chains.
-
-        Example (callback chain, ugly):
-
-        # A deferred instance
-        d = self.compute.terminate_instance(instance_id)
-        def _describe(_):
-            # Another deferred instance
-            d_desc = self.compute.describe_instances()
-            return d_desc
-        def _checkDescribe(rv):
-            self.assertEqual(rv, [])
-        d.addCallback(_describe)
-        d.addCallback(_checkDescribe)
-        d.addCallback(lambda x: self._done())
-        self._wait_for_test()
-
-        Example (inline callbacks! yay!):
-
-        yield self.compute.terminate_instance(instance_id)
-        rv = yield self.compute.describe_instances()
-        self.assertEqual(rv, [])
-
-        If the test fits the Inline Callbacks pattern we will automatically
-        handle calling wait and done.
-        """
-        # TODO(termie): this can be a wrapper function instead and
-        #               and we can make a metaclass so that we don't
-        #               have to copy all that "run" code below.
-        g = func()
-        if not hasattr(g, 'send'):
-            self._done()
-            return defer.succeed(g)
-
-        inlined = defer.inlineCallbacks(func)
-        d = inlined()
-        return d
-
-    def _catch_exceptions(self, result, failure):
-        """Catches all exceptions and handles keyboard interrupts."""
-        exc = (failure.type, failure.value, failure.getTracebackObject())
-        if isinstance(failure.value, self.failureException):
-            result.addFailure(self, exc)
-        elif isinstance(failure.value, KeyboardInterrupt):
-            raise
-        else:
-            result.addError(self, exc)
-
-        self._done()
-
-    def _timeout(self):
-        """Helper method which trips the timeouts"""
-        self._waiting = False
-        self._timed_out = True
-
-    def run(self, result=None):
-        """Runs the test case"""
-
-        result.startTest(self)
-        test_method = getattr(self, self._testMethodName)
-        try:
-            try:
-                self.setUp()
-            except KeyboardInterrupt:
-                raise
-            except:
-                result.addError(self, sys.exc_info())
-                return
-
-            ok = False
-            try:
-                d = self._maybe_inline_callbacks(test_method)
-                d.addErrback(lambda x: self._catch_exceptions(result, x))
-                d.addBoth(lambda x: self._done() and x)
-                self._wait_for_test()
-                ok = True
-            except self.failureException:
-                result.addFailure(self, sys.exc_info())
-            except KeyboardInterrupt:
-                raise
-            except:
-                result.addError(self, sys.exc_info())
-
-            try:
-                self.tearDown()
-            except KeyboardInterrupt:
-                raise
-            except:
-                result.addError(self, sys.exc_info())
-                ok = False
-            if ok:
-                result.addSuccess(self)
-        finally:
-            result.stopTest(self)