Manager throws ManagerException rather than Exception, more robust tests

octodns/manager.py

@@ -69,6 +69,10 @@ class MainThreadExecutor(object):
         return MakeThreadFuture(func, args, kwargs)
 
 
+class ManagerException(Exception):
+    pass
+
+
 class Manager(object):
     log = logging.getLogger('Manager')
 
@@ -105,16 +109,16 @@ class Manager(object):
                 _class = provider_config.pop('class')
             except KeyError:
                 self.log.exception('Invalid provider class')
-                raise Exception('Provider {} is missing class'
-                                .format(provider_name))
+                raise ManagerException('Provider {} is missing class'
+                                       .format(provider_name))
             _class = self._get_named_class('provider', _class)
             kwargs = self._build_kwargs(provider_config)
             try:
                 self.providers[provider_name] = _class(provider_name, **kwargs)
             except TypeError:
                 self.log.exception('Invalid provider config')
-                raise Exception('Incorrect provider config for {}'
-                                .format(provider_name))
+                raise ManagerException('Incorrect provider config for {}'
+                                       .format(provider_name))
 
         zone_tree = {}
         # sort by reversed strings so that parent zones always come first
@@ -148,8 +152,8 @@ class Manager(object):
                 _class = plan_output_config.pop('class')
             except KeyError:
                 self.log.exception('Invalid plan_output class')
-                raise Exception('plan_output {} is missing class'
-                                .format(plan_output_name))
+                raise ManagerException('plan_output {} is missing class'
+                                       .format(plan_output_name))
             _class = self._get_named_class('plan_output', _class)
             kwargs = self._build_kwargs(plan_output_config)
             try:
@@ -157,8 +161,8 @@ class Manager(object):
                     _class(plan_output_name, **kwargs)
             except TypeError:
                 self.log.exception('Invalid plan_output config')
-                raise Exception('Incorrect plan_output config for {}'
-                                .format(plan_output_name))
+                raise ManagerException('Incorrect plan_output config for {}'
+                                       .format(plan_output_name))
 
     def _get_named_class(self, _type, _class):
         try:
@@ -167,13 +171,15 @@ class Manager(object):
         except (ImportError, ValueError):
             self.log.exception('_get_{}_class: Unable to import '
                                'module %s', _class)
-            raise Exception('Unknown {} class: {}'.format(_type, _class))
+            raise ManagerException('Unknown {} class: {}'
+                                   .format(_type, _class))
         try:
             return getattr(module, class_name)
         except AttributeError:
             self.log.exception('_get_{}_class: Unable to get class %s '
                                'from module %s', class_name, module)
-            raise Exception('Unknown {} class: {}'.format(_type, _class))
+            raise ManagerException('Unknown {} class: {}'
+                                   .format(_type, _class))
 
     def _build_kwargs(self, source):
         # Build up the arguments we need to pass to the provider
@@ -186,9 +192,9 @@ class Manager(object):
                         v = environ[env_var]
                     except KeyError:
                         self.log.exception('Invalid provider config')
-                        raise Exception('Incorrect provider config, '
-                                        'missing env var {}'
-                                        .format(env_var))
+                        raise ManagerException('Incorrect provider config, '
+                                               'missing env var {}'
+                                               .format(env_var))
             except AttributeError:
                 pass
             kwargs[k] = v
@@ -256,12 +262,14 @@ class Manager(object):
             try:
                 sources = config['sources']
             except KeyError:
-                raise Exception('Zone {} is missing sources'.format(zone_name))
+                raise ManagerException('Zone {} is missing sources'
+                                       .format(zone_name))
 
             try:
                 targets = config['targets']
             except KeyError:
-                raise Exception('Zone {} is missing targets'.format(zone_name))
+                raise ManagerException('Zone {} is missing targets'
+                                       .format(zone_name))
             if eligible_targets:
                 targets = list(filter(lambda d: d in eligible_targets,
                                       targets))
@@ -276,26 +284,23 @@ class Manager(object):
             self.log.info('sync:   sources=%s -> targets=%s', sources, targets)
 
             try:
-                collected = []
-                for source in sources:
-                    collected.append(self.providers[source])
-                sources = collected
+                sources = [self.providers[source] for source in sources]
             except KeyError:
-                raise Exception('Zone {}, unknown source: {}'.format(zone_name,
-                                                                     source))
+                raise ManagerException('Zone {}, unknown source: {}'
+                                       .format(zone_name, source))
 
             try:
                 trgs = []
                 for target in targets:
                     trg = self.providers[target]
                     if not isinstance(trg, BaseProvider):
-                        raise Exception('{} - "{}" does not support targeting'
-                                        .format(trg, target))
+                        raise ManagerException('{} - "{}" does not support '
+                                               'targeting'.format(trg, target))
                     trgs.append(trg)
                 targets = trgs
             except KeyError:
-                raise Exception('Zone {}, unknown target: {}'.format(zone_name,
-                                                                     target))
+                raise ManagerException('Zone {}, unknown target: {}'
+                                       .format(zone_name, target))
 
             futures.append(self._executor.submit(self._populate_and_plan,
                                                  zone_name, sources, targets))
@@ -348,7 +353,7 @@ class Manager(object):
             a = [self.providers[source] for source in a]
             b = [self.providers[source] for source in b]
         except KeyError as e:
-            raise Exception('Unknown source: {}'.format(e.args[0]))
+            raise ManagerException('Unknown source: {}'.format(e.args[0]))
 
         sub_zones = self.configured_sub_zones(zone)
         za = Zone(zone, sub_zones)
@@ -374,7 +379,7 @@ class Manager(object):
         try:
             sources = [self.providers[s] for s in sources]
         except KeyError as e:
