def test_two_topics(self): transport = oslo_messaging.get_transport(self.conf, url="fake:") endpoint = mock.Mock() endpoint.info.return_value = None targets = [oslo_messaging.Target(topic="topic1"), oslo_messaging.Target(topic="topic2")] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topic="topic1") notifier.info({"ctxt": "1"}, "an_event.start1", "test") notifier = self._setup_notifier(transport, topic="topic2") notifier.info({"ctxt": "2"}, "an_event.start2", "test") self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls( [ mock.call( {"ctxt": "1"}, "testpublisher", "an_event.start1", "test", {"timestamp": mock.ANY, "message_id": mock.ANY}, ), mock.call( {"ctxt": "2"}, "testpublisher", "an_event.start2", "test", {"timestamp": mock.ANY, "message_id": mock.ANY}, ), ], any_order=True, )
def test_batch_size(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None listener_thread = self._setup_listener(transport, [endpoint], batch=(5, None)) notifier = self._setup_notifier(transport) for i in six.moves.range(10): notifier.info({}, 'an_event.start', 'test message') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) messages = [ dict(ctxt={}, publisher_id='testpublisher', event_type='an_event.start', payload='test message', metadata={ 'message_id': mock.ANY, 'timestamp': mock.ANY }) ] endpoint.info.assert_has_calls( [mock.call(messages * 5), mock.call(messages * 5)])
def test_remove_user_emits_structure_role_revoked_for_each_role_user_had_in_project( self): self.project.add_user(self.user, ProjectRole.ADMINISTRATOR) self.project.add_user(self.user, ProjectRole.MANAGER) with mock_signal_receiver(signals.structure_role_revoked) as receiver: self.project.remove_user(self.user, removed_by=self.removed_by) calls = [ mock.call( structure=self.project, user=self.user, removed_by=self.removed_by, role=ProjectRole.MANAGER, sender=Project, signal=signals.structure_role_revoked, ), mock.call( structure=self.project, user=self.user, removed_by=self.removed_by, role=ProjectRole.ADMINISTRATOR, sender=Project, signal=signals.structure_role_revoked, ), ] receiver.assert_has_calls(calls, any_order=True) self.assertEqual(receiver.call_count, 2, 'Excepted exactly 2 signals emitted')
def test_two_topics(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None targets = [ oslo_messaging.Target(topic="topic1"), oslo_messaging.Target(topic="topic2") ] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topic='topic1') notifier.info({'ctxt': '1'}, 'an_event.start1', 'test') notifier = self._setup_notifier(transport, topic='topic2') notifier.info({'ctxt': '2'}, 'an_event.start2', 'test') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls([ mock.call({'ctxt': '1'}, 'testpublisher', 'an_event.start1', 'test', { 'timestamp': mock.ANY, 'message_id': mock.ANY }), mock.call({'ctxt': '2'}, 'testpublisher', 'an_event.start2', 'test', { 'timestamp': mock.ANY, 'message_id': mock.ANY }) ], any_order=True)
def test_batch_timeout(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None listener_thread = self._setup_listener(transport, [endpoint], batch=(5, 1)) notifier = self._setup_notifier(transport) for i in six.moves.range(12): notifier.info({}, 'an_event.start', 'test message') self.wait_for_messages(3) self.assertFalse(listener_thread.stop()) messages = [dict(ctxt={}, publisher_id='testpublisher', event_type='an_event.start', payload='test message', metadata={'message_id': mock.ANY, 'timestamp': mock.ANY})] endpoint.info.assert_has_calls([mock.call(messages * 5), mock.call(messages * 5), mock.call(messages * 2)])
def test_requeue(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info = mock.Mock() def side_effect_requeue(*args, **kwargs): if endpoint.info.call_count == 1: return oslo_messaging.NotificationResult.REQUEUE return oslo_messaging.NotificationResult.HANDLED endpoint.info.side_effect = side_effect_requeue listener_thread = self._setup_listener(transport, [endpoint]) notifier = self._setup_notifier(transport) notifier.info({}, 'an_event.start', 'test') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls([ mock.call({}, 'testpublisher', 'an_event.start', 'test', { 'timestamp': mock.ANY, 'message_id': mock.ANY }), mock.call({}, 'testpublisher', 'an_event.start', 'test', { 'timestamp': mock.ANY, 'message_id': mock.ANY }) ])
def test_listen_and_direct_send(self): target = oslo_messaging.Target(exchange="exchange_test", topic="topic_test", server="server_test") with mock.patch('qpid.messaging.Connection') as conn_cls: conn = conn_cls.return_value session = conn.session.return_value session.receiver.side_effect = [ mock.Mock(), mock.Mock(), mock.Mock() ] listener = self.driver.listen(target) listener.conn.direct_send("msg_id", {}) self.assertEqual(3, len(listener.conn.consumers)) expected_calls = [ mock.call( AddressNodeMatcher( 'amq.topic/topic/exchange_test/topic_test')), mock.call( AddressNodeMatcher( 'amq.topic/topic/exchange_test/topic_test.server_test')), mock.call(AddressNodeMatcher('amq.topic/fanout/topic_test')), ] session.receiver.assert_has_calls(expected_calls) session.sender.assert_called_with( AddressNodeMatcher("amq.direct/msg_id"))
def test_two_topics(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None targets = [oslo_messaging.Target(topic="topic1"), oslo_messaging.Target(topic="topic2")] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topic='topic1') notifier.info({'ctxt': '1'}, 'an_event.start1', 'test') notifier = self._setup_notifier(transport, topic='topic2') notifier.info({'ctxt': '2'}, 'an_event.start2', 'test') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls([ mock.call({'ctxt': '1'}, 'testpublisher', 'an_event.start1', 'test', {'timestamp': mock.ANY, 'message_id': mock.ANY}), mock.call({'ctxt': '2'}, 'testpublisher', 'an_event.start2', 'test', {'timestamp': mock.ANY, 'message_id': mock.ANY})], any_order=True)
def test_requeue(self): transport = oslo_messaging.get_transport(self.conf, url="fake:") endpoint = mock.Mock() endpoint.info = mock.Mock() def side_effect_requeue(*args, **kwargs): if endpoint.info.call_count == 1: return oslo_messaging.NotificationResult.REQUEUE return oslo_messaging.NotificationResult.HANDLED endpoint.info.side_effect = side_effect_requeue listener_thread = self._setup_listener(transport, [endpoint]) notifier = self._setup_notifier(transport) notifier.info({}, "an_event.start", "test") self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls( [ mock.call( {}, "testpublisher", "an_event.start", "test", {"timestamp": mock.ANY, "message_id": mock.ANY} ), mock.call( {}, "testpublisher", "an_event.start", "test", {"timestamp": mock.ANY, "message_id": mock.ANY} ), ] )
def test_listen_and_direct_send(self): target = oslo_messaging.Target(exchange="exchange_test", topic="topic_test", server="server_test") with mock.patch('qpid.messaging.Connection') as conn_cls: conn = conn_cls.return_value session = conn.session.return_value session.receiver.side_effect = [mock.Mock(), mock.Mock(), mock.Mock()] listener = self.driver.listen(target) listener.conn.direct_send("msg_id", {}) self.assertEqual(3, len(listener.conn.consumers)) expected_calls = [ mock.call(AddressNodeMatcher( 'amq.topic/topic/exchange_test/topic_test')), mock.call(AddressNodeMatcher( 'amq.topic/topic/exchange_test/topic_test.server_test')), mock.call(AddressNodeMatcher('amq.topic/fanout/topic_test')), ] session.receiver.assert_has_calls(expected_calls) session.sender.assert_called_with( AddressNodeMatcher("amq.direct/msg_id"))
def test_handle_message_callback(transport, protocol, dispatcher): server = RPCServer(transport, protocol, dispatcher) server.trace = Mock(return_value=None) server.receive_one_message() assert server.trace.call_args_list == [call('-->', CONTEXT, RECMSG), call('<--', CONTEXT, SERMSG)] server.trace.assert_called()
def test_handle_message_callback(transport, protocol, dispatcher): server = RPCServer(transport, protocol, dispatcher) server.trace = Mock(return_value=None) server.receive_one_message() assert server.trace.call_args_list == [ call('-->', CONTEXT, RECMSG), call('<--', CONTEXT, SERMSG) ] server.trace.assert_called()
def test_run(self, *args): """Test lvm device populator.""" device_get_lv_vg_name = args[0] device_get_name = args[1] get_device_by_name = args[3] devicetree = DeviceTree() data = Mock() # Add slave/parent devices and then look up the device. device_get_name.return_value = sentinel.lv_name devicetree.get_device_by_name.return_value = None # pylint: disable=unused-argument def _get_device_by_name(name, **kwargs): if name == sentinel.lv_name: return sentinel.lv_device get_device_by_name.side_effect = _get_device_by_name device_get_lv_vg_name.return_value = sentinel.vg_name helper = self.helper_class(devicetree, data) self.assertEqual(helper.run(), sentinel.lv_device) self.assertEqual(devicetree.get_device_by_name.call_count, 3) # pylint: disable=no-member get_device_by_name.assert_has_calls([ call(sentinel.vg_name, hidden=True), call(sentinel.vg_name), call(sentinel.lv_name) ]) # Add slave/parent devices, but the device is still not in the tree get_device_by_name.side_effect = None get_device_by_name.return_value = None self.assertEqual(helper.run(), None) get_device_by_name.assert_called_with(sentinel.lv_name) # A non-vg device with the same name as the vg is already in the tree. # pylint: disable=unused-argument def _get_device_by_name2(name, **kwargs): if name == sentinel.lv_name: return sentinel.lv_device elif name == sentinel.vg_name: return sentinel.non_vg_device get_device_by_name.side_effect = _get_device_by_name2 if six.PY3: with self.assertLogs('blivet', level='WARNING') as log_cm: self.assertEqual(helper.run(), sentinel.lv_device) log_entry = "WARNING:blivet:found non-vg device with name %s" % sentinel.vg_name self.assertTrue(log_entry in log_cm.output) else: self.assertEqual(helper.run(), sentinel.lv_device)
def test_two_exchanges(self): transport = msg_notifier.get_notification_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None targets = [ oslo_messaging.Target(topic="topic", exchange="exchange1"), oslo_messaging.Target(topic="topic", exchange="exchange2") ] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topics=["topic"]) def mock_notifier_exchange(name): def side_effect(target, ctxt, message, version, retry): target.exchange = name return transport._driver.send_notification(target, ctxt, message, version, retry=retry) transport._send_notification = mock.MagicMock( side_effect=side_effect) notifier.info({'ctxt': '0'}, 'an_event.start', 'test message default exchange') mock_notifier_exchange('exchange1') notifier.info({'ctxt': '1'}, 'an_event.start', 'test message exchange1') mock_notifier_exchange('exchange2') notifier.info({'ctxt': '2'}, 'an_event.start', 'test message exchange2') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls([ mock.call({'ctxt': '1'}, 'testpublisher', 'an_event.start', 'test message exchange1', { 'timestamp': mock.ANY, 'message_id': mock.ANY }), mock.call({'ctxt': '2'}, 'testpublisher', 'an_event.start', 'test message exchange2', { 'timestamp': mock.ANY, 'message_id': mock.ANY }) ], any_order=True)
def test_two_exchanges(self): transport = oslo_messaging.get_transport(self.conf, url="fake:") endpoint = mock.Mock() endpoint.info.return_value = None targets = [ oslo_messaging.Target(topic="topic", exchange="exchange1"), oslo_messaging.Target(topic="topic", exchange="exchange2"), ] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topic="topic") def mock_notifier_exchange(name): def side_effect(target, ctxt, message, version, retry): target.exchange = name return transport._driver.send_notification(target, ctxt, message, version, retry=retry) transport._send_notification = mock.MagicMock(side_effect=side_effect) notifier.info({"ctxt": "0"}, "an_event.start", "test message default exchange") mock_notifier_exchange("exchange1") notifier.info({"ctxt": "1"}, "an_event.start", "test message exchange1") mock_notifier_exchange("exchange2") notifier.info({"ctxt": "2"}, "an_event.start", "test message exchange2") self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls( [ mock.call( {"ctxt": "1"}, "testpublisher", "an_event.start", "test message exchange1", {"timestamp": mock.ANY, "message_id": mock.ANY}, ), mock.call( {"ctxt": "2"}, "testpublisher", "an_event.start", "test message exchange2", {"timestamp": mock.ANY, "message_id": mock.ANY}, ), ], any_order=True, )
def test_pytest_configure(mocked_config): """Test plugin successful configuration. :param mocked_config: Pytest fixture """ mocked_config.option.rp_enabled = True mocked_config.option.rp_project = None pytest_configure(mocked_config) expect(mocked_config._rp_enabled is True) expect( lambda: isinstance(mocked_config.py_test_service, PyTestServiceClass)) assert_expectations() mocked_config.getoption.assert_has_calls([ mock.call('--collect-only', default=False), mock.call('--setup-plan', default=False) ])
def test_batch_size_exception_path(self): transport = oslo_messaging.get_notification_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.side_effect = [None, Exception('boom!')] listener_thread = self._setup_listener(transport, [endpoint], batch=(5, None)) notifier = self._setup_notifier(transport) for _ in range(10): notifier.info({}, 'an_event.start', 'test message') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) messages = [ dict(ctxt={}, publisher_id='testpublisher', event_type='an_event.start', payload='test message', metadata={ 'message_id': mock.ANY, 'timestamp': mock.ANY }) ] endpoint.info.assert_has_calls([mock.call(messages * 5)])
def _do_test_heartbeat_sent(self, fake_ensure_connection, fake_heartbeat_support, fake_heartbeat, fake_logger, heartbeat_side_effect=None, info=None): event = threading.Event() def heartbeat_check(rate=2): event.set() if heartbeat_side_effect: raise heartbeat_side_effect fake_heartbeat.side_effect = heartbeat_check transport = oslo_messaging.get_transport(self.conf, 'kombu+memory:////') self.addCleanup(transport.cleanup) conn = transport._driver._get_connection() conn.ensure(method=lambda: True) event.wait() conn._heartbeat_stop() # check heartbeat have been called self.assertLess(0, fake_heartbeat.call_count) if not heartbeat_side_effect: self.assertEqual(1, fake_ensure_connection.call_count) self.assertEqual(2, fake_logger.debug.call_count) self.assertEqual(0, fake_logger.info.call_count) else: self.assertEqual(2, fake_ensure_connection.call_count) self.assertEqual(2, fake_logger.debug.call_count) self.assertEqual(1, fake_logger.info.call_count) self.assertIn(mock.call(info, mock.ANY), fake_logger.info.mock_calls)
def test_constructor(self, warn): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() access_policy = dispatcher.DefaultRPCAccessPolicy warnings.simplefilter("always", FutureWarning) server = oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer, access_policy=access_policy) self.assertIs(server.conf, self.conf) self.assertIs(server.transport, transport) self.assertIsInstance(server.dispatcher, oslo_messaging.RPCDispatcher) self.assertIs(server.dispatcher.endpoints, endpoints) self.assertIs(server.dispatcher.serializer, serializer) self.assertEqual('blocking', server.executor_type) self.assertEqual([ mock.call("blocking executor is deprecated. Executor default will " "be removed. Use explicitly threading or eventlet " "instead in version 'pike' and will be removed in " "version 'rocky'", category=FutureWarning, stacklevel=3) ], warn.mock_calls)
def mocked_endpoint_call(i): return mock.call( {"ctxt": "%d" % i}, "testpublisher", "an_event.start", "test message%d" % i, {"timestamp": mock.ANY, "message_id": mock.ANY}, )
def test_constructor_without_explicit_RPCAccessPolicy(self, warn): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() warnings.simplefilter("always", FutureWarning) oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) self.assertEqual([ mock.call(mock.ANY, category=FutureWarning, stacklevel=3), mock.call("blocking executor is deprecated. Executor default will " "be removed. Use explicitly threading or eventlet " "instead in version 'pike' and will be removed in " "version 'rocky'", category=FutureWarning, stacklevel=3) ], warn.mock_calls)
def test_two_exchanges(self): transport = msg_notifier.get_notification_transport( self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.return_value = None targets = [oslo_messaging.Target(topic="topic", exchange="exchange1"), oslo_messaging.Target(topic="topic", exchange="exchange2")] listener_thread = self._setup_listener(transport, [endpoint], targets=targets) notifier = self._setup_notifier(transport, topic="topic") def mock_notifier_exchange(name): def side_effect(target, ctxt, message, version, retry): target.exchange = name return transport._driver.send_notification(target, ctxt, message, version, retry=retry) transport._send_notification = mock.MagicMock( side_effect=side_effect) notifier.info({'ctxt': '0'}, 'an_event.start', 'test message default exchange') mock_notifier_exchange('exchange1') notifier.info({'ctxt': '1'}, 'an_event.start', 'test message exchange1') mock_notifier_exchange('exchange2') notifier.info({'ctxt': '2'}, 'an_event.start', 'test message exchange2') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) endpoint.info.assert_has_calls([ mock.call({'ctxt': '1'}, 'testpublisher', 'an_event.start', 'test message exchange1', {'timestamp': mock.ANY, 'message_id': mock.ANY}), mock.call({'ctxt': '2'}, 'testpublisher', 'an_event.start', 'test message exchange2', {'timestamp': mock.ANY, 'message_id': mock.ANY})], any_order=True)
def test_reconnect_order(self): brokers = ['host1', 'host2', 'host3', 'host4', 'host5'] brokers_count = len(brokers) self.config(qpid_hosts=brokers, group='oslo_messaging_qpid') with mock.patch('qpid.messaging.Connection') as conn_mock: # starting from the first broker in the list url = oslo_messaging.TransportURL.parse(self.conf, None) connection = qpid_driver.Connection(self.conf, url, amqp.PURPOSE_SEND) # reconnect will advance to the next broker, one broker per # attempt, and then wrap to the start of the list once the end is # reached for _ in range(brokers_count): connection.reconnect() expected = [] for broker in brokers: expected.extend([ mock.call("%s:5672" % broker), mock.call().open(), mock.call().session(), mock.call().opened(), mock.call().opened().__nonzero__(), mock.call().close() ]) conn_mock.assert_has_calls(expected, any_order=True)
def test_reconnect_order(self): brokers = ['host1', 'host2', 'host3', 'host4', 'host5'] brokers_count = len(brokers) self.config(qpid_hosts=brokers, group='oslo_messaging_qpid') with mock.patch('qpid.messaging.Connection') as conn_mock: # starting from the first broker in the list url = oslo_messaging.TransportURL.parse(self.conf, None) connection = qpid_driver.Connection(self.conf, url, amqp.PURPOSE_SEND) # reconnect will advance to the next broker, one broker per # attempt, and then wrap to the start of the list once the end is # reached for _ in range(brokers_count): connection.reconnect() expected = [] for broker in brokers: expected.extend([mock.call("%s:5672" % broker), mock.call().open(), mock.call().session(), mock.call().opened(), mock.call().opened().__nonzero__(), mock.call().close()]) conn_mock.assert_has_calls(expected, any_order=True)
def test_call_serializer(self): self.config(rpc_response_timeout=None) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') serializer = msg_serializer.NoOpSerializer() client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(), serializer=serializer) transport._send = mock.Mock() kwargs = dict(wait_for_reply=True, timeout=None) if self.call else {} kwargs['retry'] = None if self.call: kwargs['call_monitor_timeout'] = None transport._send.return_value = self.retval serializer.serialize_entity = mock.Mock() serializer.deserialize_entity = mock.Mock() serializer.serialize_context = mock.Mock() def _stub(ctxt, arg): return 's' + arg msg = dict(method='foo', args=dict()) for k, v in self.args.items(): msg['args'][k] = 's' + v serializer.serialize_entity.side_effect = _stub if self.call: serializer.deserialize_entity.return_value = 'd' + self.retval serializer.serialize_context.return_value = dict(user='******') method = client.call if self.call else client.cast retval = method(self.ctxt, 'foo', **self.args) if self.retval is not None: self.assertEqual('d' + self.retval, retval) transport._send.assert_called_once_with(oslo_messaging.Target(), dict(user='******'), msg, transport_options=None, **kwargs) expected_calls = [mock.call(self.ctxt, arg) for arg in self.args] self.assertEqual(expected_calls, serializer.serialize_entity.mock_calls) if self.call: serializer.deserialize_entity.assert_called_once_with( self.ctxt, self.retval) serializer.serialize_context.assert_called_once_with(self.ctxt)
def test_paths(self, mocker): """Ensure that the specified paths are added to the path.""" paths = ['path1', 'path2', 'path3'] eval_mock = mocker.patch('matl_online.octave.OctaveSession.eval') session = OctaveSession(paths=paths) assert session.octaverc is None assert session.paths == paths expected_calls = [mock.call('addpath("''%s''")' % path) for path in paths] eval_mock.assert_has_calls(expected_calls)
def test__copy_grub_files(mock_path_exists, mock_path_copy2, sys_id, src_file_exists, dst_file_exists, log_msg, ret_value, monkeypatch, caplog): def path_exists(path): return src_file_exists if grub.CENTOS_EFIDIR_CANONICAL_PATH in path else dst_file_exists mock_path_exists.side_effect = path_exists monkeypatch.setattr("convert2rhel.systeminfo.system_info.id", sys_id) successful = grub._copy_grub_files(["grubenv", "grub.cfg"], ["user.cfg"]) assert any(log_msg in record.message for record in caplog.records) assert successful == ret_value if sys_id == "centos" and src_file_exists and not dst_file_exists: assert mock_path_copy2.call_args_list == [ mock.call("/boot/efi/EFI/centos/grubenv", "/boot/efi/EFI/redhat/grubenv"), mock.call("/boot/efi/EFI/centos/grub.cfg", "/boot/efi/EFI/redhat/grub.cfg"), mock.call("/boot/efi/EFI/centos/user.cfg", "/boot/efi/EFI/redhat/user.cfg"), ]
def test_call_serializer(self): self.config(rpc_response_timeout=None) transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') serializer = msg_serializer.NoOpSerializer() client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(), serializer=serializer) transport._send = mock.Mock() kwargs = dict(wait_for_reply=True, timeout=None) if self.call else {} kwargs['retry'] = None if self.call: kwargs['call_monitor_timeout'] = None transport._send.return_value = self.retval serializer.serialize_entity = mock.Mock() serializer.deserialize_entity = mock.Mock() serializer.serialize_context = mock.Mock() def _stub(ctxt, arg): return 's' + arg msg = dict(method='foo', args=dict()) for k, v in self.args.items(): msg['args'][k] = 's' + v serializer.serialize_entity.side_effect = _stub if self.call: serializer.deserialize_entity.return_value = 'd' + self.retval serializer.serialize_context.return_value = dict(user='******') method = client.call if self.call else client.cast retval = method(self.ctxt, 'foo', **self.args) if self.retval is not None: self.assertEqual('d' + self.retval, retval) transport._send.assert_called_once_with(oslo_messaging.Target(), dict(user='******'), msg, **kwargs) expected_calls = [mock.call(self.ctxt, arg) for arg in self.args] self.assertEqual(expected_calls, serializer.serialize_entity.mock_calls) if self.call: serializer.deserialize_entity.assert_called_once_with(self.ctxt, self.retval) serializer.serialize_context.assert_called_once_with(self.ctxt)
def test_declare_rpc_queue_bindings(self, rpc_pika_incoming_message_mock): poller = pika_poller.RpcServicePikaPoller(self._pika_engine, self._target, 1, None, self._prefetch_count) poller.start(None) self.assertTrue(self._pika_engine.create_connection.called) self.assertTrue(self._poller_connection_mock.channel.called) declare_queue_binding_by_channel_mock = ( self._pika_engine.declare_queue_binding_by_channel) self.assertEqual(6, declare_queue_binding_by_channel_mock.call_count) declare_queue_binding_by_channel_mock.assert_has_calls( (mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_None_True_False", queue_expiration=12345, routing_key="topic_None_True_False"), mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_server_True_False", queue_expiration=12345, routing_key="topic_server_True_False"), mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_server_True_True", queue_expiration=12345, routing_key="topic_all_workers_True_False"), mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_None_False_False", queue_expiration=12345, routing_key="topic_None_False_False"), mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_server_False_False", queue_expiration=12345, routing_key='topic_server_False_False'), mock.call(channel=self._poller_channel_mock, durable=False, exchange="exchange", exchange_type='direct', queue="topic_server_False_True", queue_expiration=12345, routing_key='topic_all_workers_False_False')))
def test_pytest_configure_misssing_rp_uuid(mocked_log, mocked_config): """Test plugin configuration in case of missing rp_uuid. The value of the _reportportal_configured attribute of the pytest Config object should be changed to False, stopping plugin configuration, if rp_uuid is not set. :param mocked_config: Pytest fixture """ mocked_config.option.rp_enabled = True mocked_config.option.rp_uuid = None mocked_config.getini.return_value = 0 pytest_configure(mocked_config) assert mocked_config._rp_enabled is False mocked_log.debug.assert_has_calls([ mock.call( MANDATORY_PARAMETER_MISSED_PATTERN.format( mocked_config.option.rp_project, mocked_config.option.rp_endpoint, None, )), mock.call('Disabling reporting to RP.'), ])
def test_declare_notification_queue_bindings_custom_queue(self): poller = pika_poller.NotificationPikaPoller( self._pika_engine, self._target_and_priorities, 1, None, self._prefetch_count, "custom_queue_name") poller.start(None) self.assertTrue(self._pika_engine.create_connection.called) self.assertTrue(self._poller_connection_mock.channel.called) declare_queue_binding_by_channel_mock = ( self._pika_engine.declare_queue_binding_by_channel) self.assertEqual(3, declare_queue_binding_by_channel_mock.call_count) declare_queue_binding_by_channel_mock.assert_has_calls( (mock.call(channel=self._poller_channel_mock, durable=self._pika_engine.notification_persistence, exchange="exchange1", exchange_type='direct', queue="custom_queue_name", queue_expiration=None, routing_key="topic1.1"), mock.call(channel=self._poller_channel_mock, durable=self._pika_engine.notification_persistence, exchange="exchange1", exchange_type='direct', queue="custom_queue_name", queue_expiration=None, routing_key="topic1.2"), mock.call(channel=self._poller_channel_mock, durable=self._pika_engine.notification_persistence, exchange="exchange2", exchange_type='direct', queue="custom_queue_name", queue_expiration=None, routing_key="topic2.1")))
def test_call_serializer(self): self.config(rpc_response_timeout=None) transport = _FakeTransport(self.conf) serializer = msg_serializer.NoOpSerializer() client = oslo_messaging.RPCClient(transport, oslo_messaging.Target(), serializer=serializer) transport._send = mock.Mock() msg = dict(method='foo', args=dict([(k, 's' + v) for k, v in self.args.items()])) kwargs = dict(wait_for_reply=True, timeout=None) if self.call else {} kwargs['retry'] = None transport._send.return_value = self.retval serializer.serialize_entity = mock.Mock() serializer.deserialize_entity = mock.Mock() serializer.serialize_context = mock.Mock() expected_side_effect = [] for arg in self.args: expected_side_effect.append('s' + arg) serializer.serialize_entity.side_effect = expected_side_effect if self.call: serializer.deserialize_entity.return_value = 'd' + self.retval serializer.serialize_context.return_value = dict(user='******') method = client.call if self.call else client.cast retval = method(self.ctxt, 'foo', **self.args) if self.retval is not None: self.assertEqual('d' + self.retval, retval) transport._send.assert_called_once_with(oslo_messaging.Target(), dict(user='******'), msg, **kwargs) expected_calls = [mock.call(self.ctxt, arg) for arg in self.args] self.assertEqual(expected_calls, serializer.serialize_entity.mock_calls) if self.call: serializer.deserialize_entity.assert_called_once_with( self.ctxt, self.retval) serializer.serialize_context.assert_called_once_with(self.ctxt)
def test_constructor_without_explicit_RPCAccessPolicy(self, warn): transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:') target = oslo_messaging.Target(topic='foo', server='bar') endpoints = [object()] serializer = object() warnings.simplefilter("always", FutureWarning) oslo_messaging.get_rpc_server(transport, target, endpoints, serializer=serializer) self.assertEqual([ mock.call("blocking executor is deprecated. Executor default will " "be removed. Use explicitly threading or eventlet " "instead in version 'pike' and will be removed in " "version 'rocky'", category=FutureWarning, stacklevel=3) ], warn.mock_calls)
def test_get_transport(self, fake_logger): self.config(rpc_backend=self.rpc_backend, control_exchange=self.control_exchange, transport_url=self.transport_url) driver.DriverManager = mock.Mock() invoke_args = [ self.conf, oslo_messaging.TransportURL.parse(self.conf, self.expect['url']) ] invoke_kwds = dict(default_exchange=self.expect['exchange'], allowed_remote_exmods=self.expect['allowed']) drvr = _FakeDriver(self.conf) driver.DriverManager.return_value = _FakeManager(drvr) kwargs = dict(url=self.url) if self.allowed is not None: kwargs['allowed_remote_exmods'] = self.allowed if self.aliases is not None: kwargs['aliases'] = self.aliases transport_ = oslo_messaging.get_transport(self.conf, **kwargs) if self.aliases is not None: self.assertEqual([ mock.call('legacy "rpc_backend" is deprecated, ' '"testfoo" must be replaced by ' '"%s"' % self.aliases.get('testfoo')) ], fake_logger.warning.mock_calls) self.assertIsNotNone(transport_) self.assertIs(transport_.conf, self.conf) self.assertIs(transport_._driver, drvr) self.assertTrue(isinstance(transport_, transport.RPCTransport)) driver.DriverManager.assert_called_once_with('oslo.messaging.drivers', self.expect['backend'], invoke_on_load=True, invoke_args=invoke_args, invoke_kwds=invoke_kwds)
def test_get_transport(self, fake_logger): self.config(rpc_backend=self.rpc_backend, control_exchange=self.control_exchange, transport_url=self.transport_url) driver.DriverManager = mock.Mock() invoke_args = [self.conf, oslo_messaging.TransportURL.parse(self.conf, self.expect['url'])] invoke_kwds = dict(default_exchange=self.expect['exchange'], allowed_remote_exmods=self.expect['allowed']) drvr = _FakeDriver(self.conf) driver.DriverManager.return_value = _FakeManager(drvr) kwargs = dict(url=self.url) if self.allowed is not None: kwargs['allowed_remote_exmods'] = self.allowed if self.aliases is not None: kwargs['aliases'] = self.aliases transport_ = oslo_messaging.get_transport(self.conf, **kwargs) if self.aliases is not None: self.assertEqual( [mock.call('legacy "rpc_backend" is deprecated, ' '"testfoo" must be replaced by ' '"%s"' % self.aliases.get('testfoo'))], fake_logger.warning.mock_calls ) self.assertIsNotNone(transport_) self.assertIs(transport_.conf, self.conf) self.assertIs(transport_._driver, drvr) self.assertTrue(isinstance(transport_, transport.RPCTransport)) driver.DriverManager.assert_called_once_with('oslo.messaging.drivers', self.expect['backend'], invoke_on_load=True, invoke_args=invoke_args, invoke_kwds=invoke_kwds)
def test_serializer(self): endpoint = _FakeEndpoint() serializer = msg_serializer.NoOpSerializer() dispatcher = oslo_messaging.RPCDispatcher([endpoint], serializer) endpoint.foo = mock.Mock() args = dict([(k, 'd' + v) for k, v in self.args.items()]) endpoint.foo.return_value = self.retval serializer.serialize_entity = mock.Mock() serializer.deserialize_entity = mock.Mock() serializer.deserialize_context = mock.Mock() serializer.deserialize_context.return_value = self.dctxt expected_side_effect = ['d' + arg for arg in self.args] serializer.deserialize_entity.side_effect = expected_side_effect serializer.serialize_entity.return_value = None if self.retval: serializer.serialize_entity.return_value = 's' + self.retval incoming = mock.Mock() incoming.ctxt = self.ctxt incoming.message = dict(method='foo', args=self.args) incoming.client_timeout = 0 retval = dispatcher.dispatch(incoming) if self.retval is not None: self.assertEqual('s' + self.retval, retval) endpoint.foo.assert_called_once_with(self.dctxt, **args) serializer.deserialize_context.assert_called_once_with(self.ctxt) expected_calls = [mock.call(self.dctxt, arg) for arg in self.args] self.assertEqual(expected_calls, serializer.deserialize_entity.mock_calls) serializer.serialize_entity.assert_called_once_with( self.dctxt, self.retval)
def test_serializer(self): endpoint = _FakeEndpoint() serializer = msg_serializer.NoOpSerializer() dispatcher = oslo_messaging.RPCDispatcher([endpoint], serializer) endpoint.foo = mock.Mock() args = dict([(k, 'd' + v) for k, v in self.args.items()]) endpoint.foo.return_value = self.retval serializer.serialize_entity = mock.Mock() serializer.deserialize_entity = mock.Mock() serializer.deserialize_context = mock.Mock() serializer.deserialize_context.return_value = self.dctxt expected_side_effect = ['d' + arg for arg in self.args] serializer.deserialize_entity.side_effect = expected_side_effect serializer.serialize_entity.return_value = None if self.retval: serializer.serialize_entity.return_value = 's' + self.retval incoming = mock.Mock() incoming.ctxt = self.ctxt incoming.message = dict(method='foo', args=self.args) incoming.client_timeout = 0 retval = dispatcher.dispatch(incoming) if self.retval is not None: self.assertEqual('s' + self.retval, retval) endpoint.foo.assert_called_once_with(self.dctxt, **args) serializer.deserialize_context.assert_called_once_with(self.ctxt) expected_calls = [mock.call(self.dctxt, arg) for arg in self.args] self.assertEqual(expected_calls, serializer.deserialize_entity.mock_calls) serializer.serialize_entity.assert_called_once_with(self.dctxt, self.retval)
def test_batch_size_exception_path(self): transport = oslo_messaging.get_transport(self.conf, url='fake:') endpoint = mock.Mock() endpoint.info.side_effect = [None, Exception('boom!')] listener_thread = self._setup_listener(transport, [endpoint], batch=(5, None)) notifier = self._setup_notifier(transport) for i in six.moves.range(10): notifier.info({}, 'an_event.start', 'test message') self.wait_for_messages(2) self.assertFalse(listener_thread.stop()) messages = [dict(ctxt={}, publisher_id='testpublisher', event_type='an_event.start', payload='test message', metadata={'message_id': mock.ANY, 'timestamp': mock.ANY})] endpoint.info.assert_has_calls([mock.call(messages * 5)])
def test_notifier(self, mock_utcnow): drivers = [] if self.v1: drivers.append('messaging') if self.v2: drivers.append('messagingv2') self.config(driver=drivers, topics=self.topics, group='oslo_messaging_notifications') transport = _FakeTransport(self.conf) if hasattr(self, 'ctor_pub_id'): notifier = oslo_messaging.Notifier(transport, publisher_id=self.ctor_pub_id) else: notifier = oslo_messaging.Notifier(transport) prepare_kwds = {} if hasattr(self, 'retry'): prepare_kwds['retry'] = self.retry if hasattr(self, 'prep_pub_id'): prepare_kwds['publisher_id'] = self.prep_pub_id if prepare_kwds: notifier = notifier.prepare(**prepare_kwds) transport._send_notification = mock.Mock() message_id = uuid.uuid4() uuid.uuid4 = mock.Mock(return_value=message_id) mock_utcnow.return_value = datetime.datetime.utcnow() message = { 'message_id': str(message_id), 'publisher_id': self.expected_pub_id, 'event_type': 'test.notify', 'priority': self.priority.upper(), 'payload': self.payload, 'timestamp': str(timeutils.utcnow()), } sends = [] if self.v1: sends.append(dict(version=1.0)) if self.v2: sends.append(dict(version=2.0)) calls = [] for send_kwargs in sends: for topic in self.topics: if hasattr(self, 'retry'): send_kwargs['retry'] = self.retry else: send_kwargs['retry'] = None target = oslo_messaging.Target(topic='%s.%s' % (topic, self.priority)) calls.append( mock.call(target, self.ctxt, message, **send_kwargs)) method = getattr(notifier, self.priority) method(self.ctxt, 'test.notify', self.payload) uuid.uuid4.assert_called_once_with() transport._send_notification.assert_has_calls(calls, any_order=True) self.assertTrue(notifier.is_enabled())
def mocked_endpoint_call(i): return mock.call({'ctxt': '%d' % i}, 'testpublisher', 'an_event.start', 'test message%d' % i, {'timestamp': mock.ANY, 'message_id': mock.ANY})
def test_notifier(self, mock_utcnow): drivers = [] if self.v1: drivers.append('messaging') if self.v2: drivers.append('messagingv2') self.config(driver=drivers, topics=self.topics, group='oslo_messaging_notifications') transport = _FakeTransport(self.conf) if hasattr(self, 'ctor_pub_id'): notifier = oslo_messaging.Notifier(transport, publisher_id=self.ctor_pub_id) else: notifier = oslo_messaging.Notifier(transport) prepare_kwds = {} if hasattr(self, 'retry'): prepare_kwds['retry'] = self.retry if hasattr(self, 'prep_pub_id'): prepare_kwds['publisher_id'] = self.prep_pub_id if prepare_kwds: notifier = notifier.prepare(**prepare_kwds) transport._send_notification = mock.Mock() message_id = uuid.uuid4() uuid.uuid4 = mock.Mock(return_value=message_id) mock_utcnow.return_value = datetime.datetime.utcnow() message = { 'message_id': str(message_id), 'publisher_id': self.expected_pub_id, 'event_type': 'test.notify', 'priority': self.priority.upper(), 'payload': self.payload, 'timestamp': str(timeutils.utcnow()), } sends = [] if self.v1: sends.append(dict(version=1.0)) if self.v2: sends.append(dict(version=2.0)) calls = [] for send_kwargs in sends: for topic in self.topics: if hasattr(self, 'retry'): send_kwargs['retry'] = self.retry else: send_kwargs['retry'] = None target = oslo_messaging.Target(topic='%s.%s' % (topic, self.priority)) calls.append(mock.call(target, self.ctxt, message, **send_kwargs)) method = getattr(notifier, self.priority) method(self.ctxt, 'test.notify', self.payload) uuid.uuid4.assert_called_once_with() transport._send_notification.assert_has_calls(calls, any_order=True)
def test_run(self, *args): """Test lvm format populator.""" get_device_by_uuid = args[0] devicetree = DeviceTree() data = dict() device = Mock() device.parents = [] device.size = Size("10g") devicetree._add_device(device) # pylint: disable=attribute-defined-outside-init self._pvs = blockdev.lvm.pvs self._vgs = blockdev.lvm.vgs self._lvs = blockdev.lvm.lvs blockdev.lvm.pvs = Mock(return_value=[]) blockdev.lvm.vgs = Mock(return_value=[]) blockdev.lvm.lvs = Mock(return_value=[]) self.addCleanup(self._clean_up) # base case: pv format with no vg with patch("blivet.udev.device_get_format", return_value=self.udev_type): helper = self.helper_class(devicetree, data, device) helper.run() self.assertEqual( device.format.type, self.blivet_type, msg="Wrong format type after FormatPopulator.run on %s" % self.udev_type) # pv belongs to a valid vg which is already in the tree (no lvs) pv_info = Mock() pv_info.vg_name = "testvgname" pv_info.vg_uuid = sentinel.vg_uuid pv_info.pe_start = 0 pv_info.pv_free = 0 device.path = sentinel.pv_path vg_device = Mock() vg_device.parents = [] vg_device.lvs = [] get_device_by_uuid.return_value = vg_device with patch("blivet.static_data.lvm_info.PVsInfo.cache", new_callable=PropertyMock) as mock_pvs_cache: mock_pvs_cache.return_value = {sentinel.pv_path: pv_info} with patch("blivet.udev.device_get_format", return_value=self.udev_type): helper = self.helper_class(devicetree, data, device) self.assertFalse(device in vg_device.parents) helper.run() self.assertEqual( device.format.type, self.blivet_type, msg="Wrong format type after FormatPopulator.run on %s" % self.udev_type) self.assertEqual(get_device_by_uuid.call_count, 3) get_device_by_uuid.assert_called_with(pv_info.vg_uuid, incomplete=True) self.assertTrue(device in vg_device.parents) get_device_by_uuid.reset_mock() get_device_by_uuid.return_value = None # pv belongs to a valid vg which is not in the tree (no lvs, either) pv_info.vg_size = "10g" pv_info.vg_free = 0 pv_info.vg_extent_size = "4m" pv_info.vg_extent_count = 2500 pv_info.vg_free_count = 0 pv_info.vg_pv_count = 1 with patch("blivet.static_data.lvm_info.PVsInfo.cache", new_callable=PropertyMock) as mock_pvs_cache: mock_pvs_cache.return_value = {sentinel.pv_path: pv_info} with patch("blivet.udev.device_get_format", return_value=self.udev_type): helper = self.helper_class(devicetree, data, device) helper.run() self.assertEqual( device.format.type, self.blivet_type, msg="Wrong format type after FormatPopulator.run on %s" % self.udev_type) self.assertEqual(get_device_by_uuid.call_count, 2) get_device_by_uuid.assert_called_with(pv_info.vg_uuid, incomplete=True) vg_device = devicetree.get_device_by_name(pv_info.vg_name) self.assertTrue(vg_device is not None) devicetree._remove_device(vg_device) get_device_by_uuid.reset_mock() # pv belongs to a valid vg not in the tree with two lvs lv1 = Mock() lv1.vg_name = pv_info.vg_name lv1.lv_name = "testlv1" lv1.uuid = sentinel.lv1_uuid lv1.attr = "-wi-ao----" lv1.size = "2g" lv1.segtype = "linear" lv1_name = "%s-%s" % (pv_info.vg_name, lv1.lv_name) lv2 = Mock() lv2.vg_name = pv_info.vg_name lv2.lv_name = "testlv2" lv2.uuid = sentinel.lv2_uuid lv2.attr = "-wi-ao----" lv2.size = "7g" lv2.segtype = "linear" lv2_name = "%s-%s" % (pv_info.vg_name, lv2.lv_name) lv_info = {lv1_name: lv1, lv2_name: lv2} device.format.container_uuid = pv_info.vg_uuid def gdbu(uuid, **kwargs): # pylint: disable=unused-argument # This version doesn't check format UUIDs return six.next((d for d in devicetree.devices if d.uuid == uuid), None) get_device_by_uuid.side_effect = gdbu with patch("blivet.static_data.lvm_info.PVsInfo.cache", new_callable=PropertyMock) as mock_pvs_cache: mock_pvs_cache.return_value = {sentinel.pv_path: pv_info} with patch("blivet.static_data.lvm_info.LVsInfo.cache", new_callable=PropertyMock) as mock_lvs_cache: mock_lvs_cache.return_value = lv_info with patch("blivet.udev.device_get_format", return_value=self.udev_type): self.assertEqual( devicetree.get_device_by_name(pv_info.vg_name, incomplete=True), None) helper = self.helper_class(devicetree, data, device) helper.run() self.assertEqual( device.format.type, self.blivet_type, msg="Wrong format type after FormatPopulator.run on %s" % self.udev_type) self.assertEqual(get_device_by_uuid.call_count, 4, get_device_by_uuid.mock_calls ) # two for vg and one for each lv get_device_by_uuid.assert_has_calls([ call(pv_info.vg_uuid, incomplete=True), call(lv1.uuid), call(lv2.uuid) ], any_order=True) vg_device = devicetree.get_device_by_name(pv_info.vg_name) self.assertTrue(vg_device is not None) lv1_device = devicetree.get_device_by_name(lv1_name) self.assertEqual(lv1_device.uuid, lv1.uuid) lv2_device = devicetree.get_device_by_name(lv2_name) self.assertEqual(lv2_device.uuid, lv2.uuid)
def mocked_endpoint_call(i): return mock.call({'ctxt': '%d' % i}, 'testpublisher', 'an_event.start', 'test message%d' % i, { 'timestamp': mock.ANY, 'message_id': mock.ANY })