def test_positive_create_with_template(self): """Create an operating system that points at a config template. :id: df73ecba-5a1c-4201-9c2f-b2e03e8fec25 :expectedresults: The operating system is created and points at the expected config template. :CaseLevel: Integration """ template = entities.ConfigTemplate(organization=[self.org]).create() operating_sys = entities.OperatingSystem(config_template=[template]).create() self.assertEqual(len(operating_sys.config_template), 1) self.assertEqual(operating_sys.config_template[0].id, template.id)
def test_negative_create_with_invalid_name(self): """Try to create operating system entity providing an invalid name :id: cd4286fd-7128-4385-9c8d-ef979c22ee38 :expectedresults: Operating system entity is not created :CaseImportance: Critical """ for name in invalid_values_list(): with self.subTest(name): with self.assertRaises(HTTPError): entities.OperatingSystem(name=name).create()
def test_negative_create_with_invalid_minor_version(self): """Try to create operating system entity providing incorrect minor version value (More than 16 characters and negative number) :id: dec4b456-153c-4a66-8b8e-b12ac7800e51 :expectedresults: Operating system entity is not created :CaseImportance: Critical """ for minor_version in gen_string('numeric', 17), '-5': with self.subTest(minor_version): with self.assertRaises(HTTPError): entities.OperatingSystem(minor=minor_version).create()
def test_positive_create_with_ptable(self): """Create an operating system that points at a partition table. :id: bef37ff9-d8fa-4518-9073-0518aa9f9a42 :expectedresults: The operating system is created and points at the given partition table. :CaseLevel: Integration """ ptable = entities.PartitionTable().create() operating_sys = entities.OperatingSystem(ptable=[ptable]).create() self.assertEqual(len(operating_sys.ptable), 1) self.assertEqual(operating_sys.ptable[0].id, ptable.id)
def test_positive_create_with_media(self): """Create an operating system that points at a media. :id: 56fadee4-c676-48b6-a2db-e6fef9d2a575 :expectedresults: The operating system is created and points at the given media. :CaseLevel: Integration """ medium = entities.Media(organization=[self.org]).create() operating_sys = entities.OperatingSystem(medium=[medium]).create() self.assertEqual(len(operating_sys.medium), 1) self.assertEqual(operating_sys.medium[0].id, medium.id)
def clone_setup(module_org, module_loc): name = gen_string('alpha') content = gen_string('alpha') os_list = [entities.OperatingSystem().create().title for _ in range(2)] return { 'pt': entities.ProvisioningTemplate(name=name, organization=[module_org], location=[module_loc], template=content, snippet=False).create(), 'os_list': os_list }
def test_positive_create_with_arch(self): """Create an operating system that points at an architecture. :id: 6a3f7183-b0bf-4834-8c69-a49fe8d7ee5a :expectedresults: The operating system is created and points at the given architecture. :CaseLevel: Integration """ arch = entities.Architecture().create() operating_sys = entities.OperatingSystem(architecture=[arch]).create() self.assertEqual(len(operating_sys.architecture), 1) self.assertEqual(operating_sys.architecture[0].id, arch.id)
def test_negative_create_with_invalid_minor_version(self, minor_version): """Try to create operating system entity providing incorrect minor version value (More than 16 characters and negative number) :id: dec4b456-153c-4a66-8b8e-b12ac7800e51 :parametrized: yes :expectedresults: Operating system entity is not created :CaseImportance: Critical """ with pytest.raises(HTTPError): entities.OperatingSystem(minor=minor_version).create()
def test_positive_create_with_name(self, name): """Create operating system with valid name only :id: e95707bf-3344-4d85-866f-4642a8f66cff :parametrized: yes :expectedresults: Operating system entity is created and has proper name :CaseImportance: Critical """ os = entities.OperatingSystem(name=name).create() assert os.name == name
def test_negative_create_with_invalid_name(self, name): """Try to create operating system entity providing an invalid name :id: cd4286fd-7128-4385-9c8d-ef979c22ee38 :parametrized: yes :expectedresults: Operating system entity is not created :CaseImportance: Critical """ with pytest.raises(HTTPError): entities.OperatingSystem(name=name).create()
def test_negative_create_with_too_long_description(self): """Try to create operating system entity providing too long description value :id: fe5fc36a-5994-4d8a-91f6-0425765b8c39 :expectedresults: Operating system entity is not created :BZ: 1328935 :CaseImportance: Critical """ with pytest.raises(HTTPError): entities.OperatingSystem(description=gen_string('alphanumeric', 256)).create()
def test_positive_create_with_template(self, module_org): """Create an operating system that points at a provisioning template. :id: df73ecba-5a1c-4201-9c2f-b2e03e8fec25 :expectedresults: The operating system is created and points at the expected provisioning template. :CaseLevel: Integration """ template = entities.ProvisioningTemplate(organization=[module_org]).create() operating_sys = entities.OperatingSystem(provisioning_template=[template]).create() assert len(operating_sys.provisioning_template) == 1 assert operating_sys.provisioning_template[0].id == template.id
def test_positive_create_with_password_hash(self, pass_hash): """Create operating system with valid password hash option :id: 00830e71-b414-41ab-bc8f-03fd2fbd5a84 :parametrized: yes :expectedresults: Operating system entity is created and has proper password hash type :CaseImportance: Critical """ os = entities.OperatingSystem(password_hash=pass_hash).create() assert os.password_hash == pass_hash
def test_positive_read_minor_version_as_string(self): """Create an operating system with an integer minor version. :id: b45e0b94-62f7-45ff-a19e-83c7a0f51339 :expectedresults: The minor version can be read back as a string. :CaseImportance: Critical :BZ: 1230902 """ minor = int(gen_string('numeric', random.randint(1, 16))) operating_sys = entities.OperatingSystem(minor=minor).create() assert operating_sys.minor == str(minor)
def test_positive_media_read(self): """Create a media pointing at an OS and read the media. :id: 67b656fe-9302-457a-b544-3addb11c85e0 :expectedresults: The media points at the correct operating system. :CaseImportance: Critical """ os_id = entities.OperatingSystem().create_json()['id'] media_id = entities.Media(operatingsystem=[os_id]).create_json()['id'] media = entities.Media(id=media_id).read() self.assertEqual(len(media.operatingsystem), 1) self.assertEqual(media.operatingsystem[0].id, os_id)
def test_positive_create_with_password_hash(self): """Create operating system with valid password hash option :id: 00830e71-b414-41ab-bc8f-03fd2fbd5a84 :expectedresults: Operating system entity is created and has proper password hash type :CaseImportance: Critical """ for pass_hash in ['SHA256', 'SHA512']: with self.subTest(pass_hash): os = entities.OperatingSystem(password_hash=pass_hash).create() self.assertEqual(os.password_hash, pass_hash)
def test_positive_end_to_end(session, module_org, module_loc): """Perform end to end testing for host group component :id: 537d95f2-fe32-4e06-a2cb-21c80fe8e2e2 :expectedresults: All expected CRUD actions finished successfully :CaseImportance: Critical """ name = gen_string('alpha') new_name = gen_string('alpha') description = gen_string('alpha') architecture = entities.Architecture().create() os = entities.OperatingSystem(architecture=[architecture]).create() os_name = f'{os.name} {os.major}' domain = entities.Domain(organization=[module_org], location=[module_loc]).create() with session: # Create host group with some data session.hostgroup.create({ 'host_group.name': name, 'host_group.description': description, 'host_group.lce': ENVIRONMENT, 'host_group.content_view': DEFAULT_CV, 'network.domain': domain.name, 'operating_system.architecture': architecture.name, 'operating_system.operating_system': os_name, }) hostgroup_values = session.hostgroup.read(name) assert hostgroup_values['host_group']['name'] == name assert hostgroup_values['host_group']['description'] == description assert hostgroup_values['host_group']['lce'] == ENVIRONMENT assert hostgroup_values['host_group']['content_view'] == DEFAULT_CV assert hostgroup_values['operating_system'][ 'architecture'] == architecture.name assert hostgroup_values['operating_system'][ 'operating_system'] == os_name # Update host group with new name session.hostgroup.update(name, {'host_group.name': new_name}) assert session.hostgroup.search(new_name)[0]['Name'] == new_name # Delete host group session.hostgroup.delete(new_name) assert not session.hostgroup.search(new_name)
def test_positive_create_with_name(self): """Create operating system with valid name only :id: e95707bf-3344-4d85-866f-4642a8f66cff :expectedresults: Operating system entity is created and has proper name :CaseImportance: Critical """ for name in valid_data_list(): with self.subTest(name): os = entities.OperatingSystem(name=name).create() self.assertEqual(os.name, name)
def test_positive_create_with_os_family(self): """Create operating system with every OS family possible :id: 6ad32d22-53cc-4bab-ac10-f466f75d7cc6 :expectedresults: Operating system entity is created and has proper OS family assigned :CaseImportance: Critical """ for os_family in OPERATING_SYSTEMS: with self.subTest(os_family): os = entities.OperatingSystem(family=os_family).create() self.assertEqual(os.family, os_family)
def test_positive_sort_by_os(self): """Create some Host entities and sort them by operation system ascendingly and then descendingly :id: 617e812d-258e-4ba4-8a9a-d7d02f2fb405 :customerscenario: true :expectedresults: Host entities are sorted properly :CaseImportance: High :BZ: 1268085 :CaseLevel: Integration """ org = entities.Organization().create() name_list = [gen_string('alpha', 20) for _ in range(5)] host = entities.Host(organization=org) host.create_missing() for name in name_list: os = entities.OperatingSystem(name=name).create() entities.Host( organization=org, architecture=host.architecture, domain=host.domain, environment=host.environment, location=host.location, mac=host.mac, medium=host.medium, operatingsystem=os, ptable=host.ptable, root_pass=host.root_pass, ).create() with Session(self) as session: set_context(session, org=org.name) self.hosts.navigate_to_entity() sorted_list_asc = self.hosts.sort_table_by_column( 'Operating system') self.assertEqual( [el.split(' ', 1)[0] for el in sorted_list_asc], sorted(name_list, key=six.text_type.lower) ) sorted_list_desc = self.hosts.sort_table_by_column( 'Operating system') self.assertEqual( [el.split(' ', 1)[0] for el in sorted_list_desc], sorted(name_list, key=six.text_type.lower, reverse=True) )
def test_positive_delete(self): """Create new operating system entity and then delete it. :id: 3dbffb56-ad99-441d-921c-0fad6504d257 :expectedresults: Operating System entity is deleted successfully :CaseImportance: Critical """ for name in valid_data_list(): with self.subTest(name): os = entities.OperatingSystem(name=name).create() os.delete() with self.assertRaises(HTTPError): os.read()
def test_negative_create_with_invalid_major_version(self): """Try to create operating system entity providing incorrect major version value (More than 5 characters, empty value, negative number) :id: f2646bc2-d639-4079-bdcb-ff76679f1457 :expectedresults: Operating system entity is not created :CaseImportance: Critical """ for major_version in gen_string('numeric', 6), '', '-6': with self.subTest(major_version): with self.assertRaises(HTTPError): entities.OperatingSystem(major=major_version).create()
def test_positive_create_with_os(self): """Create media entity assigned to operation system entity @id: dec22198-ed07-480c-9306-fa5458baec0b @Assert: Media entity is created and assigned to expected OS @CaseLevel: Integration """ os = entities.OperatingSystem().create() media = entities.Media( organization=[self.org], operatingsystem=[os], ).create() self.assertEqual(os.read().medium[0].read().name, media.name)
def test_positive_create_with_ptables(self): """Create an operating system that points at multiple different partition tables. @Feature: Operating System @Assert: The operating system is created and points at the expected partition tables. """ amount = range(random.randint(3, 5)) ptables = [entities.PartitionTable().create() for _ in amount] operating_sys = entities.OperatingSystem(ptable=ptables).create() self.assertEqual(len(operating_sys.ptable), len(amount)) self.assertEqual(set([ptable.id for ptable in operating_sys.ptable]), set([ptable.id for ptable in ptables]))
def test_positive_architecture_read(self): """Create an arch that points to an OS, and read the arch. :id: e4c7babe-11d8-4f85-8382-5267a49046e9 :expectedresults: The call to ``Architecture.read`` succeeds, and the response contains the correct operating system ID. :CaseImportance: Critical """ os_id = entities.OperatingSystem().create_json()['id'] arch_id = entities.Architecture(operatingsystem=[os_id]).create_json()['id'] architecture = entities.Architecture(id=arch_id).read() self.assertEqual(len(architecture.operatingsystem), 1) self.assertEqual(architecture.operatingsystem[0].id, os_id)
def test_positive_create_with_archs(self): """Create an operating system that points at multiple different architectures. @Feature: Operating System @Assert: The operating system is created and points at the expected architectures. """ amount = range(random.randint(3, 5)) archs = [entities.Architecture().create() for _ in amount] operating_sys = entities.OperatingSystem(architecture=archs).create() self.assertEqual(len(operating_sys.architecture), len(amount)) self.assertEqual(set([arch.id for arch in operating_sys.architecture]), set([arch.id for arch in archs]))
def test_positive_delete(self): """Delete an existing Architecture @Feature: Architecture - Delete @Assert: Architecture is deleted """ os = entities.OperatingSystem(name=gen_string('alpha')).create() with Session(self.browser) as session: for name in generate_strings_list(): with self.subTest(name): entities.Architecture( name=name, operatingsystem=[os]).create() session.nav.go_to_architectures() self.architecture.delete(name)
def test_positive_add_os(self): """Create an architecture and associate it with an OS. :id: 9943063d-34f3-4dbc-a341-474ec781e4d9 :expectedresults: The architecture can be created, and the association can be read back from the server. :CaseLevel: Integration """ operating_sys = entities.OperatingSystem().create() arch = entities.Architecture(operatingsystem=[operating_sys]).create() self.assertEqual({operating_sys.id}, {os.id for os in arch.operatingsystem})
def test_positive_add_os(self): """Create an architecture and associate it with an OS. @Assert: The architecture can be created, and the association can be read back from the server. @Feature: Architecture """ operating_sys = entities.OperatingSystem().create() arch = entities.Architecture(operatingsystem=[operating_sys]).create() self.assertEqual( {operating_sys.id}, {os.id for os in arch.operatingsystem}, )
def test_positive_delete(self, name): """Create new operating system entity and then delete it. :id: 3dbffb56-ad99-441d-921c-0fad6504d257 :parametrized: yes :expectedresults: Operating System entity is deleted successfully :CaseImportance: Critical """ os = entities.OperatingSystem(name=name).create() os.delete() with pytest.raises(HTTPError): os.read()