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