def test_decorated_listener_chained_multi(hive):
chained_calls = []
@hive.listener(filters=['topic1'])
def listener1(event):
return event
@hive.listener(filters=['topic2'])
def listener2(event):
return event
@hive.listener(chain=['listener1', 'listener2'])
def listener3(event):
chained_calls.append(event)
assert len(hive.listeners
) == 2, 'Added chained listener to root list of listeners'
assert len(hive.listeners._listeners['listener1'][0].chained_bees) == 1,\
'Did not correctly chain listeners'
assert len(hive.listeners._listeners['listener2'][0].chained_bees) == 1,\
'Did not correctly chain listeners'
hive.submit_event(pybeehive.Event('test1', topic='topic1'))
hive.submit_event(pybeehive.Event('test2', topic='topic2'))
run_kill_hive(hive)
assert len(
chained_calls
) == 2, 'Chained listener did not execute on_event from both chains'
def test_decorated_listener_chained_with_filters(hive):
topic1_calls = []
topic2_calls = []
@hive.listener
def listener1(event):
return event
@hive.listener(chain=['listener1'], filters=['topic1'])
def listener2(event):
event.data = 'listener2'
topic1_calls.append(event)
@hive.listener(chain=['listener1'], filters=['topic2'])
def listener3(event):
event.data = 'listener3'
topic2_calls.append(event)
hive.submit_event(pybeehive.Event('test1', topic='topic1'))
hive.submit_event(pybeehive.Event('test2', topic='topic2'))
run_kill_hive(hive)
assert len(topic1_calls
) == 1, 'Chained filtered listener did not execute on_event'
assert len(topic2_calls
) == 1, 'Chained filtered listener did not execute on_event'
assert topic1_calls[
0].data == 'listener2', 'Chained filtered listener did not execute on_event'
assert topic2_calls[
0].data == 'listener3', 'Chained filtered listener did not execute on_event'
def test_multiple_listeners_single_streamer(async_hive):
address = '127.0.0.1', random.randint(7000, 10000)
events = []
class Listener(SocketListener):
async def parse_event(self, event):
event = pybeehive.Event(event.data + 1,
created_at=event.created_at)
events.append(event)
return event
async_hive.add(SocketStreamer(address))
for _ in range(3):
async_hive.add(Listener(address))
async_hive.submit_event(pybeehive.Event(-1))
async_hive.run(threaded=True)
start = time.time()
while len(events) < 12 and time.time() - start < 2:
time.sleep(1e-4)
async_hive.close()
assert len(events) >= 12, "Hive did not process all events"
for i, e in enumerate(events[:12]):
# First three
if i < 3:
assert e.data == 0, "Multiple listeners sent incorrect events"
# Last nine (each cycle is 3x)
else:
assert e.data == 1, "Streamer did not propagate events to listeners"
def test_interrupted_streamer_listener_loop(async_hive):
address = '127.0.0.1', random.randint(7000, 10000)
events = []
def interrupt():
time.sleep(1e-2)
_thread.interrupt_main()
async def parse_event(event):
await asyncio.sleep(1e-4)
events.append(event)
return event
streamer = SocketStreamer(address)
listener = SocketListener(address)
listener.parse_event = parse_event
async_hive.add(streamer)
async_hive.add(listener)
async_hive.submit_event(pybeehive.Event(-1))
Thread(target=interrupt).start()
async_hive.run()
assert len(events) > 1, "Listener did not receive any events from streamer"
assert not async_hive.alive, 'KeyboardInterrupt did not kill hive'
assert not streamer.server.alive, 'KeyboardInterrupt did not kill server'
assert not listener.client.alive, 'KeyboardInterrupt did not kill client'
def test_event_dunder_methods():
now = time.time()
event_1_a = pybeehive.Event('test_1', created_at=now)
event_1_b = pybeehive.Event('test_1', created_at=now)
event_1_c = pybeehive.Event('test_1', created_at=now, topic='thing')
event_2 = pybeehive.Event('test_1', created_at=now + 1)
event_3 = pybeehive.Event('test_2', created_at=now)
assert event_1_a == event_1_b, "Identical events not equal"
assert event_1_a != event_1_c, "Events with different topics equal"
assert event_1_a != event_2, "Events with different times equal"
assert event_1_a != event_3, "Events with different data equal"
assert str(event_1_a) == str(event_1_b), "Event strings different"
events = set()
events.add(event_1_a)
assert len(events) == 1, "Did not add event to set"
events.add(event_1_b)
assert len(events) == 1, "Added identical events to set twice"
events.add(event_2)
assert len(events) == 2, "Did not add different event to set"
def test_filter(bee_factory):
non_filtered = bee_factory.create('listener')
filtered = bee_factory.create('listener', filters=['topic1'])
no_topic = pybeehive.Event('data')
non_filtered.notify(no_topic)
assert len(non_filtered.calls
) == 1, "Listener with no filters did not call on_event"
filtered.notify(no_topic)
assert len(
filtered.calls
) == 0, "Listener with filters called on_event for an event with no topic"
topic = pybeehive.Event('data', topic='topic1')
non_filtered.notify(topic)
assert len(non_filtered.calls
) == 2, "Listener with no filters did not call on_event"
filtered.notify(topic)
assert len(
filtered.calls
) == 1, "Listener with filters did not call on_event for an event with topic"
def test_decorated_listener_with_filters(hive):
all_calls = []
filtered_calls = []
@hive.listener
def listener1(event):
all_calls.append(event)
@hive.listener(filters='topic1')
def listener2(event):
filtered_calls.append(event)
hive.submit_event(pybeehive.Event('test'))
hive.submit_event(pybeehive.Event('test1', topic='topic1'))
run_kill_hive(hive)
assert len(all_calls
) == 2, 'Unfiltered listener did not execute all on_event calls'
assert len(
filtered_calls
) == 1, 'Filtered listener did executed on_event when it shouldnt'
def test_decorated_listener(hive):
calls = []
@hive.listener
def on_event(event):
calls.append(event)
assert len(hive.listeners) == 1, 'Did not register listener to hive'
hive.submit_event(pybeehive.Event('test'))
run_kill_hive(hive)
assert len(calls) == 1, 'Listener did not execute on_event'
assert calls[0].data == 'test', 'Listener did not return correct data'
def test_message_closed_server(async_hive):
address = '127.0.0.1', random.randint(7000, 10000)
events = []
@async_hive.socket_listener(address)
async def parse_event(event):
events.append(event)
return event
async_hive.submit_event(pybeehive.Event(-1))
async_hive.run(threaded=True)
start = time.time()
while len(events) < 1 and time.time() - start < 2:
time.sleep(1e-4)
async_hive.kill()
assert len(events) >= 1, "Hive did not process all events"
def test_create_event():
now = time.time()
same_1 = pybeehive.Event('test', created_at=now)
same_2 = pybeehive.Event(same_1)
assert same_1 == same_2, \
"Event did not create correctly from another Event"
diff_1 = pybeehive.Event('test', topic='1', created_at=now)
diff_2 = pybeehive.Event('test', topic='2', created_at=now)
diff_3 = pybeehive.Event('test', topic='1', created_at=now + 1)
diff_4 = pybeehive.Event('test1', topic='1', created_at=now)
assert diff_1 != diff_2, "Events with different topics equal"
assert diff_2 != diff_3, "Events with different created_at equal"
assert diff_3 != diff_4, "Events with different data equal"
diff_5 = pybeehive.Event(diff_1, topic='2')
diff_6 = pybeehive.Event(diff_1, created_at=now + 1)
assert diff_1 != diff_5, "Event created from event with new topic equal"
assert diff_1 != diff_6, "Event created from event with new time equal"
assert diff_5.topic == '2', 'Did not override topic correctly'
assert diff_6.created_at == now + 1, 'Did not override time correctly'
def test_decorated_listener_chained(hive):
chained_calls = []
@hive.listener
def listener1(event):
return event
@hive.listener(chain='listener1')
def listener2(event):
chained_calls.append(event)
assert len(hive.listeners
) == 1, 'Added chained listener to root list of listeners'
assert len(hive.listeners._listeners['listener1'][0].chained_bees) == 1,\
'Did not correctly chain listeners'
hive.submit_event(pybeehive.Event('test'))
run_kill_hive(hive)
assert len(chained_calls) == 1, 'Chained listener did not execute on_event'
def test_socket_streamer_listener_loop(async_hive):
address = '127.0.0.1', random.randint(7000, 10000)
events = []
@async_hive.socket_listener(address)
async def parse_event(event):
event = pybeehive.Event(event.data + 1, created_at=event.created_at)
events.append(event)
return event
async_hive.add(SocketStreamer(address))
async_hive.submit_event(pybeehive.Event(-1))
async_hive.run(threaded=True)
start = time.time()
while len(events) < 5 and time.time() - start < 2:
time.sleep(1e-4)
async_hive.close()
assert len(events) >= 5, "Hive did not process all events"
for i, e in enumerate(events):
assert i == e.data, "Event data was not parsed by listener"
async def parse_event(self, event):
event = pybeehive.Event(event.data + 1,
created_at=event.created_at)
events.append(event)
return event
def test_event_string_conversion(data, topic, created_at):
# for data, created_at, topic in test_event_data:
event = pybeehive.Event(data, topic=topic, created_at=created_at)
event_string = event.tostring()
c_event = pybeehive.Event.fromstring(event_string)
assert event == c_event, "String converted event not equal to original"
