def test_node_type(self):
"""
Test node type
:return: None
"""
node = Node('1', '2', 'Leaf1', role='leaf')
self.assertEqual(node.get_type(), 'node')
def test_pod_invalid_parent(self):
"""
Tests that the parent class of the pod
:return:
"""
session = self.login_to_apic()
parent = Node('1', '101', 'Switch')
self.assertRaises(TypeError, Pod.get, session, parent)
def test_invalid_session_populate_children(self):
"""
Test node invalid populate_children
:return: None
"""
pod1 = Pod('1')
node = Node('1', '2', 'Spine1', 'spine', pod1)
self.assertRaises(TypeError, node.populate_children)
def test_node_role(self):
"""
Test node role
:return: None
"""
node_name = 'Leaf1'
node_pod = '1'
node_node = '3'
node_role = 'leaf'
node = Node(node_pod, node_node, node_name, role=node_role)
self.assertEqual(node.role, node_role)
node_role = 'controller'
node = Node(node_pod, node_node, node_name, role=node_role)
self.assertEqual(node.role, node_role)
node_role = 'bogus'
self.assertRaises(ValueError, Node, node_pod, node_node, node_name,
node_role)
def test_get_endpoint_objects(self):
pod_id = '1'
node1_id = '2'
node2_id = '3'
slot1_id = '4'
slot2_id = '5'
port1_id = '6'
port2_id = '7'
link_id = '101'
pod = Pod(pod_id)
node1 = Node(pod_id, node1_id, 'Spine', 'spine', pod)
node2 = Node(pod_id, node2_id, 'Leaf', 'leaf', pod)
linecard1 = Linecard(slot1_id, node1)
linecard2 = Linecard(slot2_id, node2)
interface1 = Interface(interface_type='eth',
pod=pod_id,
node=node1_id,
module=slot1_id,
port=port1_id,
parent=linecard1)
interface2 = Interface(interface_type='eth',
pod=pod_id,
node=node2_id,
module=slot2_id,
port=port2_id,
parent=linecard2)
link1 = Link(pod)
link1.pod = pod_id
link1.link = link_id
link1.node1 = node1_id
link1.slot1 = slot1_id
link1.port1 = port1_id
link1.node2 = node2_id
link1.slot2 = slot2_id
link1.port2 = port2_id
self.assertEqual(node1, link1.get_node1())
self.assertEqual(node2, link1.get_node2())
self.assertEqual(linecard1, link1.get_slot1())
self.assertEqual(linecard2, link1.get_slot2())
self.assertEqual(interface1, link1.get_port1())
self.assertEqual(interface2, link1.get_port2())
def test_node_parent(self):
"""
Test node parent
:return: None
"""
pod_id = '1'
pod1 = Pod(pod_id)
node = Node('1', '2', 'Spine1', role='leaf', parent=pod1)
self.assertEqual(pod1, node.get_parent())
def test_node_id(self):
"""
Test node id
:return: None
"""
node = Node('1', '2', 'Leaf1', role='leaf')
self.assertEqual(node.get_pod(), '1')
self.assertEqual(node.get_node(), '2')
self.assertEqual(node.get_name(), 'Leaf1')
def test_node_get_fabric_state(self):
"""
Test node get fabric state
:return: None
"""
node_name = 'Leaf1'
node_pod = '1'
node_node = '3'
node_role = 'leaf'
node1 = Node(node_pod, node_node, node_name, node_role)
def test_node_model(self):
"""
Test node model
:return: None
"""
node = Node('1', '2', 'Leaf1', role='leaf')
self.assertEqual(node.get_chassis_type(), None)
node.model = 'N9K-C9396PX'
self.assertEqual(node.model, 'N9K-C9396PX')
self.assertEqual(node.get_chassis_type(), 'n9k')
def test_node_equal(self):
"""
Test node equal
:return: None
"""
node_name = 'Leaf1'
node_pod = '1'
node_node = '3'
node_role = 'leaf'
node1 = Node(node_pod, node_node, node_name, node_role)
node_name = 'Leaf2'
node2 = Node(node_pod, node_node, node_name, node_role)
self.assertNotEqual(node1, node2)
node_name = 'Leaf1'
node_pod = '2'
node2 = Node(node_pod, node_node, node_name, node_role)
self.assertNotEqual(node1, node2)
node_pod = '1'
node_node = '4'
node2 = Node(node_pod, node_node, node_name, node_role)
self.assertNotEqual(node1, node2)
node_node = '3'
node_role = 'controller'
node2 = Node(node_pod, node_node, node_name, node_role)
self.assertNotEqual(node1, node2)
node_role = 'leaf'
node2 = Node(node_pod, node_node, node_name, node_role)
self.assertEqual(node1, node2)
node2 = Pod(node_pod)
self.assertNotEqual(node1, node2)
def test_eNode_parent(self):
pod = Pod('1')
node = ExternalSwitch(parent=pod)
self.assertEqual(node.role, 'external_switch')
self.assertEqual(node._parent, pod)
children = pod.get_children()
self.assertEqual(len(children), 1)
for child in children:
self.assertEqual(child, node)
pod = Node('1', '101', 'Spine2', 'leaf')
self.assertRaises(TypeError, ExternalSwitch, pod)
def test_find(self):
pod_id = '1'
node1_id = '2'
node2_id = '3'
slot1_id = '4'
slot2_id = '5'
port2_id = '7'
pod = Pod(pod_id)
node1 = Node(pod_id, node1_id, 'Spine', 'spine', pod)
node2 = Node(pod_id, node2_id, 'Leaf', 'leaf', pod)
linecard1 = Linecard(slot1_id, node1)
linecard2 = Linecard(slot2_id, node2)
linecard1.serial = 'SerialNumber1'
linecard2.serial = 'SerialNumber2'
interface2 = Interface(interface_type='eth',
pod=pod_id,
node=node2_id,
module=slot2_id,
port=port2_id,
parent=linecard2)
so = Search()
so.node = node2_id
results = pod.find(so)
self.assertIn(node2, results)
self.assertIn(linecard2, results)
self.assertIn(interface2, results)
self.assertEqual(len(results), 3)
for result in results:
self.assertEqual(result.node, node2_id)
so = Search()
so.serial = 'SerialNumber1'
results = pod.find(so)
self.assertIn(linecard1, results)
self.assertEqual(len(results), 1)
self.assertEqual(results[0].serial, 'SerialNumber1')
def test_pod_equal(self):
"""
Test pods are equal
:return: None
"""
pod_id = '1'
pod1 = Pod(pod_id)
# check different IDs
pod_id = '2'
pod2 = Pod(pod_id)
self.assertNotEqual(pod1, pod2)
# check same
pod_id = '1'
pod2 = Pod(pod_id)
self.assertEqual(pod1, pod2)
# check different types
pod2 = Node(pod_id, '2', 'Leaf1', role='leaf')
self.assertNotEqual(pod1, pod2)
def check_mod_parent(self, mod_class):
"""
:param self:
:param mod_class:
"""
mod_pod = '1'
mod_node = '5'
mod_slot = '2'
node = Node(mod_pod, mod_node, 'Spine2', 'spine')
mod1 = mod_class(mod_pod, mod_node, mod_slot, node)
self.assertEqual(mod1.get_parent(), node)
self.assertEqual(node.get_children(), [mod1])
mod2 = mod_class(mod_pod, mod_node, mod_slot, node)
self.assertEqual(node.get_children(), [mod2])
mod_slot = '3'
mod3 = mod_class(mod_pod, mod_node, mod_slot, node)
self.assertEqual(node.get_children(), [mod2, mod3])
self.assertEqual(node.get_children(mod_class), [mod2, mod3])
# test illegal parent type
self.assertRaises(TypeError, mod_class, mod_pod, mod_node, mod_slot,
mod1)
def check_module(self, mod_class, mod_name_prefix, mod_type):
"""
:param self:
:param mod_class:
:param mod_name_prefix:
:param mod_type:
"""
mod_pod = '1'
mod_node = '5'
mod_slot = '2'
node = Node(mod_pod, mod_node, 'Spine2', 'leaf')
mod = mod_class(mod_pod, mod_node, mod_slot)
name = mod_name_prefix + '-' + '/'.join([mod_pod, mod_node, mod_slot])
self.assertNotEqual(mod, node)
self.assertEqual(mod.get_pod(), mod_pod)
self.assertEqual(mod.get_node(), mod_node)
self.assertEqual(mod.get_slot(), mod_slot)
self.assertEqual(mod.get_parent(), None)
self.assertEqual(mod.get_type(), mod_type)
self.assertEqual(mod.get_name(), name)
self.assertEqual(str(mod), name)
self.assertEqual(mod._session, None)
