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_class_message(rdisq_message_fixture: "_RdisqMessageFixture"):
summer = Summer()
receiver_service = rdisq_message_fixture.spawn_receiver(
message_class=AddMessage, instance=summer)
Thread(group=None, target=receiver_service.process).start()
receiver_service.wait_for_process_to_start(3)
request = RdisqRequest(AddMessage(1))
request.send_async()
assert request.wait(1) == 1
try:
request.send_and_wait_reply()
except:
pass
else:
raise RuntimeError("Should not have allowed message reuse")
request = RdisqRequest(AddMessage(2))
try:
assert request.response
except:
pass
else:
raise RuntimeError(
"Should not have allowed getting result before the evnet has run")
assert request.send_and_wait_reply() == 3
assert summer.sum == 3
assert request.response.returned_value == 3
rdisq_message_fixture.kill_all()
def _basic_summer_test(rdisq_message_fixture: "_RdisqMessageFixture"):
request = AddMessage(1).send_async()
rdisq_message_fixture.process_all_receivers()
assert request.wait() == 3
request = SubtractMessage(1).send_async()
rdisq_message_fixture.process_all_receivers()
assert request.wait() == 2
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_custom_filter_with_tags(
rdisq_message_fixture: "_RdisqMessageFixture"):
receivers: List[ReceiverService] = rdisq_message_fixture.spawn_receivers(4)
request = MultiRequest(RegisterAll({}, Summer)).send_async()
rdisq_message_fixture.process_all_receivers()
request.wait(1)
def filter_(receiver_status: ReceiverServiceStatus):
return receiver_status.uid in [r.uid for r in receivers[:2]]
example_tags = {'foo': 'bar'}
request = MultiRequest(SetReceiverTags(example_tags), filter_).send_async()
rdisq_message_fixture.process_all_receivers()
assert request.wait(1) == [example_tags, example_tags]
def filter_2_(receiver_status: ReceiverServiceStatus):
return receiver_status.tags.get('foo') == 'bar'
request = MultiRequest(AddMessage(3), filter_2_).send_async()
rdisq_message_fixture.process_all_receivers()
assert request.wait() == [3, 3]
assert receivers[0]._handlers[AddMessage]._handler_instance.sum == 3
assert receivers[1]._handlers[AddMessage]._handler_instance.sum == 3
assert receivers[2]._handlers[AddMessage]._handler_instance.sum == 0
assert receivers[3]._handlers[AddMessage]._handler_instance.sum == 0
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_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_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_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_dispatcher_timeout(rdisq_message_fixture: "_RdisqMessageFixture"):
receiver_service = rdisq_message_fixture.spawn_receiver()
t = Thread(group=None, target=receiver_service.process)
t.start()
original_timeout = RequestDispatcher.SERVICE_STATUS_TIMEOUT
try:
RequestDispatcher.SERVICE_STATUS_TIMEOUT = 0
receiver_service.wait_for_process_to_start()
with pytest.raises(
RuntimeError,
match=
"Tried sending a request, but not suitable receiver services were found."
):
AddMessage(3).send_and_wait()
receiver_service.stop()
t.join()
finally:
RequestDispatcher.SERVICE_STATUS_TIMEOUT = original_timeout