def test_worker_context_gets_stack(container_factory):
context_cls = worker_context_factory()
class FooService(object):
name = 'baz'
container = container_factory(FooService, {})
service = FooService()
context = context_cls(container, service, DummyProvider("bar"))
assert context.call_id == 'baz.bar.0'
assert context.call_id_stack == ['baz.bar.0']
assert context.parent_call_stack == []
# Build stack
context = context_cls(container,
service,
DummyProvider("foo"),
data={'call_id_stack': context.call_id_stack})
assert context.call_id == 'baz.foo.1'
assert context.call_id_stack == ['baz.bar.0', 'baz.foo.1']
# Long stack
many_ids = [str(i) for i in xrange(10)]
context = context_cls(container,
service,
DummyProvider("long"),
data={'call_id_stack': many_ids})
expected = many_ids + ['baz.long.2']
assert context.call_id_stack == expected
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_consume_provider(empty_config):
container = Mock(spec=ServiceContainer)
container.worker_ctx_cls = WorkerContext
container.service_name = "service"
container.config = empty_config
worker_ctx = WorkerContext(container, None, DummyProvider())
spawn_worker = container.spawn_worker
spawn_worker.return_value = worker_ctx
queue_consumer = Mock()
consume_provider = ConsumeProvider(queue=foobar_queue,
requeue_on_error=False)
consume_provider.queue_consumer = queue_consumer
consume_provider.bind("name", container)
message = Mock(headers={})
# test lifecycle
consume_provider.prepare()
queue_consumer.register_provider.assert_called_once_with(consume_provider)
consume_provider.stop()
queue_consumer.unregister_provider.assert_called_once_with(
consume_provider)
# test handling successful call
queue_consumer.reset_mock()
consume_provider.handle_message("body", message)
handle_result = spawn_worker.call_args[1]['handle_result']
handle_result(worker_ctx, 'result')
queue_consumer.ack_message.assert_called_once_with(message)
# test handling failed call without requeue
queue_consumer.reset_mock()
consume_provider.requeue_on_error = False
consume_provider.handle_message("body", message)
handle_result = spawn_worker.call_args[1]['handle_result']
handle_result(worker_ctx, None, (Exception, Exception('Error'), "tb"))
queue_consumer.ack_message.assert_called_once_with(message)
# test handling failed call with requeue
queue_consumer.reset_mock()
consume_provider.requeue_on_error = True
consume_provider.handle_message("body", message)
handle_result = spawn_worker.call_args[1]['handle_result']
handle_result(worker_ctx, None, (Exception, Exception('Error'), "tb"))
assert not queue_consumer.ack_message.called
queue_consumer.requeue_message.assert_called_once_with(message)
# test requeueing on ContainerBeingKilled (even without requeue_on_error)
queue_consumer.reset_mock()
consume_provider.requeue_on_error = False
spawn_worker.side_effect = ContainerBeingKilled()
consume_provider.handle_message("body", message)
assert not queue_consumer.ack_message.called
queue_consumer.requeue_message.assert_called_once_with(message)
def test_unserialisable_headers(rabbit_manager, rabbit_config, mock_container):
vhost = rabbit_config['vhost']
container = mock_container
container.service_name = "service"
container.config = rabbit_config
container.spawn_managed_thread = eventlet.spawn
ctx_data = {'language': 'en', 'customheader': None}
service = Mock()
worker_ctx = WorkerContext(
container, service, DummyProvider('method'), data=ctx_data
)
publisher = Publisher(
exchange=foobar_ex, queue=foobar_queue).bind(container, "publish")
publisher.setup()
publisher.start()
service.publish = publisher.get_dependency(worker_ctx)
service.publish("msg")
messages = rabbit_manager.get_messages(vhost, foobar_queue.name)
assert messages[0]['properties']['headers'] == {
'nameko.language': 'en',
'nameko.call_id_stack': ['service.method.0'],
# no `customheader`
}
def test_publish_to_exchange(maybe_declare, patch_publisher, mock_container):
container = mock_container
container.service_name = "srcservice"
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("publish"))
publisher = Publisher(exchange=foobar_ex).bind(container, "publish")
producer = Mock()
connection = Mock()
get_connection, get_producer = patch_publisher(publisher)
get_connection.return_value = as_context_manager(connection)
get_producer.return_value = as_context_manager(producer)
# test declarations
publisher.setup()
maybe_declare.assert_called_once_with(foobar_ex, connection)
# test publish
msg = "msg"
service.publish = publisher.get_dependency(worker_ctx)
service.publish(msg, publish_kwarg="value")
headers = {
'nameko.call_id_stack': ['srcservice.publish.0']
}
producer.publish.assert_called_once_with(
msg, headers=headers, exchange=foobar_ex, retry=True,
serializer=container.serializer,
retry_policy=DEFAULT_RETRY_POLICY, publish_kwarg="value")
def test_config_adapters(default_info, custom_info, mock_container):
mock_container.service_name = 'dummy'
mock_container.config = {
constants.CONFIG_KEY: {
constants.ADAPTERS_CONFIG_KEY: {
'nameko.web.handlers.HttpRequestHandler':
'test_dependency.CustomAdapter',
}
}
}
tracer = Tracer().bind(mock_container, 'logger')
tracer.setup()
default_worker_ctx = WorkerContext(mock_container, None, DummyProvider())
http_worker_ctx = WorkerContext(mock_container, None,
HttpRequestHandler('GET', 'http://yo'))
calls = [
tracer.worker_setup, tracer.worker_result, tracer.worker_setup,
tracer.worker_result
]
for call_ in calls:
call_(default_worker_ctx)
call_(http_worker_ctx)
assert default_info.call_count == 4
assert custom_info.call_count == 4
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_publish_to_exchange(empty_config, maybe_declare, patch_publisher):
container = Mock(spec=ServiceContainer)
container.service_name = "srcservice"
container.config = empty_config
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("publish"))
publisher = PublishProvider(exchange=foobar_ex)
publisher.bind("publish", container)
producer = Mock()
connection = Mock()
get_connection, get_producer = patch_publisher(publisher)
get_connection.return_value = as_context_manager(connection)
get_producer.return_value = as_context_manager(producer)
# test declarations
publisher.prepare()
maybe_declare.assert_called_once_with(foobar_ex, connection)
# test publish
msg = "msg"
publisher.inject(worker_ctx)
service.publish(msg, publish_kwarg="value")
headers = {'nameko.call_id_stack': ['srcservice.publish.0']}
producer.publish.assert_called_once_with(msg,
headers=headers,
exchange=foobar_ex,
retry=True,
retry_policy=DEFAULT_RETRY_POLICY,
publish_kwarg="value")
def test_publish_custom_headers(
mock_container, maybe_declare, mock_producer, mock_connection,
rabbit_config
):
container = mock_container
container.config = rabbit_config
container.service_name = "srcservice"
ctx_data = {'language': 'en', 'customheader': 'customvalue'}
service = Mock()
worker_ctx = WorkerContext(
container, service, DummyProvider('method'), data=ctx_data
)
publisher = Publisher(queue=foobar_queue).bind(container, "publish")
# test declarations
publisher.setup()
maybe_declare.assert_called_once_with(foobar_queue, mock_connection)
# test publish
msg = "msg"
headers = {'nameko.language': 'en',
'nameko.customheader': 'customvalue',
'nameko.call_id_stack': ['srcservice.method.0']}
service.publish = publisher.get_dependency(worker_ctx)
service.publish(msg, publish_kwarg="value")
mock_producer.publish.assert_called_once_with(
msg, headers=headers, exchange=foobar_ex, retry=True,
serializer=container.serializer, mandatory=False,
retry_policy=DEFAULT_RETRY_POLICY, publish_kwarg="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"))
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_dispatch_to_rabbit(rabbit_manager, rabbit_config):
vhost = rabbit_config['vhost']
container = Mock(spec=ServiceContainer)
container.service_name = "srcservice"
container.config = rabbit_config
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider())
dispatcher = EventDispatcher()
dispatcher.bind("dispatch", container)
dispatcher.prepare()
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_binding(vhost,
"srcservice.events",
"event-sink",
rt_key=ExampleEvent.type)
dispatcher.inject(worker_ctx)
service.dispatch(ExampleEvent("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_without_origin(self, mock_container):
mock_container.service_name = "foo"
service = Mock()
entrypoint = DummyProvider("bar")
context_data = {}
worker_ctx = WorkerContext(mock_container,
service,
entrypoint,
data=context_data)
assert worker_ctx.origin_call_id is None
def test_with_parent(self, mock_container):
mock_container.service_name = "foo"
service = Mock()
entrypoint = DummyProvider("bar")
context_data = {'call_id_stack': ['parent.method.1']}
worker_ctx = WorkerContext(mock_container,
service,
entrypoint,
data=context_data)
assert worker_ctx.immediate_parent_call_id == "parent.method.1"
def test_short_call_stack(container_factory):
class FooService(object):
name = 'baz'
container = container_factory(FooService, {PARENT_CALLS_CONFIG_KEY: 1})
service = FooService()
# Trim stack
many_ids = [str(i) for i in range(100)]
context = WorkerContext(container,
service,
DummyProvider("long"),
data={'call_id_stack': many_ids})
assert context.call_id_stack == ['99', 'baz.long.0']
def test_publish_to_queue(patch_maybe_declare, mock_producer, mock_connection,
mock_container):
container = mock_container
container.config = {'AMQP_URI': 'memory://'}
container.shared_extensions = {}
container.service_name = "srcservice"
ctx_data = {'language': 'en'}
service = Mock()
worker_ctx = WorkerContext(container,
service,
DummyProvider("publish"),
data=ctx_data)
publisher = Publisher(queue=foobar_queue).bind(container, "publish")
# test declarations
publisher.setup()
assert patch_maybe_declare.call_args_list == [
call(foobar_queue, mock_connection)
]
# test publish
msg = "msg"
headers = {
'nameko.language': 'en',
'nameko.call_id_stack': ['srcservice.publish.0'],
}
service.publish = publisher.get_dependency(worker_ctx)
service.publish(msg, publish_kwarg="value")
expected_args = ('msg', )
expected_kwargs = {
'publish_kwarg': "value",
'exchange': foobar_ex,
'headers': headers,
'declare': publisher.declare,
'retry': publisher.publisher_cls.retry,
'retry_policy': publisher.publisher_cls.retry_policy,
'compression': publisher.publisher_cls.compression,
'mandatory': publisher.publisher_cls.mandatory,
'expiration': publisher.publisher_cls.expiration,
'delivery_mode': publisher.publisher_cls.delivery_mode,
'priority': publisher.publisher_cls.priority,
'serializer': publisher.serializer
}
assert mock_producer.publish.call_args_list == [
call(*expected_args, **expected_kwargs)
]
def test_publish_custom_headers(mock_container, mock_producer, mock_connection,
rabbit_config):
container = mock_container
container.config = rabbit_config
container.service_name = "srcservice"
ctx_data = {'language': 'en', 'customheader': 'customvalue'}
service = Mock()
worker_ctx = WorkerContext(container,
service,
DummyProvider('method'),
data=ctx_data)
publisher = Publisher(queue=foobar_queue).bind(container, "publish")
publisher.setup()
# test publish
msg = "msg"
headers = {
'nameko.language': 'en',
'nameko.customheader': 'customvalue',
'nameko.call_id_stack': ['srcservice.method.0']
}
service.publish = publisher.get_dependency(worker_ctx)
service.publish(msg, publish_kwarg="value")
expected_args = ('msg', )
expected_kwargs = {
'publish_kwarg': "value",
'exchange': foobar_ex,
'headers': headers,
'declare': publisher.declare,
'retry': publisher.publisher_cls.retry,
'retry_policy': publisher.publisher_cls.retry_policy,
'compression': publisher.publisher_cls.compression,
'mandatory': publisher.publisher_cls.mandatory,
'expiration': publisher.publisher_cls.expiration,
'delivery_mode': publisher.publisher_cls.delivery_mode,
'priority': publisher.publisher_cls.priority,
'serializer': publisher.serializer
}
assert mock_producer.publish.call_args_list == [
call(*expected_args, **expected_kwargs)
]
def test_publish_to_rabbit(rabbit_manager, rabbit_config):
vhost = rabbit_config['vhost']
container = Mock(spec=ServiceContainer)
container.service_name = "service"
container.config = rabbit_config
container.spawn_managed_thread = eventlet.spawn
ctx_data = {'language': 'en', 'customheader': 'customvalue'}
service = Mock()
worker_ctx = CustomWorkerContext(container,
service,
DummyProvider('method'),
data=ctx_data)
publisher = PublishProvider(exchange=foobar_ex, queue=foobar_queue)
publisher.bind("publish", container)
# test queue, exchange and binding created in rabbit
publisher.prepare()
publisher.start()
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
bindings = rabbit_manager.get_queue_bindings(vhost, foobar_queue.name)
assert "foobar_ex" in [exchange['name'] for exchange in exchanges]
assert "foobar_queue" in [queue['name'] for queue in queues]
assert "foobar_ex" in [binding['source'] for binding in bindings]
# test message published to queue
publisher.inject(worker_ctx)
service.publish("msg")
messages = rabbit_manager.get_messages(vhost, foobar_queue.name)
assert ['msg'] == [msg['payload'] for msg in messages]
# test message headers
assert messages[0]['properties']['headers'] == {
'nameko.language': 'en',
'nameko.customheader': 'customvalue',
'nameko.call_id_stack': ['service.method.0'],
}
def test_publish_custom_headers(empty_config, maybe_declare, patch_publisher):
container = Mock(spec=ServiceContainer)
container.service_name = "srcservice"
container.config = empty_config
ctx_data = {'language': 'en', 'customheader': 'customvalue'}
service = Mock()
worker_ctx = CustomWorkerContext(container,
service,
DummyProvider('method'),
data=ctx_data)
publisher = PublishProvider(queue=foobar_queue)
publisher.bind("publish", container)
producer = Mock()
connection = Mock()
get_connection, get_producer = patch_publisher(publisher)
get_connection.return_value = as_context_manager(connection)
get_producer.return_value = as_context_manager(producer)
# test declarations
publisher.prepare()
maybe_declare.assert_called_once_with(foobar_queue, connection)
# test publish
msg = "msg"
headers = {
'nameko.language': 'en',
'nameko.customheader': 'customvalue',
'nameko.call_id_stack': ['srcservice.method.0']
}
publisher.inject(worker_ctx)
service.publish(msg, publish_kwarg="value")
producer.publish.assert_called_once_with(msg,
headers=headers,
exchange=foobar_ex,
retry=True,
retry_policy=DEFAULT_RETRY_POLICY,
publish_kwarg="value")
def test_publish_to_rabbit(rabbit_manager, rabbit_config, mock_container):
vhost = rabbit_config['vhost']
container = mock_container
container.service_name = "service"
container.config = rabbit_config
ctx_data = {'language': 'en', 'customheader': 'customvalue'}
service = Mock()
worker_ctx = WorkerContext(
container, service, DummyProvider('method'), data=ctx_data
)
publisher = Publisher(
exchange=foobar_ex, queue=foobar_queue
).bind(container, "publish")
publisher.setup()
publisher.start()
# test queue, exchange and binding created in rabbit
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
bindings = rabbit_manager.get_queue_bindings(vhost, foobar_queue.name)
assert "foobar_ex" in [exchange['name'] for exchange in exchanges]
assert "foobar_queue" in [queue['name'] for queue in queues]
assert "foobar_ex" in [binding['source'] for binding in bindings]
service.publish = publisher.get_dependency(worker_ctx)
service.publish("msg")
# test message published to queue
messages = rabbit_manager.get_messages(vhost, foobar_queue.name)
assert ['"msg"'] == [msg['payload'] for msg in messages]
# test message headers
assert messages[0]['properties']['headers'] == {
'nameko.language': 'en',
'nameko.customheader': 'customvalue',
'nameko.call_id_stack': ['service.method.0'],
}
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_publish_to_queue(empty_config, maybe_declare, patch_publisher):
container = Mock(spec=ServiceContainer)
container.shared_extensions = {}
container.service_name = "srcservice"
container.config = empty_config
ctx_data = {'language': 'en'}
service = Mock()
worker_ctx = WorkerContext(container,
service,
DummyProvider("publish"),
data=ctx_data)
publisher = Publisher(queue=foobar_queue).bind(container, "publish")
producer = Mock()
connection = Mock()
get_connection, get_producer = patch_publisher(publisher)
get_connection.return_value = as_context_manager(connection)
get_producer.return_value = as_context_manager(producer)
# test declarations
publisher.setup()
maybe_declare.assert_called_once_with(foobar_queue, connection)
# test publish
msg = "msg"
headers = {
'nameko.language': 'en',
'nameko.call_id_stack': ['srcservice.publish.0'],
}
service.publish = publisher.get_dependency(worker_ctx)
service.publish(msg, publish_kwarg="value")
producer.publish.assert_called_once_with(msg,
headers=headers,
exchange=foobar_ex,
retry=True,
retry_policy=DEFAULT_RETRY_POLICY,
publish_kwarg="value")
def test_default_adapters(default_info, http_info, mock_container):
mock_container.service_name = 'dummy'
mock_container.config = {}
tracer = Tracer().bind(mock_container, 'logger')
tracer.setup()
default_worker_ctx = WorkerContext(mock_container, None, DummyProvider())
http_worker_ctx = WorkerContext(mock_container, None,
HttpRequestHandler('GET', 'http://yo'))
calls = [
tracer.worker_setup, tracer.worker_result, tracer.worker_setup,
tracer.worker_result
]
for call_ in calls:
call_(default_worker_ctx)
call_(http_worker_ctx)
assert default_info.call_count == 4
assert http_info.call_count == 4
def test_event_dispatcher(empty_config):
container = Mock(spec=ServiceContainer)
container.service_name = "srcservice"
container.config = empty_config
service = Mock()
worker_ctx = WorkerContext(container, service, DummyProvider("dispatch"))
event_dispatcher = EventDispatcher()
event_dispatcher.bind("dispatch", container)
path = 'nameko.messaging.PublishProvider.prepare'
with patch(path, autospec=True) as prepare:
# test start method
event_dispatcher.prepare()
assert event_dispatcher.exchange.name == "srcservice.events"
assert prepare.called
evt = Mock(type="eventtype", data="msg")
event_dispatcher.inject(worker_ctx)
producer = Mock()
with patch.object(event_dispatcher, 'get_producer',
autospec=True) as get_producer:
get_producer.return_value = as_context_manager(producer)
# test dispatch
service.dispatch(evt, retry_policy={'max_retries': 5})
headers = event_dispatcher.get_message_headers(worker_ctx)
producer.publish.assert_called_once_with(
evt.data,
exchange=event_dispatcher.exchange,
headers=headers,
routing_key=evt.type,
retry=True,
retry_policy={'max_retries': 5})
def test_db(container_factory):
container = container_factory(FooService, config)
provider = next(iter(container.dependencies.injections))
# fake instance creation and provider injection
service = FooService()
worker_ctx = WorkerContext(container, service, DummyProvider())
provider.inject(worker_ctx)
assert isinstance(service.session, Session)
session = service.session
session.add(FooModel())
assert session.new
provider.worker_teardown(worker_ctx)
provider.release(worker_ctx)
# if we had not closed the session we would still have new objects
assert not session.new
# teardown removes the injection
assert not isinstance(service.session, Session)
def test_concurrency():
container = Mock()
container.config = config
container.service_name = "fooservice"
entrypoint = DummyProvider()
service_instance = Mock()
def inject(worker_ctx):
orm_session = OrmSession(DeclBase)
orm_session.container = container
return orm_session.acquire_injection(worker_ctx)
# get injections concurrently
pile = GreenPile()
for _ in xrange(CONCURRENT_REQUESTS):
worker_ctx = WorkerContext(container, service_instance, entrypoint)
pile.spawn(inject, worker_ctx)
results = set(pile)
# injections should all be unique
assert len(results) == CONCURRENT_REQUESTS
def test_consume_from_rabbit(rabbit_manager, rabbit_config, mock_container):
vhost = rabbit_config['vhost']
container = mock_container
container.shared_extensions = {}
container.worker_ctx_cls = WorkerContext
container.service_name = "service"
container.config = rabbit_config
container.max_workers = 10
content_type = 'application/data'
container.accept = [content_type]
def spawn_managed_thread(method, identifier=None):
return eventlet.spawn(method)
container.spawn_managed_thread = spawn_managed_thread
worker_ctx = WorkerContext(container, None, DummyProvider())
consumer = Consumer(
queue=foobar_queue, requeue_on_error=False).bind(container, "publish")
# prepare and start extensions
consumer.setup()
consumer.queue_consumer.setup()
consumer.start()
consumer.queue_consumer.start()
# test queue, exchange and binding created in rabbit
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
bindings = rabbit_manager.get_queue_bindings(vhost, foobar_queue.name)
assert "foobar_ex" in [exchange['name'] for exchange in exchanges]
assert "foobar_queue" in [queue['name'] for queue in queues]
assert "foobar_ex" in [binding['source'] for binding in bindings]
# test message consumed from queue
container.spawn_worker.return_value = worker_ctx
headers = {'nameko.language': 'en', 'nameko.customheader': 'customvalue'}
rabbit_manager.publish(
vhost, foobar_ex.name, '', 'msg',
properties=dict(headers=headers, content_type=content_type))
ctx_data = {
'language': 'en',
'customheader': 'customvalue',
}
with wait_for_call(CONSUME_TIMEOUT, container.spawn_worker) as method:
method.assert_called_once_with(consumer, ('msg',), {},
context_data=ctx_data,
handle_result=ANY_PARTIAL)
handle_result = method.call_args[1]['handle_result']
# ack message
handle_result(worker_ctx, 'result')
# stop will hang if the consumer hasn't acked or requeued messages
with eventlet.timeout.Timeout(CONSUME_TIMEOUT):
consumer.stop()
consumer.queue_consumer.kill()
def test_consume_from_rabbit(rabbit_manager, rabbit_config):
vhost = rabbit_config['vhost']
container = Mock(spec=ServiceContainer)
container.worker_ctx_cls = CustomWorkerContext
container.service_name = "service"
container.config = rabbit_config
container.max_workers = 10
def spawn_thread(method, protected):
return eventlet.spawn(method)
container.spawn_managed_thread = spawn_thread
worker_ctx = CustomWorkerContext(container, None, DummyProvider())
factory = DependencyFactory(ConsumeProvider,
queue=foobar_queue,
requeue_on_error=False)
consumer = factory.create_and_bind_instance("injection_name", container)
# prepare and start dependencies
consumer.prepare()
consumer.queue_consumer.prepare()
consumer.start()
consumer.queue_consumer.start()
# test queue, exchange and binding created in rabbit
exchanges = rabbit_manager.get_exchanges(vhost)
queues = rabbit_manager.get_queues(vhost)
bindings = rabbit_manager.get_queue_bindings(vhost, foobar_queue.name)
assert "foobar_ex" in [exchange['name'] for exchange in exchanges]
assert "foobar_queue" in [queue['name'] for queue in queues]
assert "foobar_ex" in [binding['source'] for binding in bindings]
# test message consumed from queue
container.spawn_worker.return_value = worker_ctx
headers = {'nameko.language': 'en', 'nameko.customheader': 'customvalue'}
rabbit_manager.publish(vhost,
foobar_ex.name,
'',
'msg',
properties=dict(headers=headers))
ctx_data = {
'language': 'en',
'customheader': 'customvalue',
}
with wait_for_call(CONSUME_TIMEOUT, container.spawn_worker) as method:
method.assert_called_once_with(consumer, ('msg', ), {},
context_data=ctx_data,
handle_result=ANY_PARTIAL)
handle_result = method.call_args[1]['handle_result']
# ack message
handle_result(worker_ctx, 'result')
# stop will hang if the consumer hasn't acked or requeued messages
with eventlet.timeout.Timeout(CONSUME_TIMEOUT):
consumer.stop()
consumer.queue_consumer.kill()
