def request_repo(self):

          self._request_repo(

              repo_name=self.args.name,

              ns=self.args.new_repo_namespace,

              branch='master',

      def request_tests_repo(self):

          self._request_repo(

              repo_name=self.args.name,

              ns='tests',

              description=self.args.description,

              bug=self.args.bug,

              name=self.name,

              config=self.config,

          )

      @staticmethod

          """ Implementation of `request_repo`.

          Submits a request for a new dist-git repo.

          :param repo_name: The repository name string.  Typically the

              value of `self.cmd.repo_name`.

          :param ns: The repository namespace string, i.e. 'rpms' or 'modules'.

          pagure_url = config_get_safely(config, pagure_section, 'url')

          pagure_token = config_get_safely(config, pagure_section, 'token')

          print(new_pagure_issue(

      def request_branch(self):

          if self.args.repo_name_for_branch:

          except rpkgError:

              active_branch = None

          self._request_branch(

              service_levels=self.args.sl,

              all_releases=self.args.all_releases,

              branch=self.args.branch,

          )

      @staticmethod

          """ Implementation of `request_branch`.

          Submits a request for a new branch of a given dist-git repo.

          :param service_levels: A list of service level strings.  Typically the

              value of `self.args.service_levels`.

          :param all_releases: A boolean indicating if this request should be made

                  b, ns, repo_name)

              print(new_pagure_issue(

              # For non-standard rpm branch requests, also request a matching new

              # module repo with a matching branch.

                  summary = ('Automatically requested module for '

                             'rpms/%s:%s.' % (repo_name, b))

                  fedpkgClient._request_repo(

                      repo_name=repo_name,

                      ns='modules',

                      branch='master',

                      config=config,

                  )

                  fedpkgClient._request_branch(

                      service_levels=service_levels,

                      all_releases=all_releases,

                      branch=b,

          distgit_token = config_get_safely(self.config, distgit_section, 'token')

          ret = do_fork(

              base_url=distgit_api_base_url,

              token=distgit_token,

              repo_name=self.cmd.repo_name,

          return None

      """

      Posts a new Pagure issue

      :param url: a string of the URL to Pagure

      :param token: a string of the Pagure API token that has rights to create

      a ticket

      base_error_msg = ('The following error occurred while creating a new '

                        'issue in Pagure: {0}')

      if not rv.ok:

          # Lets see if the API returned an error message in JSON that we can

          # show the user

          # show hint for expired token

          if re.search(r"Invalid or expired token", rv_error, re.IGNORECASE):

              base_error_msg += '\nFor invalid or expired token refer to ' \

          url.rstrip('/'), rv.json()['issue']['id'])

      """

      Creates a fork of the project.

      :param base_url: a string of the URL repository

      :param token: a string of the API token that has rights to make a fork

      :param repo_name: a string of the repository name

                       'create a new fork. The error was: {0}'.format(str(error)))

          raise rpkgError(error_msg)

      base_error_msg = ('The following error occurred while creating a new fork: {0}')

      if not rv.ok:

          # Lets see if the API returned an error message in JSON that we can

          # show the user

          if re.search(r"Repo .+ already exists", rv_error, re.IGNORECASE):

              return False

      def test_raise_error_if_connection_error(self, post):

          post.side_effect = ConnectionError

          six.assertRaisesRegex(

              self, rpkgError, 'The connection to Pagure failed',

              utils.new_pagure_issue,

      def test_responses_not_ok_and_response_body_is_not_json(self, post):

          rv = Mock(ok=False, text='error')

          rv.json.side_effect = ValueError

          post.return_value = rv

          six.assertRaisesRegex(

              self, rpkgError,

              'The following error occurred while creating a new issue',

              utils.new_pagure_issue,

      def test_responses_not_ok_when_token_is_expired(self, post):

          rv = Mock(

                   'https://pagure.io/settings#api-keys to get or renew your API token.')

          rv.json.side_effect = ValueError

          post.return_value = rv

          six.assertRaisesRegex(

              self, rpkgError,

              'For invalid or expired token refer to "fedpkg request-repo -h" to set '

              'a token in your user configuration.',

              utils.new_pagure_issue,

      def test_create_pagure_issue(self, post):

          rv = Mock(ok=True)

          rv.json.return_value = {'issue': {'id': 1}}

          post.return_value = rv

          pagure_api_url = 'http://distgit'

          issue_ticket_body = {'repo': 'pkg1'}

                                             '123456',

                                             'new package',

                                             issue_ticket_body,