def test_dynamic_service(rdisq_message_fixture: "_RdisqMessageFixture"):
summer = Summer()
receiver_service = rdisq_message_fixture.spawn_receiver()
Thread(group=None, target=receiver_service.process).start()
receiver_service.wait_for_process_to_start(3)
receiver_service.register_message(RegisterMessage(SumMessage))
assert RdisqRequest(SumMessage(1, 2)).send_and_wait_reply() == 3
receiver_service.unregister_message(UnregisterMessage(SumMessage))
try:
RdisqRequest(SumMessage(1, 2)).send_and_wait_reply(1)
except RuntimeError:
pass
else:
raise RuntimeError("Should have failed communicating with receiver")
try:
RdisqRequest(AddMessage(1)).send_and_wait_reply(1)
except RuntimeError:
pass
else:
raise RuntimeError("Should have failed communicating with receiver")
receiver_service.register_message(RegisterMessage(AddMessage, summer))
RdisqRequest(AddMessage(1)).send_and_wait_reply()
RdisqRequest(AddMessage(2)).send_and_wait_reply()
assert summer.sum == 3
rdisq_message_fixture.kill_all()
def test_handler_class_reuse(rdisq_message_fixture: "_RdisqMessageFixture"):
receiver_service_1 = rdisq_message_fixture.spawn_receiver()
RdisqRequest(RegisterMessage(AddMessage, {})).send_async()
receiver_service_1.rdisq_process_one()
RdisqRequest(RegisterMessage(SubtractMessage)).send_async()
receiver_service_1.rdisq_process_one()
r = RdisqRequest(AddMessage(4)).send_async()
receiver_service_1.rdisq_process_one()
assert r.wait(1) == 4
r = RdisqRequest(SubtractMessage(3)).send_async()
receiver_service_1.rdisq_process_one()
assert r.wait(1) == 1
def test_multi(rdisq_message_fixture: "_RdisqMessageFixture"):
receiver_service_1 = rdisq_message_fixture.spawn_receiver()
receiver_service_2 = rdisq_message_fixture.spawn_receiver()
request = MultiRequest(RegisterMessage(SumMessage)).send_async()
receiver_service_1.rdisq_process_one()
receiver_service_2.rdisq_process_one()
r = request.wait(1)
assert r == [{SumMessage} | CORE_RECEIVER_MESSAGES,
{SumMessage} | CORE_RECEIVER_MESSAGES]
request = MultiRequest(SumMessage(1, 3)).send_async()
receiver_service_1.rdisq_process_one()
receiver_service_2.rdisq_process_one()
r = request.wait(1)
assert r == [4, 4]
request = MultiRequest(SumMessage(
4, 4), lambda s: s.uid == receiver_service_1.uid).send_async()
receiver_service_1.rdisq_process_one()
r = request.wait(1)
assert r == [8]
receiver_service_3 = rdisq_message_fixture.spawn_receiver()
request = MultiRequest(
SumMessage(4, 4), lambda s: s.uid in
[receiver_service_1.uid, receiver_service_2.uid]).send_async()
assert receiver_service_3.rdisq_process_one(1) is False
receiver_service_1.rdisq_process_one()
receiver_service_2.rdisq_process_one()
assert request.wait(1) == [8, 8]
def test_service_control_messages(rdisq_message_fixture):
receiver_service = rdisq_message_fixture.spawn_receiver()
Thread(group=None, target=receiver_service.process).start()
receiver_service.wait_for_process_to_start(5)
assert RdisqRequest(RegisterMessage(SumMessage)).send_and_wait_reply() == {
SumMessage
} | CORE_RECEIVER_MESSAGES
try:
RdisqRequest(RegisterMessage(SumMessage)).send_and_wait_reply()
except Exception:
pass
else:
raise RuntimeError(
"Should have failed to re-sum_ a message to a receiver.")
dispatcher = get_rdisq_config().request_dispatcher
receivers_from_redis = dispatcher.get_receiver_services()
assert receivers_from_redis[receiver_service.uid].registered_messages == {
SumMessage
} | CORE_RECEIVER_MESSAGES
assert receivers_from_redis[
receiver_service.uid].uid == receiver_service.uid
assert receiver_service.get_registered_messages() == {
SumMessage
} | CORE_RECEIVER_MESSAGES
assert RdisqRequest(GetRegisteredMessages()).send_and_wait_reply() == {
SumMessage
} | CORE_RECEIVER_MESSAGES
assert RdisqRequest(SumMessage(1, 2)).send_and_wait_reply() == 3
RdisqRequest(UnregisterMessage(SumMessage)).send_and_wait_reply()
try:
RdisqRequest(SumMessage(1, 2)).send_and_wait_reply(1)
except RuntimeError:
pass
else:
raise RuntimeError("Should have failed communicating with receiver")
assert RdisqRequest(RegisterMessage(
AddMessage,
{"start": 1
})).send_and_wait_reply() == {AddMessage} | CORE_RECEIVER_MESSAGES
assert RdisqRequest(AddMessage(3)).send_and_wait_reply() == 4
rdisq_message_fixture.kill_all()
def test_session_data(rdisq_message_fixture: "_RdisqMessageFixture"):
receivers = rdisq_message_fixture.spawn_receiver()
MultiRequest(RegisterMessage(AddMessage, {})).send_async()
rdisq_message_fixture.process_all_receivers(1)
session = RdisqSession()
session.session_data = {"a": 3}
session.send(AddMessage(2))
session.session_data = {}
rdisq_message_fixture.process_all_receivers(1)
session.wait()
assert session.session_data == {"a": 3}
def test_session_base(rdisq_message_fixture: "_RdisqMessageFixture"):
receivers = rdisq_message_fixture.spawn_receivers(5)
MultiRequest(RegisterMessage(AddMessage, {})).send_async()
rdisq_message_fixture.process_all_receivers()
session = RdisqSession()
session.send(AddMessage(2))
receivers[-1].rdisq_process_one(1)
assert session.wait(1) == 2
assert session.current_request.returned_value == 2
assert session._service_id == receivers[-1].uid
session.send(AddMessage(2))
rdisq_message_fixture.process_all_receivers()
assert session.wait(1) == 4
def test_shutdown_message(rdisq_message_fixture: "_RdisqMessageFixture"):
receiver_service = rdisq_message_fixture.spawn_receiver()
Thread(group=None, target=receiver_service.process).start()
receiver_service.wait_for_process_to_start()
assert {AddMessage} < RegisterMessage(AddMessage, {
"start": 2
}).send_and_wait()
assert AddMessage(3).send_and_wait() == 5
ShutDownReceiver().send_and_wait()
with pytest.raises(
RuntimeError,
match=
r"Tried sending a request, but not suitable receiver services were found."
):
AddMessage(3).send_and_wait(timeout=1)
receiver_service.wait_for_process_to_stop()
assert not receiver_service.is_active
def test_queues(rdisq_message_fixture):
receiver_service = rdisq_message_fixture.spawn_receiver()
RdisqRequest(AddQueue(new_queue_name="test_queue")).send_async()
receiver_service.rdisq_process_one()
assert 'ReceiverService_test_queue' in receiver_service.listening_queues
RdisqRequest(RegisterMessage(SumMessage)).send_async()
receiver_service.rdisq_process_one()
dispatcher = get_rdisq_config().request_dispatcher
r = dispatcher.queue_task("ReceiverService_test_queue", SumMessage(1, 2))
receiver_service.rdisq_process_one()
assert r.wait(1) == 3
r = RdisqRequest(RemoveQueue(old_queue_name="test_queue")).send_async()
receiver_service.rdisq_process_one()
result = r.wait()
assert 'ReceiverService_test_queue' not in result
assert 'ReceiverService_test_queue' not in receiver_service.listening_queues
def test_send_async(rdisq_message_fixture: "_RdisqMessageFixture"):
receiver = rdisq_message_fixture.spawn_receiver()
Thread(group=None, target=receiver.process).start()
assert AddMessage in RegisterMessage(AddMessage, {}).send_and_wait()
rdisq_message_fixture.kill_all()
def test_send_sync(rdisq_message_fixture: "_RdisqMessageFixture"):
rdisq_message_fixture.spawn_receiver()
r = RegisterMessage(AddMessage, {}).send_async()
rdisq_message_fixture.process_all_receivers()
assert AddMessage in r.wait()