def test_positive_update_2(self):
"""@Test: Check if Subnet network and mask can be updated
@Feature: Subnet - Update
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = '255.255.255.0'
try:
subnet = make_subnet({
u'network': network,
u'mask': mask,
})
except CLIFactoryError as err:
self.fail(err)
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
result = Subnet.update({
u'id': subnet['id'],
u'network': new_network,
u'mask': new_mask,
})
self.assertEqual(result.return_code, 0)
# check - subnet is updated
result = Subnet.info({u'id': subnet['id']})
self.assertEqual(result.stdout['network'], new_network)
self.assertEqual(result.stdout['mask'], new_mask)
def test_positive_update_3(self, pool):
"""@Test: Check if Subnet address pool can be updated
@Feature: Subnet - Update
@Assert: Subnet address pool is updated
"""
pool.sort()
try:
subnet = make_subnet({u'mask': '255.255.255.0'})
except CLIFactoryError as err:
self.fail(err)
# generate pool range from network address
ip_from = re.sub('\d+$', str(pool[0]), subnet['network'])
ip_to = re.sub('\d+$', str(pool[1]), subnet['network'])
result = Subnet.update({
u'id': subnet['id'],
u'from': ip_from,
u'to': ip_to,
})
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
# check - subnet is updated
result = Subnet.info({u'id': subnet['id']})
self.assertEqual(result.return_code, 0)
self.assertEqual(result.stdout['from'], ip_from)
self.assertEqual(result.stdout['to'], ip_to)
def test_negative_update_address_pool(self):
"""Update subnet with invalid address pool
:id: d0a857b4-be10-4b5d-86d4-43cf99c11619
:expectedresults: Subnet is not updated
:CaseImportance: Critical
"""
subnet = make_subnet()
for options in invalid_addr_pools():
with self.subTest(options):
opts = {u'id': subnet['id']}
# generate pool range from network address
for key, val in options.items():
opts[key] = re.sub(r'\d+$', str(val), subnet['network'])
with self.assertRaisesRegex(
CLIReturnCodeError,
u'Could not update the subnet:'
):
Subnet.update(opts)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(result[key], subnet[key])
def test_list(self):
"""@Test: Check if Subnet can be listed
@Feature: Subnet - List
@Assert: Subnet is listed
"""
# Fetch current total
result = Subnet.list()
total_subnet = len(result.stdout)
# Make a new subnet
try:
make_subnet()
except CLIFactoryError as err:
self.fail(err)
# Fetch total again
result = Subnet.list()
self.assertGreater(
len(result.stdout),
total_subnet,
"Total subnets should have increased")
def setUp(self):
super(TestSubnet, self).setUp()
if TestSubnet.subnet_192_168_100 is None:
TestSubnet.subnet_192_168_100 = "subnet-192168100"
Subnet.delete({'name': TestSubnet.subnet_192_168_100})
Subnet.create_minimal(TestSubnet.subnet_192_168_100)
def test_positive_update_network_mask(self):
"""Check if Subnet network and mask can be updated
:id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4
:expectedresults: Subnet network and mask are updated
:CaseImportance: Critical
"""
network = gen_ipaddr()
mask = '255.255.255.0'
subnet = make_subnet({
u'mask': mask,
u'network': network,
})
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
Subnet.update({
u'id': subnet['id'],
u'mask': new_mask,
u'network': new_network,
})
# check - subnet is updated
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['network'], new_network)
self.assertEqual(subnet['mask'], new_mask)
def test_positive_update_1(self, test_name):
"""@Test: Check if Subnet name can be updated
@Feature: Subnet - Update
@Assert: Subnet name is updated
"""
try:
new_subnet = make_subnet()
except CLIFactoryError as err:
self.fail(err)
# Fetch it
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result.return_code, 0, "Subnet was not found")
self.assertEqual(len(result.stderr), 0, "No error was expected")
# Update the name
result = Subnet.update({'id': new_subnet['id'], 'new-name': test_name})
self.assertEqual(result.return_code, 0, "Subnet was not updated")
self.assertEqual(len(result.stderr), 0, "No error was expected")
# Fetch it again
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result.return_code, 0, "Subnet was not found")
self.assertEqual(len(result.stderr), 0, "No error was expected")
self.assertEqual(result.stdout['name'], test_name,
"Names should match")
self.assertNotEqual(result.stdout['name'], new_subnet['name'],
"Names should not match")
def test_negative_update_1(self, options):
"""@Test: Update subnet with invalid or missing required attributes
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
bug_id = options.pop('bz-bug', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest('Bugzilla bug {0} is open.'.format(bug_id))
try:
subnet = make_subnet()
except CLIFactoryError as err:
self.fail(err)
options['id'] = subnet['id']
result = Subnet.update(options)
self.assertNotEqual(result.return_code, 0)
self.assertNotEqual(len(result.stderr), 0)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(subnet[key], result.stdout[key])
def test_positive_delete_1(self, test_name):
"""
@Test: Check if Subnet can be deleted
@Feature: Subnet - Delete
@Assert: Subnet is deleted
"""
new_subnet = make_subnet({'name': test_name['name']})
# Fetch it
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(
result.return_code,
0,
"Subnet was not found")
self.assertEqual(
len(result.stderr), 0, "No error was expected")
# Delete it
result = Subnet.delete({'id': result.stdout['id']})
self.assertEqual(
result.return_code,
0,
"Subnet was not deleted")
self.assertEqual(
len(result.stderr), 0, "No error was expected")
# Fetch it again
result = Subnet.info({'id': new_subnet['id']})
self.assertGreater(
result.return_code,
0,
"Subnet should not be found")
self.assertGreater(
len(result.stderr), 0, "No error was expected")
def test_positive_update_3(self, pool):
"""@Test: Check if Subnet address pool can be updated
@Feature: Subnet - Update
@Assert: Subnet address pool is updated
"""
pool.sort()
try:
subnet = make_subnet({u'mask': '255.255.255.0'})
except CLIFactoryError as err:
self.fail(err)
# generate pool range from network address
ip_from = re.sub('\d+$', str(pool[0]), subnet['network'])
ip_to = re.sub('\d+$', str(pool[1]), subnet['network'])
result = Subnet.update({
u'id': subnet['id'],
u'from': ip_from,
u'to': ip_to,
})
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
# check - subnet is updated
result = Subnet.info({u'id': subnet['id']})
self.assertEqual(result.return_code, 0)
self.assertEqual(result.stdout['from'], ip_from)
self.assertEqual(result.stdout['to'], ip_to)
def test_positive_update_2(self):
"""@Test: Check if Subnet network and mask can be updated
@Feature: Subnet - Update
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = '255.255.255.0'
try:
subnet = make_subnet({
u'network': network,
u'mask': mask,
})
except CLIFactoryError as err:
self.fail(err)
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
result = Subnet.update({
u'id': subnet['id'],
u'network': new_network,
u'mask': new_mask,
})
self.assertEqual(result.return_code, 0)
# check - subnet is updated
result = Subnet.info({u'id': subnet['id']})
self.assertEqual(result.stdout['network'], new_network)
self.assertEqual(result.stdout['mask'], new_mask)
def test_positive_update_2(self):
"""@Test: Check if Subnet network and mask can be updated
@Feature: Subnet - Update
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = '255.255.255.0'
subnet = make_subnet({
u'mask': mask,
u'network': network,
})
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
Subnet.update({
u'id': subnet['id'],
u'mask': new_mask,
u'network': new_network,
})
# check - subnet is updated
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['network'], new_network)
self.assertEqual(subnet['mask'], new_mask)
def test_positive_update_network_mask(self):
"""Check if Subnet network and mask can be updated
:id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4
:expectedresults: Subnet network and mask are updated
:CaseImportance: Critical
"""
network = gen_ipaddr()
mask = '255.255.255.0'
subnet = make_subnet({
u'mask': mask,
u'network': network,
})
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
Subnet.update({
u'id': subnet['id'],
u'mask': new_mask,
u'network': new_network,
})
# check - subnet is updated
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['network-addr'], new_network)
self.assertEqual(subnet['network-mask'], new_mask)
def test_negative_update_1(self, options):
"""@Test: Update subnet with invalid or missing required attributes
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
bug_id = options.pop('bz-bug', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest('Bugzilla bug {0} is open.'.format(bug_id))
try:
subnet = make_subnet()
except CLIFactoryError as err:
self.fail(err)
options['id'] = subnet['id']
result = Subnet.update(options)
self.assertNotEqual(result.return_code, 0)
self.assertNotEqual(len(result.stderr), 0)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(subnet[key], result.stdout[key])
def test_positive_delete_1(self, test_name):
"""@Test: Check if Subnet can be deleted
@Feature: Subnet - Delete
@Assert: Subnet is deleted
"""
try:
new_subnet = make_subnet({'name': test_name})
except CLIFactoryError as err:
self.fail(err)
# Fetch it
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result.return_code, 0, "Subnet was not found")
self.assertEqual(len(result.stderr), 0, "No error was expected")
# Delete it
result = Subnet.delete({'id': result.stdout['id']})
self.assertEqual(result.return_code, 0, "Subnet was not deleted")
self.assertEqual(len(result.stderr), 0, "No error was expected")
# Fetch it again
result = Subnet.info({'id': new_subnet['id']})
self.assertGreater(result.return_code, 0, "Subnet should not be found")
self.assertGreater(len(result.stderr), 0, "No error was expected")
def test_positive_delete_by_id(self):
"""Check if Subnet can be deleted
@id: ad269df8-4bb2-46a5-9c82-010a80087408
@Assert: Subnet is deleted
"""
for name in valid_data_list():
with self.subTest(name):
subnet = make_subnet({'name': name})
Subnet.delete({'id': subnet['id']})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({'id': subnet['id']})
def test_positive_update_name(self):
"""Check if Subnet name can be updated
@id: 34533e6c-7081-4b13-99bd-bd57533e05c0
@Assert: Subnet name is updated
"""
new_subnet = make_subnet()
for new_name in valid_data_list():
with self.subTest(new_name):
Subnet.update({'id': new_subnet['id'], 'new-name': new_name})
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result['name'], new_name)
def test_positive_delete_by_id(self):
"""Check if Subnet can be deleted
@Feature: Subnet - Delete
@Assert: Subnet is deleted
"""
for name in valid_data_list():
with self.subTest(name):
subnet = make_subnet({'name': name})
Subnet.delete({'id': subnet['id']})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({'id': subnet['id']})
def test_positive_update_name(self):
"""Check if Subnet name can be updated
@Feature: Subnet - Update
@Assert: Subnet name is updated
"""
new_subnet = make_subnet()
for new_name in valid_data_list():
with self.subTest(new_name):
Subnet.update({'id': new_subnet['id'], 'new-name': new_name})
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result['name'], new_name)
def test_positive_delete_by_id(self):
"""Check if Subnet can be deleted
@id: ad269df8-4bb2-46a5-9c82-010a80087408
@Assert: Subnet is deleted
"""
for name in valid_data_list():
with self.subTest(name):
subnet = make_subnet({"name": name})
Subnet.delete({"id": subnet["id"]})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({"id": subnet["id"]})
def test_positive_update_1(self):
"""@Test: Check if Subnet name can be updated
@Feature: Subnet - Update
@Assert: Subnet name is updated
"""
new_subnet = make_subnet()
for new_name in valid_data_list():
with self.subTest(new_name):
Subnet.update({'id': new_subnet['id'], 'new-name': new_name})
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result['name'], new_name)
def test_positive_delete_1(self):
"""@Test: Check if Subnet can be deleted
@Feature: Subnet - Delete
@Assert: Subnet is deleted
"""
for name in valid_data_list():
with self.subTest(name):
subnet = make_subnet({'name': name})
Subnet.delete({'id': subnet['id']})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({'id': subnet['id']})
def test_positive_update_name(self):
"""Check if Subnet name can be updated
@id: 34533e6c-7081-4b13-99bd-bd57533e05c0
@Assert: Subnet name is updated
"""
new_subnet = make_subnet()
for new_name in valid_data_list():
with self.subTest(new_name):
Subnet.update({"id": new_subnet["id"], "new-name": new_name})
result = Subnet.info({"id": new_subnet["id"]})
self.assertEqual(result["name"], new_name)
def test_list(self):
"""@Test: Check if Subnet can be listed
@Feature: Subnet - List
@Assert: Subnet is listed
"""
# Fetch current total
subnets_before = Subnet.list()
# Make a new subnet
make_subnet()
# Fetch total again
subnets_after = Subnet.list()
self.assertGreater(len(subnets_after), len(subnets_before))
def test_positive_list(self):
"""Check if Subnet can be listed
@id: 2ee376f7-9dd9-4b46-b414-801197d5455c
@Assert: Subnet is listed
"""
# Fetch current total
subnets_before = Subnet.list()
# Make a new subnet
make_subnet()
# Fetch total again
subnets_after = Subnet.list()
self.assertGreater(len(subnets_after), len(subnets_before))
def test_positive_list(self):
"""Check if Subnet can be listed
@id: 2ee376f7-9dd9-4b46-b414-801197d5455c
@Assert: Subnet is listed
"""
# Fetch current total
subnets_before = Subnet.list()
# Make a new subnet
make_subnet()
# Fetch total again
subnets_after = Subnet.list()
self.assertGreater(len(subnets_after), len(subnets_before))
def test_positive_list(self):
"""Check if Subnet can be listed
@Feature: Subnet - List
@Assert: Subnet is listed
"""
# Fetch current total
subnets_before = Subnet.list()
# Make a new subnet
make_subnet()
# Fetch total again
subnets_after = Subnet.list()
self.assertGreater(len(subnets_after), len(subnets_before))
def test_positive_update_name(self):
"""Check if Subnet name can be updated
:id: 34533e6c-7081-4b13-99bd-bd57533e05c0
:expectedresults: Subnet name is updated
:CaseImportance: Critical
"""
new_subnet = make_subnet()
for new_name in valid_data_list():
with self.subTest(new_name):
Subnet.update({'id': new_subnet['id'], 'new-name': new_name})
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result['name'], new_name)
def test_positive_delete_by_id(self):
"""Check if Subnet can be deleted
:id: ad269df8-4bb2-46a5-9c82-010a80087408
:expectedresults: Subnet is deleted
:CaseImportance: Critical
"""
for name in valid_data_list():
with self.subTest(name):
subnet = make_subnet({'name': name})
Subnet.delete({'id': subnet['id']})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({'id': subnet['id']})
def test_negative_update_attributes(self):
"""Update subnet with invalid or missing required attributes
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_missing_attributes():
with self.subTest(options):
options['id'] = subnet['id']
with self.assertRaises(CLIReturnCodeError):
Subnet.update(options)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(subnet[key], result[key])
def test_delete(self):
"""
@Feature: Subnet - Delete
@Test: Check if Subnet can be deleted
@Assert: Subnet is deleted
"""
name = generate_name()
options = {}
options['name'] = name
result = Subnet.create_minimal(name)
self.assertTrue(result.return_code == 0,
"Subnet create - exit code %d" %
result.return_code)
result = Subnet.delete(options)
self.assertTrue(result.return_code == 0,
"Subnet delete - exit code %d" %
result.return_code)
def test_negative_update_attributes(self):
"""Update subnet with invalid or missing required attributes
@id: ab60372e-cef7-4495-bd66-68e7dbece475
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_missing_attributes():
with self.subTest(options):
options["id"] = subnet["id"]
with self.assertRaisesRegex(CLIReturnCodeError, u"Could not update the subnet:"):
Subnet.update(options)
# check - subnet is not updated
result = Subnet.info({u"id": subnet["id"]})
for key in options.keys():
self.assertEqual(subnet[key], result[key])
def test_positive_update_network_mask(self):
"""Check if Subnet network and mask can be updated
@id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = "255.255.255.0"
subnet = make_subnet({u"mask": mask, u"network": network})
new_network = gen_ipaddr()
new_mask = "255.255.192.0"
Subnet.update({u"id": subnet["id"], u"mask": new_mask, u"network": new_network})
# check - subnet is updated
subnet = Subnet.info({u"id": subnet["id"]})
self.assertEqual(subnet["network"], new_network)
self.assertEqual(subnet["mask"], new_mask)
def test_negative_update_1(self):
"""@Test: Update subnet with invalid or missing required attributes
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_missing_attributes():
with self.subTest(options):
options['id'] = subnet['id']
with self.assertRaises(CLIReturnCodeError):
Subnet.update(options)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(subnet[key], result[key])
def test_positive_update_1(self, test_name):
"""@Test: Check if Subnet name can be updated
@Feature: Subnet - Update
@Assert: Subnet name is updated
"""
try:
new_subnet = make_subnet()
except CLIFactoryError as err:
self.fail(err)
# Fetch it
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(
result.return_code,
0,
"Subnet was not found")
self.assertEqual(
len(result.stderr), 0, "No error was expected")
# Update the name
result = Subnet.update(
{'id': new_subnet['id'], 'new-name': test_name})
self.assertEqual(
result.return_code,
0,
"Subnet was not updated")
self.assertEqual(
len(result.stderr), 0, "No error was expected")
# Fetch it again
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(
result.return_code,
0,
"Subnet was not found")
self.assertEqual(
len(result.stderr), 0, "No error was expected")
self.assertEqual(
result.stdout['name'], test_name, "Names should match")
self.assertNotEqual(
result.stdout['name'], new_subnet['name'], "Names should not match"
)
def test_positive_update_address_pool(self):
"""Check if Subnet address pool can be updated
@id: 18ced88f-d62e-4e15-8b7b-0a08c4ef239b
@Assert: Subnet address pool is updated
"""
subnet = make_subnet({u"mask": "255.255.255.0"})
for pool in valid_addr_pools():
with self.subTest(pool):
pool.sort()
# generate pool range from network address
ip_from = re.sub(r"\d+$", str(pool[0]), subnet["network"])
ip_to = re.sub(r"\d+$", str(pool[1]), subnet["network"])
Subnet.update({u"from": ip_from, u"id": subnet["id"], u"to": ip_to})
subnet = Subnet.info({u"id": subnet["id"]})
self.assertEqual(subnet["from"], ip_from)
self.assertEqual(subnet["to"], ip_to)
def test_negative_update_attributes(self):
"""Update subnet with invalid or missing required attributes
@id: ab60372e-cef7-4495-bd66-68e7dbece475
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_missing_attributes():
with self.subTest(options):
options['id'] = subnet['id']
with self.assertRaisesRegex(CLIReturnCodeError,
u'Could not update the subnet:'):
Subnet.update(options)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(subnet[key], result[key])
def test_list(self):
"""
@Feature: Subnet - List
@Test: Check if Subnet can be listed
@Assert: Subnet is listed
"""
result = Subnet.list({'per-page': '10'})
self.assertGreater(len(result.stdout), 0,
"Subnet list - returns > 0 records")
def test_negative_update_attributes(options):
"""Update subnet with invalid or missing required attributes
:parametrized: yes
:id: ab60372e-cef7-4495-bd66-68e7dbece475
:expectedresults: Subnet is not updated
:CaseImportance: Medium
"""
subnet = make_subnet()
options['id'] = subnet['id']
with pytest.raises(CLIReturnCodeError, match='Could not update the subnet:'):
Subnet.update(options)
# check - subnet is not updated
result = Subnet.info({'id': subnet['id']})
for key in options.keys():
assert subnet[key] == result[key]
def test_create(self):
"""
@Feature: Subnet - Create
@Test: Check if Subnet can be created
@Assert: Subnet is created
"""
result = Subnet.create_minimal()
self.assertTrue(result.return_code == 0,
"Subnet create - exit code %d" %
result.return_code)
def test_negative_update_address_pool(self):
"""Update subnet with invalid address pool
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_addr_pools():
with self.subTest(options):
opts = {u'id': subnet['id']}
# generate pool range from network address
for key, val in options.iteritems():
opts[key] = re.sub(r'\d+$', str(val), subnet['network'])
with self.assertRaises(CLIReturnCodeError):
Subnet.update(opts)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(result[key], subnet[key])
def test_list(self):
"""
@Test: Check if Subnet can be listed
@Feature: Subnet - List
@Assert: Subnet is listed
"""
# Fetch current total
result = Subnet.list()
total_subnet = len(result.stdout)
# Make a new subnet
make_subnet()
# Fetch total again
result = Subnet.list()
self.assertGreater(
len(result.stdout),
total_subnet,
"Total subnets should have increased")
def test_info(self):
"""
@Feature: Subnet - Info
@Test: Check if Subnet Info is displayed
@Assert: Subnet Info is displayed
"""
options = {}
options['name'] = generate_name(8, 8)
options['network'] = generate_ipaddr(ip3=True)
options['mask'] = '255.255.255.0'
Subnet.create(options)
sleep_for_seconds(5)
result = Subnet.info({'name': options['name']})
self.assertTrue(len(result.stdout) > 1,
"Subnet info - returns 1 record")
self.assertEquals(result.stdout['name'], options['name'],
"Subnet info - check name")
def test_negative_update_address_pool(self):
"""Update subnet with invalid address pool
@id: d0a857b4-be10-4b5d-86d4-43cf99c11619
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_addr_pools():
with self.subTest(options):
opts = {u"id": subnet["id"]}
# generate pool range from network address
for key, val in options.iteritems():
opts[key] = re.sub(r"\d+$", str(val), subnet["network"])
with self.assertRaisesRegex(CLIReturnCodeError, u"Could not update the subnet:"):
Subnet.update(opts)
# check - subnet is not updated
result = Subnet.info({u"id": subnet["id"]})
for key in options.keys():
self.assertEqual(result[key], subnet[key])
def test_negative_update_2(self):
"""@Test: Update subnet with invalid address pool
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
subnet = make_subnet()
for options in invalid_addr_pools():
with self.subTest(options):
opts = {u'id': subnet['id']}
# generate pool range from network address
for key, val in options.iteritems():
opts[key] = re.sub(r'\d+$', str(val), subnet['network'])
with self.assertRaises(CLIReturnCodeError):
Subnet.update(opts)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(result[key], subnet[key])
def test_positive_list(self):
"""Check if Subnet can be listed
:id: 2ee376f7-9dd9-4b46-b414-801197d5455c
:expectedresults: Subnet is listed
"""
# Make a new subnet
subnet = make_subnet()
# Fetch ids from subnets list
subnets_ids = [subnet_['id'] for subnet_ in Subnet.list()]
self.assertIn(subnet['id'], subnets_ids)
def test_positive_list(self):
"""Check if Subnet can be listed
@id: 2ee376f7-9dd9-4b46-b414-801197d5455c
@Assert: Subnet is listed
"""
# Make a new subnet
subnet = make_subnet()
# Fetch ids from subnets list
subnets_ids = [subnet_["id"] for subnet_ in Subnet.list()]
self.assertIn(subnet["id"], subnets_ids)
def test_positive_update_address_pool(self):
"""Check if Subnet address pool can be updated
@Feature: Subnet - Update
@Assert: Subnet address pool is updated
"""
subnet = make_subnet({u'mask': '255.255.255.0'})
for pool in valid_addr_pools():
with self.subTest(pool):
pool.sort()
# generate pool range from network address
ip_from = re.sub(r'\d+$', str(pool[0]), subnet['network'])
ip_to = re.sub(r'\d+$', str(pool[1]), subnet['network'])
Subnet.update({
u'from': ip_from,
u'id': subnet['id'],
u'to': ip_to,
})
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['from'], ip_from)
self.assertEqual(subnet['to'], ip_to)
def test_positive_update_address_pool(self):
"""Check if Subnet address pool can be updated
:id: 18ced88f-d62e-4e15-8b7b-0a08c4ef239b
:expectedresults: Subnet address pool is updated
"""
subnet = make_subnet({u'mask': '255.255.255.0'})
for pool in valid_addr_pools():
with self.subTest(pool):
pool.sort()
# generate pool range from network address
ip_from = re.sub(r'\d+$', str(pool[0]), subnet['network-addr'])
ip_to = re.sub(r'\d+$', str(pool[1]), subnet['network-addr'])
Subnet.update({
u'from': ip_from,
u'id': subnet['id'],
u'to': ip_to,
})
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['start-of-ip-range'], ip_from)
self.assertEqual(subnet['end-of-ip-range'], ip_to)
def test_positive_delete_1(self, test_name):
"""@Test: Check if Subnet can be deleted
@Feature: Subnet - Delete
@Assert: Subnet is deleted
"""
try:
subnet = make_subnet({'name': test_name})
except CLIFactoryError as err:
self.fail(err)
# Delete it
result = Subnet.delete({'id': subnet['id']})
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
# Fetch it again
result = Subnet.info({'id': subnet['id']})
self.assertGreater(result.return_code, 0)
self.assertGreater(len(result.stderr), 0)
def test_negative_update_address_pool(options):
"""Update subnet with invalid address pool
:parametrized: yes
:id: d0a857b4-be10-4b5d-86d4-43cf99c11619
:expectedresults: Subnet is not updated
:CaseImportance: Medium
"""
subnet = make_subnet()
opts = {'id': subnet['id']}
# generate pool range from network address
for key, val in options.items():
opts[key] = re.sub(r'\d+$', str(val), subnet['network-addr'])
with pytest.raises(CLIReturnCodeError, match='Could not update the subnet:'):
Subnet.update(opts)
# check - subnet is not updated
result = Subnet.info({'id': subnet['id']})
for key in ['start-of-ip-range', 'end-of-ip-range']:
assert result[key] == subnet[key]
def test_negative_update_2(self, options):
"""@Test: Update subnet with invalid address pool
@Feature: Subnet - Update
@Assert: Subnet is not updated
"""
try:
subnet = make_subnet()
except CLIFactoryError as err:
self.fail(err)
opts = {u'id': subnet['id']}
# generate pool range from network address
for key, val in options.iteritems():
opts[key] = re.sub('\d+$', str(val), subnet['network'])
result = Subnet.update(opts)
self.assertNotEqual(result.return_code, 0)
# check - subnet is not updated
result = Subnet.info({u'id': subnet['id']})
for key in options.keys():
self.assertEqual(result.stdout[key], subnet[key])
def test_positive_update_network_mask(self):
"""Check if Subnet network and mask can be updated
@id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = '255.255.255.0'
subnet = make_subnet({
u'mask': mask,
u'network': network,
})
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
Subnet.update({
u'id': subnet['id'],
u'mask': new_mask,
u'network': new_network,
})
# check - subnet is updated
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['network'], new_network)
self.assertEqual(subnet['mask'], new_mask)
def test_positive_update_network_mask(self):
"""Check if Subnet network and mask can be updated
@Feature: Subnet - Update
@Assert: Subnet network and mask are updated
"""
network = gen_ipaddr()
mask = '255.255.255.0'
subnet = make_subnet({
u'mask': mask,
u'network': network,
})
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
Subnet.update({
u'id': subnet['id'],
u'mask': new_mask,
u'network': new_network,
})
# check - subnet is updated
subnet = Subnet.info({u'id': subnet['id']})
self.assertEqual(subnet['network'], new_network)
self.assertEqual(subnet['mask'], new_mask)
def test_positive_create_1(self, test_name):
"""@Test: Check if Subnet can be created with random names
@Feature: Subnet - Create
@Assert: Subnet is created and has random name
"""
try:
new_subnet = make_subnet({'name': test_name})
except CLIFactoryError as err:
self.fail(err)
# Fetch it
result = Subnet.info({'id': new_subnet['id']})
self.assertEqual(result.return_code, 0, "Subnet was not found")
self.assertEqual(len(result.stderr), 0, "No error was expected")
self.assertEqual(result.stdout['name'], new_subnet['name'],
"Names don't match")
def _cleanup():
if Subnet.exists(search=('name', subnet['name'])):
Subnet.delete(options={'id': subnet['id']})
def test_positive_CRUD(self):
"""Create, update and delete subnet
:id: d74a52a7-df56-44ef-89a3-081c14e81e43
:expectedresults: Subnet is created, updated and deleted
:CaseImportance: Critical
"""
name = valid_data_list()[0]
pool = sorted(valid_addr_pools()[0])
mask = '255.255.255.0'
# generate pool range from network address
network = gen_ipaddr()
from_ip = re.sub(r'\d+$', str(pool[0]), network)
to_ip = re.sub(r'\d+$', str(pool[1]), network)
domains_amount = random.randint(3, 5)
domains = [make_domain() for _ in range(domains_amount)]
gateway = gen_ipaddr(ip3=True)
ipam_type = SUBNET_IPAM_TYPES['dhcp']
subnet = make_subnet(
{
'name': name,
'from': from_ip,
'mask': mask,
'network': network,
'to': to_ip,
'domain-ids': [domain['id'] for domain in domains],
'gateway': gateway,
'ipam': ipam_type,
}
)
# Check if Subnet can be listed
subnets_ids = [subnet_['id'] for subnet_ in Subnet.list()]
self.assertIn(subnet['id'], subnets_ids)
self.assertEqual(subnet['name'], name)
self.assertEqual(subnet['start-of-ip-range'], from_ip)
self.assertEqual(subnet['end-of-ip-range'], to_ip)
self.assertEqual(len(subnet['domains']), domains_amount)
for domain in domains:
self.assertIn(domain['name'], subnet['domains'])
self.assertIn(gateway, subnet['gateway-addr'])
self.assertIn(ipam_type, subnet['ipam'])
# update subnet
new_name = valid_data_list()[0]
pool = sorted(valid_addr_pools()[0])
# generate pool range from network address
new_network = gen_ipaddr()
new_mask = '255.255.192.0'
ip_from = re.sub(r'\d+$', str(pool[0]), new_network)
ip_to = re.sub(r'\d+$', str(pool[1]), new_network)
ipam_type = SUBNET_IPAM_TYPES['internal']
Subnet.update(
{
'new-name': new_name,
'from': ip_from,
'id': subnet['id'],
'to': ip_to,
'mask': new_mask,
'network': new_network,
'ipam': ipam_type,
'domain-ids': "", # delete domains needed for subnet delete
}
)
subnet = Subnet.info({'id': subnet['id']})
self.assertEqual(subnet['name'], new_name)
self.assertEqual(subnet['start-of-ip-range'], ip_from)
self.assertEqual(subnet['end-of-ip-range'], ip_to)
self.assertEqual(subnet['network-addr'], new_network)
self.assertEqual(subnet['network-mask'], new_mask)
self.assertIn(ipam_type, subnet['ipam'])
# delete subnet
Subnet.delete({'id': subnet['id']})
with self.assertRaises(CLIReturnCodeError):
Subnet.info({'id': subnet['id']})