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)
self.z.create()
def test_create_name_invalid(self):
i = self.vsan_id[2]
v = Vsan(self.switch, i)
v.create()
name = self.zone_name_invalid
z = Zone(self.switch, v, name)
with self.assertRaises(CLIError) as e:
z.create()
self.assertEqual(
"The command \" zone name " + str(name) + " vsan " + str(i) +
" \" gave the error \" Illegal character present in the name \".",
str(e.exception))
v.delete()
def test_create_name_invalidfirstchar(self):
i = self.vsan_id[3]
v = Vsan(self.switch, i)
v.create()
name = self.zone_name_invalidfirstchar
z = Zone(self.switch, v, name)
with self.assertRaises(CLIError) as e:
z.create()
self.assertEqual(
"The command \" zone name " + str(name) + " vsan " + str(i) +
" \" gave the error \" Illegal first character (name must start with a letter) \".",
str(e.exception))
v.delete()
def test_default_zone_write_invalid(self):
v = Vsan(self.switch, self.vsan_id[3])
v.create()
z = Zone(self.switch, v, self.zone_name[3])
z.create()
default_zone = 'asdf'
with self.assertRaises(CLIError) as e:
z.default_zone = default_zone
self.assertEqual(
'The command " No cmd sent " gave the error " Invalid default-zone value '
+ str(default_zone) + ' . Valid values are: permit,deny ".',
str(e.exception))
v.delete()
def test_create_name_beyondmax(self):
i = self.vsan_id[4]
v = Vsan(self.switch, i)
v.create()
name = self.zone_name_beyondmax
z = Zone(self.switch, v, name)
with self.assertRaises(CLIError) as e:
z.create()
self.maxDiff = 1000
self.assertEqual(
"The command \" zone name " + str(name) + " vsan " + str(i) +
" \" gave the error \" % String exceeded max length of (64) \".",
str(e.exception))
v.delete()
def test_remove_members_dict(self):
i = self.vsan_id[0]
v = Vsan(self.switch, i)
v.create()
z = Zone(self.switch, v, self.zone_name[0])
z.create()
self.switch.config('fcalias name somefcalias vsan '+str(i))
members = self.members_dict
z.add_members(members)
self.assertIsNotNone(z.members)
z.remove_members(members)
self.assertIsNone(z.members)
z.delete()
v.delete()
def test_activate_multiple(self):
v = Vsan(self.switch, self.vsan_id[2])
v.create()
zoneset = ZoneSet(self.switch, v, self.zoneset_name[2] )
zoneset.create()
zone = Zone(self.switch, v, self.zone_name[2])
zone.create()
zone.add_members(self.zone_members)
zoneset.add_members([zone])
zoneset.activate(True)
self.assertTrue(zoneset.is_active())
zoneset1 = ZoneSet(self.switch, v, self.zoneset_name[3] )
zoneset1.create()
zoneset1.add_members([zone])
zoneset1.activate(True)
self.assertTrue(zoneset1.is_active())
self.assertFalse(zoneset.is_active())
zone.delete()
zoneset.delete()
zoneset1.delete()
v.delete()
def test_fulldb_zoneset_count_read_nonexisting(self):
v = Vsan(self.switch, self.vsan_id[1])
v.create()
z = Zone(self.switch, v, self.zone_name[1])
print("Full DB Zoneset Count(nonexisting) : " +
str(z.fulldb_zoneset_count))
v.delete()
def test_activedb_zoneset_name_read_nonexisting(self):
v = Vsan(self.switch, self.vsan_id[1])
v.create()
z = Zone(self.switch, v, self.zone_name[1])
print("Active DB Zoneset Name(nonexisting) : " +
str(z.activedb_zoneset_name))
v.delete()
def test_effectivedb_size_percentage_read_nonexisting(self):
v = Vsan(self.switch, self.vsan_id[1])
v.create()
z = Zone(self.switch, v, self.zone_name[1])
print("Effective DB Size Percentage(nonexisting) : " +
str(z.effectivedb_size_percentage))
v.delete()
def test_add_members(self):
zone1 = Zone(self.switch, "test_zone1", self.id)
zone1.create()
zone2 = Zone(self.switch, "test_zone2", self.id)
zone2.create()
members = [zone1, zone2]
self.zoneset.add_members(members)
self.assertEqual([zone.name for zone in members],
list(self.zoneset.members.keys()))
def test_add_members(self):
v = Vsan(self.switch,self.vsan_id[1])
v.create()
z = Zone(self.switch, v, self.zone_name[1])
z.create()
members = self.members_list
z.add_members(members)
self.assertEqual(len(members),len(z.members))
print("Zone Members : "+str(z.members))
z.delete()
v.delete()
def test_add_members_nonexisting(self):
v = Vsan(self.switch, self.vsan_id[0])
v.create()
zonename = self.zone_name[0]
zone = Zone(self.switch, v, zonename)
zoneset = ZoneSet(self.switch, v, self.zoneset_name[0])
with self.assertRaises(ZoneNotPresent) as e:
zoneset.add_members([zone])
self.assertEqual("ZoneNotPresent: The given zoneset member '"+str(zonename)+"' is not present in the switch. Please create the zone first.",str(e.exception))
v.delete()
class TestZoneAttrActiveMembers(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)
self.z.create()
def test_active_members_read(self):
self.skipTest("not a correct test case Needs to be fixed")
zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
zoneset.create()
members = [{"fcid": "0x123456"}]
self.z.add_members(members)
zoneset.add_members([self.z])
zoneset.activate(True)
if zoneset.is_active():
self.assertEqual(members, self.z.active_members)
def test_active_members_read_nonexisting(self):
self.skipTest("not a correct test case Needs to be fixed")
# with self.assertRaises(CLIError) as e:
# self.z.active_members
# self.assertIn("Zone not present", str(e.exception))
def test_active_members_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.active_members = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestZoneSetRemoveMembers(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()
def test_remove_members_nonexisting(self):
self.assertEqual({}, self.zoneset.members)
with self.assertRaises(CLIError) as e:
self.zoneset.remove_members([self.zone])
self.assertEqual(
'The command " zoneset name test_zoneset vsan '
+ str(self.id)
+ ' ; no member test_zone " gave the error " Zone not present ".',
str(e.exception),
)
def test_remove_members(self):
zone1 = self.zone
zone2 = Zone(self.switch, "test_zone2", self.id)
zone2.create()
self.zoneset.add_members([zone1, zone2])
self.assertIsNotNone(self.zoneset.members)
self.zoneset.remove_members([zone1, zone2])
self.assertEqual({}, self.zoneset.members)
def tearDown(self) -> None:
self.v.delete()
def test_add_members_dict(self):
i = self.vsan_id[0]
v = Vsan(self.switch, i)
v.create()
z = Zone(self.switch, v, self.zone_name[0])
z.create()
members = self.members_dict
self.switch.config('fcalias name somefcalias vsan '+str(i))
z.add_members(members)
self.assertEqual(len(members),len(z.members))
print("Zone Members : "+str(z.members))
z.delete()
v.delete()
def test_add_members_error_fcid(self):
i = self.vsan_id[4]
v = Vsan(self.switch,i)
v.create()
name = self.zone_name[4]
z = Zone(self.switch, v, name)
z.create()
members = [{'fcid': '0x123'}]
with self.assertRaises(CLIError) as e:
z.add_members(members)
self.assertEqual('The command " zone name '+str(name)+' vsan '+str(i)+' ; member fcid 0x123 " gave the error " Invalid FCID ".',str(e.exception))
z.delete()
v.delete()
def test_add_members_error_fcalias(self):
i = self.vsan_id[6]
v = Vsan(self.switch,i)
v.create()
name = self.zone_name[6]
z = Zone(self.switch, v, name)
z.create()
members = [{'fcalias': 'somefcalias'}]
with self.assertRaises(CLIError) as e:
z.add_members(members)
self.assertEqual('The command " zone name '+str(name)+' vsan '+str(i)+' ; member fcalias somefcalias " gave the error " Alias not present ".',str(e.exception))
z.delete()
v.delete()
def test_add_members_error_pwwn(self):
i = self.vsan_id[2]
v = Vsan(self.switch,i)
v.create()
name = self.zone_name[2]
z = Zone(self.switch, v, name)
z.create()
members = [{'pwwn': '50:08:01:60:08:9f:4d:00:01'}]
with self.assertRaises(CLIError) as e:
z.add_members(members)
self.assertEqual('The command " zone name '+str(name)+' vsan '+str(i)+' ; member pwwn 50:08:01:60:08:9f:4d:00:01 " gave the error " % Invalid command ".',str(e.exception))
z.delete()
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 = 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 test_add_members_error_ip(self):
i = self.vsan_id[3]
v = Vsan(self.switch,i)
v.create()
name = self.zone_name[3]
z = Zone(self.switch, v, name)
z.create()
members = [{'ip-address': '1.1.1.1.1'}]
with self.assertRaises(CLIError) as e:
z.add_members(members)
self.assertEqual('The command " zone name '+str(name)+' vsan '+str(i)+' ; member ip-address 1.1.1.1.1 " gave the error " % Invalid ip address ".',str(e.exception))
z.delete()
v.delete()
def test_add_members_error_fwwn(self):
i = self.vsan_id[5]
v = Vsan(self.switch,i)
v.create()
name = self.zone_name[5]
z = Zone(self.switch, v, name)
z.create()
members = [{'fwwn': '11:12:13:14:15:16:17:18:19'}]
with self.assertRaises(CLIError) as e:
z.add_members(members)
self.assertEqual('The command " zone name '+str(name)+' vsan '+str(i)+' ; member fwwn 11:12:13:14:15:16:17:18:19 " gave the error " % Invalid command ".',str(e.exception))
z.delete()
v.delete()
class TestZoneAttrMode(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)
self.old = self.z.mode
def test_mode_read(self):
self.assertIn(self.z.mode, [BASIC, ENHANCED])
def test_mode_write(self):
self.z.create()
self.z.mode = BASIC
self.assertEqual(BASIC, self.z.mode)
self.z.mode = ENHANCED
self.assertEqual(ENHANCED, self.z.mode)
def test_mode_write_invalid(self):
mode = "asdf"
with self.assertRaises(InvalidZoneMode) as e:
self.z.mode = mode
self.assertEqual(
"InvalidZoneMode: Invalid zone mode " + str(mode) +
" . Valid values are: basic,enhanced",
str(e.exception),
)
def tearDown(self) -> None:
self.z.mode = self.old
self.v.delete()
class TestZoneAttrDefaultZone(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)
self.old = self.z.default_zone
def test_default_zone_read(self):
self.assertIn(self.z.default_zone, [PERMIT, DENY])
def test_default_zone_write(self):
self.z.default_zone = DENY
self.assertEqual(DENY, self.z.default_zone)
self.z.default_zone = PERMIT
self.assertEqual(PERMIT, self.z.default_zone)
def test_default_zone_write_invalid(self):
self.z.create()
default_zone = "asdf"
with self.assertRaises(InvalidDefaultZone) as e:
self.z.default_zone = default_zone
self.assertIn(
"Invalid default-zone value " + default_zone +
" . Valid values are: " + PERMIT + "," + DENY,
str(e.exception),
)
def tearDown(self) -> None:
self.z.default_zone = self.old
self.v.delete()
class TestZoneDelete(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_delete(self):
self.z.create()
self.assertEqual("test_zone", self.z.name)
self.z.delete()
with self.assertRaises(CLIError) as e:
self.z.name
self.assertIn("Zone not present", str(e.exception))
def test_delete_nonexisting(self):
with self.assertRaises(CLIError) as e:
self.z.delete()
self.assertIn("Zone not present", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
class TestZoneAttrSmartZone(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)
self.old = self.z.smart_zone
def test_smart_zone_read(self):
self.assertIn(self.z.smart_zone, [True, False])
def test_smart_zone_write(self):
self.z.create()
old = self.z.smart_zone
self.z.smart_zone = True
self.assertTrue(self.z.smart_zone)
self.z.smart_zone = False
self.assertFalse(self.z.smart_zone)
self.z.smart_zone = old
def test_smart_zone_write_invalid(self):
with self.assertRaises(ValueError) as e:
self.z.smart_zone = "asdf"
self.assertEqual("Smart zone value must be of typr bool, True/False",
str(e.exception))
def tearDown(self) -> None:
self.z.smart_zone = self.old
self.v.delete()
class TestZoneAttrActivedbZoneCount(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_activedb_zone_count_read(self):
self.z.create()
zoneset = ZoneSet(self.switch, "test_zoneset", self.id)
zoneset.create()
self.z.add_members([{"fcid": "0x123456"}])
zoneset.add_members([self.z])
zoneset.activate(True)
if zoneset.is_active():
self.assertIsNotNone(self.z.activedb_zone_count)
else:
self.assertIsNone(self.z.activedb_zone_count)
def test_activedb_zone_count_read_nonexisting(self):
self.assertIsNone(self.z.activedb_zone_count)
def test_activedb_zone_count_write_error(self):
with self.assertRaises(AttributeError) as e:
self.z.activedb_zone_count = "asdf"
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
self.v.delete()
def test_default_zone_write(self):
v = Vsan(self.switch, self.vsan_id[2])
v.create()
z = Zone(self.switch, v, self.zone_name[2])
z.create()
old = z.default_zone
z.default_zone = DENY
self.assertEqual(DENY, z.default_zone)
z.default_zone = PERMIT
self.assertEqual(PERMIT, z.default_zone)
z.default_zone = old
v.delete()
def test_mode_write(self):
v = Vsan(self.switch,self.vsan_id[2])
v.create()
z = Zone(self.switch, v, self.zone_name[2])
z.create()
old = z.mode
z.mode = BASIC
self.assertEqual(BASIC,z.mode)
z.mode = ENHANCED
self.assertEqual(ENHANCED,z.mode)
z.mode = old
v.delete()
def test_smart_zone_write(self):
v = Vsan(self.switch, self.vsan_id[2])
v.create()
z = Zone(self.switch, v, self.zone_name[2])
z.create()
old = z.smart_zone
z.smart_zone = True
self.assertEqual('enabled', z.smart_zone)
z.smart_zone = False
self.assertEqual('disabled', z.smart_zone)
z.smart_zone = old
v.delete()