def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.scheduler = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
self.peer_node_id, self.peer_port.id,
{}, self.scheduler)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
self.node_id, self.port.id, {},
self.scheduler)
self.port.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.set_queue(
queue.fanout_fifo.FanoutFIFO(
{
'queue_length': 4,
'direction': "out"
}, {}))
self.peer_port.attach_endpoint(self.tunnel_out)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.attach_endpoint(self.local_in)
self.peer_port.attach_endpoint(self.local_out)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.trigger_loop = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
self.peer_node_id, self.peer_port.id,
self.trigger_loop)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
self.node_id, self.port.id,
self.trigger_loop)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.attach_endpoint(self.tunnel_out)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.trigger_loop = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, self.trigger_loop)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, self.trigger_loop)
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.attach_endpoint(self.tunnel_out)
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.scheduler = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, {}, self.scheduler)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, {}, self.scheduler)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "out"}, {}))
self.peer_port.attach_endpoint(self.tunnel_out)
class TestLocalEndpoint(unittest.TestCase):
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
self.peer_port.set_queue(
queue.fanout_fifo.FanoutFIFO(
{
'queue_length': 4,
'direction': "out"
}, {}))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def test_is_connected(self):
assert self.local_in.is_connected
assert self.local_out.is_connected
def test_communicate(self):
self.peer_port.queue.write(0, None)
self.peer_port.queue.write(1, None)
for e in self.peer_port.endpoints:
e.communicate()
assert self.peer_port.tokens_available(4)
self.local_out.port.queue.write(2, None)
assert not self.peer_port.tokens_available(4)
assert self.peer_port.tokens_available(3)
assert self.port.tokens_available(2, self.port.id)
for e in self.peer_port.endpoints:
e.communicate()
assert self.port.tokens_available(3, self.port.id)
for i in range(3):
assert self.port.queue.peek(self.port.id) == i
assert self.port.tokens_available(0, self.port.id)
self.port.queue.commit(self.port.id)
assert self.port.tokens_available(0, self.port.id)
def test_get_peer(self):
assert self.local_in.get_peer() == ('local', self.peer_port.id)
assert self.local_out.get_peer() == ('local', self.port.id)
def test_attach_endpoint_to_inport(inport, outport):
inport.owner.did_connect = Mock()
first_outport = OutPort("out", actor())
first_endpoint = LocalInEndpoint(inport, first_outport)
first_endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
endpoint = LocalInEndpoint(inport, outport)
endpoint._fifo_mismatch_fix = Mock() # Skip fifo mismatch fixing
inport.set_queue(queue.fanout_fifo.FanoutFIFO({'queue_length': 4, 'direction': "in"}, {}))
inport.attach_endpoint(first_endpoint)
assert inport.is_connected_to(first_outport.id)
prev_endpoint = inport.attach_endpoint(endpoint)
assert prev_endpoint == None
assert inport.is_connected_to(outport.id)
assert inport.is_connected_to(first_outport.id)
assert inport.owner.did_connect.called
class TestLocalEndpoint(unittest.TestCase):
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.attach_endpoint(self.local_out)
self.port.attach_endpoint(self.local_in)
def test_is_connected(self):
assert self.local_in.is_connected
assert self.local_out.is_connected
def test_communicate(self):
self.peer_port.queue.write(0)
self.peer_port.queue.write(1)
for e in self.peer_port.endpoints:
e.communicate()
assert self.peer_port.tokens_available(4)
self.local_out.port.queue.write(2)
assert not self.peer_port.tokens_available(4)
assert self.peer_port.tokens_available(3)
assert self.port.tokens_available(2, self.port.id)
for e in self.peer_port.endpoints:
e.communicate()
assert self.port.tokens_available(3, self.port.id)
for i in range(3):
assert self.port.queue.peek(self.port.id) == i
assert self.port.tokens_available(0, self.port.id)
self.port.queue.commit()
assert self.port.tokens_available(0, self.port.id)
def test_get_peer(self):
assert self.local_in.get_peer() == ('local', self.peer_port.id)
assert self.local_out.get_peer() == ('local', self.port.id)
class TestTunnelEndpoint(unittest.TestCase):
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.trigger_loop = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel, self.peer_node_id, self.peer_port.id, self.trigger_loop)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel, self.node_id, self.port.id, self.trigger_loop)
self.port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.set_queue(queue.fanout_fifo.FanoutFIFO(5))
self.peer_port.attach_endpoint(self.tunnel_out)
def test_recv_token(self):
expected_reply = {
'cmd': 'TOKEN_REPLY',
'port_id': self.port.id,
'peer_port_id': self.peer_port.id,
'sequencenbr': 0,
'value': 'ACK'
}
payload = {
'port_id': self.port.id,
'peer_port_id': self.peer_port.id,
'sequencenbr': 0,
'token': {'type': 'Token', 'data': 5}
}
self.tunnel_in.recv_token(payload)
assert self.trigger_loop.called
assert self.port.queue.fifo[0].value == 5
self.tunnel.send.assert_called_with(expected_reply)
self.trigger_loop.reset_mock()
self.tunnel.send.reset_mock()
payload['sequencenbr'] = 100
self.tunnel_in.recv_token(payload)
assert not self.trigger_loop.called
expected_reply['sequencenbr'] = 100
expected_reply['value'] = 'NACK'
self.tunnel.send.assert_called_with(expected_reply)
self.trigger_loop.reset_mock()
self.tunnel.send.reset_mock()
payload['sequencenbr'] = 0
self.tunnel_in.recv_token(payload)
assert not self.trigger_loop.called
expected_reply['sequencenbr'] = 0
expected_reply['value'] = 'ACK'
self.tunnel.send.assert_called_with(expected_reply)
def test_get_peer(self):
assert self.tunnel_in.get_peer() == (self.peer_node_id, self.peer_port.id)
assert self.tunnel_out.get_peer() == (self.node_id, self.port.id)
def test_reply(self):
self.tunnel_out.port.queue.com_commit = Mock()
self.tunnel_out.port.queue.com_cancel = Mock()
self.tunnel.send = Mock()
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']
self.tunnel_out.reply(0, 'ACK')
self.tunnel_out.port.queue.com_commit.assert_called_with(self.port.id, nbr)
assert self.trigger_loop.called
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']
self.tunnel_out.reply(nbr, 'NACK')
assert self.tunnel_out.port.queue.com_cancel.called
def test_nack_reply(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
self.tunnel_out.port.queue.commit(self.port.id)
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.port.write_token(Token(3))
self.tunnel_out._send_one_token()
self.tunnel_out._send_one_token()
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 3
self.tunnel_out.reply(1, 'NACK')
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
def test_bulk_communicate(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.bulk = True
self.tunnel_out.communicate()
assert self.tunnel.send.call_count == 2
def test_communicate(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.bulk = False
assert self.tunnel_out.communicate() is True
assert self.tunnel.send.call_count == 1
assert self.tunnel_out.communicate() is False
self.tunnel_out.reply(1, 'ACK')
assert self.tunnel_out.communicate() is True
assert self.tunnel.send.call_count == 2
def outport():
return OutPort("outport", actor())
class TestTunnelEndpoint(unittest.TestCase):
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.tunnel = Mock()
self.scheduler = Mock()
self.node_id = 123
self.peer_node_id = 456
self.tunnel_in = TunnelInEndpoint(self.port, self.tunnel,
self.peer_node_id, self.peer_port.id,
{}, self.scheduler)
self.tunnel_out = TunnelOutEndpoint(self.peer_port, self.tunnel,
self.node_id, self.port.id, {},
self.scheduler)
self.port.set_queue(
queue.fanout_fifo.FanoutFIFO({
'queue_length': 4,
'direction': "in"
}, {}))
self.port.attach_endpoint(self.tunnel_in)
self.peer_port.set_queue(
queue.fanout_fifo.FanoutFIFO(
{
'queue_length': 4,
'direction': "out"
}, {}))
self.peer_port.attach_endpoint(self.tunnel_out)
def test_recv_token(self):
expected_reply = {
'cmd': 'TOKEN_REPLY',
'port_id': self.port.id,
'peer_port_id': self.peer_port.id,
'sequencenbr': 0,
'value': 'ACK'
}
payload = {
'port_id': self.port.id,
'peer_port_id': self.peer_port.id,
'sequencenbr': 0,
'token': {
'type': 'Token',
'data': 5
}
}
self.tunnel_in.recv_token(payload)
assert self.scheduler.tunnel_rx.called
assert self.port.queue.fifo[0].value == 5
self.tunnel.send.assert_called_with(expected_reply)
self.scheduler.reset_mock()
self.tunnel.send.reset_mock()
payload['sequencenbr'] = 100
self.tunnel_in.recv_token(payload)
assert not self.scheduler.tunnel_rx.called
expected_reply['sequencenbr'] = 100
expected_reply['value'] = 'NACK'
self.tunnel.send.assert_called_with(expected_reply)
self.scheduler.reset_mock()
self.tunnel.send.reset_mock()
payload['sequencenbr'] = 0
self.tunnel_in.recv_token(payload)
assert not self.scheduler.called
expected_reply['sequencenbr'] = 0
expected_reply['value'] = 'ACK'
self.tunnel.send.assert_called_with(expected_reply)
def test_get_peer(self):
assert self.tunnel_in.get_peer() == (self.peer_node_id,
self.peer_port.id)
assert self.tunnel_out.get_peer() == (self.node_id, self.port.id)
def test_reply(self):
self.tunnel_out.port.queue.com_commit = Mock()
self.tunnel_out.port.queue.com_cancel = Mock()
self.tunnel.send = Mock()
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']
self.tunnel_out.reply(0, 'ACK')
self.tunnel_out.port.queue.com_commit.assert_called_with(
self.port.id, nbr)
assert self.scheduler.tunnel_tx_ack.called
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
nbr = self.tunnel.send.call_args_list[-1][0][0]['sequencenbr']
self.tunnel_out.reply(nbr, 'NACK')
assert self.tunnel_out.port.queue.com_cancel.called
assert self.scheduler.tunnel_tx_nack.called
def test_nack_reply(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out._send_one_token()
self.tunnel_out.port.queue.commit(self.port.id)
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.port.write_token(Token(3))
self.tunnel_out._send_one_token()
self.tunnel_out._send_one_token()
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 3
self.tunnel_out.reply(1, 'NACK')
assert self.tunnel_out.port.queue.tentative_read_pos[self.port.id] == 1
assert self.tunnel_out.port.queue.read_pos[self.port.id] == 1
def test_bulk_communicate(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.bulk = True
self.tunnel_out.communicate()
assert self.tunnel.send.call_count == 2
def test_communicate(self):
self.tunnel_out.port.write_token(Token(1))
self.tunnel_out.port.write_token(Token(2))
self.tunnel_out.bulk = False
assert self.tunnel_out.communicate() is True
assert self.tunnel.send.call_count == 1
assert self.tunnel_out.communicate() is False
self.tunnel_out.reply(1, 'ACK')
assert self.tunnel_out.communicate() is True
assert self.tunnel.send.call_count == 2
class TestLocalEndpoint(unittest.TestCase):
def setUp(self):
self.port = InPort("port", Mock())
self.peer_port = OutPort("peer_port", Mock())
self.local_in = LocalInEndpoint(self.port, self.peer_port)
self.local_out = LocalOutEndpoint(self.peer_port, self.port)
self.port.attach_endpoint(self.local_in)
self.peer_port.attach_endpoint(self.local_out)
def test_is_connected(self):
assert self.local_in.is_connected
assert self.local_out.is_connected
def test_read_token_fixes_fifo_mismatch(self):
self.local_in.fifo_mismatch = True
token = self.local_in.read_token()
assert token is None
assert self.local_in.fifo_mismatch is False
def test_read_token_commits_if_token_is_not_none(self):
self.local_in.port.fifo.commit_reads = Mock()
self.local_out.port.fifo.commit_reads = Mock()
self.local_in.port.fifo.write(1)
assert self.local_in.data_in_local_fifo is True
assert self.local_in.read_token() == 1
assert self.local_in.data_in_local_fifo is True
self.local_in.port.fifo.commit_reads.assert_called_with(self.port.id, True)
self.local_out.port.fifo.write(2)
assert self.local_in.data_in_local_fifo is True
assert self.local_in.read_token() == 2
assert self.local_in.data_in_local_fifo is False
self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id, True)
def test_peek_token(self):
self.local_in.port.fifo.commit_reads = Mock()
self.local_out.port.fifo.commit_reads = Mock()
self.local_in.port.fifo.write(1)
assert self.local_in.peek_token() == 1
assert not self.local_in.port.fifo.commit_reads.called
assert self.local_in.peek_token() is None
self.local_in.peek_rewind()
self.local_in.commit_peek_as_read()
self.local_in.port.fifo.commit_reads.assert_called_with(self.port.id)
self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id)
self.local_in.port.fifo.commit_reads.reset_mock()
self.local_out.port.fifo.commit_reads.reset_mock()
self.local_out.port.fifo.write(2)
assert self.local_in.peek_token() == 2
assert not self.local_out.port.fifo.commit_reads.called
self.local_in.commit_peek_as_read()
assert not self.local_in.port.fifo.commit_reads.called
self.local_out.port.fifo.commit_reads.assert_called_with(self.port.id)
def test_available_tokens(self):
self.local_in.port.fifo.write(1)
self.local_in.port.fifo.write(1)
assert self.local_in.available_tokens() == 2
self.local_out.port.fifo.write(1)
assert self.local_in.available_tokens() == 3
def test_get_peer(self):
assert self.local_in.get_peer() == ('local', self.peer_port.id)
assert self.local_out.get_peer() == ('local', self.port.id)