def test_buffer(self):
"""Test ScheduleBroadcasts() multiprocessing target function."""
# Alias multi-process target function.
schedule = ScheduleBroadcasts._ScheduleBroadcasts__inject
# Create inputs to process.
run_event = multiprocessing.Event()
queue = multiprocessing.Queue()
speed = 1.0
# Ensure process can exist when the run_event() is clear.
run_event.clear()
schedule(run_event,
queue,
speed)
# Listen for message broadcasts.
data_buffer = list()
listener = MessageListener(UnitTestMessageA)
listener.subscribe(lambda data: data_buffer.append(data))
# Create data for testing.
data = {'elapsed_time': 0.0,
'topic': '',
'payload': UnitTestMessageA(data=0.0)}
# Ensure process can exist when the run_event() is clear.
queue.put(data)
run_event.set()
schedule(run_event,
queue,
speed)
self.assertEqual(len(data_buffer), 1)
self.assertDictEqual(data['payload'], data_buffer[0]['payload'])
def test_buffer(self):
"""Test ScheduleBroadcasts() multiprocessing target function."""
# Alias multi-process target function.
schedule = ScheduleBroadcasts._ScheduleBroadcasts__inject
# Create inputs to process.
run_event = multiprocessing.Event()
queue = multiprocessing.Queue()
speed = 1.0
# Ensure process can exist when the run_event() is clear.
run_event.clear()
schedule(run_event, queue, speed)
# Listen for message broadcasts.
data_buffer = list()
listener = MessageListener(UnitTestMessageA)
listener.subscribe(lambda data: data_buffer.append(data))
# Create data for testing.
data = {
'elapsed_time': 0.0,
'topic': '',
'payload': UnitTestMessageA(data=0.0)
}
# Ensure process can exist when the run_event() is clear.
queue.put(data)
run_event.set()
schedule(run_event, queue, speed)
self.assertEqual(len(data_buffer), 1)
self.assertDictEqual(data['payload'], data_buffer[0]['payload'])
def schedule(self, speed=None):
"""Schedule broadcasts."""
# Listen for message broadcasts.
listener_A = MessageListener(UnitTestMessageA)
listener_B = MessageListener(UnitTestMessageB)
buffer_A = list()
buffer_B = list()
# Subscribe callbacks.
def callback_A(data):
buffer_A.append(data)
def callback_B(data):
buffer_B.append(data)
listener_A.subscribe(callback_A)
listener_B.subscribe(callback_B)
# Create objects for reading and scheduling data.
read = ReadDirectory(LOG_PATH, message=True)
data = BufferData(read)
data.start()
# Wait for buffer to fill.
start_wait = time.time()
while not data.is_ready() and ((time.time() - start_wait) < TIMEOUT):
time.sleep(0.1)
# Schedule data.
if not speed:
speed = 1.0
scheduler = ScheduleBroadcasts(data.queue)
else:
scheduler = ScheduleBroadcasts(data.queue, speed=speed)
scheduler.start()
# Wait for broadcasts to end.
run_time = 1.0 / float(speed)
start_wait = time.time()
while True:
duration = time.time() - start_wait
if scheduler.is_alive() and duration < 2.0 * run_time:
time.sleep(0.1)
else:
break
# Ensure all messages were received.
self.assertEqual(len(buffer_A) + len(buffer_B), 20)
# Ensure timing is approximately correct.
self.assertGreaterEqual(duration, 0.5 * run_time)
self.assertLessEqual(duration, 2.0 * run_time)
def test_message_init(self):
"""Test %s MessageListener() initialisation."""
# Ensure non-Message() inputs are caught.
with self.assertRaises(TypeError):
MessageListener(dict)
with self.assertRaises(TypeError):
MessageListener(0)
# Ensure errors are propagated.
with self.assertRaises(Exception):
MessageListener(self.BadMessage)
# Create an instance of MessageListener() with defaults.
listener = MessageListener(self.Message)
self.assertEqual(listener.topics, None)
self.assertTrue(listener.is_open)
listener.close()
# Create an instance of MessageListener() with a specific topic.
listener = MessageListener(self.Message, topics=TOPIC)
self.assertEqual(listener.topics, TOPIC)
self.assertTrue(listener.is_open)
listener.close()
# Ensure non-string topics are caught.
with self.assertRaises(TypeError):
MessageListener(self.Message, topics=False)
def replay(self, speed=None):
"""Schedule broadcasts."""
# Listen for message broadcasts.
listener_A = MessageListener(UnitTestMessageA)
listener_B = MessageListener(UnitTestMessageB)
buffer_A = list()
buffer_B = list()
# Subscribe callbacks.
def callback_A(data):
buffer_A.append(data)
def callback_B(data):
buffer_B.append(data)
listener_A.subscribe(callback_A)
listener_B.subscribe(callback_B)
# Create objects for replaying data.
reader = ReadDirectory(LOG_PATH, message=True)
if not speed:
speed = 1.0
replay = Replay(reader)
else:
replay = Replay(reader, speed=speed)
# Start replay and Wait for broadcasts to end.
replay.start()
run_time = 1.0 / float(speed)
start_wait = time.time()
while True:
duration = time.time() - start_wait
if replay.is_alive() and duration < 2.0 * run_time:
time.sleep(0.05)
else:
break
# Ensure all messages were received.
self.assertEqual(len(buffer_A) + len(buffer_B), 20)
# Ensure timing is approximately correct.
self.assertGreaterEqual(duration, 0.5 * run_time)
self.assertLessEqual(duration, 2.0 * run_time)
# Ensure replay can be restarted successfully after finishing a replay.
self.assertTrue(replay.start())
time.sleep(0.05)
self.assertTrue(replay.is_alive())
self.assertTrue(replay.stop())
def schedule(self, speed=None):
"""Schedule broadcasts."""
# Listen for message broadcasts.
listener_A = MessageListener(UnitTestMessageA)
listener_B = MessageListener(UnitTestMessageB)
buffer_A = list()
buffer_B = list()
# Subscribe callbacks.
def callback_A(data): buffer_A.append(data)
def callback_B(data): buffer_B.append(data)
listener_A.subscribe(callback_A)
listener_B.subscribe(callback_B)
# Create objects for reading and scheduling data.
read = ReadDirectory(LOG_PATH, message=True)
data = BufferData(read)
data.start()
# Wait for buffer to fill.
start_wait = time.time()
while not data.is_ready() and ((time.time() - start_wait) < TIMEOUT):
time.sleep(0.1)
# Schedule data.
if not speed:
speed = 1.0
scheduler = ScheduleBroadcasts(data.queue)
else:
scheduler = ScheduleBroadcasts(data.queue, speed=speed)
scheduler.start()
# Wait for broadcasts to end.
run_time = 1.0 / float(speed)
start_wait = time.time()
while True:
duration = time.time() - start_wait
if scheduler.is_alive() and duration < 2.0 * run_time:
time.sleep(0.1)
else:
break
# Ensure all messages were received.
self.assertEqual(len(buffer_A) + len(buffer_B), 20)
# Ensure timing is approximately correct.
self.assertGreaterEqual(duration, 0.5 * run_time)
self.assertLessEqual(duration, 2.0 * run_time)
def replay(self, speed=None):
"""Schedule broadcasts."""
# Listen for message broadcasts.
listener_A = MessageListener(UnitTestMessageA)
listener_B = MessageListener(UnitTestMessageB)
buffer_A = list()
buffer_B = list()
# Subscribe callbacks.
def callback_A(data): buffer_A.append(data)
def callback_B(data): buffer_B.append(data)
listener_A.subscribe(callback_A)
listener_B.subscribe(callback_B)
# Create objects for replaying data.
reader = ReadDirectory(LOG_PATH, message=True)
if not speed:
speed = 1.0
replay = Replay(reader)
else:
replay = Replay(reader, speed=speed)
# Start replay and Wait for broadcasts to end.
replay.start()
run_time = 1.0 / float(speed)
start_wait = time.time()
while True:
duration = time.time() - start_wait
if replay.is_alive() and duration < 2.0 * run_time:
time.sleep(0.05)
else:
break
# Ensure all messages were received.
self.assertEqual(len(buffer_A) + len(buffer_B), 20)
# Ensure timing is approximately correct.
self.assertGreaterEqual(duration, 0.5 * run_time)
self.assertLessEqual(duration, 2.0 * run_time)
# Ensure replay can be restarted successfully after finishing a replay.
self.assertTrue(replay.start())
time.sleep(0.05)
self.assertTrue(replay.is_alive())
self.assertTrue(replay.stop())
def test_message_send_receive(self):
"""Test %s with MessageBroadcaster/Listener() objects."""
# NOTE: this test listens for multiple topics from many. Rather than
# sending raw data (a previous test), Message() objects are
# sent. This tests all the functionality of the
# MessageBroadcaster() and MessageListener() objects.
# Send multiple topics, receive SOME topics.
send_topics = ['topic A', 'topic B', 'topic C', 'topic D', 'topic E']
listen_topics = ['topic A', 'topic C', 'topic E']
# Create broadcaster.
broadcaster = MessageBroadcaster(self.Message)
# Catch messages with a specific topic.
topic_buffer = list()
listener_topic = MessageListener(self.Message, topics=listen_topics)
# Subscribe callback.
def callback(data): topic_buffer.append(data)
self.assertTrue(listener_topic.subscribe(callback))
self.assertTrue(listener_topic.is_subscribed(callback))
self.assertEqual(listener_topic.num_subscriptions(), 1)
# Catch all messages. This ensures the unit-test does not time out
# waiting for messages that are filtered out by topic.
message_buffer = list()
listener_message = MessageListener(self.Message)
# Ensure network objects are open.
self.assertTrue(broadcaster.is_open)
self.assertTrue(listener_topic.is_open)
self.assertTrue(listener_message.is_open)
# Publish messages with different topics.
messages = list()
for (i, topic) in enumerate(send_topics):
messages.append(self.Message())
messages[-1]['text'] = '%s: %1.8f' % (topic, time.time())
# Perform test.
message_buffer = self.publish(broadcaster,
listener_message,
messages[-1],
topic=topic,
received_buffer=message_buffer)
# Close connections.
broadcaster.close()
listener_topic.close()
listener_message.close()
self.assertFalse(broadcaster.is_open)
self.assertFalse(listener_topic.is_open)
self.assertFalse(listener_message.is_open)
# Ensure all topics were received.
self.assertEqual(len(topic_buffer), len(listen_topics))
for i, topic in enumerate(listen_topics):
self.assertEqual(topic_buffer[i]['payload'],
messages[send_topics.index(topic)])
def test_message_send_receive(self):
"""Test %s with MessageBroadcaster/Listener() objects."""
# NOTE: this test listens for multiple topics from many. Rather than
# sending raw data (a previous test), Message() objects are
# sent. This tests all the functionality of the
# MessageBroadcaster() and MessageListener() objects.
# Send multiple topics, receive SOME topics.
send_topics = ['topic A', 'topic B', 'topic C', 'topic D', 'topic E']
listen_topics = ['topic A', 'topic C', 'topic E']
# Create broadcaster.
broadcaster = MessageBroadcaster(self.Message)
# Catch messages with a specific topic.
topic_buffer = list()
listener_topic = MessageListener(self.Message, topics=listen_topics)
# Subscribe callback.
def callback(data):
topic_buffer.append(data)
self.assertTrue(listener_topic.subscribe(callback))
self.assertTrue(listener_topic.is_subscribed(callback))
self.assertEqual(listener_topic.num_subscriptions(), 1)
# Catch all messages. This ensures the unit-test does not time out
# waiting for messages that are filtered out by topic.
message_buffer = list()
listener_message = MessageListener(self.Message)
# Ensure network objects are open.
self.assertTrue(broadcaster.is_open)
self.assertTrue(listener_topic.is_open)
self.assertTrue(listener_message.is_open)
# Publish messages with different topics.
messages = list()
for (i, topic) in enumerate(send_topics):
messages.append(self.Message())
messages[-1]['text'] = '%s: %1.8f' % (topic, time.time())
# Perform test.
message_buffer = self.publish(broadcaster,
listener_message,
messages[-1],
topic=topic,
received_buffer=message_buffer)
# Close connections.
broadcaster.close()
listener_topic.close()
listener_message.close()
self.assertFalse(broadcaster.is_open)
self.assertFalse(listener_topic.is_open)
self.assertFalse(listener_message.is_open)
# Ensure all topics were received.
self.assertEqual(len(topic_buffer), len(listen_topics))
for i, topic in enumerate(listen_topics):
self.assertEqual(topic_buffer[i]['payload'],
messages[send_topics.index(topic)])
def test_message_init(self):
"""Test %s MessageListener() initialisation."""
# Ensure non-Message() inputs are caught.
with self.assertRaises(TypeError):
MessageListener(dict)
with self.assertRaises(TypeError):
MessageListener(0)
# Ensure errors are propagated.
with self.assertRaises(Exception):
MessageListener(self.BadMessage)
# Create an instance of MessageListener() with defaults.
listener = MessageListener(self.Message)
self.assertEqual(listener.topics, None)
self.assertTrue(listener.is_open)
listener.close()
# Create an instance of MessageListener() with a specific topic.
listener = MessageListener(self.Message, topics=TOPIC)
self.assertEqual(listener.topics, TOPIC)
self.assertTrue(listener.is_open)
listener.close()
# Ensure non-string topics are caught.
with self.assertRaises(TypeError):
MessageListener(self.Message, topics=False)