class TestDeviceAliasAttrLocked(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.d = DeviceAlias(self.switch)
self.old = self.d.distribute
currdb = self.d.database
if currdb is None:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
else:
while True:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
if self.name not in currdb.keys(
) and self.pwwn not in currdb.values():
break
log.debug({self.name: self.pwwn})
def test_locked_values(self):
self.assertIn(self.d.locked, [True, False])
def test_locked_write_error(self):
with self.assertRaises(AttributeError) as e:
self.d.locked = True
self.assertEqual("can't set attribute", str(e.exception))
def test_acquire_lock(self):
# Verify that lock is not acquired first
self.assertFalse(self.d.locked)
# Verify that distribute is set
if not self.old:
self.d.distribute = True
self.assertTrue(self.d.distribute)
self.switch.config("device-alias database ; device-alias name " +
self.name + " pwwn " + self.pwwn)
self.assertTrue(self.d.locked)
self.d.clear_lock()
self.assertFalse(self.d.locked)
self.d.distribute = self.old
self.assertFalse(self.d.locked)
def tearDown(self) -> None:
self.d.distribute = self.old
self.assertEqual(self.d.distribute, self.old)
try:
self.d.delete(self.name)
newdb = self.d.database
if newdb is not None:
self.assertNotIn(self.name, newdb.keys())
self.assertNotIn(self.pwwn, newdb.values())
except CLIError as c:
if "Device Alias not present" not in c.message:
raise CLIError(c.args)
finally:
self.assertFalse(self.d.locked)
def test_create(self):
d = DeviceAlias(self.switch)
d.create(self.new)
self.assertEqual(self.new, d.database)
keys = list(self.new.keys())
for k in keys:
d.delete(k)
def test_delete(self):
d = DeviceAlias(self.switch)
d.create(self.new)
keys = list(self.new.keys())
d.delete(keys[0])
self.assertIsNone(d.database.get(keys[0]))
keys.remove(keys[0])
for k in keys:
d.delete(k)
def test_delete_emptydb(self):
d = DeviceAlias(self.switch)
d.clear_database()
with self.assertRaises(CLIError) as e:
d.delete(self.nonexisting)
self.assertEqual(
'The command " device-alias database ; no device-alias name ' +
str(self.nonexisting) +
' " gave the error " Device Alias not present\nPlease use \'show device-alias session rejected\' to display the rejected set of commands and for the device-alias best-practices recommendation. ".',
str(e.exception))
class TestDeviceAliasAttrDatabase(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.d = DeviceAlias(self.switch)
currdb = self.d.database
if currdb is None:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
else:
while True:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
if self.name not in currdb.keys() and self.pwwn not in currdb.values():
break
log.debug({self.name: self.pwwn})
def test_database_read(self):
log.debug("Starting test test_database_read")
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
self.d.delete(self.name)
newdb = self.d.database
if newdb is not None:
self.assertNotIn(self.name, newdb.keys())
self.assertNotIn(self.pwwn, newdb.values())
def test_database_write_error(self):
log.debug("Starting test test_database_write_error")
with self.assertRaises(AttributeError) as e:
self.d.database = {self.name: self.pwwn}
self.assertEqual("can't set attribute", str(e.exception))
def tearDown(self) -> None:
try:
self.d.delete(self.name)
newdb = self.d.database
if newdb is not None:
self.assertNotIn(self.name, newdb.keys())
self.assertNotIn(self.pwwn, newdb.values())
except CLIError as c:
if "Device Alias not present" not in c.message:
# raise CLIError(c.args)
raise CLIError(c.command, c.message)
def test_create_name_existing(self):
d = DeviceAlias(self.switch)
d.create(self.new_existingname)
name = list(self.existingname.keys())[0]
pwwn = list(self.existingname.values())[0]
with self.assertLogs(level='INFO') as l:
d.create(self.existingname)
self.assertEqual(
'INFO:mdssdk.devicealias:The command : device-alias database ; device-alias name '
+ str(name) + ' pwwn ' + str(pwwn) +
' ; was not executed because Device Alias already present',
l.output[0])
keys = list(self.new_existingname.keys())
for k in keys:
d.delete(k)
def test_remove_members_dict(self):
fc_name = ""
for k, v in list(self.switch.interfaces.items()):
if type(v) is Fc:
fc_name = k
break
while True:
pc_id = get_random_id(1, 256)
if "port-channel" + str(pc_id) not in self.switch.interfaces.keys():
break
pc = PortChannel(self.switch, pc_id)
d = DeviceAlias(self.switch)
olddb = d.database
if olddb is None:
da_name = get_random_string()
da_pwwn = get_random_pwwn()
else:
while True:
da_name = get_random_string()
da_pwwn = get_random_pwwn()
if da_name not in olddb.keys() and da_pwwn not in olddb.values():
break
d.create({da_name: da_pwwn})
members = [
{"pwwn": "50:08:01:60:08:9f:4d:00"},
{"interface": fc_name},
{"device-alias": da_name},
{"ip-address": "1.1.1.1"},
{"symbolic-nodename": "symbnodename"},
{"fwwn": "11:12:13:14:15:16:17:18"},
{"fcid": "0x123456"},
{"interface": pc.name},
{"fcalias": "somefcalias"},
]
self.switch.config("fcalias name somefcalias vsan " + str(self.id))
self.z.add_members(members)
mem = self.z.members
self.assertIsNotNone(self.z.members)
self.z.remove_members(members)
self.assertEqual([], self.z.members)
d.delete(da_name)
class TestDeviceAliasDelete(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.d = DeviceAlias(self.switch)
self.olddb = self.d.database
if self.olddb is None:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
else:
while True:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
if (
self.name not in self.olddb.keys()
and self.pwwn not in self.olddb.values()
):
break
log.debug({self.name: self.pwwn})
def test_delete(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
self.d.delete(self.name)
newdb = self.d.database
if newdb is not None:
self.assertNotIn(self.name, newdb.keys())
self.assertNotIn(self.pwwn, newdb.values())
def test_delete_nonexisting(self):
db = self.d.database
while True:
somename = get_random_string()
if db is None or somename not in db.keys():
break
with self.assertRaises(CLIError) as e:
self.d.delete(somename)
self.assertIn("Device Alias not present", str(e.exception))
def tearDown(self) -> None:
try:
self.d.delete(self.name)
except CLIError as c:
if "Device Alias not present" not in c.message:
self.fail("Tear down failed: " + c.message)
enddb = self.d.database
if enddb is not None:
self.assertEqual(enddb, self.olddb)
def test_delete_nonexisting(self):
d = DeviceAlias(self.switch)
d.create(self.new1)
keys = list(self.new1.keys())
d.delete(keys[0])
with self.assertRaises(CLIError) as e:
d.delete(keys[0])
self.assertEqual(
'The command " device-alias database ; no device-alias name ' +
str(keys[0]) +
' " gave the error " Device Alias not present\nPlease use \'show device-alias session rejected\' to display the rejected set of commands and for the device-alias best-practices recommendation. ".',
str(e.exception))
keys.remove(keys[0])
for k in keys:
d.delete(k)
from tests.test_zone.test_zoneattractivedbzonesetname import *
TestZoneAttrActivedbZonesetName.switch = sw
TestZoneAttrActivedbZonesetName.vsan_id = vsan_id
TestZoneAttrActivedbZonesetName.zone_name = zone_name
from tests.test_zone.test_zoneattrmaxdbsize import *
TestZoneAttrMaxdbSize.switch = sw
TestZoneAttrMaxdbSize.vsan_id = vsan_id
TestZoneAttrMaxdbSize.zone_name = zone_name
from tests.test_zone.test_zoneattreffectivedbsize import *
TestZoneAttrEffectivedbSize.switch = sw
TestZoneAttrEffectivedbSize.vsan_id = vsan_id
TestZoneAttrEffectivedbSize.zone_name = zone_name
from tests.test_zone.test_zoneattreffectivedbsizepercentage import *
TestZoneAttrEffectivedbSizePercentage.switch = sw
TestZoneAttrEffectivedbSizePercentage.vsan_id = vsan_id
TestZoneAttrEffectivedbSizePercentage.zone_name = zone_name
from tests.test_zone.test_zoneattrstatus import *
TestZoneAttrStatus.switch = sw
TestZoneAttrStatus.vsan_id = vsan_id
TestZoneAttrStatus.zone_name = zone_name
suite = unittest.TestLoader().discover('tests.test_zone', 'test_zone*.py')
unittest.TextTestRunner(verbosity=2).run(suite)
d.delete(da_name)
print(d.database)
print("Mode : " + d.mode)
print("Distribute : " + str(d.distribute))
print("Locked : " + str(d.locked))
old = d.database
d.clear_database()
# Adding new device alias
new = {
"device1": "21:00:00:0e:1e:30:34:a5",
"device2": "21:00:00:0e:1e:30:3c:c5"
}
d.create(new)
prnt("Clearing database\nDatabase after adding new entry")
print(d.database)
# Renaming the device alias
d.rename("device1", "device_new_name")
print("Database after renaming device alias device1 as device_new_name")
print(d.database)
# Deleting device alias
d.delete("device_new_name")
d.delete("device2")
# Recreating original database
d.create(old)
class TestDeviceAliasCreate(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.d = DeviceAlias(self.switch)
self.olddb = self.d.database
if self.olddb is None:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
else:
while True:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
if (
self.name not in self.olddb.keys()
and self.pwwn not in self.olddb.values()
):
break
log.debug({self.name: self.pwwn})
def test_create(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
self.d.delete(self.name)
newdb = self.d.database
if newdb is not None:
self.assertNotIn(self.name, newdb.keys())
self.assertNotIn(self.pwwn, newdb.values())
def test_create_name_invalid(self):
invalid_name = {
"da1&": get_random_pwwn()
} # da name a-zA-Z1-9 - _ $ ^ 64chars max
name = list(invalid_name.keys())[0]
pwwn = list(invalid_name.values())[0]
with self.assertRaises(CLIError) as e:
self.d.create(invalid_name)
self.assertEqual(
'The command " device-alias database ; device-alias name '
+ str(name)
+ " pwwn "
+ str(pwwn)
+ ' ; " gave the error " Illegal character present in the name ".',
str(e.exception),
)
self.d.clear_lock()
def test_create_name_invalidfirstchar(self):
invalidfirstchar = {"1da": "53:66:61:01:0e:00:01:ff"}
name = list(invalidfirstchar.keys())[0]
pwwn = list(invalidfirstchar.values())[0]
with self.assertRaises(CLIError) as e:
self.d.create(invalidfirstchar)
self.assertEqual(
'The command " device-alias database ; device-alias name '
+ str(name)
+ " pwwn "
+ str(pwwn)
+ ' ; " gave the error " Illegal first character. Name must start with a letter ".',
str(e.exception),
)
self.d.clear_lock()
def test_create_name_beyondmax(self):
beyondmax = {
"da123456789123456789123456789123456789123456789123456789123456789": get_random_pwwn()
}
name = list(beyondmax.keys())[0]
pwwn = list(beyondmax.values())[0]
with self.assertRaises(CLIError) as e:
self.d.create(beyondmax)
self.assertEqual(
'The command " device-alias database ; device-alias name '
+ str(name)
+ " pwwn "
+ str(pwwn)
+ ' ; " gave the error " % String exceeded max length of (64) ".',
str(e.exception),
)
def test_create_pwwn_existing(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
newname = get_random_string()
with self.assertRaises(CLIError) as e:
self.d.create({newname: self.pwwn})
self.assertIn(
"Another device-alias already present with the same pwwn", str(e.exception)
)
# DB should not be updated with the new name
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
self.d.delete(self.name)
def test_create_name_existing(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
newpwwn = get_random_pwwn()
with self.assertRaises(CLIError) as e:
self.d.create({self.name: newpwwn})
self.assertIn("Device Alias already present", str(e.exception))
# DB should not be updated with the new pwwn
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
self.d.delete(self.name)
def tearDown(self) -> None:
try:
self.d.delete(self.name)
except CLIError as c:
if "Device Alias not present" not in c.message:
self.fail("Tear down failed: " + c.message)
enddb = self.d.database
if enddb is not None:
self.assertEqual(enddb, self.olddb)
class TestDeviceAliasRename(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.d = DeviceAlias(self.switch)
self.olddb = self.d.database
if self.olddb is None:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
else:
while True:
self.name = get_random_string()
self.pwwn = get_random_pwwn()
if (
self.name not in self.olddb.keys()
and self.pwwn not in self.olddb.values()
):
break
log.debug({self.name: self.pwwn})
def test_rename(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
while True:
self.newname_to_replace = get_random_string()
if self.newname_to_replace not in newdb.keys():
break
self.d.rename(oldname=self.name, newname=self.newname_to_replace)
chkdb = self.d.database
self.assertIn(self.newname_to_replace, chkdb.keys())
self.assertEqual(self.pwwn, chkdb[self.newname_to_replace])
self.assertNotIn(self.name, chkdb.keys())
self.d.delete(self.newname_to_replace)
chkdb = self.d.database
if chkdb is not None:
self.assertNotIn(self.newname_to_replace, chkdb.keys())
self.assertNotIn(self.pwwn, chkdb.values())
self.assertNotIn(self.name, chkdb.keys())
def test_rename_not_present(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
while True:
self.newname_to_replace = get_random_string()
if self.newname_to_replace not in newdb.keys():
break
with self.assertRaises(CLIError) as e:
self.d.rename(oldname=self.newname_to_replace, newname=self.name)
self.assertIn("Device Alias not present", str(e.exception))
self.d.delete(self.name)
chkdb = self.d.database
if chkdb is not None:
self.assertNotIn(self.newname_to_replace, chkdb.keys())
self.assertNotIn(self.pwwn, chkdb.values())
self.assertNotIn(self.name, chkdb.keys())
def test_rename_already_present(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
with self.assertRaises(CLIError) as e:
self.d.rename(oldname=self.name, newname=self.name)
self.assertIn(
"Target device-alias name already in use. Please specify a new name.",
str(e.exception),
)
self.d.delete(self.name)
chkdb = self.d.database
if chkdb is not None:
self.assertNotIn(self.pwwn, chkdb.values())
self.assertNotIn(self.name, chkdb.keys())
def test_rename_invalid(self):
self.d.create({self.name: self.pwwn})
newdb = self.d.database
self.assertIn(self.name, newdb.keys())
self.assertEqual(self.pwwn, newdb[self.name])
invalid_name = "da1&" # da name a-zA-Z1-9 - _ $ ^ 64chars max
with self.assertRaises(CLIError) as e:
self.d.rename(oldname=self.name, newname=invalid_name)
self.assertIn("Illegal character present in the name", str(e.exception))
self.d.clear_lock()
self.d.delete(self.name)
chkdb = self.d.database
if chkdb is not None:
self.assertNotIn(self.pwwn, chkdb.values())
self.assertNotIn(self.name, chkdb.keys())
def tearDown(self) -> None:
try:
self.d.delete(self.name)
except CLIError as c:
if "Device Alias not present" not in c.message:
self.fail("Tear down failed: " + c.message)
enddb = self.d.database
if enddb is not None:
self.assertEqual(enddb, self.olddb)
def test_database_read(self):
d = DeviceAlias(self.switch)
d.create(self.new)
self.assertEquals(self.new, d.database)
for da in self.new.keys():
d.delete(da)
# Activating zoneset
zoneset.activate(True)
# Display zoneset information
print("Zoneset name: " + zoneset.name)
print("Vsan id: " + str(zoneset.vsan.id))
print("Zoneset members: " + str(zoneset.members))
print("Activation: " + zonese.is_active())
# Removing members from zoneset
zoneset.remove_members([z])
# Deleting zoneset
zoneset.delete()
# Removing members from zone
z.remove_members(memlist)
# Deleting zone
z.delete()
# Deleting vsan
v.delete()
# Deleting device alias
d.delete("da1")
# Deleting port channel
pc1.delete()
def test_create_name_max(self):
d = DeviceAlias(self.switch)
name = list(self.new_max.keys())[0]
d.create(self.new_max)
self.assertEqual(self.new_max, d.database)
d.delete(name)