-            raise Exception('Unknown source: {}'.format(e.args[0]))
+            raise ManagerException('Unknown source: {}'.format(e.args[0]))
 
         clz = YamlProvider
         if split:
@@ -397,16 +402,14 @@ class Manager(object):
             try:
                 sources = config['sources']
             except KeyError:
-                raise Exception('Zone {} is missing sources'.format(zone_name))
+                raise ManagerException('Zone {} is missing sources'
+                                       .format(zone_name))
 
             try:
-                collected = []
-                for source in sources:
-                    collected.append(self.providers[source])
-                sources = collected
+                sources = [self.providers[source] for source in sources]
             except KeyError:
-                raise Exception('Zone {}, unknown source: {}'.format(zone_name,
-                                                                     source))
+                raise ManagerException('Zone {}, unknown source: {}'
+                                       .format(zone_name, source))
 
             for source in sources:
                 if isinstance(source, YamlProvider):

tests/test_octodns_manager.py

@@ -11,7 +11,8 @@ from six import text_type
 from unittest import TestCase
 
 from octodns.record import Record
-from octodns.manager import _AggregateTarget, MainThreadExecutor, Manager
+from octodns.manager import _AggregateTarget, MainThreadExecutor, Manager, \
+    ManagerException
 from octodns.yaml import safe_load
 from octodns.zone import Zone
 
@@ -28,77 +29,77 @@ def get_config_filename(which):
 class TestManager(TestCase):
 
     def test_missing_provider_class(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('missing-provider-class.yaml')).sync()
         self.assertTrue('missing class' in text_type(ctx.exception))
 
     def test_bad_provider_class(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('bad-provider-class.yaml')).sync()
         self.assertTrue('Unknown provider class' in text_type(ctx.exception))
 
     def test_bad_provider_class_module(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('bad-provider-class-module.yaml')) \
                 .sync()
         self.assertTrue('Unknown provider class' in text_type(ctx.exception))
 
     def test_bad_provider_class_no_module(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('bad-provider-class-no-module.yaml')) \
                 .sync()
         self.assertTrue('Unknown provider class' in text_type(ctx.exception))
 
     def test_missing_provider_config(self):
         # Missing provider config
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('missing-provider-config.yaml')).sync()
         self.assertTrue('provider config' in text_type(ctx.exception))
 
     def test_missing_env_config(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('missing-provider-env.yaml')).sync()
         self.assertTrue('missing env var' in text_type(ctx.exception))
 
     def test_missing_source(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('provider-problems.yaml')) \
                 .sync(['missing.sources.'])
         self.assertTrue('missing sources' in text_type(ctx.exception))
 
     def test_missing_targets(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('provider-problems.yaml')) \
                 .sync(['missing.targets.'])
         self.assertTrue('missing targets' in text_type(ctx.exception))
 
     def test_unknown_source(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('provider-problems.yaml')) \
                 .sync(['unknown.source.'])
         self.assertTrue('unknown source' in text_type(ctx.exception))
 
     def test_unknown_target(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('provider-problems.yaml')) \
                 .sync(['unknown.target.'])
         self.assertTrue('unknown target' in text_type(ctx.exception))
 
     def test_bad_plan_output_class(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             name = 'bad-plan-output-missing-class.yaml'
             Manager(get_config_filename(name)).sync()
         self.assertEquals('plan_output bad is missing class',
                           text_type(ctx.exception))
 
     def test_bad_plan_output_config(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('bad-plan-output-config.yaml')).sync()
         self.assertEqual('Incorrect plan_output config for bad',
                          text_type(ctx.exception))
 
     def test_source_only_as_a_target(self):
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('provider-problems.yaml')) \
                 .sync(['not.targetable.'])
         self.assertTrue('does not support targeting' in
@@ -182,7 +183,7 @@ class TestManager(TestCase):
                                       'unit.tests.')
             self.assertEquals(14, len(changes))
 
-            with self.assertRaises(Exception) as ctx:
+            with self.assertRaises(ManagerException) as ctx:
                 manager.compare(['nope'], ['dump'], 'unit.tests.')
             self.assertEquals('Unknown source: nope', text_type(ctx.exception))
 
@@ -222,7 +223,7 @@ class TestManager(TestCase):
             environ['YAML_TMP_DIR'] = tmpdir.dirname
             manager = Manager(get_config_filename('simple.yaml'))
 
-            with self.assertRaises(Exception) as ctx:
+            with self.assertRaises(ManagerException) as ctx:
                 manager.dump('unit.tests.', tmpdir.dirname, False, False,
                              'nope')
             self.assertEquals('Unknown source: nope', text_type(ctx.exception))
@@ -251,7 +252,7 @@ class TestManager(TestCase):
             environ['YAML_TMP_DIR'] = tmpdir.dirname
             manager = Manager(get_config_filename('simple-split.yaml'))
 
-            with self.assertRaises(Exception) as ctx:
+            with self.assertRaises(ManagerException) as ctx:
                 manager.dump('unit.tests.', tmpdir.dirname, False, True,
                              'nope')
             self.assertEquals('Unknown source: nope', text_type(ctx.exception))
@@ -267,12 +268,12 @@ class TestManager(TestCase):
     def test_validate_configs(self):
         Manager(get_config_filename('simple-validate.yaml')).validate_configs()
 
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('missing-sources.yaml')) \
                 .validate_configs()
         self.assertTrue('missing sources' in text_type(ctx.exception))
 
-        with self.assertRaises(Exception) as ctx:
+        with self.assertRaises(ManagerException) as ctx:
             Manager(get_config_filename('unknown-provider.yaml')) \
                 .validate_configs()
         self.assertTrue('unknown source' in text_type(ctx.exception))