def test_addoperatingsystem_ptable(self):
"""@Test: Check if Partition Table can be associated with operating system
@Feature: Partition Table - Add operating system
@Assert: Operating system added
"""
content = "Fake ptable"
name = generate_name(6)
try:
make_partition_table({'name': name, 'content': content})
except CLIFactoryError as err:
self.fail(err)
result = PartitionTable().exists(tuple_search=('name', name))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
ptable = result.stdout
os_list = OperatingSys.list()
self.assertEqual(os_list.return_code, 0, "Failed to list os")
self.assertEqual(
len(os_list.stderr), 0, "Should not have gotten an error")
args = {'id': ptable['id'],
'operatingsystem-id': os_list.stdout[0]['id']}
result = PartitionTable().add_operating_system(args)
self.assertEqual(result.return_code, 0, "Association Failed")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
def test_update_ptable(self):
"""@Test: Check if Partition Table can be updated
@Feature: Partition Table - Update
@Assert: Partition Table is updated
"""
try:
make_partition_table(self.args)
except CLIFactoryError as err:
self.fail(err)
result = PartitionTable().exists(tuple_search=('name', self.name))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
nw_nm = generate_name(6)
args = {'name': self.name,
'new-name': nw_nm}
result = PartitionTable().update(args)
self.assertEqual(result.return_code, 0, "Failed to update object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
self.assertFalse(
PartitionTable().exists(tuple_search=('new-name', nw_nm)).stdout)
def test_delete_medium_1(self):
"""Creates and immediately deletes partition table."""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(('name', name)).stdout
args = {
'id': ptable['id'],
}
PartitionTable().delete(args)
self.assertFalse(PartitionTable().exists(('name', name)).stdout)
def test_create_ptable(self):
"""
@Feature: Partition Table - Create
@Test: Check if Partition Table can be created
@Assert: Partition Table is created
"""
try:
make_partition_table(self.args)
except CLIFactoryError as err:
self.fail(err)
result = PartitionTable().exists(tuple_search=('name', self.name))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
def test_add_ptable(self):
"""@test: Add ptable to os
@feature: Operating System - Add ptable
@assert: Operating System is updated with ptable
"""
# Create a partition table.
ptable_name = make_partition_table()['name']
# Create an operating system.
os_id = make_os()['id']
# Add the partition table to the operating system.
response = OperatingSys.add_ptable({
'id': os_id,
'partition-table': ptable_name,
})
self.assertEqual(response.return_code, 0)
self.assertEqual(len(response.stderr), 0)
# Verify that the operating system has a partition table.
response = OperatingSys.info({'id': os_id})
self.assertEqual(len(response.stdout['partition-tables']), 1)
self.assertEqual(response.stdout['partition-tables'][0], ptable_name)
def test_bugzilla_1203457(self):
"""@test: Create an OS pointing to an arch, medium and partition table.
@feature: Operating System - Create
@assert: An operating system is created.
@bz: 1203457, 1200116
"""
architecture = make_architecture()
medium = make_medium()
ptable = make_partition_table()
operating_system = make_os({
u'architecture-ids': architecture['id'],
u'medium-ids': medium['id'],
u'partition-table-ids': ptable['id'],
})
for attr in (
'architectures', 'installation-media', 'partition-tables'):
self.assertEqual(len(operating_system[attr]), 1)
self.assertEqual(
operating_system['architectures'][0], architecture['name'])
self.assertEqual(
operating_system['installation-media'][0], medium['name'])
self.assertEqual(
operating_system['partition-tables'][0], ptable['name'])
def test_positive_create_with_arch_medium_ptable(self):
"""Create an OS pointing to an arch, medium and partition table.
:id: 05bdb2c6-0d2e-4141-9e07-3ada3933b577
:expectedresults: An operating system is created.
:CaseImportance: Critical
"""
architecture = make_architecture()
medium = make_medium()
ptable = make_partition_table()
operating_system = make_os(
{
'architecture-ids': architecture['id'],
'medium-ids': medium['id'],
'partition-table-ids': ptable['id'],
}
)
for attr in ('architectures', 'installation-media', 'partition-tables'):
assert len(operating_system[attr]) == 1
assert operating_system['architectures'][0] == architecture['name']
assert operating_system['installation-media'][0] == medium['name']
assert operating_system['partition-tables'][0] == ptable['name']
def test_bugzilla_1203457(self):
"""@test: Create an OS pointing to an arch, medium and partition table.
@feature: Operating System - Create
@assert: An operating system is created.
"""
architecture = make_architecture()
medium = make_medium()
ptable = make_partition_table()
operating_system = make_os({
u'architecture-ids': architecture['id'],
u'medium-ids': medium['id'],
u'partition-table-ids': ptable['id'],
})
result = OperatingSys.info({'id': operating_system['id']})
self.assertEqual(result.return_code, 0)
stdout = result.stdout
for attr in (
'architectures', 'installation-media', 'partition-tables'):
self.assertEqual(len(stdout[attr]), 1)
self.assertEqual(stdout['architectures'][0], architecture['name'])
self.assertEqual(stdout['installation-media'][0], medium['name'])
self.assertEqual(stdout['partition-tables'][0], ptable['name'])
def test_positive_create_with_arch_medium_ptable(self):
"""Create an OS pointing to an arch, medium and partition table.
@id: 05bdb2c6-0d2e-4141-9e07-3ada3933b577
@assert: An operating system is created.
"""
architecture = make_architecture()
medium = make_medium()
ptable = make_partition_table()
operating_system = make_os({
u'architecture-ids': architecture['id'],
u'medium-ids': medium['id'],
u'partition-table-ids': ptable['id'],
})
for attr in ('architectures', 'installation-media',
'partition-tables'):
self.assertEqual(len(operating_system[attr]), 1)
self.assertEqual(operating_system['architectures'][0],
architecture['name'])
self.assertEqual(operating_system['installation-media'][0],
medium['name'])
self.assertEqual(operating_system['partition-tables'][0],
ptable['name'])
def test_dump_ptable_1(self):
"""Creates partition table with specific content."""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(('name', name)).stdout
args = {
'id': ptable['id'],
}
ptable_content = PartitionTable().dump(args)
self.assertTrue(content in ptable_content.stdout[0])
def test_positive_create_with_arch_medium_ptable(self):
"""Create an OS pointing to an arch, medium and partition table.
@id: 05bdb2c6-0d2e-4141-9e07-3ada3933b577
@assert: An operating system is created.
"""
architecture = make_architecture()
medium = make_medium()
ptable = make_partition_table()
operating_system = make_os({
u'architecture-ids': architecture['id'],
u'medium-ids': medium['id'],
u'partition-table-ids': ptable['id'],
})
for attr in (
'architectures', 'installation-media', 'partition-tables'):
self.assertEqual(len(operating_system[attr]), 1)
self.assertEqual(
operating_system['architectures'][0], architecture['name'])
self.assertEqual(
operating_system['installation-media'][0], medium['name'])
self.assertEqual(
operating_system['partition-tables'][0], ptable['name'])
def test_add_ptable(self):
"""@test: Add ptable to os
@feature: Operating System - Add ptable
@assert: Operating System is updated with ptable
"""
ptable_obj = make_partition_table()
result = PartitionTable.info({'id': ptable_obj['id']})
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
self.assertEqual(ptable_obj['name'], result.stdout['name'])
new_obj = make_os()
result = OperatingSys.add_ptable({'id': new_obj['id'],
'ptable': ptable_obj['name']})
self.assertEqual(result.return_code, 0, "Failed to add ptable")
self.assertEqual(
len(result.stderr), 0, "Should not have gotten an error")
result = OperatingSys.info({'id': new_obj['id']})
self.assertEqual(result.return_code, 0, "Failed to find object")
self.assertEqual(len(result.stdout['partition-tables']), 1)
self.assertIn(ptable_obj['name'], result.stdout['partition-tables'][0])
def test_add_ptable(self):
"""@test: Add ptable to os
@feature: Operating System - Add ptable
@assert: Operating System is updated with ptable
"""
# Create a partition table.
ptable_name = make_partition_table()['name']
response = PartitionTable.info({'name': ptable_name})
self.assertEqual(response.return_code, 0, response.stderr)
self.assertEqual(len(response.stderr), 0, response.stderr)
# Create an operating system.
os_id = make_os()['id']
response = OperatingSys.info({'id': os_id})
self.assertEqual(response.return_code, 0, response.stderr)
self.assertEqual(len(response.stderr), 0, response.stderr)
# Add the partition table to the operating system.
response = OperatingSys.add_ptable({
'id': os_id,
'partition-table': ptable_name,
})
self.assertEqual(response.return_code, 0, response.stderr)
self.assertEqual(len(response.stderr), 0, response.stderr)
# Verify that the operating system has a partition table.
response = OperatingSys.info({'id': os_id})
self.assertEqual(len(response.stdout['partition-tables']), 1,
response.stdout['partition-tables'])
self.assertEqual(response.stdout['partition-tables'][0], ptable_name)
def test_create_ptable(self):
"""@Test: Check if Partition Table can be created
@Assert: Partition Table is created
@Feature: Partition Table - Create
"""
try:
make_partition_table(self.args)
except CLIFactoryError as err:
self.fail(err)
result = PartitionTable().exists(search=('name', self.name))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
def test_dump_ptable_1(self):
"""
@Feature: Partition Table - Create
@Test: Check if Partition Table can be created with specific content
@Assert: Partition Table is created
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {'id': ptable['id']}
ptable_content = PartitionTable().dump(args)
self.assertTrue(content in ptable_content.stdout[0])
def test_positive_create_with_name_content(self):
"""Create a Partition Table with name and content
@Assert: Partition Table is created and has correct name and content
@Feature: Partition Table
"""
ptable = make_partition_table(self.args)
self.assertEqual(ptable['name'], self.name)
def test_create_ptable(self):
"""@Test: Check if Partition Table can be created
@Assert: Partition Table is created
@Feature: Partition Table - Create
"""
ptable = make_partition_table(self.args)
self.assertEqual(ptable['name'], self.name)
def test_delete_ptable_1(self):
"""
@Feature: Partition Table - Delete
@Test: Check if Partition Table can be deleted
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(('name', name)).stdout
args = {
'id': ptable['id'],
}
PartitionTable().delete(args)
self.assertFalse(PartitionTable().exists(('name', name)).stdout)
def test_positive_delete_by_name(self):
"""Create a Partition Table then delete it by its name
@id: 27bd427c-7601-4f3b-998f-b7baaaad0fb0
@Assert: Partition Table is deleted
"""
ptable = make_partition_table()
PartitionTable.delete({'name': ptable['name']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'name': ptable['name']})
def test_dump_ptable_1(self):
"""
@Feature: Partition Table - Create
@Test: Check if Partition Table can be created with specific content
@Assert: Partition Table is created
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {
'id': ptable['id'],
}
ptable_content = PartitionTable().dump(args)
self.assertTrue(content in ptable_content.stdout[0])
def test_positive_delete_by_name(self):
"""Create a Partition Table then delete it by its name
:id: 27bd427c-7601-4f3b-998f-b7baaaad0fb0
:expectedresults: Partition Table is deleted
"""
ptable = make_partition_table()
PartitionTable.delete({'name': ptable['name']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'name': ptable['name']})
def test_positive_delete_by_id(self):
"""Create a Partition Table then delete it by its ID
@id: 4d2369eb-4dc1-4ab5-96d4-c872c39f4ff5
@Assert: Partition Table is deleted
"""
ptable = make_partition_table()
PartitionTable.delete({'id': ptable['id']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'id': ptable['id']})
def test_positive_create_with_content(self):
"""Create a Partition Table with content
@id: 28bfbd8b-2ada-44d0-89f3-63885cfb3495
@Assert: Partition Table is created and has correct content
"""
content = 'Fake ptable'
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_create_with_name(self):
"""Create Partition Tables with different names
@id: e7d8a444-c69a-4863-a715-83d2dcb3b6ec
@Assert: Partition Table is created and has correct name
"""
for name in generate_strings_list(length=randint(4, 30)):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_delete_by_name(self):
"""Create a Partition Table then delete it by its name
@Feature: Partition Table
@Assert: Partition Table is deleted
"""
ptable = make_partition_table()
PartitionTable.delete({'name': ptable['name']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'name': ptable['name']})
def test_positive_create_with_content(self):
"""Create a Partition Table with content
@Feature: Partition Table
@Assert: Partition Table is created and has correct content
"""
content = 'Fake ptable'
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_create_with_content(self):
"""Create a Partition Table with content
@Feature: Partition Table
@Assert: Partition Table is created and has correct content
"""
content = "Fake ptable"
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_delete_ptable_1(self):
"""
@Feature: Partition Table - Delete
@Test: Check if Partition Table can be deleted
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {
'id': ptable['id'],
}
PartitionTable().delete(args)
self.assertFalse(PartitionTable().exists(tuple_search=('name',
name)).stdout)
def test_positive_delete_by_id(self):
"""Create a Partition Table then delete it by its ID
@id: 4d2369eb-4dc1-4ab5-96d4-c872c39f4ff5
@Assert: Partition Table is deleted
"""
ptable = make_partition_table()
PartitionTable.delete({'id': ptable['id']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'id': ptable['id']})
def test_positive_create_with_content(self):
"""Create a Partition Table with content
@id: 28bfbd8b-2ada-44d0-89f3-63885cfb3495
@Assert: Partition Table is created and has correct content
"""
content = 'Fake ptable'
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_create_with_name(self):
"""Create Partition Tables with different names
@id: e7d8a444-c69a-4863-a715-83d2dcb3b6ec
@Assert: Partition Table is created and has correct name
"""
for name in generate_strings_list(length=randint(4, 30)):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_create_with_name(self):
"""Create Partition Tables with different names
@Assert: Partition Table is created and has correct name
@Feature: Partition Table
"""
for name in generate_strings_list(length=randint(4, 30)):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_delete_by_id(self):
"""Create a Partition Table then delete it by its ID
@Feature: Partition Table
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = gen_alphanumeric(6)
ptable = make_partition_table({'name': name, 'content': content})
PartitionTable().delete({'id': ptable['id']})
self.assertFalse(PartitionTable().exists(search=('name', name)))
def test_delete_ptable_1(self):
"""
@Feature: Partition Table - Delete
@Test: Check if Partition Table can be deleted
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = generate_name(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(tuple_search=('name', name)).stdout
args = {'id': ptable['id']}
result = PartitionTable().delete(args)
self.assertEqual(result.return_code, 0, "Deletion Failed")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
self.assertFalse(
PartitionTable().exists(tuple_search=('name', name)).stdout)
def test_dump_ptable_1(self):
"""@Test: Check if Partition Table can be created with specific content
@Feature: Partition Table - Create
@Assert: Partition Table is created
"""
content = "Fake ptable"
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_create_with_one_character_name(self):
"""Create Partition table with 1 character in name
@Assert: Partition table was created
@Feature: Partition Table - Create
@BZ: 1229384
"""
for name in generate_strings_list(length=1):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_delete_ptable_1(self):
"""@Test: Check if Partition Table can be deleted
@Feature: Partition Table - Delete
@Assert: Partition Table is deleted
"""
content = "Fake ptable"
name = gen_alphanumeric(6)
make_partition_table({'name': name, 'content': content})
ptable = PartitionTable().exists(search=('name', name)).stdout
args = {'id': ptable['id']}
result = PartitionTable().delete(args)
self.assertEqual(result.return_code, 0, "Deletion Failed")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
self.assertFalse(PartitionTable().exists(search=('name', name)).stdout)
def test_positive_create_with_one_character_name(self):
"""Create Partition table with 1 character in name
@id: cfec857c-ed6e-4472-93bb-70e1d4f39bae
@Assert: Partition table was created
@BZ: 1229384
"""
for name in generate_strings_list(length=1):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_create_with_one_character_name(self):
"""Create Partition table with 1 character in name
@id: cfec857c-ed6e-4472-93bb-70e1d4f39bae
@Assert: Partition table was created
@BZ: 1229384
"""
for name in generate_strings_list(length=1):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_create_with_content(self):
"""Create a Partition Table with content
:id: 28bfbd8b-2ada-44d0-89f3-63885cfb3495
:expectedresults: Partition Table is created and has correct content
:CaseImportance: Critical
"""
content = 'Fake ptable'
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_create_with_content(self):
"""Create a Partition Table with content
:id: 28bfbd8b-2ada-44d0-89f3-63885cfb3495
:expectedresults: Partition Table is created and has correct content
:CaseImportance: Critical
"""
content = 'Fake ptable'
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_delete_by_id(self):
"""Create a Partition Table then delete it by its ID
:id: 4d2369eb-4dc1-4ab5-96d4-c872c39f4ff5
:expectedresults: Partition Table is deleted
:CaseImportance: Critical
"""
ptable = make_partition_table()
PartitionTable.delete({'id': ptable['id']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'id': ptable['id']})
def test_positive_delete_by_name(self):
"""Create a Partition Table then delete it by its name
:id: 27bd427c-7601-4f3b-998f-b7baaaad0fb0
:expectedresults: Partition Table is deleted
:CaseImportance: Critical
"""
ptable = make_partition_table()
PartitionTable.delete({'name': ptable['name']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'name': ptable['name']})
def test_positive_create_with_content_length(self):
"""Create a Partition Table with content length more than 4096 chars
:id: 59e6f9ef-85c2-4229-8831-00edb41b19f4
:expectedresults: Partition Table is created and has correct content
:BZ: 1270181
"""
content = gen_string('alpha', 5000)
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
assert content in ptable_content[0]
def test_positive_create_with_content_length(self):
"""Create a Partition Table with content length more than 4096 chars
:id: 59e6f9ef-85c2-4229-8831-00edb41b19f4
:expectedresults: Partition Table is created and has correct content
:BZ: 1270181
"""
content = gen_string('alpha', 5000)
ptable = make_partition_table({'content': content})
ptable_content = PartitionTable().dump({'id': ptable['id']})
self.assertTrue(content in ptable_content[0])
def test_positive_delete_by_id(self):
"""Create a Partition Table then delete it by its ID
:id: 4d2369eb-4dc1-4ab5-96d4-c872c39f4ff5
:expectedresults: Partition Table is deleted
:CaseImportance: Critical
"""
ptable = make_partition_table()
PartitionTable.delete({'id': ptable['id']})
with self.assertRaises(CLIReturnCodeError):
PartitionTable.info({'id': ptable['id']})
def test_positive_generate_report_sanitized(self):
"""Generate report template where there are values in comma outputted
which might brake CSV format
:id: 84b577db-144e-4961-a42e-e93887464986
:setup: User with reporting access rights, Host Statuses report,
a host with OS that has comma in its name
:steps:
1. hammer report-template generate ...
:expectedresults: Report is generated in proper CSV format (value with comma is quoted)
:CaseImportance: Medium
"""
os_name = gen_string('alpha') + "," + gen_string('alpha')
architecture = make_architecture()
partition_table = make_partition_table()
medium = make_medium()
os = make_os({
'name': os_name,
'architecture-ids': architecture['id'],
'medium-ids': medium['id'],
'partition-table-ids': partition_table['id'],
})
host_name = gen_string('alpha')
host = make_fake_host({
'name': host_name,
'architecture-id': architecture['id'],
'medium-id': medium['id'],
'operatingsystem-id': os['id'],
'partition-table-id': partition_table['id']
})
report_template = make_report_template({
'content': REPORT_TEMPLATE_FILE,
})
result = ReportTemplate.generate({
'name': report_template['name'],
})
self.assertIn('Name,Operating System',
result) # verify header of custom template
self.assertIn(
'{0},"{1}"'.format(host['name'],
host['operating-system']['operating-system']),
result)
def test_addoperatingsystem_ptable(self):
"""@Test: Check if Partition Table can be associated
with operating system
@Feature: Partition Table - Add operating system
@Assert: Operating system added
"""
content = "Fake ptable"
name = gen_alphanumeric(6)
try:
make_partition_table({'name': name, 'content': content})
except CLIFactoryError as err:
self.fail(err)
result = PartitionTable().exists(search=('name', name))
self.assertEqual(result.return_code, 0, "Failed to create object")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
ptable = result.stdout
os_list = OperatingSys.list()
self.assertEqual(os_list.return_code, 0, "Failed to list os")
self.assertEqual(len(os_list.stderr), 0,
"Should not have gotten an error")
args = {
'id': ptable['id'],
'operatingsystem-id': os_list.stdout[0]['id']
}
result = PartitionTable().add_operating_system(args)
self.assertEqual(result.return_code, 0, "Association Failed")
self.assertEqual(len(result.stderr), 0,
"There should not be an exception here")
def test_positive_create_1(self):
"""@test: A host can be created with a random name
@feature: Hosts
@assert: A host is created and the name matches
"""
# Use the default installation smart proxy
result = Proxy.list()
self.assertEqual(result.return_code, 0)
self.assertEqual(len(result.stderr), 0)
self.assertGreater(len(result.stdout), 0)
puppet_proxy = result.stdout[0]
host_name = gen_string(str_type='alpha', length=gen_integer(1, 10))
try:
# Creating dependent objects
architecture = make_architecture()
domain = make_domain()
environment = make_environment()
location = make_location()
medium = make_medium()
ptable = make_partition_table()
organization = make_org(cached=True)
os = make_os({
u'architecture-ids': architecture['id'],
u'medium-ids': medium['id'],
u'partition-table-ids': ptable['id'],
})
host = make_host({
u'architecture-id': architecture['id'],
u'domain-id': domain['id'],
u'environment-id': environment['id'],
u'location-id': location['id'],
u'medium-id': medium['id'],
u'name': host_name,
u'operatingsystem-id': os['id'],
u'organization-id': organization['id'],
u'partition-table-id': ptable['id'],
u'puppet-proxy-id': puppet_proxy['id'],
})
except CLIFactoryError as err:
self.fail(err)
name = '{0}.{1}'.format(host_name, domain['name']).lower()
self.assertEqual(host['name'], name)
def test_positive_create_with_one_character_name(self):
"""Create Partition table with 1 character in name
:id: cfec857c-ed6e-4472-93bb-70e1d4f39bae
:expectedresults: Partition table was created
:BZ: 1229384
:CaseImportance: Critical
"""
for name in generate_strings_list(length=1):
with self.subTest(name):
ptable = make_partition_table({'name': name})
self.assertEqual(ptable['name'], name)
def test_positive_create_with_one_character_name(self, name):
"""Create Partition table with 1 character in name
:id: cfec857c-ed6e-4472-93bb-70e1d4f39bae
:parametrized: yes
:expectedresults: Partition table was created
:BZ: 1229384
:CaseImportance: Medium
"""
ptable = make_partition_table({'name': name})
assert ptable['name'] == name
def test_positive_add_os_by_id(self):
"""Create a partition table then add an operating system to it using
IDs for association
:id: 37415a34-5dba-4551-b1c5-e6e59329f4ca
:expectedresults: Operating system is added to partition table
:CaseLevel: Integration
"""
ptable = make_partition_table()
os = make_os()
PartitionTable.add_operating_system({'id': ptable['id'], 'operatingsystem-id': os['id']})
ptable = PartitionTable.info({'id': ptable['id']})
self.assertIn(os['title'], ptable['operating-systems'])
def test_positive_update_name(self):
"""Create a Partition Table and update its name
@Feature: Partition Table
@Assert: Partition Table is created and its name can be updated
"""
ptable = make_partition_table()
for new_name in generate_strings_list(length=randint(4, 30)):
with self.subTest(new_name):
PartitionTable.update({
'id': ptable['id'],
'new-name': new_name,
})
ptable = PartitionTable.info({'id': ptable['id']})
self.assertEqual(ptable['name'], new_name)
def test_positive_update_name(self):
"""Create a Partition Table and update its name
:id: 6242c915-0f15-4d5f-9f7a-73cb58fac81e
:expectedresults: Partition Table is created and its name can be
updated
:CaseImportance: Medium
"""
ptable = make_partition_table()
for new_name in generate_strings_list(length=randint(4, 30)):
with self.subTest(new_name):
PartitionTable.update({'id': ptable['id'], 'new-name': new_name})
ptable = PartitionTable.info({'id': ptable['id']})
self.assertEqual(ptable['name'], new_name)
def test_positive_add_os_by_name(self):
"""Create a partition table then add an operating system to it using
names for association
@Feature: Partition Table
@Assert: Operating system is added to partition table
"""
ptable = make_partition_table()
os = make_os()
PartitionTable.add_operating_system({
'name': ptable['name'],
'operatingsystem': os['title'],
})
ptable = PartitionTable.info({'name': ptable['name']})
self.assertIn(os['title'], ptable['operating-systems'])
def test_positive_add_os_by_name(self):
"""Create a partition table then add an operating system to it using
names for association
:id: ad97800a-0ef8-4ee9-ab49-05c82c77017f
:expectedresults: Operating system is added to partition table
:CaseLevel: Integration
"""
ptable = make_partition_table()
os = make_os()
PartitionTable.add_operating_system(
{'name': ptable['name'], 'operatingsystem': os['title']}
)
ptable = PartitionTable.info({'name': ptable['name']})
self.assertIn(os['title'], ptable['operating-systems'])
def test_positive_add_remove_os_by_id(self):
"""Create a partition table then add and remove an operating system to it using
IDs for association
:id: 33b5ddca-2151-45cb-bf30-951c2733165f
:expectedresults: Operating system is added to partition table
:CaseLevel: Integration
"""
ptable = make_partition_table()
os = make_os()
PartitionTable.add_operating_system({'id': ptable['id'], 'operatingsystem-id': os['id']})
ptable = PartitionTable.info({'id': ptable['id']})
assert os['title'] in ptable['operating-systems']
PartitionTable.remove_operating_system({'id': ptable['id'], 'operatingsystem-id': os['id']})
ptable = PartitionTable.info({'id': ptable['id']})
assert os['title'] not in ptable['operating-systems']
