def test_queue_accepts_packets_on_handle_message_call():
sim, producer = Mock(), Mock()
sim.stime = 0
queue = Queue(sim=sim)
conn = queue.connections.set('input', producer, reverse=False)
pkt = NetworkPacket(data=AppData(size=123))
queue.handle_message(pkt, sender=producer, connection=conn)
assert tuple(qp.packet for qp in queue.as_tuple()) == (pkt, )
def test_wired_interface_integration_serves_user_packet():
sim, user, peer = Mock(), Mock(), Mock()
sim.stime = 10
from pycsmaca.simulations.modules.queues import Queue
queue = Queue(sim)
transceiver = WiredTransceiver(sim, 1000, 22, 0.03, 0.05)
iface = WiredInterface(sim, 1, queue=queue, transceiver=transceiver)
user_conn = iface.connections.set('user', user, rname='iface')
wire_rev_conn = Mock()
peer.connections.set = Mock(return_value=wire_rev_conn)
wire_conn = iface.connections.set('wire', peer, rname='wire')
wire_conn.delay = 0.01
user_pkt = NetworkPacket(data=AppData(size=100))
transceiver_queue_conn = transceiver.connections['queue']
queue_iface_conn = iface.connections['_queue'].reverse
iface_transceiver_conn = iface.connections['_peer']
# First of all, we need to force transceiver start, since no actual
# simulation execution is performed:
transceiver.start()
# 1) Simulate like a new packet arrived from user, make sure that queue
# delivery was scheduled:
iface.handle_message(user_pkt, connection=user_conn, sender=user)
sim.schedule.assert_called_with(0,
queue.handle_message,
args=(user_pkt, ),
kwargs={
'connection': queue_iface_conn,
'sender': iface,
})
sim.schedule.reset_mock()
# 2) Force execution of queue packet delivery, make sure the packet arrives
# at the transceiver:
queue.handle_message(user_pkt, queue_iface_conn, iface)
sim.schedule.assert_called_with(0,
transceiver.handle_message,
args=(user_pkt, ),
kwargs={
'connection': transceiver_queue_conn,
'sender': queue,
})
sim.schedule.reset_mock()
# 3) Force packet handling at the transceiver and make sure it schedules
# packet delivery at its peer (iface itself):
transceiver.handle_message(user_pkt,
connection=transceiver_queue_conn,
sender=queue)
frame = transceiver.tx_frame
sim.schedule.assert_any_call(0,
iface.handle_message,
args=(frame, ),
kwargs={
'connection': iface_transceiver_conn,
'sender': transceiver,
})
assert frame.packet == user_pkt
sim.schedule.reset_mock()
# 4) Finally, force frame arrival at the interface and make sure it
# schedules frame reception at its peer after the channel delay:
iface.handle_message(frame, iface_transceiver_conn, transceiver)
sim.schedule.assert_called_with(wire_conn.delay,
peer.handle_message,
args=(frame, ),
kwargs={
'connection': wire_rev_conn,
'sender': iface,
})