def test_max_parallel(self):
for i in range(self.wormhole.max_parallel):
v = Vector3Message(1, 2, 3)
v.delay = 5
v.send(wormhole=self.wormhole)
v = Vector3Message(4, 5, 6)
s: WormholeSession
with pytest.raises(WormholeWaitForReplyError):
s = v.send(wormhole=self.wormhole)
s.wait(timeout=1, retries=0)
assert s.is_error
# Verify the wormhole did not take the message because it was too busy
assert s.receiver_id == ''
def test_simple_setup(self):
instance = Vector3MixinHandler(self.wormhole)
with pytest.raises(WormholeWaitForReplyError):
Vector3Message(1, 5,
3).send(wormhole=self.wormhole).wait(timeout=1)
wait_all(instance.activate_all_handlers())
wait_all([
Vector3Message(1, 5, 3).send(wormhole=self.wormhole)
for _ in range(50)
])
wait_all(instance.deactivate_all_handlers())
with pytest.raises(WormholeWaitForReplyError):
Vector3Message(1, 5,
3).send(wormhole=self.wormhole).wait(timeout=1)
def asddas_test_max_parallel2(self):
for i in range(self.wormhole.max_parallel):
v = Vector3Message(1, 2, 3)
v.delay = 3
v.send(wormhole=self.wormhole)
v = Vector3Message(1, 2, 3)
s: WormholeSession
other_wormhole = GeventWormhole(channel=self.wormhole_channel)
other_wormhole.process_async(2)
handler = Vector3Handler()
WormholeHandler.register_all_handlers_of_instance(
other_wormhole, handler)
s = v.send(wormhole=self.wormhole)
s.wait(timeout=1)
assert not s.is_error
# Verify the first wormhole did not take the message because it was too busy
assert s.receiver_id == other_wormhole.id
other_wormhole.stop(wait=True)
def test_delayed_simple(self):
promises = []
for i in range(0, 20):
m = Vector3Message(i, i * 2, i * i)
m.delay = 0.2
p = m.send(wormhole=self.wormhole)
promises.append((m, p))
for m, p in promises:
assert p.wait() == m.magnitude
def test_group_multi(self):
group_name = "mass_group"
# add all to the group
wait_all([wh.add_to_group(group_name) for wh in self.wormholes])
sessions = [
Vector3Message(2, 5, 6).send(wormhole=self.wormhole,
group=group_name) for _ in range(400)
]
wait_all(sessions)
assert len(set([s.receiver_id for s in sessions])) == 5
def test_groups(self):
group_name = "group111"
group_name2 = "group222"
self.wormhole.add_to_group(group_name).wait()
assert self.wormhole.id in self.wormhole.find_group_members(group_name)
Vector3Message(2, 5, 6).send(wormhole=self.wormhole,
group=group_name).wait()
self.wormhole.add_to_group(group_name2).wait()
Vector3Message(2, 5, 6).send(wormhole=self.wormhole,
group=group_name2).wait()
self.wormhole.remove_from_group(group_name).wait()
assert self.wormhole.id not in self.wormhole.find_group_members(
group_name)
async_result = Vector3Message(2, 5, 6).send(wormhole=self.wormhole,
group=group_name)
gevent.sleep(1)
assert not async_result.poll()
Vector3Message(2, 5, 6).send(wormhole=self.wormhole,
group=group_name2).wait()
def test_session_simple(self):
i = 1
m = Vector3Message(i, i * 2, i * i)
session = m.send(wormhole=self.wormhole)
assert session.wait() == m.magnitude
i = 5
for _ in range(20):
m2 = Vector3Message(i, i * 2, i * i)
session2 = m2.send(wormhole=session)
assert session2.wait() == m2.magnitude
assert session2.receiver_id == session.receiver_id
# Test sanity check to see other wormholes are working
m3 = Vector3Message(i, i * 2, i * i)
ok = False
for _ in range(20):
r = m3.send(wormhole=self.wormhole)
r.wait()
if r.receiver_id != self.wormhole:
ok = True
break
assert ok
def test_wait_for_any(self):
reply_data = "asd1242FAS"
v = Vector3Message(1, 2, 3)
self.wormhole.unregister_all_handlers()
async_result = v.send(wormhole=self.wormhole)
r = redis.Redis.from_url(self.TEST_REDIS)
wait_result = self.wormhole.wait_for_any(Vector3Message,
"asd",
timeout=5)
assert not wait_result.timeout
assert wait_result.item == Vector3Message
assert wait_result.tag is None
assert wait_result.data is not None
assert wait_result.data == v
wait_result.reply(reply_data)
assert async_result.wait() == reply_data
dummy_data = "lalala"
async_result = self.wormhole.send("asd", dummy_data)
wait_result = self.wormhole.wait_for_any(Vector3Message,
"asd",
timeout=3)
assert wait_result.tag is None
assert not wait_result.timeout
wait_result.reply(dummy_data)
assert async_result.wait() == dummy_data
# Send data with a tag
tag = "tag111"
async_result = self.wormhole.send("asd", dummy_data, tag)
wait_result = self.wormhole.wait_for_any(WormholeWaitable("asd", tag),
"asd",
timeout=3)
assert wait_result.tag == tag
assert not wait_result.timeout
wait_result.reply(dummy_data)
assert async_result.wait() == dummy_data
# Now send without the tag and make sure the non tag one is handled
async_result = self.wormhole.send("asd", dummy_data)
wait_result = self.wormhole.wait_for_any(WormholeWaitable("asd", tag),
"asd",
timeout=3)
assert wait_result.tag is None
assert not wait_result.timeout
wait_result.reply(dummy_data)
assert async_result.wait() == dummy_data
# Send one more time and make sure we timeout
with pytest.raises(WormholeWaitForReplyError):
self.wormhole.send("asd", dummy_data).wait(timeout=1)
def test_simple(self):
messages = [Vector3Message(i, i * 2, i * i) for i in range(100)]
promises = [m.send(wormhole=self.wormhole) for m in messages]
message_promise_couples = zip(messages, promises)
assert all(
[p.wait() == m.magnitude for m, p in message_promise_couples])