def test_positive_CRUD(self): """Create new user group with valid elements that attached group. List the user group, update and delete it. :id: bacef0e3-31dd-4991-93f7-f54fbe64d0f0 :expectedresults: User group is created, listed, updated and deleted successfully. :CaseImportance: Critical """ user = make_user() ug_name = random.choice(valid_usernames_list()) role_name = random.choice(valid_usernames_list()) role = make_role({'name': role_name}) sub_user_group = make_usergroup() # Create user_group = make_usergroup({ 'user-ids': user['id'], 'name': ug_name, 'role-ids': role['id'], 'user-group-ids': sub_user_group['id'], }) self.assertEqual(user_group['name'], ug_name) self.assertEqual(user_group['users'][0], user['login']) self.assertEqual(len(user_group['roles']), 1) self.assertEqual(user_group['roles'][0], role_name) self.assertEqual(user_group['user-groups'][0]['usergroup'], sub_user_group['name']) # List result_list = UserGroup.list( {'search': 'name={0}'.format(user_group['name'])}) self.assertTrue(len(result_list) > 0) self.assertTrue(UserGroup.exists(search=('name', user_group['name']))) # Update new_name = random.choice(valid_usernames_list()) UserGroup.update({'id': user_group['id'], 'new-name': new_name}) user_group = UserGroup.info({'id': user_group['id']}) self.assertEqual(user_group['name'], new_name) # Delete UserGroup.delete({'name': user_group['name']}) with self.assertRaises(CLIReturnCodeError): UserGroup.info({'name': user_group['name']})
def test_filtered_datapoint_True(self): """Tests if run_one_datapoint=false returns all data points""" settings.run_one_datapoint = False self.assertEqual(len(generate_strings_list()), 7) self.assertEqual(len(invalid_emails_list()), 8) self.assertEqual(len(invalid_id_list()), 4) self.assertEqual(len(invalid_interfaces_list()), 8) self.assertEqual(len(invalid_names_list()), 7) self.assertEqual(len(invalid_values_list()), 10) self.assertEqual(len(invalid_usernames_list()), 4) self.assertEqual(len(valid_labels_list()), 2) self.assertEqual(len(valid_data_list()), 7) self.assertEqual(len(valid_emails_list()), 8) self.assertEqual(len(valid_environments_list()), 4) self.assertEqual(len(valid_hosts_list()), 3) self.assertEqual(len(valid_hostgroups_list()), 7) self.assertEqual(len(valid_interfaces_list()), 3) self.assertEqual(len(valid_names_list()), 15) self.assertEqual(len(valid_org_names_list()), 7) self.assertEqual(len(valid_usernames_list()), 6) with mock.patch('robottelo.datafactory.bz_bug_is_open', return_value=True): self.assertEqual(len(valid_docker_repository_names()), 6) with mock.patch('robottelo.datafactory.bz_bug_is_open', return_value=False): self.assertEqual(len(valid_docker_repository_names()), 7)
def test_user_remove_role_1(self): """@Test: Remove role to User for all variations of role names @Feature: User - Remove role @Steps: 1. Create role and add it to the user . Try to remove the role @Assert: Role is removed @BZ: 1138553 """ user = make_user() include_list = [gen_string("alphanumeric", 100)] for role_name in valid_usernames_list() + include_list: with self.subTest(role_name): make_role({'name': role_name}) self.__assert_exists(user) UserObj.add_role({ 'login': user['login'], 'role': role_name, }) user = UserObj.info({'id': user['id']}) self.assertIn(role_name, user['roles']) UserObj.remove_role({ 'login': user['login'], 'role': role_name, }) user = UserObj.info({'id': user['id']}) self.assertNotIn(role_name, user['roles'])
def test_positive_remove_role(self): """Remove role from User for all variations of role names @Feature: User - Remove role @Assert: Role is removed @BZ: 1138553 """ user = make_user() include_list = [gen_string("alphanumeric", 100)] for role_name in valid_usernames_list() + include_list: with self.subTest(role_name): make_role({'name': role_name}) User.add_role({ 'login': user['login'], 'role': role_name, }) user = User.info({'id': user['id']}) self.assertIn(role_name, user['roles']) User.remove_role({ 'login': user['login'], 'role': role_name, }) user = User.info({'id': user['id']}) self.assertNotIn(role_name, user['roles'])
def test_positive_remove_role(self): """Remove role from User for all variations of role names @id: 51b15516-da42-4149-8032-87baa93f9e56 @Assert: Role is removed @BZ: 1138553 @CaseLevel: Integration """ user = make_user() include_list = [gen_string("alphanumeric", 100)] for role_name in valid_usernames_list() + include_list: with self.subTest(role_name): make_role({'name': role_name}) User.add_role({ 'login': user['login'], 'role': role_name, }) user = User.info({'id': user['id']}) self.assertIn(role_name, user['roles']) User.remove_role({ 'login': user['login'], 'role': role_name, }) user = User.info({'id': user['id']}) self.assertNotIn(role_name, user['roles'])
def test_return_type(self): """This test validates return types for functions: 1. :meth:`robottelo.datafactory.generate_strings_list` 2. :meth:`robottelo.datafactory.invalid_emails_list` 3. :meth:`robottelo.datafactory.invalid_names_list` 4. :meth:`robottelo.datafactory.valid_data_list` 5. :meth:`robottelo.datafactory.valid_emails_list` 6. :meth:`robottelo.datafactory.valid_environments_list` 7. :meth:`robottelo.datafactory.valid_labels_list` 8. :meth:`robottelo.datafactory.valid_names_list` 9. :meth:`robottelo.datafactory.valid_usernames_list` 10. :meth:`robottelo.datafactory.invalid_id_list` """ for item in itertools.chain( generate_strings_list(), invalid_emails_list(), invalid_names_list(), valid_data_list(), valid_emails_list(), valid_environments_list(), valid_labels_list(), valid_names_list(), valid_usernames_list(),): self.assertIsInstance(item, six.text_type) for item in invalid_id_list(): if not (isinstance(item, (six.text_type, int)) or item is None): self.fail('Unexpected data type')
def test_list_user_3(self): """@Test: List User for all variations of Surname @Feature: User - list @Steps: 1. Create User for all Surname variations in [1] using valid Username, First Name, Email Address, Language, authorized by 2. List User @Assert: User is listed """ include_list = [gen_string("alphanumeric", 50)] for lastname in valid_usernames_list() + include_list: with self.subTest(lastname): user = make_user({'lastname': lastname}) self.__assert_exists(user) result = UserObj.list({ u'search': u'lastname = {0}'.format(lastname), }) # make sure user is in list result self.assertIn({ 'email': user['email'], 'id': user['id'], 'login': user['login'], 'name': user['name'], }, result)
def test_filtered_datapoint_True(self): """Tests if run_one_datapoint=false returns all data points""" settings.run_one_datapoint = False self.assertEqual(len(generate_strings_list()), 7) self.assertEqual(len(invalid_emails_list()), 8) self.assertEqual(len(invalid_id_list()), 4) self.assertEqual(len(invalid_interfaces_list()), 8) self.assertEqual(len(invalid_names_list()), 7) self.assertEqual(len(invalid_values_list()), 10) self.assertEqual(len(invalid_usernames_list()), 4) self.assertEqual(len(valid_labels_list()), 2) self.assertEqual(len(valid_data_list()), 7) self.assertEqual(len(valid_emails_list()), 8) self.assertEqual(len(valid_environments_list()), 4) self.assertEqual(len(valid_hosts_list()), 3) self.assertEqual(len(valid_hostgroups_list()), 7) self.assertEqual(len(valid_interfaces_list()), 3) self.assertEqual(len(valid_names_list()), 15) self.assertEqual(len(valid_org_names_list()), 7) self.assertEqual(len(valid_usernames_list()), 6) self.assertEqual(len((valid_cron_expressions())), 4) with mock.patch('robottelo.datafactory.bz_bug_is_open', return_value=True): self.assertEqual(len(valid_docker_repository_names()), 6) with mock.patch('robottelo.datafactory.bz_bug_is_open', return_value=False): self.assertEqual(len(valid_docker_repository_names()), 7)
def test_filtered_datapoint(self, run_one_datapoint): """Tests if run_one_datapoint=false returns all data points""" if run_one_datapoint: assert len(datafactory.generate_strings_list()) == 1 assert len(datafactory.invalid_emails_list()) == 1 assert len(datafactory.invalid_environments_list()) == 1 assert len(datafactory.invalid_id_list()) == 1 assert len(datafactory.invalid_interfaces_list()) == 1 assert len(datafactory.invalid_names_list()) == 1 assert len(datafactory.invalid_values_list()) == 1 assert len(datafactory.valid_data_list()) == 1 assert len(datafactory.valid_docker_repository_names()) == 1 assert len(datafactory.valid_emails_list()) == 1 assert len(datafactory.valid_environments_list()) == 1 assert len(datafactory.valid_hosts_list()) == 1 assert len(datafactory.valid_hostgroups_list()) == 1 assert len(datafactory.valid_interfaces_list()) == 1 assert len(datafactory.valid_labels_list()) == 1 assert len(datafactory.valid_names_list()) == 1 assert len(datafactory.valid_org_names_list()) == 1 assert len(datafactory.valid_usernames_list()) == 1 assert len(datafactory.valid_cron_expressions()) == 1 else: assert len(datafactory.generate_strings_list()) == 7 assert len(datafactory.invalid_emails_list()) == 8 assert len(datafactory.invalid_environments_list()) == 4 assert len(datafactory.invalid_id_list()) == 4 assert len(datafactory.invalid_interfaces_list()) == 8 assert len(datafactory.invalid_names_list()) == 7 assert len(datafactory.invalid_values_list()) == 10 assert len(datafactory.invalid_usernames_list()) == 4 assert len(datafactory.valid_labels_list()) == 2 assert len(datafactory.valid_data_list()) == 7 assert len(datafactory.valid_emails_list()) == 8 assert len(datafactory.valid_environments_list()) == 4 assert len(datafactory.valid_hosts_list()) == 3 assert len(datafactory.valid_hostgroups_list()) == 7 assert len(datafactory.valid_interfaces_list()) == 3 assert len(datafactory.valid_names_list()) == 15 assert len(datafactory.valid_org_names_list()) == 7 assert len(datafactory.valid_usernames_list()) == 6 assert len(datafactory.valid_cron_expressions()) == 4 assert len(datafactory.valid_docker_repository_names()) == 7
def test_positive_create_with_username(self): """Create User for all variations of Username @Feature: User - Positive Create @Assert: User is created """ for username in valid_usernames_list(): with self.subTest(username): user = entities.User(login=username).create() self.assertEqual(user.login, username)
def test_positive_create_with_username(self): """Create User for all variations of Username @id: a9827cda-7f6d-4785-86ff-3b6969c9c00a @Assert: User is created """ for username in valid_usernames_list(): with self.subTest(username): user = entities.User(login=username).create() self.assertEqual(user.login, username)
def test_positive_create_with_firstname(self): """Create User for all variations of First Name @id: b5f07890-020c-4ea0-a519-75d325127b2b @Assert: User is created """ include_list = [gen_string("alphanumeric", 50)] for firstname in valid_usernames_list() + include_list: with self.subTest(firstname): user = make_user({'firstname': firstname}) self.assertIn(firstname, user['name'])
def test_positive_create_with_name(self): """Create User for all variations of Username @Feature: User - Positive Create @Assert: User is created """ include_list = [gen_string("alphanumeric", 100)] for login in valid_usernames_list() + include_list: with self.subTest(login): user = make_user({'login': login}) self.assertEqual(user['login'], login)
def test_positive_create_with_name(self): """Create User for all variations of Username @id: 2d430243-8512-46ee-8d21-7ccf0c7af807 @Assert: User is created """ include_list = [gen_string("alphanumeric", 100)] for login in valid_usernames_list() + include_list: with self.subTest(login): user = make_user({'login': login}) self.assertEqual(user['login'], login)
def test_positive_create_with_surname(self): """Create User for all variations of Surname @Feature: User - Positive Create @Assert: User is created """ include_list = [gen_string("alphanumeric", 50)] for lastname in valid_usernames_list() + include_list: with self.subTest(lastname): user = make_user({'lastname': lastname}) self.assertIn(lastname, user['name'])
def test_positive_create_with_password(self): """Create User for all variations of Password @id: cffb7317-0a17-4fff-bd2b-66d295cd40ad @Assert: User is created """ include_list = [gen_string("alphanumeric", 3000)] for password in valid_usernames_list() + include_list: with self.subTest(password): user = make_user({'password': password}) self.assertTrue(user)
def test_positive_create_with_password(self): """Create User for all variations of Password @Feature: User - Positive Create @Assert: User is created """ include_list = [gen_string("alphanumeric", 3000)] for password in valid_usernames_list() + include_list: with self.subTest(password): user = make_user({'password': password}) self.assertTrue(user)
def test_positive_create_with_surname(self): """Create User for all variations of Surname @id: 1b3d7014-6575-4cfd-b6d7-8ff2bfef587e @Assert: User is created """ include_list = [gen_string("alphanumeric", 50)] for lastname in valid_usernames_list() + include_list: with self.subTest(lastname): user = make_user({'lastname': lastname}) self.assertIn(lastname, user['name'])
def test_positive_delete_admin(self): """Delete an admin user @id: 9752706c-fdbd-4a36-af6f-27824d22ea03 @Assert: User is deleted """ for login in valid_usernames_list(): with self.subTest(login), self.assertRaises(CLIReturnCodeError): user = make_user({"login": login, "admin": 'true'}) self.assertEqual(user['admin'], 'yes') User.delete({'login': user['login']}) User.info({'login': user['login']})
def test_positive_create_with_username(self): """Create User for all variations of Username :id: a9827cda-7f6d-4785-86ff-3b6969c9c00a :expectedresults: User is created :CaseImportance: Critical """ for username in valid_usernames_list(): with self.subTest(username): user = entities.User(login=username).create() self.assertEqual(user.login, username)
def test_positive_create_with_user(self): """Create new user group using valid user attached to that group. @id: ab127e09-31d2-4c5b-ae6c-726e4b11a21e @Assert: User group is created successfully. """ for login in valid_usernames_list(): with self.subTest(login): user = entities.User(login=login).create() user_group = entities.UserGroup(user=[user]).create() self.assertEqual(len(user_group.user), 1) self.assertEqual(user_group.user[0].read().login, login)
def test_positive_create_with_user(self): """Create new user group using valid user attached to that group. @Feature: Usergroup @Assert: User group is created successfully. """ for login in valid_usernames_list(): with self.subTest(login): user = entities.User(login=login).create() user_group = entities.UserGroup(user=[user]).create() self.assertEqual(len(user_group.user), 1) self.assertEqual(user_group.user[0].read().login, login)
def test_positive_delete_by_name(self): """Create an user and then delete it using its name @Feature: User - Positive Delete @Assert: User is deleted """ for login in valid_usernames_list(): with self.subTest(login): user = make_user({'login': login}) self.assertEqual(user['login'], login) User.delete({'login': user['login']}) with self.assertRaises(CLIReturnCodeError): User.info({'login': user['login']})
def test_positive_create_with_user_name(self): """Create new user group using valid user attached to that group. Use user name as a parameter @Feature: Usergroup @Assert: User group is created successfully. """ for login in valid_usernames_list(): with self.subTest(login): user = make_user({'login': login}) user_group = make_usergroup({'users': user['login']}) self.assertEqual(len(user_group['users']), 1) self.assertEqual(user_group['users'][0], login)
def test_datacheck_False(self): """Tests if run_one_datapoint=True returns one data point""" settings.run_one_datapoint = True self.assertEqual(len(generate_strings_list()), 1) self.assertEqual(len(invalid_emails_list()), 1) self.assertEqual(len(invalid_id_list()), 1) self.assertEqual(len(invalid_names_list()), 1) self.assertEqual(len(invalid_values_list()), 1) self.assertEqual(len(valid_data_list()), 1) self.assertEqual(len(valid_emails_list()), 1) self.assertEqual(len(valid_environments_list()), 1) self.assertEqual(len(valid_labels_list()), 1) self.assertEqual(len(valid_names_list()), 1) self.assertEqual(len(valid_usernames_list()), 1)
def test_datacheck_True(self): """Tests if run_one_datapoint=false returns all data points""" settings.run_one_datapoint = False self.assertEqual(len(generate_strings_list()), 7) self.assertEqual(len(invalid_id_list()), 4) self.assertEqual(len(invalid_emails_list()), 10) self.assertEqual(len(invalid_names_list()), 7) self.assertEqual(len(invalid_values_list()), 10) self.assertEqual(len(valid_labels_list()), 2) self.assertEqual(len(valid_data_list()), 7) self.assertEqual(len(valid_emails_list()), 8) self.assertEqual(len(valid_environments_list()), 3) self.assertEqual(len(valid_names_list()), 15) self.assertEqual(len(valid_usernames_list()), 4)
def test_positive_delete_by_name(self): """Create an user and then delete it using its name @id: 37cf4313-012f-4215-b537-030ee61c1c3c @Assert: User is deleted """ for login in valid_usernames_list(): with self.subTest(login): user = make_user({'login': login}) self.assertEqual(user['login'], login) User.delete({'login': user['login']}) with self.assertRaises(CLIReturnCodeError): User.info({'login': user['login']})
def test_positive_delete_admin(self): """Delete an admin user @Feature: User - Positive Delete @Assert: User is deleted """ for login in valid_usernames_list(): with self.subTest(login): user = make_user({"login": login, "admin": 'true'}) self.assertEqual(user['admin'], 'yes') User.delete({'login': user['login']}) with self.assertRaises(CLIReturnCodeError): User.info({'login': user['login']})
def test_positive_delete_by_name(self): """Create an user and then delete it using its name @id: 37cf4313-012f-4215-b537-030ee61c1c3c @Assert: User is deleted """ for login in valid_usernames_list(): with self.subTest(login), self.assertRaises(CLIReturnCodeError): user = make_user({'login': login}) self.assertEqual(user['login'], login) User.delete({'login': user['login']}) User.info({'login': user['login']})
def test_positive_create_with_user(self): """Create new user group using valid user attached to that group. :id: ab127e09-31d2-4c5b-ae6c-726e4b11a21e :expectedresults: User group is created successfully. :CaseImportance: Critical """ for login in valid_usernames_list(): with self.subTest(login): user = entities.User(login=login).create() user_group = entities.UserGroup(user=[user]).create() self.assertEqual(len(user_group.user), 1) self.assertEqual(user_group.user[0].read().login, login)
def test_positive_create_in_ldap_mode(self): """Create User in ldap mode :id: 6f8616b1-5380-40d2-8678-7c4434050cfb :expectedresults: User is created without specifying the password :CaseLevel: Integration """ for username in valid_usernames_list(): with self.subTest(username): user = entities.User( login=username, auth_source=self.authsource, password='' ).create() self.assertEqual(user.login, username)
def test_positive_update_username(self): """Update a user and provide new username. :id: a8e218b1-7256-4f20-91f3-3958d58ea5a8 :expectedresults: The user's ``Username`` attribute is updated. :CaseImportance: Critical """ user = entities.User().create() for login in valid_usernames_list(): with self.subTest(login): user.login = login user = user.update(['login']) self.assertEqual(user.login, login)
def test_positive_update_password(self): """Update Password/Verify fields for existing User @id: 065197ab-1352-4da8-9df6-b6ff332e6847 @Assert: User is updated """ user = self.user for password in valid_usernames_list(): with self.subTest(password): User.update({ 'id': user['id'], 'password': password, }) user = User.info({'id': user['id']}) self.assertTrue(user)
def test_positive_update_password(self): """Update Password/Verify fields for existing User @id: 065197ab-1352-4da8-9df6-b6ff332e6847 @Assert: User is updated """ user = make_user() for password in valid_usernames_list(): with self.subTest(password): User.update({ 'id': user['id'], 'password': password, }) user = User.info({'id': user['id']}) self.assertTrue(user)
def test_positive_create_user_5(self): """@Test: Create User for all variations of Password @Feature: User - Positive Create @Steps: 1. Create User for all valid Password variation in [1] using valid Username, First Name, Surname, Email Address, Language, authorized by @Assert: User is created """ include_list = [gen_string("alphanumeric", 3000)] for password in valid_usernames_list() + include_list: with self.subTest(password): user = make_user({'password': password}) self.__assert_exists(user)
def test_positive_update_password(self): """Update Password/Verify fields for existing User @Feature: User - Positive Update @Assert: User is updated """ user = make_user() for password in valid_usernames_list(): with self.subTest(password): User.update({ 'id': user['id'], 'password': password, }) user = User.info({'id': user['id']}) self.assertTrue(user)
def test_positive_create_user_1(self): """@Test: Create User for all variations of Username @Feature: User - Positive Create @Steps: 1. Create User for all valid Username variation in [1] using valid First Name, Surname, Email Address, Language, authorized by @Assert: User is created """ include_list = [gen_string("alphanumeric", 100)] for login in valid_usernames_list() + include_list: with self.subTest(login): user = make_user({'login': login}) self.__assert_exists(user)
def test_positive_delete_by_name(self): """Create an user and then delete it using its name :id: 37cf4313-012f-4215-b537-030ee61c1c3c :expectedresults: User is deleted :CaseImportance: Critical """ for login in valid_usernames_list(): with self.subTest(login), self.assertRaises(CLIReturnCodeError): user = make_user({'login': login}) self.assertEqual(user['login'], login) User.delete({'login': user['login']}) User.info({'login': user['login']})
def test_positive_create_with_user_name(self): """Create new user group using valid user attached to that group. Use user name as a parameter :id: 50baa271-c741-4905-aa56-a3ee48be0dc0 :expectedresults: User group is created successfully. :CaseImportance: Critical """ for login in valid_usernames_list(): with self.subTest(login): user = make_user({'login': login}) user_group = make_usergroup({'users': user['login']}) self.assertEqual(len(user_group['users']), 1) self.assertEqual(user_group['users'][0], login)
def test_return_type(self): """This test validates return types for functions: 1. :meth:`robottelo.datafactory.generate_strings_list` 2. :meth:`robottelo.datafactory.invalid_emails_list` 3. :meth:`robottelo.datafactory.invalid_names_list` 4. :meth:`robottelo.datafactory.valid_data_list` 5. :meth:`robottelo.datafactory.valid_docker_repository_names` 6. :meth:`robottelo.datafactory.valid_emails_list` 7. :meth:`robottelo.datafactory.valid_environments_list` 8. :meth:`robottelo.datafactory.valid_hosts_list` 9. :meth:`robottelo.datafactory.valid_hostgroups_list` 10. :meth:`robottelo.datafactory.valid_labels_list` 11. :meth:`robottelo.datafactory.valid_names_list` 12. :meth:`robottelo.datafactory.valid_org_names_list` 13. :meth:`robottelo.datafactory.valid_usernames_list` 14. :meth:`robottelo.datafactory.invalid_id_list` 15. :meth:`robottelo.datafactory.invalid_interfaces_list` 16. :meth:`robottelo.datafactory.valid_interfaces_list` 17. :meth:`robottelo.datafactory.valid_cron_expressions` """ with mock.patch('robottelo.datafactory.bz_bug_is_open', return_value=False): for item in itertools.chain( generate_strings_list(), invalid_emails_list(), invalid_interfaces_list(), invalid_names_list(), valid_data_list(), valid_docker_repository_names(), valid_emails_list(), valid_environments_list(), valid_hosts_list(), valid_hostgroups_list(), valid_interfaces_list(), valid_labels_list(), valid_names_list(), valid_org_names_list(), valid_cron_expressions(), valid_usernames_list()): self.assertIsInstance(item, six.text_type) for item in invalid_id_list(): if not ( isinstance(item, (six.text_type, int)) or item is None ): self.fail('Unexpected data type')
def test_positive_update_lastname(self): """Update Last Name value for existing User @id: 03479f69-7606-46b3-9dc1-664d30f40ae1 @Assert: User is updated """ user = self.user for new_lastname in valid_usernames_list(): with self.subTest(new_lastname): User.update({ 'id': user['id'], 'lastname': new_lastname, }) user = User.info({'id': user['id']}) last_name_after = user['name'].split(' ') self.assertEqual(last_name_after[1], new_lastname)
def test_return_type(self): """This test validates return types for functions: 1. :meth:`robottelo.datafactory.generate_strings_list` 2. :meth:`robottelo.datafactory.invalid_emails_list` 3. :meth:`robottelo.datafactory.invalid_environments_list` 4. :meth:`robottelo.datafactory.invalid_names_list` 5. :meth:`robottelo.datafactory.valid_data_list` 6. :meth:`robottelo.datafactory.valid_docker_repository_names` 7. :meth:`robottelo.datafactory.valid_emails_list` 8. :meth:`robottelo.datafactory.valid_environments_list` 9. :meth:`robottelo.datafactory.valid_hosts_list` 10. :meth:`robottelo.datafactory.valid_hostgroups_list` 11. :meth:`robottelo.datafactory.valid_labels_list` 12. :meth:`robottelo.datafactory.valid_names_list` 13. :meth:`robottelo.datafactory.valid_org_names_list` 14. :meth:`robottelo.datafactory.valid_usernames_list` 15. :meth:`robottelo.datafactory.invalid_id_list` 16. :meth:`robottelo.datafactory.invalid_interfaces_list` 17. :meth:`robottelo.datafactory.valid_interfaces_list` 18. :meth:`robottelo.datafactory.valid_cron_expressions` """ for item in itertools.chain( datafactory.generate_strings_list(), datafactory.invalid_emails_list(), datafactory.invalid_environments_list(), datafactory.invalid_interfaces_list(), datafactory.invalid_names_list(), datafactory.valid_data_list(), datafactory.valid_docker_repository_names(), datafactory.valid_emails_list(), datafactory.valid_environments_list(), datafactory.valid_hosts_list(), datafactory.valid_hostgroups_list(), datafactory.valid_interfaces_list(), datafactory.valid_labels_list(), datafactory.valid_names_list(), datafactory.valid_org_names_list(), datafactory.valid_cron_expressions(), datafactory.valid_usernames_list(), ): assert isinstance(item, str) for item in datafactory.invalid_id_list(): if not (isinstance(item, (str, int)) or item is None): pytest.fail('Unexpected data type')
def test_positive_update_username(self): """Update username value for existing User @id: 72734d5a-bfba-4db8-9c8f-cc6190c74b69 @Assert: User is updated """ user = self.user include_list = [gen_string("alphanumeric", 100)] for new_login in valid_usernames_list() + include_list: with self.subTest(new_login): User.update({ 'id': user['id'], 'login': new_login, }) user = User.info({'id': user['id']}) self.assertEqual(user['login'], new_login)