def test_send_back_from_non_peer(self):
"""Test send back from non peer"""
message = Message('ucla', 1)
self.sri.add_link(Link(self.ucla, 1))
self.utah.add_link(Link(self.sri, 1))
message.send(self.utah)
assert message.location().name == 'ucla', message.location
def setUp(self):
self.ucla = Node('ucla')
self.sri = Node('sri')
self.ucla.add_link(Link(self.sri, 1))
self.utah = Node('utah')
self.sri.add_link(Link(self.utah, 1))
def test_send_with_two_routes(self):
"""Test send with two routes"""
ucsb = Node('ucsb')
self.ucla.add_link(Link(ucsb, 1))
ucsb.add_link(Link(self.sri, 1))
message = Message('utah', 1)
message.send(self.ucla)
assert message.location().name == 'utah', message.location
def test_send_by_least_busy_route(self):
"""Test send by least busy route"""
ucsb = Node('ucsb')
self.ucla.add_link(Link(ucsb, 1))
ucsb.add_link(Link(self.sri, 1))
self.ucla.links['sri'].weight = 10
message = Message('utah', 1)
message.send(self.ucla)
assert message.route_nodes == [self.utah, self.sri, ucsb, self.ucla]
def test_create_network(self):
"""Test create network"""
assert self.ucla.__str__() == 'ucla-->[]', self.ucla.__str__()
self.ucla.add_link(Link(self.sri, 0))
assert self.ucla.links['sri'].dest.name == 'sri'
assert self.ucla.__str__() == "ucla-->['sri']", self.ucla.__str__()
def test_link_to_rl_buffer(self):
"""
Links can indicate whether messages sent via them should be
added to the right to left or the left to right buffer.
"""
message = Message('sri', 1)
self.sri.add_message = MagicMock()
self.ucla.add_link(Link(self.sri, 0, True))
self.ucla.add_message(message)
for _ in range(self.ucla.buffer_length):
self.ucla.process()
self.sri.add_message.assert_called_with(message, 1)
def __init__(self, network, transmitter=None):
self.nodes = {}
self.transmitter = transmitter
if self.transmitter is None:
display = None
else:
display = Wireless(self.transmitter)
for node in network:
if not node['from'] in self.nodes:
from_node = Node(node['from'], display)
self.nodes[from_node.name] = from_node
else:
from_node = self.nodes[node['from']]
if not node['to'] in self.nodes:
to_node = Node(node['to'], display)
self.nodes[to_node.name] = to_node
else:
to_node = self.nodes[node['to']]
self.nodes[node['from']].add_link(
Link(to_node, node['weight'], node['r2l']))
if node['bidirectional']:
self.nodes[node['to']].add_link(
Link(from_node, node['weight'], not node['r2l']))
def test_message_gets_sent_when_leaves_buffer(self):
"""
When a message gets to the end of the buffer it should be sent to the
next node on its route
Unless this is the last node on the route...
"""
self.ucla.add_link(Link(self.sri, 0))
message = Message('sri', 1)
message.route(self.ucla)
self.sri.add_message = MagicMock()
self.ucla.add_message(message)
for _ in range(self.ucla.buffer_length):
self.ucla.process()
assert self.sri.add_message.call_count == 1
assert self.ucla.buffer_contents(0) == [None, None, None
], self.ucla.buffer_contents(0)
def test_dont_go_round_in_circles(self):
"""
If there is a route back to the origin, check we don't end up going round in circles
"""
NODES = ['ucla', 'ucsb', 'sri', 'utah']
LINKS = [('ucla', 'sri', 1), ('ucla', 'ucsb', 1), ('ucsb', 'sri', 1),
('sri', 'utah', 1), ('utah', 'sri', 1), ('sri', 'ucsb', 1),
('sri', 'ucla', 1), ('ucsb', 'ucla', 1)]
network = {}
for node in NODES:
network[node] = Node(node)
for link in LINKS:
network[link[0]].add_link(Link(network[link[1]], link[2]))
message = Message('utah', 1)
message.route(network['ucla'])
assert message.route_nodes[0] == network['utah']