get service unittests runnning again

6 files changed, 149 insertions, 66 deletions

diff --git a/nova/service_eventlet.py b/nova/service_eventlet.py
index 83f0692ce..576cf8b85 100644
--- a/nova/service_eventlet.py
+++ b/nova/service_eventlet.py
@@ -68,6 +68,7 @@ class Service(object):
         self.periodic_interval = periodic_interval
         super(Service, self).__init__(*args, **kwargs)
         self.saved_args, self.saved_kwargs = args, kwargs
+        self.timers = []
 
     def start(self):
         manager_class = utils.import_class(self.manager_class_name)
@@ -96,15 +97,17 @@ class Service(object):
                     topic='%s.%s' % (self.topic, self.host),
                     proxy=self)
 
-            consumer_all.attach_to_eventlet()
-            consumer_node.attach_to_eventlet()
+            self.timers.append(consumer_all.attach_to_eventlet())
+            self.timers.append(consumer_node.attach_to_eventlet())
             
             pulse = utils.LoopingCall(self.report_state)
             pulse.start(interval=self.report_interval, now=False)
+            self.timers.append(pulse)
 
         if self.periodic_interval:
-            pulse = utils.LoopingCall(self.periodic_tasks)
-            pulse.start(interval=self.periodic_interval, now=False)
+            periodic = utils.LoopingCall(self.periodic_tasks)
+            periodic.start(interval=self.periodic_interval, now=False)
+            self.timers.append(periodic)
 
     def _create_service_ref(self, context):
         service_ref = db.service_create(context,
@@ -156,11 +159,20 @@ class Service(object):
 
     def kill(self):
         """Destroy the service object in the datastore"""
+        self.stop()
         try:
             db.service_destroy(context.get_admin_context(), self.service_id)
         except exception.NotFound:
             logging.warn("Service killed that has no database entry")
 
+    def stop(self):
+        for x in self.timers:
+            try:
+                x.stop()
+            except Exception:
+                pass
+        self.timers = []
+
     def periodic_tasks(self):
         """Tasks to be run at a periodic interval"""
         self.manager.periodic_tasks(context.get_admin_context())
diff --git a/nova/test.py b/nova/test.py
index bbf063aca..e27d29166 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -30,6 +30,7 @@ import unittest
 import mox
 import stubout
 from twisted.internet import defer
+from twisted.trial import unittest as trial_unittest
 
 from nova import context
 from nova import db
@@ -54,7 +55,6 @@ def skip_if_fake(func):
             return func(*args, **kw)
     return _skipper
 
-
 class TrialTestCase(unittest.TestCase):
     """Test case base class for all unit tests"""
     def setUp(self):
@@ -125,29 +125,6 @@ class TrialTestCase(unittest.TestCase):
         for k, v in self._original_flags.iteritems():
             setattr(FLAGS, k, v)
 
-    #def run(self, result=None):
-    #    test_method = getattr(self, self._testMethodName)
-    #    setattr(self,
-    #            self._testMethodName,
-    #            self._maybeInlineCallbacks(test_method, result))
-    #    rv = super(TrialTestCase, self).run(result)
-    #    setattr(self, self._testMethodName, test_method)
-    #    return rv
-
-    #def _maybeInlineCallbacks(self, func, result):
-    #    def _wrapped():
-    #        g = func()
-    #        if isinstance(g, defer.Deferred):
-    #            return g
-    #        if not hasattr(g, 'send'):
-    #            return defer.succeed(g)
-
-    #        inlined = defer.inlineCallbacks(func)
-    #        d = inlined()
-    #        return d
-    #    _wrapped.func_name = func.func_name
-    #    return _wrapped
-
     def _monkey_patch_attach(self):
         self.originalAttach = rpc.Consumer.attach_to_eventlet
 
@@ -158,3 +135,96 @@ class TrialTestCase(unittest.TestCase):
 
         _wrapped.func_name = self.originalAttach.func_name
         rpc.Consumer.attach_to_eventlet = _wrapped
+
+
+class OLDTrialTestCase(trial_unittest.TestCase):
+    """Test case base class for all unit tests"""
+    def setUp(self):
+        """Run before each test method to initialize test environment"""
+        super(TrialTestCase, self).setUp()
+        # NOTE(vish): We need a better method for creating fixtures for tests
+        #             now that we have some required db setup for the system
+        #             to work properly.
+        self.start = datetime.datetime.utcnow()
+        ctxt = context.get_admin_context()
+        if db.network_count(ctxt) != 5:
+            network_manager.VlanManager().create_networks(ctxt,
+                                                          FLAGS.fixed_range,
+                                                          5, 16,
+                                                          FLAGS.vlan_start,
+                                                          FLAGS.vpn_start)
+
+        # emulate some of the mox stuff, we can't use the metaclass
+        # because it screws with our generators
+        self.mox = mox.Mox()
+        self.stubs = stubout.StubOutForTesting()
+        self.flag_overrides = {}
+        self.injected = []
+        self._original_flags = FLAGS.FlagValuesDict()
+
+    def tearDown(self):
+        """Runs after each test method to finalize/tear down test
+        environment."""
+        try:
+            self.mox.UnsetStubs()
+            self.stubs.UnsetAll()
+            self.stubs.SmartUnsetAll()
+            self.mox.VerifyAll()
+            # NOTE(vish): Clean up any ips associated during the test.
+            ctxt = context.get_admin_context()
+            db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
+                                                    self.start)
+            db.network_disassociate_all(ctxt)
+            rpc.Consumer.attach_to_eventlet = self.originalAttach
+            for x in self.injected:
+                try:
+                    x.stop()
+                except AssertionError:
+                    pass
+
+            if FLAGS.fake_rabbit:
+                fakerabbit.reset_all()
+
+            db.security_group_destroy_all(ctxt)
+            super(TrialTestCase, self).tearDown()
+        finally:
+            self.reset_flags()
+
+    def flags(self, **kw):
+        """Override flag variables for a test"""
+        for k, v in kw.iteritems():
+            if k in self.flag_overrides:
+                self.reset_flags()
+                raise Exception(
+                        'trying to override already overriden flag: %s' % k)
+            self.flag_overrides[k] = getattr(FLAGS, k)
+            setattr(FLAGS, k, v)
+
+    def reset_flags(self):
+        """Resets all flag variables for the test.  Runs after each test"""
+        FLAGS.Reset()
+        for k, v in self._original_flags.iteritems():
+            setattr(FLAGS, k, v)
+
+    def run(self, result=None):
+        test_method = getattr(self, self._testMethodName)
+        setattr(self,
+                self._testMethodName,
+                self._maybeInlineCallbacks(test_method, result))
+        rv = super(TrialTestCase, self).run(result)
+        setattr(self, self._testMethodName, test_method)
+        return rv
+
+    def _maybeInlineCallbacks(self, func, result):
+        def _wrapped():
+            g = func()
+            if isinstance(g, defer.Deferred):
+                return g
+            if not hasattr(g, 'send'):
+                return defer.succeed(g)
+
+            inlined = defer.inlineCallbacks(func)
+            d = inlined()
+            return d
+        _wrapped.func_name = func.func_name
+        return _wrapped
diff --git a/nova/tests/scheduler_unittest.py b/nova/tests/scheduler_unittest.py
index cb5fe6b9c..37d15567f 100644
--- a/nova/tests/scheduler_unittest.py
+++ b/nova/tests/scheduler_unittest.py
@@ -22,7 +22,7 @@ Tests For Scheduler
 from nova import context
 from nova import db
 from nova import flags
