def test_keyed_sticky(self):
def make_receiver(count, obj, sem, r):
def on_message(msg):
obj.update(msg)
sem.release()
nonlocal count
count -= 1
if not count:
r.stop()
return on_message
s1 = Sender("/x.keyedsticky")
s2 = Sender("/x.keyedsticky")
obj1 = {}
obj2 = {}
sem1 = Semaphore(0)
sem2 = Semaphore(0)
r1 = Receiver("/x.keyedsticky")
r2 = Receiver("/x.keyedsticky")
r1.on_message = make_receiver(4, obj1, sem1, r1)
r1.start()
Thread(target=r1.run).start()
assert sem1.acquire(timeout=10) # Won't timeout for the first message.
assert obj1 == {}
s1.start()
s1.send({"foo": "bar"}, headers={"KEY": "1"})
assert sem1.acquire(timeout=10) # Must not timeout.
assert obj1 == {"1": {"foo": "bar"}}
r2.on_message = make_receiver(3, obj2, sem2, r2)
r2.start()
Thread(target=r2.run).start()
assert sem2.acquire(timeout=10) # Must not timeout.
assert obj2 == {"1": {"foo": "bar"}}
s2.start()
s2.send({"baz": "grr"}, headers={"KEY": "2"})
assert sem1.acquire(timeout=10)
assert sem2.acquire(timeout=10)
assert obj1 == {"1": {"foo": "bar"}, "2": {"baz": "grr"}}
assert obj2 == {"1": {"foo": "bar"}, "2": {"baz": "grr"}}
s2.send({"foo": "hello"}, headers={"KEY": "1"})
assert sem1.acquire(timeout=10)
assert sem2.acquire(timeout=10)
assert obj1 == {"1": {"foo": "hello"}, "2": {"baz": "grr"}}
assert obj2 == {"1": {"foo": "hello"}, "2": {"baz": "grr"}}
def test_sticky_simple_enqueue_dequeue(self):
def make_receiver(count, msgs, sem, r):
def on_message(msg):
msgs.append(msg)
sem.release()
nonlocal count
count -= 1
if not count:
r.stop()
return on_message
sem1 = Semaphore(0)
sem2 = Semaphore(0)
msgs1 = []
msgs2 = []
op = {"foo": "bar"}
s = Sender("/a.sticky")
s.start()
r1 = Receiver("/a.sticky")
r1.on_message = make_receiver(2, msgs1, sem1, r1)
r1.start()
Thread(target=r1.run).start()
assert not sem1.acquire(timeout=2) # Assert that this times out.
assert len(msgs1) == 0
s.send(op)
assert sem1.acquire(timeout=10) # This shouldn't timeout.
assert len(msgs1) == 1
assert not sem1.acquire(timeout=2) # This should timeout again.
assert len(msgs1) == 1
r2 = Receiver("/a.sticky")
r2.on_message = make_receiver(2, msgs2, sem2, r2)
r2.start()
Thread(target=r2.run).start()
assert sem2.acquire(timeout=10) # This shouldn't timeout.
assert len(msgs2) == 1
assert not sem2.acquire(timeout=2) # This should timeout.
s.send(op)
assert sem1.acquire(timeout=10)
assert sem2.acquire(timeout=2)
assert len(msgs1) == 2
assert len(msgs2) == 2
def test_multiple_enqueue_dequeue(self):
obj = {"foo": "bar"}
s = Sender("/a.b.c")
r = Receiver("/a.b.c")
s.start()
for _ in range(10):
s.send(obj)
expected_message_count = 10
def on_message(msg):
assert msg == obj
nonlocal expected_message_count
if expected_message_count == 1:
r.stop()
expected_message_count -= 1
r.start()
r.on_message = on_message
thread = Thread(target=r.run)
thread.start()
thread.join()
def start_echo_receiver(cls, queue):
sender = Sender(queue)
sender.start()
def reply(msg):
sender.send(msg)
receiver = Receiver(queue)
receiver.on_message = reply
receiver.start()
def test_simple_enqueue_dequeue(self):
msgs = []
s = Sender("/a.b.c")
r = Receiver("/a.b.c")
s.start()
r.start()
r.on_message = lambda msg: msgs.append(msg) or r.stop()
s.send({"foo": "bar"})
thread = Thread(target=r.run)
thread.start()
thread.join()
assert msgs == [{"foo": "bar"}]