def test_restricted_parameters(
self, mock_container, producer
):
""" Verify that providing routing parameters at instantiation
time has no effect.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
exchange = Mock()
routing_key = Mock()
dispatcher = EventDispatcher(
exchange=exchange,
routing_key=routing_key,
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
event_exchange = get_event_exchange("service")
event_type = "event-type"
dispatch(event_type, "event-data")
assert producer.publish.call_args[1]['exchange'] == event_exchange
assert producer.publish.call_args[1]['routing_key'] == event_type
def test_restricted_parameters(self, mock_container, producer):
""" Verify that providing routing parameters at instantiation
time has no effect.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
exchange = Mock()
routing_key = Mock()
dispatcher = EventDispatcher(
exchange=exchange,
routing_key=routing_key,
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
event_exchange = get_event_exchange("service", config={})
event_type = "event-type"
dispatch(event_type, "event-data")
assert producer.publish.call_args[1]['exchange'] == event_exchange
assert producer.publish.call_args[1]['routing_key'] == event_type
def test_dispatch_to_rabbit(rabbit_manager, rabbit_config, mock_container):
vhost = rabbit_config['vhost']
container = mock_container
container.shared_extensions = {}
container.service_name = "srcservice"
container.config = rabbit_config
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider())
dispatcher = EventDispatcher().bind(container, 'dispatch')
dispatcher.setup()
dispatcher.start()
# we should have an exchange but no queues
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
assert "srcservice.events" in [exchange['name'] for exchange in exchanges]
assert queues == []
# manually add a queue to capture the events
rabbit_manager.create_queue(vhost, "event-sink", auto_delete=True)
rabbit_manager.create_queue_binding(vhost,
"srcservice.events",
"event-sink",
routing_key="eventtype")
service.dispatch = dispatcher.get_dependency(worker_ctx)
service.dispatch("eventtype", "msg")
# test event receieved on manually added queue
messages = rabbit_manager.get_messages(vhost, "event-sink")
assert ['"msg"'] == [msg['payload'] for msg in messages]
def test_event_dispatcher(mock_container):
container = mock_container
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
event_dispatcher = EventDispatcher(retry_policy={'max_retries': 5}).bind(
container, attr_name="dispatch")
event_dispatcher.setup()
service.dispatch = event_dispatcher.get_dependency(worker_ctx)
from mock import ANY
with patch('nameko.standalone.events.producers') as mock_producers:
with mock_producers[ANY].acquire() as mock_producer:
service.dispatch('eventtype', 'msg')
headers = event_dispatcher.get_message_headers(worker_ctx)
mock_producer.publish.assert_called_once_with(
'msg', exchange=ANY, headers=headers,
serializer=container.serializer,
routing_key='eventtype', retry=True, retry_policy={'max_retries': 5})
_, call_kwargs = mock_producer.publish.call_args
exchange = call_kwargs['exchange']
assert exchange.name == 'srcservice.events'
def test_dispatch_to_rabbit(rabbit_manager, rabbit_config, mock_container):
vhost = rabbit_config['vhost']
container = mock_container
container.shared_extensions = {}
container.service_name = "srcservice"
container.config = rabbit_config
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider())
dispatcher = EventDispatcher().bind(container, 'dispatch')
dispatcher.setup()
dispatcher.start()
# we should have an exchange but no queues
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
assert "srcservice.events" in [exchange['name'] for exchange in exchanges]
assert queues == []
# manually add a queue to capture the events
rabbit_manager.create_queue(vhost, "event-sink", auto_delete=True)
rabbit_manager.create_queue_binding(
vhost, "srcservice.events", "event-sink", routing_key="eventtype")
service.dispatch = dispatcher.get_dependency(worker_ctx)
service.dispatch("eventtype", "msg")
# test event receieved on manually added queue
messages = rabbit_manager.get_messages(vhost, "event-sink")
assert ['"msg"'] == [msg['payload'] for msg in messages]
def test_event_dispatcher(mock_container):
container = mock_container
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
event_dispatcher = EventDispatcher(retry_policy={
'max_retries': 5
}).bind(container, attr_name="dispatch")
event_dispatcher.setup()
service.dispatch = event_dispatcher.get_dependency(worker_ctx)
from mock import ANY
with patch('nameko.standalone.events.producers') as mock_producers:
with mock_producers[ANY].acquire() as mock_producer:
service.dispatch('eventtype', 'msg')
headers = event_dispatcher.get_message_headers(worker_ctx)
mock_producer.publish.assert_called_once_with(
'msg',
exchange=ANY,
headers=headers,
serializer=container.serializer,
routing_key='eventtype',
retry=True,
retry_policy={'max_retries': 5})
_, call_kwargs = mock_producer.publish.call_args
exchange = call_kwargs['exchange']
assert exchange.name == 'srcservice.events'
def test_event_dispatcher(mock_container, mock_producer, rabbit_config):
container = mock_container
container.config = rabbit_config
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
event_dispatcher = EventDispatcher(retry_policy={
'max_retries': 5
}).bind(container, attr_name="dispatch")
event_dispatcher.setup()
service.dispatch = event_dispatcher.get_dependency(worker_ctx)
service.dispatch('eventtype', 'msg')
headers = event_dispatcher.get_message_headers(worker_ctx)
mock_producer.publish.assert_called_once_with(
'msg',
exchange=ANY,
headers=headers,
serializer=container.serializer,
routing_key='eventtype',
retry=True,
mandatory=False,
retry_policy={'max_retries': 5})
_, call_kwargs = mock_producer.publish.call_args
exchange = call_kwargs['exchange']
assert exchange.name == 'srcservice.events'
def test_regular_parameters(self, parameter, mock_container, producer):
""" Verify that most parameters can be specified at instantiation time.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
value = Mock()
dispatcher = EventDispatcher(**{
parameter: value
}).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
dispatch("event-type", "event-data")
assert producer.publish.call_args[1][parameter] == value
def test_event_dispatcher(mock_container, mock_producer, rabbit_config):
container = mock_container
container.config = rabbit_config
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
custom_retry_policy = {'max_retries': 5}
event_dispatcher = EventDispatcher(retry_policy=custom_retry_policy).bind(
container, attr_name="dispatch")
event_dispatcher.setup()
service.dispatch = event_dispatcher.get_dependency(worker_ctx)
service.dispatch('eventtype', 'msg')
headers = event_dispatcher.get_message_headers(worker_ctx)
expected_args = ('msg',)
expected_kwargs = {
'exchange': ANY,
'routing_key': 'eventtype',
'headers': headers,
'declare': event_dispatcher.declare,
'retry': event_dispatcher.publisher_cls.retry,
'retry_policy': custom_retry_policy,
'compression': event_dispatcher.publisher_cls.compression,
'mandatory': event_dispatcher.publisher_cls.mandatory,
'expiration': event_dispatcher.publisher_cls.expiration,
'delivery_mode': event_dispatcher.publisher_cls.delivery_mode,
'priority': event_dispatcher.publisher_cls.priority,
'serializer': event_dispatcher.serializer,
}
assert mock_producer.publish.call_count == 1
args, kwargs = mock_producer.publish.call_args
assert args == expected_args
assert kwargs == expected_kwargs
assert kwargs['exchange'].name == 'srcservice.events'
def test_event_dispatcher(mock_container, mock_producer, rabbit_config):
container = mock_container
container.config = rabbit_config
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
custom_retry_policy = {'max_retries': 5}
event_dispatcher = EventDispatcher(retry_policy=custom_retry_policy).bind(
container, attr_name="dispatch")
event_dispatcher.setup()
service.dispatch = event_dispatcher.get_dependency(worker_ctx)
service.dispatch('eventtype', 'msg')
headers = event_dispatcher.get_message_headers(worker_ctx)
expected_args = ('msg',)
expected_kwargs = {
'exchange': ANY,
'routing_key': 'eventtype',
'headers': headers,
'declare': event_dispatcher.declare,
'retry': event_dispatcher.publisher_cls.retry,
'retry_policy': custom_retry_policy,
'compression': event_dispatcher.publisher_cls.compression,
'mandatory': event_dispatcher.publisher_cls.mandatory,
'expiration': event_dispatcher.publisher_cls.expiration,
'delivery_mode': event_dispatcher.publisher_cls.delivery_mode,
'priority': event_dispatcher.publisher_cls.priority,
'serializer': event_dispatcher.serializer,
}
assert mock_producer.publish.call_count == 1
args, kwargs = mock_producer.publish.call_args
assert args == expected_args
assert kwargs == expected_kwargs
assert kwargs['exchange'].name == 'srcservice.events'
def test_headers(self, mock_container, producer):
""" Headers can be provided at instantiation time, and are merged with
Nameko headers.
"""
mock_container.config = {
'AMQP_URI': 'memory://localhost'
}
mock_container.service_name = "service"
# use a real worker context so nameko headers are generated
service = Mock()
entrypoint = Mock(method_name="method")
worker_ctx = WorkerContext(
mock_container, service, entrypoint, data={'context': 'data'}
)
nameko_headers = {
'nameko.context': 'data',
'nameko.call_id_stack': ['service.method.0'],
}
value = {'foo': Mock()}
dispatcher = EventDispatcher(
**{'headers': value}
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
def merge_dicts(base, *updates):
merged = base.copy()
[merged.update(update) for update in updates]
return merged
dispatch("event-type", "event-data")
assert producer.publish.call_args[1]['headers'] == merge_dicts(
nameko_headers, value
)
def test_regular_parameters(
self, parameter, mock_container, producer
):
""" Verify that most parameters can be specified at instantiation time.
"""
mock_container.config = {'AMQP_URI': 'memory://localhost'}
mock_container.service_name = "service"
worker_ctx = Mock()
worker_ctx.context_data = {}
value = Mock()
dispatcher = EventDispatcher(
**{parameter: value}
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
dispatch("event-type", "event-data")
assert producer.publish.call_args[1][parameter] == value
def test_headers(self, mock_container, producer):
""" Headers can be provided at instantiation time, and are merged with
Nameko headers.
"""
mock_container.config = {
'AMQP_URI': 'memory://localhost'
}
mock_container.service_name = "service"
# use a real worker context so nameko headers are generated
service = Mock()
entrypoint = Mock(method_name="method")
worker_ctx = WorkerContext(
mock_container, service, entrypoint, data={'context': 'data'}
)
nameko_headers = {
'nameko.context': 'data',
'nameko.call_id_stack': ['service.method.0'],
}
value = {'foo': Mock()}
dispatcher = EventDispatcher(
**{'headers': value}
).bind(mock_container, "dispatch")
dispatcher.setup()
dispatch = dispatcher.get_dependency(worker_ctx)
def merge_dicts(base, *updates):
merged = base.copy()
[merged.update(update) for update in updates]
return merged
dispatch("event-type", "event-data")
assert producer.publish.call_args[1]['headers'] == merge_dicts(
nameko_headers, value
)