-from nova import service
+from nova import service_eventlet as service
 from nova import test
 from nova import rpc
 from nova import utils
@@ -122,12 +122,12 @@ class SimpleDriverTestCase(test.TrialTestCase):
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute1.startService()
+        compute1.start()
         compute2 = service.Service('host2',
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute2.startService()
+        compute2.start()
         hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
         self.assertEqual(len(hosts), 2)
         compute1.kill()
@@ -139,12 +139,12 @@ class SimpleDriverTestCase(test.TrialTestCase):
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute1.startService()
+        compute1.start()
         compute2 = service.Service('host2',
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute2.startService()
+        compute2.start()
         instance_id1 = self._create_instance()
         compute1.run_instance(self.context, instance_id1)
         instance_id2 = self._create_instance()
@@ -162,12 +162,12 @@ class SimpleDriverTestCase(test.TrialTestCase):
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute1.startService()
+        compute1.start()
         compute2 = service.Service('host2',
                                    'nova-compute',
                                    'compute',
                                    FLAGS.compute_manager)
-        compute2.startService()
+        compute2.start()
         instance_ids1 = []
         instance_ids2 = []
         for index in xrange(FLAGS.max_cores):
@@ -195,12 +195,12 @@ class SimpleDriverTestCase(test.TrialTestCase):
                                    'nova-volume',
                                    'volume',
                                    FLAGS.volume_manager)
-        volume1.startService()
+        volume1.start()
         volume2 = service.Service('host2',
                                    'nova-volume',
                                    'volume',
                                    FLAGS.volume_manager)
-        volume2.startService()
+        volume2.start()
         volume_id1 = self._create_volume()
         volume1.create_volume(self.context, volume_id1)
         volume_id2 = self._create_volume()
@@ -218,12 +218,12 @@ class SimpleDriverTestCase(test.TrialTestCase):
                                    'nova-volume',
                                    'volume',
                                    FLAGS.volume_manager)
