def test_process_work_queue_calls_close_after_commit(session):
message = messages.Message(topic="annotation", payload="bar")
queue = [message]
streamer.process_work_queue({}, queue, session_factory=lambda _: session)
assert session.method_calls[-2:] == [mock.call.commit(), mock.call.close()]
def test_it_handles_a_full_queue(self, _handler, work_queue):
work_queue.put(messages.Message(topic="queue_is_full", payload={}))
_handler({"foo": "bar"})
result = work_queue.get_nowait()
assert result.topic == "queue_is_full"
def test_process_work_queue_commits_after_each_message(session):
message1 = websocket.Message(socket=mock.sentinel.SOCKET, payload="bar")
message2 = messages.Message(topic="user", payload="bar")
queue = [message1, message2]
streamer.process_work_queue({}, queue, session_factory=lambda _: session)
assert session.commit.call_count == 2
def test_process_work_queue_calls_close_after_rollback(session):
message = messages.Message(topic='foo', payload='bar')
queue = [message]
messages.handle_message.side_effect = RuntimeError('explosion')
streamer.process_work_queue({}, queue, session_factory=lambda: session)
assert session.method_calls[-2:] == [call.rollback(), call.close()]
def test_process_work_queue_sends_realtime_messages_to_messages_handle_message(
session):
message = messages.Message(topic='foo', payload='bar')
queue = [message]
streamer.process_work_queue({}, queue, session_factory=lambda: session)
messages.handle_message.assert_called_once_with(message,
topic_handlers=mock.ANY)
def test_does_not_send_messages_down_websocket_if_handler_response_is_none(self, websocket):
handler = mock.Mock(return_value=None)
message = messages.Message(topic='foo', payload={'foo': 'bar'})
socket = FakeSocket('a')
websocket.instances = [socket]
messages.handle_message(message, topic_handlers={'foo': handler})
assert socket.send.call_count == 0
def test_sends_serialized_messages_down_websocket(self, websocket):
handler = mock.Mock(return_value={'just': 'some message'})
message = messages.Message(topic='foo', payload={'foo': 'bar'})
socket = FakeSocket('a')
websocket.instances = [socket]
messages.handle_message(message, topic_handlers={'foo': handler})
socket.send.assert_called_once_with('{"just": "some message"}')
def test_process_work_queue_rolls_back_on_handler_exception(session):
message = messages.Message(topic="foo", payload="bar")
queue = [message]
messages.handle_message.side_effect = RuntimeError("explosion")
streamer.process_work_queue({}, queue, session_factory=lambda _: session)
session.commit.assert_not_called()
session.rollback.assert_called_once_with()
def test_does_not_send_messages_down_websocket_if_socket_terminated(self, websocket):
handler = mock.Mock(return_value={'just': 'some message'})
message = messages.Message(topic='foo', payload={'foo': 'bar'})
socket = FakeSocket('a')
socket.terminated = True
websocket.instances = [socket]
messages.handle_message(message, topic_handlers={'foo': handler})
assert socket.send.call_count == 0
def test_it_raises_RuntimeError_for_bad_topics(self, registry):
message = messages.Message(topic="unknown", payload={})
topic_handlers = {"known": sentinel.handler}
with pytest.raises(RuntimeError):
messages.handle_message(
message,
registry,
session=sentinel.db_session,
topic_handlers=topic_handlers,
)
def test_process_work_queue_calls_close_after_rollback(session):
message = messages.Message(topic="foo", payload="bar")
queue = [message]
messages.handle_message.side_effect = RuntimeError("explosion")
streamer.process_work_queue({}, queue, session_factory=lambda _: session)
assert session.method_calls[-2:] == [
mock.call.rollback(), mock.call.close()
]
def test_calls_handler_with_list_of_sockets(self, websocket):
handler = mock.Mock(return_value=None)
session = mock.sentinel.db_session
message = messages.Message(topic='foo', payload={'foo': 'bar'})
websocket.instances = [FakeSocket('a'), FakeSocket('b')]
messages.handle_message(message,
session,
topic_handlers={'foo': handler})
handler.assert_called_once_with(message.payload,
list(websocket.instances), session)
def test_calls_handler_once_per_socket_with_deserialized_message(self, websocket):
handler = mock.Mock(return_value=None)
message = messages.Message(topic='foo', payload={'foo': 'bar'})
websocket.instances = [FakeSocket('a'), FakeSocket('b')]
messages.handle_message(message, topic_handlers={'foo': handler})
print(repr(mock.call({'foo': 'bar'}, websocket.instances[0])))
print(repr(handler.mock_calls[0]))
assert handler.mock_calls == [
mock.call({'foo': 'bar'}, websocket.instances[0]),
mock.call({'foo': 'bar'}, websocket.instances[1]),
]
def test_process_work_queue_sends_realtime_messages_to_messages_handle_message(
session):
message = messages.Message(topic="foo", payload="bar")
queue = [message]
settings = {"foo": "bar"}
streamer.process_work_queue(settings,
queue,
session_factory=lambda _: session)
messages.handle_message.assert_called_once_with(message,
settings,
session,
topic_handlers=mock.ANY)
def test_calls_handler_with_list_of_sockets(self, websocket):
handler = mock.Mock(return_value=None)
session = mock.sentinel.db_session
settings = mock.sentinel.settings
message = messages.Message(topic="foo", payload={"foo": "bar"})
websocket.instances = [FakeSocket("a"), FakeSocket("b")]
messages.handle_message(
message, settings, session, topic_handlers={"foo": handler}
)
handler.assert_called_once_with(
message.payload, list(websocket.instances), settings, session
)
def test_process_work_queue_uses_appropriate_topic_handlers_for_realtime_messages(
session):
message = messages.Message(topic='user', payload='bar')
queue = [message]
streamer.process_work_queue({}, queue, session_factory=lambda: session)
topic_handlers = {
'annotation': messages.handle_annotation_event,
'user': messages.handle_user_event,
}
messages.handle_message.assert_called_once_with(
mock.ANY, topic_handlers=topic_handlers)
def test_calls_handler_with_list_of_sockets(self, websocket, registry):
handler = Mock(return_value=None)
session = sentinel.db_session
message = messages.Message(topic="foo", payload={"foo": "bar"})
websocket.instances = [sentinel.socket_1, sentinel.socket_2]
messages.handle_message(message,
registry,
session,
topic_handlers={"foo": handler})
handler.assert_called_once_with(
message.payload,
websocket.instances,
Any.object.of_type(Request).with_attrs({"registry": registry}),
session,
)
def test_process_work_queue_uses_appropriate_topic_handlers_for_realtime_messages(
session):
message = messages.Message(topic="user", payload="bar")
queue = [message]
settings = {"foo": "bar"}
streamer.process_work_queue(settings,
queue,
session_factory=lambda _: session)
topic_handlers = {
"annotation": messages.handle_annotation_event,
"user": messages.handle_user_event,
}
messages.handle_message.assert_called_once_with(
mock.ANY, settings, session, topic_handlers=topic_handlers)
def message(self):
return messages.Message(topic="foo", payload="bar")
