def setup_fake_modules(self):
fake_module1 = tests.FakeRatingModule()
fake_module1.module_name = 'fake1'
fake_module1.set_priority(3)
fake_module2 = tests.FakeRatingModule()
fake_module2.module_name = 'fake2'
fake_module2.set_priority(1)
fake_module3 = tests.FakeRatingModule()
fake_module3.module_name = 'fake3'
fake_module3.set_priority(2)
fake_extensions = [
extension.Extension(
'fake1',
'cloudkitty.tests.FakeRatingModule1',
None,
fake_module1),
extension.Extension(
'fake2',
'cloudkitty.tests.FakeRatingModule2',
None,
fake_module2),
extension.Extension(
'fake3',
'cloudkitty.tests.FakeRatingModule3',
None,
fake_module3)]
return fake_extensions
def test_multiple_drivers(self):
# The idea for this test was contributed by clayg:
# https://gist.github.com/clayg/6311348
extensions = [
extension.Extension(
'backend',
pkg_resources.EntryPoint.parse('backend = pkg1:driver'),
'pkg backend',
None,
),
extension.Extension(
'backend',
pkg_resources.EntryPoint.parse('backend = pkg2:driver'),
'pkg backend',
None,
),
]
try:
dm = driver.DriverManager.make_test_instance(extensions[0])
# Call the initialization code that verifies the extension
dm._init_plugins(extensions)
except exception.MultipleMatches as err:
self.assertIn("Multiple", str(err))
else:
self.fail('Should have had an error')
def setUp(self):
super(TestHardwareManagerLoading, self).setUp()
# In order to use ExtensionManager.make_test_instance() without
# creating a new only-for-test codepath, we instantiate the test
# instance outside of the test case in setUp, where we can access
# make_test_instance() before it gets mocked. Inside of the test case
# we set this as the return value of the mocked constructor, so we can
# verify that the constructor is called correctly while still using a
# more realistic ExtensionManager
fake_ep = mock.Mock()
fake_ep.module_name = 'fake'
fake_ep.attrs = ['fake attrs']
ext1 = extension.Extension(
'fake_generic0', fake_ep, None,
FakeHardwareManager(hardware.HardwareSupport.GENERIC))
ext2 = extension.Extension(
'fake_mainline0', fake_ep, None,
FakeHardwareManager(hardware.HardwareSupport.MAINLINE))
ext3 = extension.Extension(
'fake_generic1', fake_ep, None,
FakeHardwareManager(hardware.HardwareSupport.GENERIC))
self.correct_hw_manager = ext2.obj
self.fake_ext_mgr = extension.ExtensionManager.make_test_instance([
ext1, ext2, ext3
])
def create_extension_list(self):
return [
extension.Extension(
'test',
None,
None,
self.Pollster(),
),
extension.Extension(
'testbatch',
None,
None,
self.BatchPollster(),
),
extension.Extension(
'testanother',
None,
None,
self.PollsterAnother(),
),
extension.Extension(
'testexception',
None,
None,
self.PollsterException(),
),
extension.Extension(
'testexceptionanother',
None,
None,
self.PollsterExceptionAnother(),
)
]
def setup_fake_modules(self):
def fake_metric(start, end=None, project_id=None, q_filter=None):
return None
fake_module1 = tests.FakeCollectorModule()
fake_module1.collector_name = 'fake1'
fake_module1.get_compute = fake_metric
fake_module2 = tests.FakeCollectorModule()
fake_module2.collector_name = 'fake2'
fake_module2.get_volume = fake_metric
fake_module3 = tests.FakeCollectorModule()
fake_module3.collector_name = 'fake3'
fake_module3.get_compute = fake_metric
fake_extensions = [
extension.Extension('fake1',
'cloudkitty.tests.FakeCollectorModule1', None,
fake_module1),
extension.Extension('fake2',
'cloudkitty.tests.FakeCollectorModule2', None,
fake_module2),
extension.Extension('fake3',
'cloudkitty.tests.FakeCollectorModule3', None,
fake_module3)
]
return fake_extensions[0]
def get_extention_list(self):
return [
extension.Extension(
'test',
None,
None,
self.Pollster(),
),
extension.Extension(
'testanother',
None,
None,
self.PollsterAnother(),
),
extension.Extension(
'testexception',
None,
None,
self.PollsterException(),
),
extension.Extension(
'testexceptionanother',
None,
None,
self.PollsterExceptionAnother(),
)
]
def create_extension_list(self):
return [
extension.Extension(
'test',
None,
None,
self.Pollster(self.CONF),
),
extension.Extension(
'testbatch',
None,
None,
self.BatchPollster(self.CONF),
),
extension.Extension(
'testanother',
None,
None,
self.PollsterAnother(self.CONF),
),
extension.Extension(
'testkeystone',
None,
None,
self.PollsterKeystone(self.CONF),
),
extension.Extension(
'testpollingexception',
None,
None,
self.PollsterPollingException(self.CONF),
)
]
def create_pollster_manager(self):
return extension.ExtensionManager.make_test_instance(
[
extension.Extension(
'test',
None,
None,
self.Pollster(), ),
extension.Extension(
'testanother',
None,
None,
self.PollsterAnother(), ),
extension.Extension(
'testexception',
None,
None,
self.PollsterException(), ),
extension.Extension(
'testexceptionanother',
None,
None,
self.PollsterExceptionAnother(), ),
],
)
def setup_fake_modules(self):
class FakeConfigController(rating.RatingRestControllerBase):
_custom_actions = {'test': ['GET']}
@wsme_pecan.wsexpose(wtypes.text)
def get_test(self):
"""Return the list of every mapping type available.
"""
return 'OK'
fake_module1 = tests.FakeRatingModule()
fake_module1.module_name = 'fake1'
fake_module1.set_priority(3)
fake_module2 = tests.FakeRatingModule()
fake_module2.module_name = 'fake2'
fake_module2.config_controller = FakeConfigController
fake_module2.set_priority(1)
fake_module3 = tests.FakeRatingModule()
fake_module3.module_name = 'fake3'
fake_module3.set_priority(2)
fake_extensions = [
extension.Extension('fake1', 'cloudkitty.tests.FakeRatingModule1',
None, fake_module1),
extension.Extension('fake2', 'cloudkitty.tests.FakeRatingModule2',
None, fake_module2),
extension.Extension('fake3', 'cloudkitty.tests.FakeRatingModule3',
None, fake_module3)
]
return fake_extensions
def create_extension_manager(self):
return extension_tests.TestExtensionManager(
[
extension.Extension(
'test',
None,
None,
self.Pollster(),
),
extension.Extension(
'testanother',
None,
None,
self.PollsterAnother(),
),
extension.Extension(
'testexception',
None,
None,
self.PollsterException(),
),
extension.Extension(
'testexceptionanother',
None,
None,
self.PollsterExceptionAnother(),
),
],
'fake',
invoke_on_load=False,
)
def fake_get_ext_mgr(namespace, *args, **kwargs):
if 'builder' in namespace:
return extension.ExtensionManager.make_test_instance([
extension.Extension('builder', None, TestPollsterBuilder,
None),
])
else:
return extension.ExtensionManager.make_test_instance([
extension.Extension('test', None, None,
TestPollster(self.conf)),
])
def create_extension_list(self):
exts = super(TestRunTasks, self).create_extension_list()
exts.extend([extension.Extension('testkeystone',
None,
None,
self.PollsterKeystone(), ),
extension.Extension('testpollingexception',
None,
None,
self.PollsterPollingException(), )])
return exts
def fake_get_ext_mgr(namespace):
if 'builder' in namespace:
return extension.ExtensionManager.make_test_instance([
extension.Extension('builder', None, TestPollsterBuilder,
None),
])
else:
return extension.ExtensionManager.make_test_instance([
extension.Extension('test', None, None,
agentbase.TestPollster()),
])
def test_hardware_discover_fail_minimize_logs(self, novalog, baselog):
self.useFixture(
mockpatch.PatchObject(novaclient.HTTPClient,
'authenticate',
side_effect=requests.ConnectionError))
class PollsterHardware(agentbase.TestPollster):
discovery = 'tripleo_overcloud_nodes'
class PollsterHardwareAnother(agentbase.TestPollster):
discovery = 'tripleo_overcloud_nodes'
self.mgr.extensions.extend([
extension.Extension(
'testhardware',
None,
None,
PollsterHardware(self.CONF),
),
extension.Extension(
'testhardware2',
None,
None,
PollsterHardwareAnother(self.CONF),
)
])
ext = extension.Extension('tripleo_overcloud_nodes', None, None,
discovery.NodesDiscoveryTripleO(self.CONF))
self.mgr.discoveries = (extension.ExtensionManager.make_test_instance(
[ext]))
self.pipeline_cfg = {
'sources': [{
'name': "test_hardware",
'interval': 10,
'meters': ['testhardware', 'testhardware2'],
'sinks': ['test_sink']
}],
'sinks': [{
'name': 'test_sink',
'transformers': [],
'publishers': ["test"]
}]
}
self.mgr.polling_manager = pipeline.PollingManager(
self.CONF, self.pipeline_cfg)
polling_tasks = self.mgr.setup_polling_tasks()
self.mgr.interval_task(list(polling_tasks.values())[0])
self.assertEqual(1, novalog.exception.call_count)
self.assertFalse(baselog.exception.called)
def setUp(self):
super(TestAlarmEvaluationService, self).setUp()
conf = service.prepare_service(argv=[], config_files=[])
self.CONF = self.useFixture(fixture_config.Config(conf)).conf
self.CONF.set_override('workers', 1, 'evaluator')
self.setup_messaging(self.CONF)
self.threshold_eval = mock.MagicMock()
self._fake_conn = mock.Mock()
self._fake_conn.get_alarms.return_value = []
self._fake_pc = mock.Mock()
self._fake_em = extension.ExtensionManager.make_test_instance([
extension.Extension('gnocchi_aggregation_by_metrics_threshold',
None, None, self.threshold_eval),
])
self.useFixture(
fixtures.MockPatch('stevedore.extension.ExtensionManager',
return_value=self._fake_em))
self.useFixture(
fixtures.MockPatch('aodh.coordination.PartitionCoordinator',
return_value=self._fake_pc))
self.useFixture(
fixtures.MockPatch('aodh.storage.get_connection_from_config',
return_value=self._fake_conn))
def test_list_opts_with_opts(self):
expected_sections = self.base_sections + [
'watcher_strategies.strategy_1']
# Set up the fake Stevedore extensions
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[extension.Extension(
name=fake_strategies.FakeDummy1Strategy1.get_name(),
entry_point="%s:%s" % (
fake_strategies.FakeDummy1Strategy1.__module__,
fake_strategies.FakeDummy1Strategy1.__name__),
plugin=fake_strategies.FakeDummy1Strategy1,
obj=None,
)],
namespace="watcher_strategies",
)
def m_list_available(namespace):
if namespace == "watcher_strategies":
return fake_extmanager_call
else:
return extension.ExtensionManager.make_test_instance(
extensions=[], namespace=namespace)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
m_ext_manager.side_effect = m_list_available
result = opts.list_opts()
self.assertIsNotNone(result)
self._assert_name_or_group(result, expected_sections)
result_map = dict(result)
strategy_opts = result_map['watcher_strategies.strategy_1']
self.assertEqual(['test_opt'], [opt.name for opt in strategy_opts])
def test_detach(self, mock_detach):
plg = extension.Extension(name="demo",
entry_point="os-acc",
plugin=DemoPlugin,
obj=None)
with mock.patch('stevedore.extension.ExtensionManager.names',
return_value=['foobar']),\
mock.patch('stevedore.extension.ExtensionManager.__getitem__',
return_value=plg):
os_acc.initialize()
fake_acc = {
"instance_uuid": "",
"interface_type": "demo",
"name": "NVIDIA Corporation GP100GL",
"address": "0000:81:00.0"
}
fake_instance = {}
fake_inst_type = {}
fake_guest = ""
fake_host = ""
os_acc.detach(fake_acc, fake_guest, fake_host, fake_instance,
fake_inst_type)
mock_detach.assert_called_once_with(fake_acc, fake_guest,
fake_host, fake_instance,
fake_inst_type)
def test_entrypoint_works(self):
method = uuid.uuid4().hex
plugin_name = self.getUniqueString()
# Register the method using the given plugin
cf = self.useFixture(config_fixture.Config())
cf.register_opt(cfg.StrOpt(method), group='auth')
cf.config(group='auth', **{method: plugin_name})
# Setup stevedore.DriverManager to return a driver for the plugin
extension_ = extension.Extension(plugin_name,
entry_point=mock.sentinel.entry_point,
plugin=mock.sentinel.plugin,
obj=mock.sentinel.driver)
auth_plugin_namespace = 'keystone.auth.%s' % method
fake_driver_manager = stevedore.DriverManager.make_test_instance(
extension_, namespace=auth_plugin_namespace)
driver_manager_mock = self.useFixture(
fixtures.MockPatchObject(stevedore,
'DriverManager',
return_value=fake_driver_manager)).mock
driver = controllers.load_auth_method(method)
self.assertEqual(auth_plugin_namespace, fake_driver_manager.namespace)
driver_manager_mock.assert_called_once_with(auth_plugin_namespace,
plugin_name,
invoke_on_load=True)
self.assertIs(driver, mock.sentinel.driver)
def setUp(self):
super(TestFlowExtension, self).setUp()
self.agent_extension = flow.FlowExtension()
self.agent_extension.ext_mgr = enabled.EnabledExtensionManager.\
make_test_instance([extension.Extension('fake', None,
FakeExtension,
FakeExtension())])
def __init__(self, templates=None):
templates = templates or {}
super(TemplatePluginFixture, self).__init__()
self.templates = [
extension.Extension(k, None, v, None)
for (k, v) in templates.items()
]
def test_process_notification(self):
pub = self.PublisherClass()
transformer_manager = transformer.TransformerExtensionManager(
'ceilometer.transformer', )
publisher_manager = publisher.PublisherExtensionManager('fake', )
publisher_manager.extensions = [
extension.Extension(
'test_pub',
None,
None,
pub,
),
]
publisher_manager.by_name = dict(
(e.name, e) for e in publisher_manager.extensions)
notifier._pipeline_manager = pipeline.PipelineManager(
[{
'name': "test_pipeline",
'interval': 60,
'counters': ['*'],
'transformers': [],
'publishers': ["test_pub"],
}], transformer_manager, publisher_manager)
self.assertEqual(len(pub.counters), 0)
notifier.notify(None, MESSAGE)
self.assertTrue(len(pub.counters) > 0)
self.assertIn('disk.ephemeral.size', [c.name for c in pub.counters])
def setUp(self):
super(TestPartitionedAlarmService, self).setUp()
self.threshold_eval = mock.Mock()
self.api_client = mock.MagicMock()
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF.set_override('host',
'fake_host')
self.CONF.set_override('partition_rpc_topic',
'fake_topic',
group='alarm')
self.setup_messaging(self.CONF)
self.partitioned = service.PartitionedAlarmService()
self.partitioned.tg = mock.Mock()
self.partitioned.partition_coordinator = mock.Mock()
self.extension_mgr = extension.ExtensionManager.make_test_instance(
[
extension.Extension(
'threshold',
None,
None,
self.threshold_eval, ),
]
)
self.partitioned.extension_manager = self.extension_mgr
def test_show_plugins(self):
# Set up the fake Stevedore extensions
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[
extension.Extension(
name=fake_strategies.FakeDummy1Strategy1.get_name(),
entry_point="%s:%s" %
(fake_strategies.FakeDummy1Strategy1.__module__,
fake_strategies.FakeDummy1Strategy1.__name__),
plugin=fake_strategies.FakeDummy1Strategy1,
obj=None,
)
],
namespace="watcher_strategies",
)
def m_list_available(namespace):
if namespace == "watcher_strategies":
return fake_extmanager_call
else:
return extension.ExtensionManager.make_test_instance(
extensions=[], namespace=namespace)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
with mock.patch.object(plugins,
"_show_plugins_ascii_table") as m_show:
m_ext_manager.side_effect = m_list_available
plugins.show_plugins()
m_show.assert_called_once_with([
('watcher_strategies.strategy_1', 'strategy_1',
'watcher.tests.decision_engine.'
'fake_strategies.FakeDummy1Strategy1')
])
def setUp(self):
super(TestAlarmEvaluationService, self).setUp()
conf = service.prepare_service(argv=[], config_files=[])
self.CONF = self.useFixture(fixture_config.Config(conf)).conf
self.setup_messaging(self.CONF)
self.threshold_eval = mock.Mock()
self.evaluators = extension.ExtensionManager.make_test_instance(
[
extension.Extension(
'threshold',
None,
None,
self.threshold_eval),
]
)
self.storage_conn = mock.MagicMock()
self.svc = evaluator.AlarmEvaluationService(self.CONF)
self.svc.tg = mock.Mock()
self.svc.partition_coordinator = mock.MagicMock()
p_coord = self.svc.partition_coordinator
p_coord.extract_my_subset.side_effect = lambda _, x: x
self.svc.evaluators = self.evaluators
self.svc.supported_evaluators = ['threshold']
def setUp(self):
super(TestMultipleHardwareManagerLoading, self).setUp()
fake_ep = mock.Mock()
fake_ep.module_name = 'fake'
fake_ep.attrs = ['fake attrs']
ext1 = extension.Extension('fake_generic', fake_ep, None,
FakeGenericHardwareManager())
ext2 = extension.Extension('fake_mainline', fake_ep, None,
FakeMainlineHardwareManager())
self.fake_ext_mgr = extension.ExtensionManager.make_test_instance(
[ext1, ext2])
self.extension_mgr_patcher = mock.patch('stevedore.ExtensionManager')
self.mocked_extension_mgr = self.extension_mgr_patcher.start()
self.mocked_extension_mgr.return_value = self.fake_ext_mgr
hardware._global_managers = None
def test_message_to_event_missing_keys(self):
now = timeutils.utcnow()
timeutils.set_time_override(now)
message = {'event_type': "foo",
'message_id': "abc",
'publisher_id': "1"}
mock_dispatcher = MagicMock()
self.srv.dispatcher_manager = test_manager.TestExtensionManager(
[extension.Extension('test',
None,
None,
mock_dispatcher
),
])
with patch('ceilometer.collector.service.LOG') as mylog:
self.srv._message_to_event(message)
self.assertFalse(mylog.exception.called)
events = mock_dispatcher.record_events.call_args[0]
self.assertEqual(1, len(events))
event = events[0]
self.assertEqual("foo", event.event_name)
self.assertEqual(now, event.generated)
self.assertEqual(1, len(event.traits))
def __init__(self):
self.extensions = []
self.extensions.append(
extension.Extension(name=FAKE_BACKEND,
plugin=FakeConnection,
entry_point=None,
obj=None))
def test_when_keystone_fail(self):
"""Test for bug 1316532."""
self.useFixture(mockpatch.Patch(
'keystoneclient.v2_0.client.Client',
side_effect=Exception))
self.pipeline_cfg = [
{
'name': "test_keystone",
'interval': 10,
'counters': ['testkeystone'],
'resources': ['test://'] if self.source_resources else [],
'transformers': [],
'publishers': ["test"],
},
]
self.mgr.pipeline_manager = pipeline.PipelineManager(
self.pipeline_cfg,
self.transformer_manager)
self.mgr.extensions = itertools.chain(
self.mgr.extensions,
[extension.Extension('testkeystone', None, None,
self.PollsterKeystone())])
polling_tasks = self.mgr.setup_polling_tasks()
self.mgr.interval_task(polling_tasks.values()[0])
self.assertFalse(self.PollsterKeystone.samples)
def test_list_opts_no_opts(self):
expected_sections = self.base_sections
# Set up the fake Stevedore extensions
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[
extension.Extension(
name=fake_strategies.FakeDummy1Strategy2.get_name(),
entry_point="%s:%s" %
(fake_strategies.FakeDummy1Strategy2.__module__,
fake_strategies.FakeDummy1Strategy2.__name__),
plugin=fake_strategies.FakeDummy1Strategy2,
obj=None,
)
],
namespace="watcher_strategies",
)
def m_list_available(namespace):
if namespace == "watcher_strategies":
return fake_extmanager_call
else:
return extension.ExtensionManager.make_test_instance(
extensions=[], namespace=namespace)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
m_ext_manager.side_effect = m_list_available
result = opts.list_opts()
self.assertIsNotNone(result)
for section_name, options in result:
self.assertIn(section_name, expected_sections)
self.assertTrue(len(options))
def get_extension_list(self):
exts = super(TestRunTasks, self).get_extension_list()
exts.append(extension.Extension('testkeystone',
None,
None,
self.PollsterKeystone(),))
return exts
