def test_queue_with_service_passes_new_packet_directly_after_get_next_call():
sim, service = Mock(), Mock()
sim.stime = 0
service_rev_conn = Mock()
service.connections.set = Mock(return_value=service_rev_conn)
queue = Queue(sim=sim)
queue.connections.set('service', service, rname='queue')
queue.get_next(service=service)
packet = NetworkPacket(data=AppData(size=100))
sim.stime = 13
queue.push(packet)
# Check that the message was delivered to the service:
sim.schedule.assert_called_once_with(0,
service.handle_message,
args=(packet, ),
kwargs={
'connection': service_rev_conn,
'sender': queue,
})
# Check that queue is still empty:
assert queue.as_tuple() == ()
# Also make sure that size updates were not written:
assert queue.size_trace.as_tuple() == ((0, 0), )
assert queue.bitsize_trace.as_tuple() == ((0, 0), )
assert queue.num_dropped == 0
def test_data_request_to_queue_from_module_not_connected_raises_error():
sim, service = Mock(), Mock()
sim.stime = 0
queue = Queue(sim=sim)
with pytest.raises(ValueError):
queue.get_next(service=service)
def test_queue_with_service_passes_single_stored_packet_after_get_next_call():
t0, t1, t2, t3, t4 = 0, 13, 19, 22, 29
size = [100, 200, 300]
sim, service = Mock(), Mock()
sim.stime = t0
service_rev_conn = Mock()
service.connections.set = Mock(return_value=service_rev_conn)
queue = Queue(sim=sim)
queue.connections.set('service', service, rname='queue')
packets = [NetworkPacket(data=AppData(size=sz)) for sz in size]
sim.stime = t1
queue.push(packets[0])
sim.stime = t2
queue.push(packets[1])
# Check that queue is updated, since no `get_next()` call was performed:
assert tuple(qp.packet for qp in queue.as_tuple()) == tuple(packets[0:2])
sim.schedule.assert_not_called()
# Check that after `get_next()` request the message is passed:
sim.stime = t3
queue.get_next(service=service)
assert tuple(qp.packet for qp in queue.as_tuple()) == (packets[1], )
sim.schedule.assert_called_once_with(0,
service.handle_message,
args=(packets[0], ),
kwargs={
'connection': service_rev_conn,
'sender': queue,
})
sim.stime = t4
queue.push(packets[2])
assert tuple(qp.packet for qp in queue.as_tuple()) == tuple(packets[1:3])
# Also make sure that size updates were written:
assert queue.size_trace.as_tuple() == (
(t0, 0),
(t1, 1),
(t2, 2),
(t3, 1),
(t4, 2),
)
assert queue.bitsize_trace.as_tuple() == (
(t0, 0),
(t1, size[0]),
(t2, size[0] + size[1]),
(t3, size[1]),
(t4, size[1] + size[2]),
)
assert queue.num_dropped == 0
def test_queue_with_several_services_finds_right_connections():
sim, blue, red, green = Mock(), Mock(), Mock(), Mock()
sim.stime = 0
blue_rev_conn = Mock()
blue.connections.set = Mock(return_value=blue_rev_conn)
red_rev_conn = Mock()
red.connections.set = Mock(return_value=red_rev_conn)
green_rev_conn = Mock()
green.connections.set = Mock(return_value=green_rev_conn)
queue = Queue(sim=sim)
queue.connections.set('blue', blue, rname='queue')
queue.connections.set('red', red, rname='queue')
queue.connections.set('green', green, rname='queue')
# First, we fill the queue:
pkt_1 = NetworkPacket(data=AppData(size=100))
pkt_2 = NetworkPacket(data=AppData(size=200))
pkt_3 = NetworkPacket(data=AppData(size=300))
# Now, while queue is empty, two services request data:
sim.stime = 0.5
queue.get_next(green)
sim.stime = 1.0
queue.get_next(blue)
# At some moment, a packet arrives. It should be passed to the module that
# first requested the packet:
sim.stime = 2
queue.push(pkt_1)
sim.schedule.assert_called_once_with(0,
green.handle_message,
args=(pkt_1, ),
kwargs={
'connection': green_rev_conn,
'sender': queue,
})
assert queue.as_tuple() == ()
sim.schedule.reset_mock()
# At the next moment, another packet arrives and is being passed to the
# module that requested data after the first one:
sim.stime = 5
queue.push(pkt_2)
sim.schedule.assert_called_once_with(0,
blue.handle_message,
args=(pkt_2, ),
kwargs={
'connection': blue_rev_conn,
'sender': queue,
})
assert queue.as_tuple() == ()
sim.schedule.reset_mock()
# Now another packet arrives, and it should be stored since both requests
# were fulfilled previously:
sim.stime = 10
queue.push(pkt_3)
assert tuple(qp.packet for qp in queue.as_tuple()) == (pkt_3, )
sim.schedule.assert_not_called()
# Finally, the another module requests a packet, and it is immediately
# delivered to it:
sim.stime = 19
queue.get_next(red)
sim.schedule.assert_called_once_with(0,
red.handle_message,
args=(pkt_3, ),
kwargs={
'connection': red_rev_conn,
'sender': queue,
})