コード例 #1
0
    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']})
コード例 #2
0
ファイル: test_datafactory.py プロジェクト: renzon/robottelo
 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)
コード例 #3
0
ファイル: test_user.py プロジェクト: cpeters/robottelo
    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'])
コード例 #4
0
    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'])
コード例 #5
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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'])
コード例 #6
0
ファイル: test_datafactory.py プロジェクト: cpeters/robottelo
    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')
コード例 #7
0
ファイル: test_user.py プロジェクト: cpeters/robottelo
    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)
コード例 #8
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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'])
コード例 #9
0
 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)
コード例 #10
0
 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
コード例 #11
0
    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)
コード例 #12
0
ファイル: test_user.py プロジェクト: rohitkadam19/robottelo
    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)
コード例 #13
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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)
コード例 #14
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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)
コード例 #15
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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'])
コード例 #16
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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)
コード例 #17
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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)
コード例 #18
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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'])
コード例 #19
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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)
コード例 #20
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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)
コード例 #21
0
    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)
コード例 #22
0
    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'])
コード例 #23
0
    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'])
コード例 #24
0
    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'])
コード例 #25
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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'])
コード例 #26
0
    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)
コード例 #27
0
    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)
コード例 #28
0
    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)
コード例 #29
0
    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']})
コード例 #30
0
ファイル: test_user.py プロジェクト: Ichimonji10/robottelo
    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']})
コード例 #31
0
    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)
コード例 #32
0
    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)
コード例 #33
0
ファイル: test_user.py プロジェクト: JacobCallahan/robottelo
    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)
コード例 #34
0
    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)
コード例 #35
0
    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']})
コード例 #36
0
    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)
コード例 #37
0
ファイル: test_usergroup.py プロジェクト: anarang/robottelo
    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)
コード例 #38
0
ファイル: test_datafactory.py プロジェクト: cpeters/robottelo
 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)
コード例 #39
0
ファイル: test_datafactory.py プロジェクト: cpeters/robottelo
 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)
コード例 #40
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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']})
コード例 #41
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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']})
コード例 #42
0
ファイル: test_user.py プロジェクト: anarang/robottelo
    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']})
コード例 #43
0
    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']})
コード例 #44
0
    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']})
コード例 #45
0
    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)
コード例 #46
0
    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)
コード例 #47
0
ファイル: test_user.py プロジェクト: JacobCallahan/robottelo
    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)
コード例 #48
0
    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)
コード例 #49
0
    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)
コード例 #50
0
ファイル: test_user.py プロジェクト: waffle-iron/robottelo
    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)
コード例 #51
0
ファイル: test_user.py プロジェクト: cpeters/robottelo
    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)
コード例 #52
0
    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)
コード例 #53
0
ファイル: test_user.py プロジェクト: cpeters/robottelo
    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)
コード例 #54
0
ファイル: test_user.py プロジェクト: elyezer/robottelo
    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']})
コード例 #55
0
ファイル: test_usergroup.py プロジェクト: elyezer/robottelo
    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)
コード例 #56
0
    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)
コード例 #57
0
    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')
コード例 #58
0
    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)
コード例 #59
0
    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')
コード例 #60
0
    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)