def test_create(self):
reg = registry.Registry('SENLIN', None)
self.assertEqual('SENLIN', reg.registry_name)
self.assertEqual({}, reg._registry)
self.assertTrue(reg.is_global)
self.assertIsNone(reg.global_registry)
reg_sub = registry.Registry('SUB', reg)
self.assertEqual('SUB', reg_sub.registry_name)
self.assertEqual({}, reg_sub._registry)
self.assertFalse(reg_sub.is_global)
self.assertEqual(reg, reg_sub.global_registry)
def __init__(self, env=None, is_global=False):
"""Create an Environment from a dict.
:param env: the json environment
:param is_global: boolean indicating if this is a user created one.
"""
self.params = {}
if is_global:
self.profile_registry = registry.Registry('profiles')
self.policy_registry = registry.Registry('policies')
self.driver_registry = registry.Registry('drivers')
self.endpoint_registry = registry.Registry('endpoints')
else:
self.profile_registry = registry.Registry(
'profiles',
global_env().profile_registry)
self.policy_registry = registry.Registry(
'policies',
global_env().policy_registry)
self.driver_registry = registry.Registry(
'drivers',
global_env().driver_registry)
self.endpoint_registry = registry.Registry(
'endpoints',
global_env().endpoint_registry)
if env is not None:
# Merge user specified keys with current environment
self.params = env.get(self.PARAMETERS, {})
custom_profiles = env.get(self.CUSTOM_PROFILES, {})
custom_policies = env.get(self.CUSTOM_POLICIES, {})
self.profile_registry.load(custom_profiles)
self.policy_registry.load(custom_policies)
def test_load(self):
snippet = {
'K2': 'Class2',
'K4': 'Class4',
'K5': 'Class5',
}
reg = registry.Registry('SENLIN', None)
reg.load(snippet)
pi2 = reg._registry.get('K2')
self.assertIsInstance(pi2, registry.PluginInfo)
self.assertEqual('K2', pi2.name)
self.assertEqual('Class2', pi2.plugin)
pi4 = reg._registry.get('K4')
self.assertIsInstance(pi4, registry.PluginInfo)
self.assertEqual('K4', pi4.name)
self.assertEqual('Class4', pi4.plugin)
pi5 = reg._registry.get('K5')
self.assertIsInstance(pi5, registry.PluginInfo)
self.assertEqual('K5', pi5.name)
self.assertEqual('Class5', pi5.plugin)
# load with None
snippet = {'K5': None}
reg.load(snippet)
res = reg._registry.get('K5')
self.assertIsNone(res)
def test_iterable_by(self):
reg = registry.Registry('GLOBAL', None)
plugin = mock.Mock()
reg.register_plugin('FOO', plugin)
res = [r for r in reg.iterable_by('FOO')]
self.assertEqual(1, len(res))
self.assertEqual('FOO', res[0].name)
def test_get_types(self):
reg = registry.Registry('GLOBAL', None)
plugin1 = mock.Mock()
reg.register_plugin('FOO', plugin1)
plugin2 = mock.Mock()
reg.register_plugin('BAR', plugin2)
self.assertIn({'name': 'FOO'}, reg.get_types())
self.assertIn({'name': 'BAR'}, reg.get_types())
def test_register_plugin(self):
reg = registry.Registry('SENLIN', None)
plugin = mock.Mock()
reg.register_plugin('FOO', plugin)
pi = reg._registry.get('FOO')
self.assertIsInstance(pi, registry.PluginInfo)
self.assertEqual(plugin, pi.plugin)
self.assertEqual('FOO', pi.name)
def test_as_dict(self):
reg = registry.Registry('GLOBAL', None)
plugin1 = mock.Mock()
reg.register_plugin('FOO', plugin1)
plugin2 = mock.Mock()
reg.register_plugin('BAR', plugin2)
res = reg.as_dict()
self.assertIsInstance(res, dict)
self.assertEqual(plugin1, res.get('FOO'))
self.assertEqual(plugin2, res.get('BAR'))
def test_get_plugin(self):
# Global registry
reg = registry.Registry('GLOBAL', None)
self.assertTrue(reg.is_global)
# Register plugin in global
plugin = mock.Mock()
reg.register_plugin('FOO', plugin)
self.assertEqual(plugin, reg.get_plugin('FOO'))
# Sub registry
sub = registry.Registry('SUB', reg)
self.assertFalse(sub.is_global)
# Retrieve plugin from global registry
self.assertEqual(plugin, sub.get_plugin('FOO'))
# Plugin in local registry overrides that in the global registry
plugin_new = mock.Mock()
sub.register_plugin('FOO', plugin_new)
self.assertEqual(plugin_new, sub.get_plugin('FOO'))
def test_get_types(self):
reg = registry.Registry('GLOBAL', None)
plugin1 = mock.Mock(VERSIONS={'foo': 'bar'})
reg.register_plugin('FOO-1.0', plugin1)
plugin2 = mock.Mock(VERSIONS={'zoo': 'car'})
reg.register_plugin('BAR-1.1', plugin2)
self.assertIn(
{
'name': 'FOO',
'version': '1.0',
'support_status': {
'foo': 'bar'
}
}, reg.get_types())
self.assertIn(
{
'name': 'BAR',
'version': '1.1',
'support_status': {
'zoo': 'car'
}
}, reg.get_types())
def test_register_info(self):
reg = registry.Registry('SENLIN', None)
plugin = mock.Mock()
pi = registry.PluginInfo(reg, 'FOO', plugin)
reg._register_info('FOO', pi)
result = reg._registry.get('FOO')
self.assertEqual(pi, result)
# register the same name and same PluginInfo, no new entry added
reg._register_info('FOO', pi)
self.assertEqual(1, len(reg._registry))
# register the same name with different PluginInfo -> replacement
new_pi = registry.PluginInfo(reg, 'FOO', plugin)
reg._register_info('FOO', new_pi)
self.assertEqual(1, len(reg._registry))
# additional check: this is a global registry
self.assertFalse(new_pi.user_provided)
# removal
reg._register_info('FOO', None)
self.assertEqual(0, len(reg._registry))
def setUp(self):
super(PluginInfoTest, self).setUp()
self.reg = registry.Registry('SENLIN', None)
