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 _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
})