-        volume1.startService()
+        volume1.start()
         volume2 = service.Service('host2',
                                    'nova-volume',
                                    'volume',
                                    FLAGS.volume_manager)
-        volume2.startService()
+        volume2.start()
         volume_ids1 = []
         volume_ids2 = []
         for index in xrange(FLAGS.max_gigabytes):
diff --git a/nova/tests/service_unittest.py b/nova/tests/service_unittest.py
index 4f8d2d550..a2bac9af0 100644
--- a/nova/tests/service_unittest.py
+++ b/nova/tests/service_unittest.py
@@ -22,14 +22,11 @@ Unit Tests for remote procedure calls using queue
 
 import mox
 
-from twisted.application.app import startApplication
-from twisted.internet import defer
-
 from nova import exception
 from nova import flags
 from nova import rpc
 from nova import test
-from nova import service
+from nova import service_eventlet as service
 from nova import manager
 
 FLAGS = flags.FLAGS
@@ -63,7 +60,7 @@ class ServiceManagerTestCase(test.TrialTestCase):
                                'test',
                                'test',
                                'nova.tests.service_unittest.FakeManager')
-        serv.startService()
+        serv.start()
         self.assertEqual(serv.test_method(), 'manager')
 
     def test_override_manager_method(self):
@@ -71,7 +68,7 @@ class ServiceManagerTestCase(test.TrialTestCase):
                                'test',
                                'test',
                                'nova.tests.service_unittest.FakeManager')
-        serv.startService()
+        serv.start()
         self.assertEqual(serv.test_method(), 'service')
 
 
@@ -94,8 +91,8 @@ class ServiceTestCase(test.TrialTestCase):
         self.mox.StubOutWithMock(rpc,
                                  'AdapterConsumer',
                                  use_mock_anything=True)
-        self.mox.StubOutWithMock(
-                service.task, 'LoopingCall', use_mock_anything=True)
+        #self.mox.StubOutWithMock(
+        #        service.task, 'LoopingCall', use_mock_anything=True)
         rpc.AdapterConsumer(connection=mox.IgnoreArg(),
                             topic=topic,
                             proxy=mox.IsA(service.Service)).AndReturn(
@@ -106,19 +103,19 @@ class ServiceTestCase(test.TrialTestCase):
                             proxy=mox.IsA(service.Service)).AndReturn(
                                     rpc.AdapterConsumer)
 
