def setUpClass(self):
self.maxDiff = None
self.node_a = Node(name='nodeA', lat=0, lon=0)
self.node_b = Node(name='nodeB', lat=0, lon=0)
self.interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=self.node_a,
remote_node_object=self.node_b,
circuit_id=1)
self.interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=self.node_b,
remote_node_object=self.node_a,
circuit_id=1)
self.rsvp_lsp_a = RSVP_LSP(source_node_object=self.node_a,
dest_node_object=self.node_b,
lsp_name='A-to-B')
self.model = PerformanceModel(
interface_objects=set([self.interface_a, self.interface_b]),
node_objects=set([self.node_a, self.node_b]),
demand_objects=set([]),
rsvp_lsp_objects=set([self.rsvp_lsp_a]))
self.demand = Demand(source_node_object=self.node_a,
dest_node_object=self.node_b,
traffic=10,
name='A-to-B')
def test_unroutable_demand(self):
node_a = Node(name='nodeA', lat=0, lon=0)
node_b = Node(name='nodeB', lat=0, lon=0)
node_d = Node(name='nodeD')
interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=node_a,
remote_node_object=node_b,
circuit_id=1)
interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=node_b,
remote_node_object=node_a,
circuit_id=1)
dmd_a_d = Demand(node_a, node_d, traffic=10)
model = PerformanceModel(interface_objects=set(
[interface_a, interface_b]),
node_objects=set([node_a, node_b, node_d]),
demand_objects=set([dmd_a_d]),
rsvp_lsp_objects=set([]))
model.update_simulation()
self.assertEqual(dmd_a_d.path, 'Unrouted')
def setUpClass(self):
self.maxDiff = None
self.node_a = Node(name='nodeA', lat=0, lon=0)
self.node_b = Node(name='nodeB', lat=0, lon=0)
self.interface_a = Interface(name='inerfaceA-to-B', cost=4, capacity=100,
node_object=self.node_a, remote_node_object=self.node_b, circuit_id=1)
self.interface_b = Interface(name='inerfaceB-to-A', cost=4, capacity=100,
node_object=self.node_b, remote_node_object=self.node_a, circuit_id=1)
def setUpClass(self):
self.maxDiff = None
self.node_a = Node(name='nodeA', lat=0, lon=0)
self.node_b = Node(name='nodeB', lat=0, lon=0)
self.interface_a = Interface(name='inerfaceA-to-B', cost=4, capacity=100,
node_object=self.node_a, remote_node_object=self.node_b, circuit_id=1)
self.interface_b = Interface(name='inerfaceB-to-A', cost=4, capacity=100,
node_object=self.node_b, remote_node_object=self.node_a, circuit_id=1)
self.model = Model(interface_objects=set([self.interface_a, self.interface_b]),
node_objects=set([self.node_a, self.node_b]),
demand_objects=set([]), rsvp_lsp_objects=set([]))
def test_duplicate_int_near_side(self):
model = FlexModel.load_model_file('test/parallel_link_model_test_topology.csv')
model.update_simulation()
node_a_2 = Node('A')
node_b_2 = Node('B')
err_msg = 'already exists in model'
with self.assertRaises(ModelException) as context:
model.add_circuit(node_a_2, node_b_2, 'A-to-B', 'B-to-A', 40, 40, circuit_id=100)
self.assertIn(err_msg, context.exception.args[0])
def test_duplicate_int_remote_side(self):
model = PerformanceModel.load_model_file("test/igp_routing_topology.csv")
model.update_simulation()
node_d_2 = Node("D")
node_b_2 = Node("B")
err_msg = "already exists in model"
with self.assertRaises(ModelException) as context:
model.add_circuit(node_d_2, node_b_2, "D-to-B", "B-to-A", 40, 40, 100)
self.assertIn(err_msg, context.exception.args[0])
def test_not_equal(self):
model = PerformanceModel.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
int_a_b = model.get_interface_object('A-to-B', 'A')
circuit_id = int_a_b.circuit_id
node_a_prime = Node('A')
node_b_prime = Node('B')
int_a_b_prime = Interface('A-to-B', 20, 125, node_a_prime, node_b_prime, circuit_id)
self.assertFalse(int_a_b == int_a_b_prime)
def test_not_equal(self):
model = Model.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
int_a_b = model.get_interface_object('A-to-B', 'A')
address = int_a_b.address
node_a_prime = Node('A')
node_b_prime = Node('B')
int_a_b_prime = Interface('A-to-B', 20, 125, node_a_prime,
node_b_prime, address)
self.assertFalse(int_a_b == int_a_b_prime)
def test_duplicate_int_near_side(self):
model = FlexModel.load_model_file(
"test/parallel_link_model_test_topology.csv")
model.update_simulation()
node_a_2 = Node("A")
node_b_2 = Node("B")
err_msg = "already exists in model"
with self.assertRaises(ModelException) as context:
model.add_circuit(node_a_2,
node_b_2,
"A-to-B",
"B-to-A",
40,
40,
circuit_id=100)
self.assertIn(err_msg, context.exception.args[0])
def test_add_node(self):
model = FlexModel.load_model_file('test/parallel_link_model_test_topology.csv')
model.update_simulation()
node_z = Node('Z')
model.add_node(node_z)
model.update_simulation()
self.assertIn(node_z, model.node_objects)
def test_add_node(self):
model = PerformanceModel.load_model_file("test/igp_routing_topology.csv")
model.update_simulation()
node_z = Node("Z")
model.add_node(node_z)
model.update_simulation()
self.assertIn(node_z, model.node_objects)
def test_add_node(self):
model = Model.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
node_z = Node('Z')
model.add_node(node_z)
model.update_simulation()
self.assertIn(node_z, model.node_objects)
def test_node_orphan(self):
model = PerformanceModel.load_model_file("test/igp_routing_topology.csv")
model.update_simulation()
zz = Node("ZZ")
model.add_node(zz)
model.update_simulation()
node_a = model.get_node_object("A")
self.assertTrue(model.is_node_an_orphan(zz))
self.assertFalse(model.is_node_an_orphan(node_a))
def test_node_orphan(self):
model = Model.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
zz = Node('ZZ')
model.add_node(zz)
model.update_simulation()
node_a = model.get_node_object('A')
self.assertTrue(model.is_node_an_orphan(zz))
self.assertFalse(model.is_node_an_orphan(node_a))
def test_add_duplicate_node(self):
model = Model.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
node_a = Node('A')
err_msg = 'A node with name A already exists in the model'
with self.assertRaises(ModelException) as context:
model.add_node(node_a)
self.assertTrue(err_msg in context.exception.args[0])
def test_add_duplicate_node(self):
model = FlexModel.load_model_file(
"test/parallel_link_model_test_topology.csv")
model.update_simulation()
node_a = Node("A")
err_msg = "A node with name A already exists in the model"
with self.assertRaises(ModelException) as context:
model.add_node(node_a)
self.assertTrue(err_msg in context.exception.args[0])
def test_node_orphan(self):
model = Parallel_Link_Model.load_model_file(
'test/parallel_link_model_test_topology.csv')
model.update_simulation()
zz = Node('ZZ')
model.add_node(zz)
model.update_simulation()
node_a = model.get_node_object('A')
self.assertTrue(model.is_node_an_orphan(zz))
self.assertFalse(model.is_node_an_orphan(node_a))
def test_node_orphan(self):
model = FlexModel.load_model_file(
"test/parallel_link_model_test_topology.csv")
model.update_simulation()
zz = Node("ZZ")
model.add_node(zz)
model.update_simulation()
node_a = model.get_node_object("A")
self.assertTrue(model.is_node_an_orphan(zz))
self.assertFalse(model.is_node_an_orphan(node_a))
def test_demand_on_lsp(self):
"""
Ensure the demand takes an available LSP
:return:
"""
node_a = Node(name='nodeA', lat=0, lon=0)
node_b = Node(name='nodeB', lat=0, lon=0)
node_d = Node(name='nodeD')
interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=node_a,
remote_node_object=node_b,
address=1)
interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=node_b,
remote_node_object=node_a,
address=1)
dmd_a_b = Demand(node_a, node_b, traffic=10)
lsp_a_b = RSVP_LSP(source_node_object=node_a,
dest_node_object=node_b,
lsp_name='lsp_a_b')
model = Model(interface_objects=set([interface_a, interface_b]),
node_objects=set([node_a, node_b, node_d]),
demand_objects=set([dmd_a_b]),
rsvp_lsp_objects=set([lsp_a_b]))
model.update_simulation()
self.assertEqual(
str(dmd_a_b.path),
"[RSVP_LSP(source = nodeA, dest = nodeB, lsp_name = 'lsp_a_b')]")
def test_ckt_add(self):
model = PerformanceModel.load_model_file("test/igp_routing_topology.csv")
model.update_simulation()
node_zz = Node("ZZ")
model.add_node(node_zz)
model.update_simulation()
node_a = model.get_node_object("A")
model.add_circuit(node_a, node_zz, "A-to-ZZ", "ZZ-to-A", 20, 20, 1000)
model.update_simulation()
ckt = model.get_circuit_object_from_interface("ZZ-to-A", "ZZ")
self.assertTrue(isinstance(ckt, Circuit))
def test_ckt_add(self):
model = FlexModel.load_model_file(
"test/parallel_link_model_test_topology.csv")
model.update_simulation()
node_zz = Node("ZZ")
model.add_node(node_zz)
model.update_simulation()
node_a = model.get_node_object("A")
model.add_circuit(node_a,
node_zz,
"A-to-ZZ",
"ZZ-to-A",
20,
20,
1000,
circuit_id=90)
model.update_simulation()
ckt = model.get_circuit_object_from_interface("ZZ-to-A", "ZZ")
self.assertTrue(isinstance(ckt, Circuit))
# Fail interface on node A, interface A-to-B
print('Failing interface A-to-B on node A')
int_to_fail = model1.get_interface_object('A-to-B', 'A')
int_to_fail.fail_interface(model1)
# Calculate new traffic on interfaces and display
# the new traffic after the failure
print('Here is the traffic after the failure:')
model1.update_simulation()
model1.display_interfaces_traffic()
print()
# Add a node to the model
print("Adding Node('Z') to model")
new_node = Node('Z')
model1.add_node(new_node)
new_node.lat = 40
new_node.lon = 50
print()
# Display all the nodes without interfaces
print("Here are the nodes without any interfaces:",
model1.get_orphan_node_objects())
print()
# Add a circuit from new_node to node A
print("Add a circuit between Node('A') and Node('Z')")
model1.add_circuit(Node('A'), Node('Z'), 'a-to-z', 'z-to-a')
print()
# Fail interface on node A, interface A-to-B
print('Failing interface A-to-B on node A')
int_to_fail = model1.get_interface_object('A-to-B', 'A')
int_to_fail.fail_interface(model1)
# Calculate new traffic on interfaces and display
# the new traffic after the failure
print('Here is the traffic after the failure:')
model1.update_simulation()
model1.display_interfaces_traffic()
print()
# Add a node to the model
print("Adding Node('G') to model")
new_node = Node('G')
model1.add_node(new_node)
print()
# Display all the nodes without interfaces
print("Here are the nodes without any interfaces:",
model1.get_orphan_node_objects())
print()
# Add a circuit from new_node to node A
print("Add a circuit between Node('A') and Node('G')")
model1.add_circuit(Node('A'), Node('G'), 'a-to-g', 'g-to-a')
print()
# Add traffic to the model
class TestNode(unittest.TestCase):
@classmethod
def setUpClass(self):
self.maxDiff = None
self.node_a = Node(name='nodeA', lat=0, lon=0)
self.node_b = Node(name='nodeB', lat=0, lon=0)
self.interface_a = Interface(name='inerfaceA-to-B',
cost=4,
capacity=100,
node_object=self.node_a,
remote_node_object=self.node_b,
address=1)
self.interface_b = Interface(name='inerfaceB-to-A',
cost=4,
capacity=100,
node_object=self.node_b,
remote_node_object=self.node_a,
address=1)
self.model = Model(interface_objects=set(
[self.interface_a, self.interface_b]),
node_objects=set([self.node_a, self.node_b]),
demand_objects=set([]),
rsvp_lsp_objects=set([]))
def test_eq(self):
if self.node_a == self.node_a:
self.assertTrue(True)
def test_repr(self):
self.assertEqual(repr(self.node_a), "Node('nodeA')")
def test_key(self):
self.assertEqual(self.node_a._key(), "nodeA")
def test_lat_error(self):
with self.assertRaises(ValueError):
Node(name='nodeC', lat='twelve', lon=0)
def test_lon_error(self):
with self.assertRaises(ValueError):
Node(name='nodeC', lat=0, lon='the number two')
def test_lat_error_2(self):
with self.assertRaises(ValueError):
self.node_a.lat = 'twelve'
def test_lon_error_2(self):
with self.assertRaises(ValueError):
self.node_a.lon = 'twelve'
def test_set_failed(self):
self.node_a.failed = True
self.assertEqual(True, self.node_a.failed)
def test_set_failed_error(self):
with self.assertRaises(ModelException):
self.node_a.failed = 100
def test_interfaces(self):
iface_list = self.node_a.interfaces(self.model)
self.assertEqual([self.interface_a], iface_list)
def test_adjacent_nodes(self):
node_list = self.node_a.adjacent_nodes(self.model)
self.assertEqual({self.node_b}, node_list)
def test_fail_node(self):
model = Model.load_model_file('test/igp_routing_topology.csv')
model.update_simulation()
model.fail_node('A')
model.update_simulation()
node_a = model.get_node_object('A')
self.assertTrue(node_a.failed)
