class AnityaForm(pagure.forms.PagureForm):

      anitya_status = wtforms.SelectField(

          "Monitoring status of the package in anitya",

  class OrphanReasonForm(pagure.forms.PagureForm):

      orphan_reason = wtforms.SelectField(

          "Reason for orphaning package",

  class BZOverrideForm(pagure.forms.PagureForm):

      fedora_assignee = wtforms.StringField(

          "Maintainer name", [wtforms.validators.optional(strip_whitespace=True)]

          "rpms": "rpm",

          "modules": "module",

          "container": "container",

      }

      try:

          pdc_namespace = to_pdc_namespace[namespace]

          raise pagure.exceptions.APIError(

              500,

              error_code=APIERROR.ENOCODE,

          )

      branch = "master"

              error="The output of %s could not be converted to JSON" % req.url,

          )

      return data["results"][0]["active"] is True

          output["orphan"] = True

          if repo.orphan_reason:

              output["reason"] = repo.orphan_reason.reason

      return flask.jsonify(output)

      repo = _get_repo(repo, namespace=namespace)

      _check_token(repo, project_token=False)

      if not user_obj:

          raise pagure.exceptions.APIError(404, error_code=APIERROR.ENOUSER)

              401, error_code=APIERROR.EMODIFYPROJECTNOTALLOWED

          )

          raise pagure.exceptions.APIError(

              401, error_code=APIERROR.EMODIFYPROJECTNOTALLOWED

          )

                  reason_info=form.orphan_reason_info.data,

              )

              flask.g.session.add(reason)

              if user_obj in repo.users:

                  pagure.lib.query.remove_user_of_project(

                      flask.g.session, user_obj, repo, user_obj.user

      repo = _get_repo(repo, namespace=namespace)

      _check_token(repo, project_token=False)

      if not user_obj:

          raise pagure.exceptions.APIError(404, error_code=APIERROR.ENOUSER)

  def query_oraculum_versions(package):

      """

      Receives package versions from oraculum

      """

      oraculum_base_url = "https://packager-dashboard.fedoraproject.org/api/"

          raise pagure.exceptions.APIError(

              500,

              error_code=APIERROR.ENOCODE,

          )

      _log.debug("Based ORACULUM url: %s", oraculum_url)

      if not req_releases.ok:

          raise pagure.exceptions.APIError(

      if not req_versions.ok:

          raise pagure.exceptions.APIError(

      versions_resp = req_versions.json()

      releases_resp = req_releases.json()

      return releases, versions, rawhide

  def query_bodhi_versions(repo):

      """

      Receives package versions from bodhi

      """

      bodhi_base_url = "https://bodhi.fedoraproject.org/"

      return releases, updates, rawhide

  @DISTGIT_NS.route("/bodhi_updates/<namespace>/<repo>", methods=["GET"])

  @api_method

  def bodhi_updates_endpoint(namespace, repo):

              errors=["Namespace not supported"],

          )

      repo = _get_repo(repo, namespace=namespace)

      html = pagure.utils.is_true(flask.request.args.get("html", False))

              else:

                  # This makes things a little slower but is needed for builds

                  # that do not go through bodhi, for example, via releng-managed

                  if release == rawhide:

                      mdapi_release = "rawhide"

                  else:

                      )

                      stable = (

                          "<a href='https://koji.fedoraproject.org/koji/search?"

                      )

              testing = ""

              if updates.get(release, {}).get("testing"):

                          updates[release].get("testing")

                      )

                  )

              html_output += row

          html_output += "</table>"

          return html_output

      """Updates the default assignees of this package."""

      def _validate_input(inputname):

          valid = False

          if inputname.startswith("@"):

              group = pagure.lib.query.search_groups(

                  valid = True

          else:

              if user_obj:

                  valid = True

  from __future__ import print_function

  import json

  import pagure.lib.query

  from pagure_distgit import plugin

  class PagureFlaskApiProjectBZOverrideTests(tests.Modeltests):

      def setUp(self):

          super(PagureFlaskApiProjectBZOverrideTests, self).setUp()

          self.session.flush()

          tests.create_projects(self.session)

          self._app.register_blueprint(plugin.DISTGIT_NS)

      def test_default_values(self):

          expected_result = {

              "epel_assignee": "pingou",

          self.assertDictEqual(data, expected_result)

      def test_token_missing_ACL(self):

          headers = {"Authorization": "token foo_token"}

          # invalid token

          self.assertEqual(output.status_code, 401)

      def test_invalid_token(self):

          headers = {"Authorization": "token BBBZZZOOO"}

          datainput = {}

          output = self.app.post(

          self.assertEqual(output.status_code, 401)

      def test_change_both_assignee(self):

          headers = {"Authorization": "token aaabbbcccddd"}

          datainput = {"epel_assignee": "foo", "fedora_assignee": "foo"}

          output = self.app.post(

          )

          self.assertEqual(output.status_code, 200)

          data = json.loads(output.get_data(as_text=True))

          repo = pagure.lib.query.get_authorized_project(

              self.session,

              "test3",

          with tests.user_set(self.app.application, user):

              # change one assignee

              datainput = {"epel_assignee": "foo"}

              self.assertEqual(output.status_code, 200)

              data = json.loads(output.get_data(as_text=True))

              self.assertDictEqual(

              )

      def test_change_fedora_assignee_logged_in(self):

          """

          user = tests.FakeUser(username="pingou")

          with tests.user_set(self.app.application, user):

              # change one assignee

              datainput = {"fedora_assignee": "foo"}

              self.assertEqual(output.status_code, 200)

              data = json.loads(output.get_data(as_text=True))

              self.assertDictEqual(

          user = tests.FakeUser(username="pingou")

          with tests.user_set(self.app.application, user):

              datainput = {"epel_assignee": "foo", "fedora_assignee": "foo"}

              self.assertEqual(output.status_code, 200)

              data = json.loads(output.get_data(as_text=True))

      def test_resetting_assignees_logged_in(self):

          user = tests.FakeUser(username="pingou")

          with tests.user_set(self.app.application, user):

              # Changing one of them before the reset

              datainput = {"epel_assignee": "foo"}

              self.assertEqual(output.status_code, 200)

              data = json.loads(output.get_data(as_text=True))

              self.assertDictEqual(

  from __future__ import print_function

  from mock import Mock, patch

  import pagure.config

  import tests

  class DistGitAuthTests(tests.Modeltests):

      maxDiff = None

      def setUp(self):

          super(DistGitAuthTests, self).setUp()

          pagure.config.config["ACL_DEBUG"] = True

          self.session.commit()

      def tearDown(self):

          self.dga = None

          super(DistGitAuthTests, self).tearDown()

              if msg == expect_msg:

                  found = True

          if not found:

  class DistGitAuthTestsGeneric(DistGitAuthTests):

      def test_unprotected_pr_required_repo_pr_only_no_pr(self):

          settings = {"pull_request_access_only": True}

          self.assertFalse(

              self.dga.check_acl(

      def test_unprotected_pr_required_repo_pr_only(self):

          settings = {"pull_request_access_only": True}

          self.assertTrue(

              self.dga.check_acl(

                  self.session,

          self.expect_info_msg("Unspecified ref refs/heads/f28 is blocked")

      @patch("dist_git_auth.requests")

          project = self.create_namespaced_project("rpms", "test")

          res = Mock()

          res.ok = True

          self.expect_info_msg("Unspecified branch push")

      @patch("dist_git_auth.requests")

          project = self.create_namespaced_project("rpms", "test")

          res = Mock()

          res.ok = True

          self.expect_info_msg("Fall-through deny")

      @patch("dist_git_auth.requests")

          project = get_project(self.session, name="test", namespace="rpms")

          res = Mock()

          res.ok = True

          "RCM_BRANCHES": ["refs/heads/f[0-9]+"],

          "ACL_PROTECTED_NAMESPACES": ["rpms", "modules", "container"],

          "PDC_URL": "invalid://",

      }

      def setUp(self):

      @patch("dist_git_auth.requests")

      def test_pushing_to_containers_calls_pdc_correctly(self, mock_requests):

          res = Mock()

          res.ok = True

          res.json.return_value = {"results": []}

  import json

  import os

  import pagure.lib.model

  import pagure.lib.query

  from pagure_distgit import model

  from pagure_distgit import plugin

  import tests

  class PagureFlaskApiOrphanEndpointTests(tests.Modeltests):

      def setUp(self):

          super(PagureFlaskApiOrphanEndpointTests, self).setUp()

          self.session.flush()

          tests.create_projects(self.session)

          tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

          tests.create_tokens(self.session)

          tests.create_tokens_acl(self.session)

          repo = pagure.lib.query.get_authorized_project(

              self.session,

              "test3",

          self._app.register_blueprint(plugin.DISTGIT_NS)

      def test_token_missing_ACL(self):

          headers = {"Authorization": "token foo_token"}

          # invalid token

          assert output.status_code == 401

      def test_invalid_token(self):

          headers = {"Authorization": "token BBBZZZOOO"}

          datainput = {}

          output = self.app.post(

  class PagureFlaskApiOrphanGetEndpointTests(tests.Modeltests):

      def setUp(self):

          super(PagureFlaskApiOrphanGetEndpointTests, self).setUp()

          self.session.flush()

          tests.create_projects(self.session)

          tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

          tests.create_tokens(self.session)

          tests.create_tokens_acl(self.session)

          repo = pagure.lib.query.get_authorized_project(

              self.session,

              "test3",

  class PagureFlaskApiTakeOrphanEndpointTests(tests.Modeltests):

      def setUp(self):

          super(PagureFlaskApiTakeOrphanEndpointTests, self).setUp()

          self.session.flush()

          tests.create_projects(self.session)

          tests.create_projects_git(os.path.join(self.path, "repos"), bare=True)

          tests.create_tokens(self.session)

          tests.create_tokens_acl(self.session)

          pagure.lib.query.add_group(

              self.session,

              "packager",

          assert output.status_code == 401

      def test_invalid_token(self):

          headers = {"Authorization": "token BBBZZZOOO"}

          output = self.app.post(

              "/_dg/take_orphan/somenamespace/test3",

  """

  import os

  import subprocess

          This test runs flake8 on the code, and will fail if it returns a

          non-zero exit code.

          """

          # We ignore W503, which disallows line break before binary operator

          flake8_command = [

              sys.executable,

              "-m",

              "flake8",

              REPO_PATH,

          ]

          if old_flake:

              raise unittest.SkipTest("Flake8 version too old to be useful")

          print(proc.communicate())

          self.assertEqual(proc.returncode, 0)

              "-m",

              "black",

              "-l",

              "--check",

              "--exclude",

              '_build|buck-out|build|dist)/"',  # noqa

              REPO_PATH,

              TESTS_PATH,