Python utils.create_random_str函数代码示例

    def test_validate_get_all_project_details(self):
        """ Check if managesf allow us to fetch projects details
        """
        project = 'p_%s' % create_random_str()
        self.create_project(project, config.USER_2)
        admin_cookies = dict(
            auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie'])
        user2_cookies = dict(
            auth_pubtkt=config.USERS[config.USER_2]['auth_cookie'])
        url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/")
        resp = requests.get(url, cookies=admin_cookies)
        self.assertEqual(200, resp.status_code)
        self.assertTrue(project in resp.json())
        self.assertTrue('config' in resp.json())
        resp = requests.get(url, cookies=user2_cookies)
        self.assertEqual(200, resp.status_code)
        self.assertTrue(project in resp.json())
        self.assertTrue('config' in resp.json())
        resp = requests.get(url, cookies=user2_cookies)

        # Validate the same behavior with project including a '/'
        project = 'p/%s' % create_random_str()
        self.create_project(project, config.USER_2)
        url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/")
        # Wait 15 seconds for managesf cache invalidation
        import time
        time.sleep(15)
        resp = requests.get(url, cookies=user2_cookies)
        self.assertEqual(200, resp.status_code)
        self.assertTrue(project in resp.json())

    def test_gitweb_access(self):
        """ Test if gitweb access works correctly
        """
        pub_pname = 'p_public_%s' % create_random_str()
        self.create_project(pub_pname)

        priv_pname = 'p_private_%s' % create_random_str()
        self.create_project(priv_pname, options={"private": ""})

        # Test access to a public repo first
        url = "%s/r/gitweb?p=%s.git" % (config.GATEWAY_URL, pub_pname)
        expected_title = "%s.git/summary" % pub_pname

        resp = requests.get(url)
        self.assertTrue(resp.url.endswith('/r/gitweb?p=%s.git' % pub_pname))
        self.assertTrue(expected_title in resp.text)

        # Test anonymous access to a private repo
        url = "%s/r/gitweb?p=%s.git" % (config.GATEWAY_URL, priv_pname)
        expected_title = "%s.git/summary" % priv_pname

        resp = requests.get(url)
        self.assertTrue("auth/login" in resp.url)
        self.assertFalse(expected_title in resp.text)

        # Test authenticated access to a private repo
        resp = requests.get(
            url,
            cookies=dict(
                auth_pubtkt=config.USERS[config.USER_1]['auth_cookie']))
        self.assertTrue(resp.url.endswith('/r/gitweb?p=%s.git' % priv_pname))
        self.assertTrue(expected_title in resp.text)

    def _test_update_issue_hooks(self, comment_template, status):
        """ A referenced issue in commit msg triggers the hook
        """
        pname = 'p_%s' % create_random_str()

        # Be sure the project does not exist
        self.msu.deleteProject(pname, self.u)

        # Create the project
        self.create_project(pname, self.u)
        # Put USER_2 as core for the project
        self.gu.add_group_member(self.u2, "%s-core" % pname)

        # Create an issue on the project
        issue_id = self.rm.create_issue(pname, "There is a problem")

        # Clone and commit something
        url = "ssh://%[email protected]%s:29418/%s" % (self.u, config.GATEWAY_HOST,
                                        pname)
        clone_dir = self.gitu.clone(url, pname)
        cmt_msg = comment_template % issue_id
        self.gitu.add_commit_and_publish(clone_dir, 'master', cmt_msg)

        # Check issue status (Gerrit hook updates the issue to in progress)
        attempt = 0
        while True:
            if self.rm.test_issue_status(issue_id, 'In Progress'):
                break
            if attempt > 10:
                break
            time.sleep(1)
            attempt += 1
        self.assertTrue(self.rm.test_issue_status(issue_id, 'In Progress'))
        self._test_merging(pname, issue_id, status)

    def test_review_labels(self):
        """ Test if list of review labels are as expected
        """
        pname = 'p_%s' % create_random_str()
        self.create_project(pname)
        un = config.ADMIN_USER
        gu = GerritUtils(
            config.GATEWAY_URL,
            auth_cookie=config.USERS[un]['auth_cookie'])
        k_index = gu.add_pubkey(config.USERS[un]["pubkey"])
        self.assertTrue(gu.project_exists(pname))
        priv_key_path = set_private_key(config.USERS[un]["privkey"])
        gitu = GerritGitUtils(un,
                              priv_key_path,
                              config.USERS[un]['email'])
        url = "ssh://%[email protected]%s:29418/%s" % (un, config.GATEWAY_HOST,
                                        pname)
        clone_dir = gitu.clone(url, pname)
        self.dirs_to_delete.append(os.path.dirname(clone_dir))

        gitu.add_commit_and_publish(clone_dir, "master", "Test commit")

        change_ids = gu.get_my_changes_for_project(pname)
        self.assertEqual(len(change_ids), 1)
        change_id = change_ids[0]

        labels = gu.get_labels_list_for_change(change_id)

        self.assertIn('Workflow', labels)
        self.assertIn('Code-Review', labels)
        self.assertIn('Verified', labels)
        self.assertEqual(len(labels.keys()), 3)

        gu.del_pubkey(k_index)

    def _prepare_review_submit_testing(self, project_options=None):
        if project_options is None:
            u2mail = config.USERS[config.USER_2]['email']
            project_options = {'core-group': u2mail}
        pname = 'p_%s' % create_random_str()
        self.create_project(pname, project_options)
        un = config.ADMIN_USER
        gu = GerritUtils(
            config.GATEWAY_URL,
            auth_cookie=config.USERS[un]['auth_cookie'])
        k_index = gu.add_pubkey(config.USERS[un]["pubkey"])
        self.assertTrue(gu.project_exists(pname))
        priv_key_path = set_private_key(config.USERS[un]["privkey"])
        gitu = GerritGitUtils(un,
                              priv_key_path,
                              config.USERS[un]['email'])
        url = "ssh://%[email protected]%s:29418/%s" % (un, config.GATEWAY_HOST,
                                        pname)
        clone_dir = gitu.clone(url, pname)
        self.dirs_to_delete.append(os.path.dirname(clone_dir))

        gitu.add_commit_and_publish(clone_dir, "master", "Test commit")

        change_ids = gu.get_my_changes_for_project(pname)
        self.assertEqual(len(change_ids), 1)
        change_id = change_ids[0]

        return change_id, gu, k_index

 def test_create_private_project_as_admin_clone_as_admin(self):
     """ Clone private project as admin and check content
     """
     pname = 'p_%s' % create_random_str()
     options = {"private": ""}
     self.create_project(pname, config.ADMIN_USER, options=options)
     ggu = GerritGitUtils(config.ADMIN_USER,
                          config.ADMIN_PRIV_KEY_PATH,
                          config.USERS[config.ADMIN_USER]['email'])
     url = "ssh://%[email protected]%s:29418/%s" % (config.ADMIN_USER,
                                     config.GATEWAY_HOST, pname)
     clone_dir = ggu.clone(url, pname)
     self.dirs_to_delete.append(os.path.dirname(clone_dir))
     # Test that the clone is a success
     self.assertTrue(os.path.isdir(clone_dir))
     # Verify master own the .gitreview file
     self.assertTrue(os.path.isfile(os.path.join(clone_dir,
                                                 '.gitreview')))
     # Verify meta/config branch own both group and ACLs config file
     ggu.fetch_meta_config(clone_dir)
     self.assertTrue(os.path.isfile(os.path.join(clone_dir,
                                                 'project.config')))
     self.assertTrue(os.path.isfile(os.path.join(clone_dir,
                                                 'groups')))
     # There is a group dev for a private project
     content = file(os.path.join(clone_dir, 'project.config')).read()
     self.assertTrue('%s-dev' % pname in content)
     content = file(os.path.join(clone_dir, 'groups')).read()
     self.assertTrue('%s-dev' % pname in content)

    def test_basic_ops_project_namespace(self):
        """ Check if a project named with a / (namespace) is handled
        correctly on basic ops by managesf
        """
        pname = 'skydive/%s' % create_random_str()
        self.create_project(pname, config.USER_2)
        self.assertTrue(self.gu.project_exists(pname))
        self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
        if is_present("SFRedmine"):
            rname = '_'.join(pname.split('/'))
            self.assertTrue(self.rm.project_exists(rname))
        # Try to clone
        ggu = GerritGitUtils(config.ADMIN_USER,
                             config.ADMIN_PRIV_KEY_PATH,
                             config.USERS[config.ADMIN_USER]['email'])
        url = "ssh://%[email protected]%s:29418/%s" % (config.ADMIN_USER,
                                        config.GATEWAY_HOST, pname)
        clone_dir = ggu.clone(url, pname.split('/')[-1])
        self.dirs_to_delete.append(os.path.dirname(clone_dir))
        # Test that the clone is a success
        self.assertTrue(os.path.isdir(clone_dir))
        # Verify master own the .gitreview file
        self.assertTrue(os.path.isfile(os.path.join(clone_dir,
                                                    '.gitreview')))
        # Delete the project from SF
        self.msu.deleteProject(pname, config.ADMIN_USER)
        self.assertFalse(self.gu.project_exists(pname))
        self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
        if is_present("SFRedmine"):
            rname = '_'.join(pname.split('/'))
            self.assertFalse(self.rm.project_exists(rname))
        self.assertFalse(self.gu.group_exists('%s-core' % pname))

        # Clean local clone directory
        self.projects.remove(pname)

 def test_create_private_project_as_admin(self):
     """ Create private project on redmine and gerrit as admin
     """
     pname = 'p_%s' % create_random_str()
     options = {"private": ""}
     self.create_project(pname, config.ADMIN_USER,
                         options=options)
     # Gerrit part
     self.assertTrue(self.gu.project_exists(pname))
     self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
     self.assertTrue(self.gu.group_exists('%s-core' % pname))
     self.assertTrue(self.gu.group_exists('%s-dev' % pname))
     # TODO(Project creator, as project owner, should only be in ptl group)
     self.assertTrue(
         self.gu.member_in_group(config.ADMIN_USER, '%s-ptl' % pname))
     self.assertTrue(
         self.gu.member_in_group(config.ADMIN_USER, '%s-core' % pname))
     self.assertTrue(
         self.gu.member_in_group(config.ADMIN_USER, '%s-dev' % pname))
     # Redmine part
     self.assertTrue(self.rm.project_exists(pname))
     self.assertTrue(
         self.rm.check_user_role(pname, config.ADMIN_USER, 'Manager'))
     self.assertTrue(
         self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer'))
     self.assertFalse(self.project_exists_ex(pname, config.USER_2))

 def test_create_public_project_as_user_clone_as_user(self):
     """ Create public project as user then clone as user
     """
     pname = 'p_%s' % create_random_str()
     # create the project as admin
     self.create_project(pname, config.USER_2)
     # add user2 ssh pubkey to user2
     gu = GerritUtils(
         'https://%s/' % config.GATEWAY_HOST,
         auth_cookie=config.USERS[config.USER_2]['auth_cookie'])
     gu.add_pubkey(config.USER_2_PUB_KEY)
     # prepare to clone
     priv_key_path = set_private_key(config.USER_2_PRIV_KEY)
     self.dirs_to_delete.append(os.path.dirname(priv_key_path))
     ggu = GerritGitUtils(config.USER_2,
                          priv_key_path,
                          config.USERS[config.USER_2]['email'])
     url = "ssh://%[email protected]%s:29418/%s" % (config.USER_2,
                                     config.GATEWAY_HOST, pname)
     # clone
     clone_dir = ggu.clone(url, pname)
     self.dirs_to_delete.append(os.path.dirname(clone_dir))
     # Test that the clone is a success
     self.assertTrue(os.path.isdir(clone_dir))
     # Verify master own the .gitreview file
     self.assertTrue(os.path.isfile(os.path.join(clone_dir,
                                                 '.gitreview')))

 def test_init_user_tests(self):
     """ Check if a test init feature behave as expected
     """
     project = "p_%s" % create_random_str()
     self.create_project(project, config.USER_4)
     self.msu.create_init_tests(project, config.USER_4)
     ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]["email"])
     open_reviews = ggu.list_open_reviews("config", config.GATEWAY_HOST)
     match = [
         True
         for review in open_reviews
         if review["commitMessage"].startswith(
             "%s proposes initial test " "definition for project %s" % (config.USER_4, project)
         )
     ]
     self.assertEqual(len(match), 1)
     open_reviews = ggu.list_open_reviews(project, config.GATEWAY_HOST)
     match = [
         True
         for review in open_reviews
         if review["commitMessage"].startswith(
             "%s proposes initial test " "scripts for project %s" % (config.USER_4, project)
         )
     ]
     self.assertEqual(len(match), 1)

    def test_admin_manage_project_members(self):
        """ Test admin can add and delete users from all project groups
        """
        pname = "p_%s" % create_random_str()
        self.create_project(pname, config.ADMIN_USER)
        # Gerrit part
        self.assertTrue(self.gu.project_exists(pname))
        self.assertTrue(self.gu.group_exists("%s-ptl" % pname))
        self.assertTrue(self.gu.group_exists("%s-core" % pname))
        groups = "ptl-group core-group"
        # Add user2 to ptl and core groups
        self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname, config.USER_2, groups)
        # Test if user2 exists in ptl and core groups
        self.assertTrue(self.gu.member_in_group(config.USER_2, "%s-ptl" % pname))
        self.assertTrue(self.gu.member_in_group(config.USER_2, "%s-core" % pname))
        # Redmine part
        self.assertTrue(self.rm.check_user_role(pname, config.USER_2, "Manager"))
        self.assertTrue(self.rm.check_user_role(pname, config.USER_2, "Developer"))

        # Delete user2 from project groups
        self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname, config.USER_2)
        # Test if user exists in ptl and core groups
        self.assertFalse(self.gu.member_in_group(config.USER_2, "%s-ptl" % pname))
        self.assertFalse(self.gu.member_in_group(config.USER_2, "%s-core" % pname))
        # Redmine part
        self.assertFalse(self.rm.check_user_role(pname, config.USER_2, "Manager"))
        self.assertFalse(self.rm.check_user_role(pname, config.USER_2, "Developer"))

    def test_ptl_manage_project_members(self):
        """ Test ptl can add and delete users from all project groups
        """
        # Let user2 create the project, so he will be ptl for this project
        pname = "p_%s" % create_random_str()
        self.create_project(pname, config.USER_2)
        # Gerrit part
        self.assertTrue(self.gu.project_exists(pname))
        self.assertTrue(self.gu.group_exists("%s-ptl" % pname))
        self.assertTrue(self.gu.group_exists("%s-core" % pname))
        groups = "ptl-group core-group"

        # ptl should be ale to add users to all groups
        # so user2 should be able to add user3 to ptl and core groups
        self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3, groups)
        # Test if user3 exists in ptl and core groups
        self.assertTrue(self.gu.member_in_group(config.USER_3, "%s-ptl" % pname))
        self.assertTrue(self.gu.member_in_group(config.USER_3, "%s-core" % pname))
        # Redmine part
        self.assertTrue(self.rm.check_user_role(pname, config.USER_3, "Manager"))
        self.assertTrue(self.rm.check_user_role(pname, config.USER_3, "Developer"))

        # ptl should be able to remove users from all groups
        self.msu.deleteUserFromProjectGroups(config.USER_2, pname, config.USER_3)
        # user3 shouldn't exist in any group
        self.assertFalse(self.gu.member_in_group(config.USER_3, "%s-ptl" % pname))
        self.assertFalse(self.gu.member_in_group(config.USER_3, "%s-core" % pname))
        # Redmine part
        self.assertFalse(self.rm.check_user_role(pname, config.USER_3, "Manager"))
        self.assertFalse(self.rm.check_user_role(pname, config.USER_3, "Developer"))

    def test_non_member_manage_project_members(self):
        """ Test non project members can add and delete users to core group
        """
        # Let admin create the project
        pname = 'p_%s' % create_random_str()
        self.create_project(pname, config.ADMIN_USER)
        # Gerrit part
        self.assertTrue(self.gu.project_exists(pname))
        self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
        self.assertTrue(self.gu.group_exists('%s-core' % pname))

        # non project meber can't add user to core group
        # user2 can't add user3 to core group
        groups = 'core-group'
        self.msu.addUsertoProjectGroups(config.USER_2, pname,
                                        config.USER_3, groups)
        # user3 shouldn't exist in core group
        self.assertFalse(self.gu.member_in_group(config.USER_3,
                                                 '%s-core' % pname))
        # Redmine part
        if is_present("SFRedmine"):
            self.assertFalse(self.rm.check_user_role(pname,
                                                     config.USER_3,
                                                     'Developer'))

        groups = 'ptl-group'
        # non project meber can't add usr to ptl group
        # user2 can't add user3 to ptl group
        self.msu.addUsertoProjectGroups(config.USER_2, pname,
                                        config.USER_3, groups)
        # user3 shouldn't exist in ptl group
        self.assertFalse(self.gu.member_in_group(config.USER_3,
                                                 '%s-ptl' % pname))
        # Redmine part
        self.assertFalse(self.rm.check_user_role(pname,
                                                 config.USER_3, 'Manager'))

        # non project meber can't delete usr from any group.
        # Let admin add user3 to ptl and core groups,
        # then try to remove user3 from ptl and core groups by
        # user2 (i.e non member user)
        groups = 'ptl-group core-group'
        self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
                                        config.USER_3, groups)
        # non-admin user(user2) can't remove users from project groups
        self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
                                             config.USER_3)
        # user3 should exist in ptl and core group
        self.assertTrue(self.gu.member_in_group(config.USER_3,
                                                '%s-ptl' % pname))
        self.assertTrue(self.gu.member_in_group(config.USER_3,
                                                '%s-core' % pname))
        # Redmine part
        if is_present("SFRedmine"):
            self.assertTrue(self.rm.check_user_role(pname,
                                                    config.USER_3,
                                                    'Manager'))
            self.assertTrue(self.rm.check_user_role(pname,
                                                    config.USER_3,
                                                    'Developer'))

 def test_create_private_project_with_users_in_group(self):
     """ Create private project on redmine and gerrit with users in groups
     """
     pname = 'p_%s' % create_random_str()
     u2mail = config.USERS[config.USER_2]['email']
     u3mail = config.USERS[config.USER_3]['email']
     u4mail = config.USERS[config.USER_4]['email']
     options = {"private": "",
                "ptl-group": "",
                "core-group": "%s,%s" % (u2mail, u3mail),
                "dev-group": "%s" % u4mail,
                }
     self.create_project(pname, config.ADMIN_USER,
                         options=options)
     # Gerrit part
     self.assertTrue(self.gu.project_exists(pname))
     # TODO(Project creator, as project owner, should only be in ptl group)
     self.assertTrue(
         self.gu.member_in_group(config.ADMIN_USER, '%s-ptl' % pname))
     for user in (config.ADMIN_USER, config.USER_2, config.USER_3):
         self.assertTrue(self.gu.member_in_group(user, '%s-core' % pname))
     self.assertTrue(
         self.gu.member_in_group(config.USER_4, '%s-dev' % pname))
     # Redmine part
     # it should be visible to admin
     self.assertTrue(self.rm.project_exists(pname))
     self.assertTrue(
         self.rm.check_user_role(pname, config.ADMIN_USER, 'Manager'))
     for user in (config.ADMIN_USER, config.USER_2,
                  config.USER_3, config.USER_4):
         self.assertTrue(self.rm.check_user_role(pname, user, 'Developer'))

    def test_core_manage_project_members(self):
        """ Test core can add and delete users to core group
        """
        # let admin create the project
        pname = 'p_%s' % create_random_str()
        self.create_project(pname, config.ADMIN_USER)
        # Gerrit part
        self.assertTrue(self.gu.project_exists(pname))
        self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
        self.assertTrue(self.gu.group_exists('%s-core' % pname))
        groups = 'core-group'

        # Add user2 as core user
        self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
                                        config.USER_2, groups)
        # Test if user2 exists in core group
        self.assertTrue(self.gu.member_in_group(config.USER_2,
                                                '%s-core' % pname))
        # Redmine part
        self.assertTrue(self.rm.check_user_role(pname,
                                                config.USER_2, 'Developer'))

        groups = 'core-group'
        # core should be ale to add users to only core group and not ptl group
        # so user2 should be able to add user3 to only core group and not
        # ptl group
        self.msu.addUsertoProjectGroups(config.USER_2, pname,
                                        config.USER_3, groups)
        # user3 should exist in core group
        self.assertTrue(self.gu.member_in_group(config.USER_3,
                                                '%s-core' % pname))
        # Redmine part
        self.assertTrue(self.rm.check_user_role(pname,
                                                config.USER_3, 'Developer'))

        groups = 'ptl-group'
        # core should not be allowed to add users to ptl group
        # so user2 should not be able to add user3 to ptl group
        self.msu.addUsertoProjectGroups(config.USER_2, pname,
                                        config.USER_3, groups)
        # user3 shouldn't exist in ptl group
        self.assertFalse(self.gu.member_in_group(config.USER_3,
                                                 '%s-ptl' % pname))
        # Redmine part
        self.assertFalse(self.rm.check_user_role(pname,
                                                 config.USER_3, 'Manager'))

        # core should be able to remove users from core group
        group = 'core-group'
        self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
                                             config.USER_3, group)
        # user3 shouldn't exist in core group
        self.assertFalse(self.gu.member_in_group(config.USER_3,
                                                 '%s-core' % pname))
        # Redmine part
        self.assertFalse(self.rm.check_user_role(pname,
                                                 config.USER_3, 'Developer'))