class TestZoneAttrVsan(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.z = Zone(self.switch, "test_zone", self.id)
def test_vsan_read(self):
self.assertEqual(self.id, self.z.vsan.id)
def test_vsan_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.vsan = 5
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestVsanAttrInterfaces(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
def test_interfaces_read(self):
## reading interfaces in default vsan 1
self.assertIsNotNone(self.vsandb[1].interfaces)
def test_interfaces_read_nonexistingvsan(self):
self.assertIsNone(self.v.interfaces)
def test_interfaces_write_error(self):
with self.assertRaises(AttributeError) as e:
self.v.interfaces = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
if self.v.id is not None:
self.v.delete()
self.assertEqual(self.vsandb.keys(), self.switch.vsans.keys())
class TestZoneAttrName(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.z = Zone(self.switch, "test_zone", self.id)
def test_name_read(self):
self.z.create()
self.assertEqual("test_zone", self.z.name)
def test_name_read_nonexisting(self):
# TODO: Was working in 8.4.2a not in 8.4.2b (CSCvv59174)
# with self.assertRaises(CLIError) as c:
# self.z.name
# self.assertIn("Zone not present", str(c.exception))
self.assertIsNone(self.z.name)
def test_name_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.name = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestZoneSetDelete(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
def test_delete(self):
self.zoneset.create()
self.assertEqual("test_zoneset", self.zoneset.name)
self.zoneset.delete()
with self.assertRaises(CLIError) as e:
self.zoneset.name
self.assertIn("Zoneset not present", str(e.exception))
def test_delete_nonexisting(self):
with self.assertRaises(CLIError) as e:
self.zoneset.delete()
self.assertIn("Zoneset not present", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestSwitchAttrActiveZonesets(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = random.randint(2, 400)
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
def test_active_zonesets_read(self):
# self.skipTest("need to check")
zone = Zone(self.switch, "test_zone", self.id)
zone.create()
zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
zoneset.create()
zone.add_members([{"fcid": "0x123456"}])
zoneset.add_members([zone])
zoneset.activate(True)
active_zonesets = self.switch.active_zonesets
self.assertIn(self.v.id, list(active_zonesets.keys()))
def test_active_zonesets_write_error(self):
with self.assertRaises(AttributeError) as e:
self.switch.active_zonesets = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestZoneAttrFulldbZoneCount(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.z = Zone(self.switch, "test_zone", self.id)
def test_fulldb_zone_count_read(self):
self.z.create()
log.debug("Full DB Zone Count : " + str(self.z.fulldb_zone_count))
self.assertEqual(1, self.z.fulldb_zone_count)
def test_fulldb_zone_count_read_nonexisting(self):
log.debug("Full DB Zone Count(nonexisting) : " + str(self.z.fulldb_zone_count))
self.assertEqual(0, self.z.fulldb_zone_count)
def test_fulldb_zone_count_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.fulldb_zone_count = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestZoneAttrEffectivedbSize(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.z = Zone(self.switch, "test_zone", self.id)
def test_effectivedb_size_read(self):
self.z.create()
log.debug("Effective DB Size : " + str(self.z.effectivedb_size))
self.assertIsNotNone(self.z.effectivedb_size)
def test_effectivedb_size_read_nonexisting(self):
log.debug("Effective DB Size(nonexisting) : " +
str(self.z.effectivedb_size))
self.assertIsNotNone(self.z.effectivedb_size)
def test_effectivedb_size_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.effectivedb_size = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
def test_nonexistingvsan(self):
i = self.vsan_id[0]
v = Vsan(self.switch, i)
if v.id is not None:
v.delete()
with self.assertRaises(VsanNotPresent) as e:
z = ZoneSet(self.switch, v, self.zoneset_name[0])
self.assertEqual("VsanNotPresent: Vsan "+str(i)+" is not present on the switch.",str(e.exception))
def test_create_boundary(self):
for i in self.boundary_id:
v = Vsan(switch=self.switch, id=i)
with self.assertRaises(CLIError) as e:
v.create()
self.assertEqual(
'The command " vsan database ; vsan ' + str(i) +
' " gave the error " % Invalid command ".', str(e.exception))
def test_delete_reserved(self):
for i in self.reserved_id:
v = Vsan(switch=self.switch, id=i)
with self.assertRaises(CLIError) as e:
v.delete()
self.assertEqual(
'The command " terminal dont-ask ; vsan database ; no vsan ' +
str(i) + ' " gave the error " vsan ' + str(i) +
':vsan(s) reserved ".', str(e.exception))
def test_name_write_reserved(self):
for i in self.reserved_id:
v = Vsan(switch=self.switch, id=i)
with self.assertRaises(CLIError) as e:
v.name = 'vsan'
self.assertEqual(
'The command " vsan database ; vsan ' + str(i) +
' name \'vsan\' " gave the error " vsan ' + str(i) +
':vsan(s) reserved ".', str(e.exception))
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
def test_delete_default_vsan(self):
i = self.default_id
v = Vsan(switch=self.switch, id=i)
with self.assertRaises(CLIError) as e:
v.delete()
self.assertEqual(
'The command " terminal dont-ask ; vsan database ; no vsan ' +
str(i) + ' " gave the error " vsan ' + str(i) +
':cannot delete default vsan ".', str(e.exception))
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = random.randint(2, 400)
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
def test_nonexistingvsan(self):
i = self.vsan_id[0]
v = Vsan(self.switch, i)
if v.id is not None:
v.delete()
with self.assertRaises(VsanNotPresent) as e:
z = Zone(self.switch, v, "z1")
self.assertEqual(
"VsanNotPresent: Vsan " + str(i) +
" is not present on the switch. Please create the vsan first.",
str(e.exception))
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
class TestZoneSetActivate(unittest.TestCase):
def __init__(self, testName, sw):
super().__init__(testName)
self.switch = sw
def setUp(self) -> None:
log.debug(self.switch.version)
log.debug(self.switch.ipaddr)
self.vsandb = self.switch.vsans
while True:
self.id = get_random_id()
if self.id not in self.vsandb.keys():
break
self.v = Vsan(switch=self.switch, id=self.id)
self.v.create()
self.zone = Zone(self.switch, "test_zone", self.id)
self.zone.create()
self.zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
self.zoneset.create()
self.zone_members = members_dict
def test_activate(self):
self.zone.add_members(self.zone_members)
self.zoneset.add_members([self.zone])
self.zoneset.activate(True)
self.assertTrue(self.zoneset.is_active())
self.zoneset.activate(False)
self.assertFalse(self.zoneset.is_active())
def test_activate_zonehasnomembers(self):
self.zoneset.add_members([self.zone])
self.zoneset.activate(True) # not activated since zone has no members
self.assertFalse(self.zoneset.is_active())
def test_activate_multiple(self):
self.zone.add_members(self.zone_members)
self.zoneset.add_members([self.zone])
self.zoneset.activate(True)
self.assertTrue(self.zoneset.is_active())
zoneset1 = ZoneSet(self.switch, "test_zoneset_2", self.id)
zoneset1.create()
zoneset1.add_members([self.zone])
zoneset1.activate(True)
self.assertTrue(zoneset1.is_active())
self.assertFalse(self.zoneset.is_active())
def tearDown(self) -> None:
self.v.delete()
def test_name_write_repeated(self):
name = "test___repeated___name"
self.v.create(name)
while True:
i = get_random_id()
if i not in self.switch.vsans.keys():
break
v1 = Vsan(switch=self.switch, id=i)
with self.assertRaises(CLIError) as e:
v1.name = name
self.assertIn("vsan name is already in use", str(e.exception))
self.v.delete()
def test_addinterfaces_type_error(self):
v = Vsan(switch=self.switch, id=self.vsan_id[0])
v.create()
fc = Fc(switch=self.switch, name=self.fc_name[0])
with self.assertRaises(TypeError) as e:
v.add_interfaces(fc)
self.assertEqual("'Fc' object is not iterable", str(e.exception))
pc = PortChannel(self.switch, self.pc_id[0])
with self.assertRaises(TypeError) as e:
v.add_interfaces(pc)
self.assertEqual("'PortChannel' object is not iterable",
str(e.exception))
v.delete()
def test_addinterfaces_invalid(self):
v = Vsan(switch=self.switch, id=self.vsan_id[6])
v.create()
with self.assertRaises(AttributeError) as e:
v.add_interfaces("asdfg")
self.assertEqual("'str' object has no attribute 'name'",
str(e.exception))
v.delete()
def test_suspend_write(self):
v = Vsan(switch=self.switch, id=self.vsan_id[0])
v.create()
v.suspend = True
self.assertEqual("suspended", v.state)
v.suspend = False
self.assertEqual("active", v.state)
v.delete()
def test_addinterfaces_splitlist(self):
v = Vsan(switch=self.switch, id=self.vsan_id[3])
v.create()
fc1 = Fc(switch=self.switch, name=self.fc_name[2])
fc2 = Fc(switch=self.switch, name=self.fc_name[3])
pc = PortChannel(self.switch, self.pc_id[2])
pc.create()
v.add_interfaces([fc1])
v.add_interfaces([fc2])
v.add_interfaces([pc])
self.assertEqual(fc1.name, v.interfaces[0].name)
self.assertEqual(fc2.name, v.interfaces[1].name)
self.assertEqual(pc.name, v.interfaces[2].name)
pc.delete()
v.delete()
def test_add_members_samezone(self):
v = Vsan(self.switch, self.vsan_id[2])
v.create()
zone1 = Zone(self.switch, v, self.zone_name[3])
zone2 = Zone(self.switch, v, self.zone_name[4])
zone1.create()
zone2.create()
zoneset1 = ZoneSet(self.switch, v, self.zoneset_name[2])
zoneset2 = ZoneSet(self.switch, v, self.zoneset_name[3])
members = [zone1, zone2]
zoneset1.add_members(members)
zoneset2.add_members(members)
self.assertEqual([zone.name for zone in members],list(zoneset1.members.keys()))
self.assertEqual([zone.name for zone in members],list(zoneset2.members.keys()))
def test_create_success(self):
i = self.create_id
v = Vsan(switch=self.switch, id=i)
if v.id is not None:
v.delete()
self.assertIsNone(v.id)
v.create()
self.assertEqual(i, v.id)
v.delete()
def test_addinterfaces_repeated(self):
v = Vsan(switch=self.switch, id=self.vsan_id[8])
v.create()
fc1 = Fc(switch=self.switch, name=self.fc_name[7])
pc = PortChannel(self.switch, self.pc_id[5])
pc.create()
v.add_interfaces([fc1, fc1, fc1, fc1])
self.assertEqual(fc1.name, v.interfaces[0].name)
pc.delete()
v.delete()
def test_id_read_nonexistingvsan(self):
v = Vsan(switch=self.switch, id=self.vsan_id)
if v.id is not None:
v.delete()
for i in self.boundary_id:
v = Vsan(switch=self.switch, id=i)
self.assertIsNone(v.id)
for i in self.reserved_id:
v = Vsan(switch=self.switch, id=i)
self.assertEqual(i, v.id)
def test_id_write_error(self):
v = Vsan(switch=self.switch, id=self.vsan_id)
v.create()
with self.assertRaises(AttributeError) as e:
v.id = 4
self.assertEqual("can't set attribute", str(e.exception))
v.delete()
def test_suspend_write_nonexistingvsan(self):
v = Vsan(switch=self.switch, id=self.vsan_id[2])
if v.id is not None:
v.delete()
v.suspend = True
self.assertEqual("suspended", v.state)
v.delete()
def test_name_write_max32(self):
v = Vsan(switch=self.switch, id=self.vsan_id[3])
v.create()
name = self.max32_name
v.name = name
self.assertEqual(name, v.name)
v.delete()
def test_interfaces_read(self):
v = Vsan(switch=self.switch, id=self.vsan_id[0])
v.create()
fc = [
Fc(switch=self.switch, name=self.fc_name[0]),
Fc(switch=self.switch, name=self.fc_name[1])
]
v.add_interfaces(fc)
self.assertEqual(self.fc_name[0], v.interfaces[0].name)
self.assertEqual(self.fc_name[1], v.interfaces[1].name)
v.delete()
