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_name_invalidfirstchar(self):
d = DeviceAlias(self.switch)
name = list(self.new_invalidfirstchar.keys())[0]
pwwn = list(self.new_invalidfirstchar.values())[0]
with self.assertRaises(CLIError) as e:
d.create(self.new_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))
d.clear_lock()
def test_create_name_invalid(self):
d = DeviceAlias(self.switch)
name = list(self.new_invalidname.keys())[0]
pwwn = list(self.new_invalidname.values())[0]
with self.assertRaises(CLIError) as e:
d.create(self.new_invalidname)
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))
d.clear_lock()
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)
def test_clear_lock(self):
d = DeviceAlias(self.switch)
d.clear_lock()
self.assertEqual(False, d.locked)
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)