-        rpc.AdapterConsumer.attach_to_twisted()
-        rpc.AdapterConsumer.attach_to_twisted()
+        rpc.AdapterConsumer.attach_to_eventlet()
+        rpc.AdapterConsumer.attach_to_eventlet()
 
         # Stub out looping call a bit needlessly since we don't have an easy
         # way to cancel it (yet) when the tests finishes
-        service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
-                        service.task.LoopingCall)
-        service.task.LoopingCall.start(interval=mox.IgnoreArg(),
-                                       now=mox.IgnoreArg())
-        service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
-                        service.task.LoopingCall)
-        service.task.LoopingCall.start(interval=mox.IgnoreArg(),
-                                       now=mox.IgnoreArg())
+        #service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
+        #                service.task.LoopingCall)
+        #service.task.LoopingCall.start(interval=mox.IgnoreArg(),
+        #                               now=mox.IgnoreArg())
+        #service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
+        #                service.task.LoopingCall)
+        #service.task.LoopingCall.start(interval=mox.IgnoreArg(),
+        #                               now=mox.IgnoreArg())
 
         service_create = {'host': host,
                           'binary': binary,
@@ -135,8 +132,9 @@ class ServiceTestCase(test.TrialTestCase):
         service.db.service_create(mox.IgnoreArg(),
                                   service_create).AndReturn(service_ref)
         self.mox.ReplayAll()
-
-        startApplication(app, False)
+        
+        app.start()
+        app.stop()
         self.assert_(app)
 
     # We're testing sort of weird behavior in how report_state decides
@@ -172,7 +170,7 @@ class ServiceTestCase(test.TrialTestCase):
                                binary,
                                topic,
                                'nova.tests.service_unittest.FakeManager')
-        serv.startService()
+        serv.start()
         serv.report_state()
 
     def test_report_state_newly_disconnected(self):
@@ -202,7 +200,7 @@ class ServiceTestCase(test.TrialTestCase):
                                binary,
                                topic,
                                'nova.tests.service_unittest.FakeManager')
-        serv.startService()
+        serv.start()
         serv.report_state()
         self.assert_(serv.model_disconnected)
 
@@ -235,7 +233,7 @@ class ServiceTestCase(test.TrialTestCase):
                                binary,
                                topic,
                                'nova.tests.service_unittest.FakeManager')
-        serv.startService()
+        serv.start()
         serv.model_disconnected = True
         serv.report_state()
 
diff --git a/nova/utils.py b/nova/utils.py
index 2c43203d8..ddbe0479e 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -253,13 +253,18 @@ class LoopingCall(object):
                 return
             
             done.send(True)
+
+        self.done = done
         
         greenthread.spawn(_inner)
-        return done    
+        return self.done
         
     def stop(self):
         self._running = False
 
+    def wait(self):
+        return self.done.wait()
+
 
 def xhtml_escape(value):
     """Escapes a string so it is valid within XML or XHTML.
diff --git a/run_tests.py b/run_tests.py
index 883d2b768..33bf51b18 100644
--- a/run_tests.py
+++ b/run_tests.py
@@ -48,7 +48,6 @@ import sys
 
 
 from twisted.scripts import trial as trial_script
-import unittest
 
 from nova import flags
 from nova import twistd
@@ -62,11 +61,10 @@ from nova.tests.flags_unittest import *
 from nova.tests.misc_unittest import *
 from nova.tests.network_unittest import *
 #from nova.tests.objectstore_unittest import *
-#from nova.tests.process_unittest import *
 from nova.tests.quota_unittest import *
 from nova.tests.rpc_unittest import *
 from nova.tests.scheduler_unittest import *
-#from nova.tests.service_unittest import *
+from nova.tests.service_unittest import *
 from nova.tests.twistd_unittest import *
 from nova.tests.validator_unittest import *
 from nova.tests.virt_unittest import *