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 test_express_event(self):
receiver = Receiver("/services/test/events")
receiver.start()
obj = receiver.receive()
assert len(obj.task) == 1
value = next(iter(obj.task.values()))
value.pop("id")
queue = value.pop("queue")
assert value == {
"name": "event",
"description": "event-desc",
"params": {
"arg1": {
"type": "string"
}
}
}
event_receiver = Receiver(queue)
event_receiver.start()
self.service.event.fire(arg1="blah")
obj = event_receiver.receive().task
assert obj == {"arg1": "blah"}
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_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_update_status(self):
receiver = Receiver("/services/test/status")
receiver.start()
self.service.update_status("test-status")
receiver.receive().task == "test-status"
class AppLister(object):
def __init__(self, shell_component):
self.apps = []
self.shell_component = shell_component
self.app_list_receiver = Receiver("/_system/applications")
def start(self):
self.app_list_receiver.on_message = self.process_app_list_message
self.app_list_receiver.start()
self.receiver_thread = Thread(target=self.app_list_receiver.run)
self.receiver_thread.start()
def stop(self):
self.app_list_receiver.stop()
self.receiver_thread.join()
def process_app_list_message(self, msg):
self.apps = msg
for obj in self.apps.values():
obj["kind"] = "APP"
self.shell_component.notify_all('dock_apps', self.apps)
def test_express_simple_capability_with_bad_schema(self):
receiver = Receiver("/services/test/capabilities")
receiver.start()
obj = receiver.receive()
assert len(obj.task) == 1
value = next(iter(obj.task.values()))
value.pop("id")
queue = value.pop("queue")
assert value == {
"name": "test",
"description": "testdesc",
"params": {
"arg1": {
"type": "string"
}
},
}
sender = Sender(queue)
sender.start()
with pytest.raises(SchemaValidationFailed):
sender.send({"arg2": "new-value"})
def test_express_simple_capability_with_correct_schema(self):
receiver = Receiver("/services/test/capabilities")
receiver.start()
obj = receiver.receive()
assert len(obj.task) == 1
value = next(iter(obj.task.values()))
value.pop("id")
queue = value.pop("queue")
assert value == {
"name": "test",
"description": "testdesc",
"params": {
"arg1": {
"type": "string"
}
},
}
sender = Sender(queue)
sender.start()
sender.send({"arg1": "new-value"})
assert self.service.get_value() == "new-value"
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"}]
def __init__(self, shell_component):
self.apps = []
self.shell_component = shell_component
self.app_list_receiver = Receiver("/_system/applications")
def test_dequeue_from_unknown_queue(self):
r = Receiver("unknown.queue")
r.start()
with pytest.raises(QueueNotFound):
r.receive()
def test_service_registration(self):
receiver = Receiver("/root/services")
receiver.start()
obj = receiver.receive().task
assert obj == {"/services/test/": {}}