Merge pull request #173 from ramielrowe/master

Injecting fake verifier config in tests

etc/pip-requires.txt

@@ -7,3 +7,4 @@ prettytable>=0.7.2
 argparse
 Pympler
 requests
+south

tests/unit/test_base_verifier.py

@@ -2,61 +2,47 @@ import datetime
 import time
 from django.db import transaction
 import mox
-import stubout
 from stacktach import message_service
 from tests.unit import StacktachBaseTestCase
 from tests.unit.utils import HOST, PORT, VIRTUAL_HOST, USERID, PASSWORD, TICK_TIME, SETTLE_TIME, SETTLE_UNITS
-from verifier import config as verifier_config
+from tests.unit.utils import make_verifier_config
 from verifier import base_verifier
 
 
 class BaseVerifierTestCase(StacktachBaseTestCase):
     def setUp(self):
         self.mox = mox.Mox()
+        config = make_verifier_config(False)
         self.pool = self.mox.CreateMockAnything()
-        self.stubs = stubout.StubOutForTesting()
         self.reconciler = self.mox.CreateMockAnything()
-        self.verifier_with_reconciler = base_verifier.Verifier(
+        self.verifier_with_reconciler = base_verifier.Verifier(config,
             pool=self.pool, reconciler=self.reconciler)
         self.verifier_without_notifications = self\
             ._verifier_with_notifications_disabled()
         self.verifier_with_notifications = self\
             ._verifier_with_notifications_enabled()
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(verifier_config, 'durable_queue', lambda: True)
-        self.stubs.Set(verifier_config, 'topics', lambda:
-            {'exchange': ['notifications.info']})
-        self.stubs.Set(verifier_config, 'host', lambda: HOST)
-        self.stubs.Set(verifier_config, 'port', lambda: PORT)
-        self.stubs.Set(verifier_config, 'virtual_host', lambda: VIRTUAL_HOST)
-        self.stubs.Set(verifier_config, 'userid', lambda: USERID)
-        self.stubs.Set(verifier_config, 'password', lambda: PASSWORD)
-        self.stubs.Set(verifier_config, 'tick_time', lambda: TICK_TIME)
-        self.stubs.Set(verifier_config, 'settle_time', lambda: SETTLE_TIME)
-        self.stubs.Set(verifier_config, 'settle_units', lambda: SETTLE_UNITS)
-        self.stubs.Set(self.verifier_with_notifications, 'exchange',
-                       lambda: 'exchange')
 
     def _verifier_with_notifications_disabled(self):
-            self.stubs.Set(verifier_config, 'enable_notifications', lambda: False)
+        config = make_verifier_config(False)
         reconciler = self.mox.CreateMockAnything()
-            return base_verifier.Verifier(
+        return base_verifier.Verifier(config,
-                pool=self.pool, reconciler=reconciler)
+                                      pool=self.pool,
+                                      reconciler=reconciler)
 
     def _verifier_with_notifications_enabled(self):
-        self.stubs.Set(verifier_config, 'enable_notifications', lambda: True)
+        config = make_verifier_config(True)
         reconciler = self.mox.CreateMockAnything()
-        return base_verifier.Verifier(
+        return base_verifier.Verifier(config,
-            pool=self.pool, reconciler=reconciler)
+                                      pool=self.pool,
+                                      reconciler=reconciler)
 
     def tearDown(self):
         self.mox.UnsetStubs()
-        self.stubs.UnsetAll()
 
     def test_should_create_verifier_with_reconciler(self):
-        self.stubs.Set(verifier_config, 'reconcile', lambda: True)
+        config = make_verifier_config(False)
         rec = self.mox.CreateMockAnything()
-        verifier = base_verifier.Verifier(pool=None, reconciler=rec)
+        verifier = base_verifier.Verifier(config, pool=None, reconciler=rec)
         self.assertEqual(verifier.reconciler, rec)
 
     def test_clean_results_full(self):
@@ -153,7 +139,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
         self.mox.VerifyAll()
 
     def test_run_notifications(self):
-        self._mock_exchange_create_and_connect()
+        self._mock_exchange_create_and_connect(self.verifier_with_notifications)
         self.mox.StubOutWithMock(self.verifier_with_notifications, '_run')
         self.verifier_with_notifications._run(callback=mox.Not(mox.Is(None)))
         self.mox.ReplayAll()
@@ -161,7 +147,7 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
         self.mox.VerifyAll()
 
     def test_run_notifications_with_routing_keys(self):
-        self._mock_exchange_create_and_connect()
+        self._mock_exchange_create_and_connect(self.verifier_with_notifications)
         self.mox.StubOutWithMock(self.verifier_with_notifications, '_run')
         self.verifier_with_notifications._run(callback=mox.Not(mox.Is(None)))
         self.mox.ReplayAll()
@@ -216,7 +202,8 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
         tran.__enter__().AndReturn(tran)
         tran.__exit__(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg())
         transaction.commit_on_success().AndReturn(tran)
-        self._mock_exchange_create_and_connect()
+        self._mock_exchange_create_and_connect(self.verifier_with_notifications)
+        self.verifier_with_notifications.exchange().AndReturn('exchange')
         self.mox.StubOutWithMock(self.verifier_with_notifications, '_keep_running')
         self.verifier_with_notifications._keep_running().AndReturn(True)
         start = datetime.datetime.utcnow()
@@ -247,7 +234,9 @@ class BaseVerifierTestCase(StacktachBaseTestCase):
 
         self.mox.VerifyAll()
 
-    def _mock_exchange_create_and_connect(self):
+    def _mock_exchange_create_and_connect(self, verifier):
+        self.mox.StubOutWithMock(verifier, 'exchange')
+        self.verifier_with_notifications.exchange().AndReturn('exchange')
         self.mox.StubOutWithMock(message_service, 'create_exchange')
         exchange = self.mox.CreateMockAnything()
         message_service.create_exchange('exchange', 'topic', durable=True) \

tests/unit/test_glance_verifier.py

@@ -25,17 +25,16 @@ import uuid
 import kombu
 
 import mox
-import stubout
 
 from stacktach import datetime_to_decimal as dt
 from stacktach import models
 from tests.unit import StacktachBaseTestCase
 from utils import IMAGE_UUID_1
+from utils import make_verifier_config
 from verifier import glance_verifier
 from verifier import FieldMismatch
 from verifier import NotFound
 from verifier import VerificationException
-from verifier import config as verifier_config
 
 
 class GlanceVerifierTestCase(StacktachBaseTestCase):
@@ -44,14 +43,14 @@ class GlanceVerifierTestCase(StacktachBaseTestCase):
         self.mox.StubOutWithMock(models, 'ImageUsage', use_mock_anything=True)
         models.ImageUsage.objects = self.mox.CreateMockAnything()
         self.pool = self.mox.CreateMockAnything()
-        self.glance_verifier = glance_verifier.GlanceVerifier(pool=self.pool)
+        config = make_verifier_config(False)
+        self.glance_verifier = glance_verifier.GlanceVerifier(config,
+                                                              pool=self.pool)
         self.mox.StubOutWithMock(models, 'ImageDeletes',
                                  use_mock_anything=True)
         models.ImageDeletes.objects = self.mox.CreateMockAnything()
         self.mox.StubOutWithMock(models, 'ImageExists',
                                  use_mock_anything=True)
-        self.stubs = stubout.StubOutForTesting()
-        self.stubs.Set(verifier_config, 'pool_size', lambda: 5)
 
     def tearDown(self):
         self.mox.UnsetStubs()

tests/unit/test_nova_verifier.py

@@ -31,6 +31,7 @@ import mox
 from stacktach import datetime_to_decimal as dt
 from stacktach import models
 from tests.unit import StacktachBaseTestCase
+from utils import make_verifier_config
 from utils import INSTANCE_ID_1
 from utils import RAX_OPTIONS_1
 from utils import RAX_OPTIONS_2
@@ -84,7 +85,8 @@ class NovaVerifierTestCase(StacktachBaseTestCase):
     def _setup_verifier(self):
         self.pool = self.mox.CreateMockAnything()
         self.reconciler = self.mox.CreateMockAnything()
-        self.verifier = nova_verifier.NovaVerifier(
+        config = make_verifier_config(False)
+        self.verifier = nova_verifier.NovaVerifier(config,
             pool=self.pool, reconciler=self.reconciler)
 
     def tearDown(self):

tests/unit/utils.py

@@ -146,3 +146,28 @@ def create_tracker(mox, request_id, lifecycle, start, last_timing=None,
     tracker.last_timing=last_timing
     tracker.duration=duration
     return tracker
+
+
+class FakeVerifierConfig(object):
+    def __init__(self, host, port, virtual_host, userid, password, tick_time,
+                 settle_time, settle_units, durable_queue, topics, notifs):
+        self.host = lambda: host
+        self.port = lambda: port
+        self.virtual_host = lambda: virtual_host
+        self.userid = lambda: userid
+        self.password = lambda: password
+        self.pool_size = lambda: 5
+        self.tick_time = lambda: tick_time
+        self.settle_time = lambda: settle_time
+        self.settle_units = lambda: settle_units
+        self.durable_queue = lambda: durable_queue
+        self.topics = lambda: topics
+        self.enable_notifications = lambda: notifs
+
+
+def make_verifier_config(notifs):
+        topics = {'exchange': ['notifications.info']}
+        config = FakeVerifierConfig(HOST, PORT, VIRTUAL_HOST, USERID,
+                                    PASSWORD, TICK_TIME, SETTLE_TIME,
+                                    SETTLE_UNITS, True, topics, notifs)
+        return config

verifier/base_verifier.py

@@ -32,8 +32,6 @@ POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'stacktach')):
     sys.path.insert(0, POSSIBLE_TOPDIR)
 
-from verifier import config as verifier_config
-
 from stacktach import stacklog, message_service
 LOG = stacklog.get_logger('verifier')
 
@@ -68,9 +66,10 @@ def _verify_date_field(d1, d2, same_second=False):
 
 
 class Verifier(object):
-    def __init__(self, pool=None, reconciler=None):
+    def __init__(self, config, pool=None, reconciler=None):
-        self.pool = pool or multiprocessing.Pool(verifier_config.pool_size())
+        self.config = config
-        self.enable_notifications = verifier_config.enable_notifications()
+        self.pool = pool or multiprocessing.Pool(config.pool_size())
+        self.enable_notifications = config.enable_notifications()
         self.reconciler = reconciler
         self.results = []
         self.failed = []
@@ -102,9 +101,9 @@ class Verifier(object):
         return datetime.datetime.utcnow()
 
     def _run(self, callback=None):
-        tick_time = verifier_config.tick_time()
+        tick_time = self.config.tick_time()
-        settle_units = verifier_config.settle_units()
+        settle_units = self.config.settle_units()
-        settle_time = verifier_config.settle_time()
+        settle_time = self.config.settle_time()
         while self._keep_running():
             with transaction.commit_on_success():
                 now = self._utcnow()
@@ -120,22 +119,27 @@ class Verifier(object):
 
     def run(self):
         if self.enable_notifications:
+            exchange_name = self.exchange()
             exchange = message_service.create_exchange(
-                self.exchange(), 'topic',
+                exchange_name, 'topic',
-                durable=verifier_config.durable_queue())
+                durable=self.config.durable_queue())
-            routing_keys = verifier_config.topics()[self.exchange()]
+            routing_keys = self.config.topics()[exchange_name]
 
             with message_service.create_connection(
-                verifier_config.host(), verifier_config.port(),
+                self.config.host(), self.config.port(),
-                verifier_config.userid(), verifier_config.password(),
+                self.config.userid(), self.config.password(),
-                "librabbitmq", verifier_config.virtual_host()) as conn:
+                "librabbitmq", self.config.virtual_host()) as conn:
                 def callback(result):
                     (verified, exist) = result
                     if verified:
                         self.send_verified_notification(
                             exist, conn, exchange, routing_keys=routing_keys)
 
+                try:
                     self._run(callback=callback)
+                except Exception, e:
+                    print e
+                    raise e
         else:
             self._run()
 

verifier/glance_verifier.py

@@ -127,8 +127,8 @@ def _verify(exist):
 
 
 class GlanceVerifier(Verifier):
-    def __init__(self, pool=None):
+    def __init__(self, config, pool=None):
-        super(GlanceVerifier, self).__init__(pool)
+        super(GlanceVerifier, self).__init__(config, pool=pool)
 
     def verify_for_range(self, ending_max, callback=None):
         exists = models.ImageExists.find(

verifier/nova_verifier.py

@@ -215,8 +215,10 @@ def _verify(exist):
 
 
 class NovaVerifier(base_verifier.Verifier):
-    def __init__(self, pool=None, reconciler=None):
+    def __init__(self, config, pool=None, reconciler=None):
-        super(NovaVerifier, self).__init__(pool, reconciler)
+        super(NovaVerifier, self).__init__(config,
+                                           pool=pool,
+                                           reconciler=reconciler)
 
     def send_verified_notification(self, exist, connection, exchange,
                                    routing_keys=None):