os.environ["PAGURE_CONFIG"] = config

  import pagure.config

  db_url = pagure.config.config.get("DB_URL")

  if db_url.startswith("postgres"):

      engine = create_engine(db_url, echo=True)

  BASE.metadata.create_all(

          PagureAnitya.__table__,

          PagureBZOverride.__table__,

  )

          self.pdc_url = pagure_config.get("PDC_URL")

      def is_supported_branch(self, project, refname):

          This retrieves the information about EOL status from PDC, to prevent

          EOL branches being pushed to.

          return res[0]["active"]

      def info(self, msg):

          _log.info(msg)

          print(msg)

      def debug(self, msg):

          _log.debug(msg)

          if self.is_debug:

              self.info(msg)

          revfrom,

          revto,

          is_internal,

      ):

          For arguments, see GitAuthHelper.check_acl."""

          usergroups = set(user.groups)

          # Determine whether the user is a committer/collaborator, ie: may commit

          # Determine whether the user is a SIG member

          user_sigs = self.supported_sigs & usergroups

              # For Fedora, allow supported branches, these are the active

              # branches in PDC

              if is_supported is False:

                  self.info("Branch %s is unsupported" % refname)

                  return False

  class PagureAnitya(BASE):

      Table -- pagure_anitya

      """

  class PagureOrphanReason(BASE):

      Table -- pagure_orphan_reason

  class PagureBZOverride(BASE):

      Table -- pagure_bzoverride

      """

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

  def anitya_get_endpoint(namespace, repo):

      repo = flask.g.repo

      output = {"monitoring": "no-monitoring"}

      if repo.anitya:

  @api_login_required(acls=["modify_project"])

  @api_method

  def anitya_patch_endpoint(namespace, repo):

      repo = _get_repo(repo, namespace=namespace)

      _check_token(repo, project_token=False)

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

  @api_method

  def get_actived_status(namespace, repo):

      _log.info("Received a request to unorphan: %s/%s", namespace, repo)

      repo = _get_repo(repo, namespace=namespace)

  def _is_active_in_pdc(name, namespace):

      branch in PDC or not.

      """

      pdc_url = flask.current_app.config.get("PDC_URL")

  @api_login_required(acls=["modify_project"])

  @api_method

  def take_orphan_endpoint(namespace, repo):

      _log.info("Received a request to unorphan: %s/%s", namespace, repo)

      repo = _get_repo(repo, namespace=namespace)

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

  @api_method

  def bodhi_updates_endpoint(namespace, repo):

      if namespace not in ["rpms"]:

          raise pagure.exceptions.APIError(

              400,

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

  @api_method

  def bzoverride_get_endpoint(repo, namespace):

      """

      repo = _get_repo(repo, namespace=namespace)

      output = {

  @api_method

  @api_login_required(acls=["modify_project"])

  def bzoverride_patch_endpoint(repo, namespace):

      def _validate_input(inputname):

          """ Validate if the input is either an username or a group name. """

          self.assertDictEqual(data, expected_result)

      def test_token_missing_ACL(self):

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

          output = self.app.post(

              "/_dg/bzoverrides/somenamespace/test3", headers=headers

          self.assertDictEqual(data, expected_result)

      def test_reset_fedora_assignees(self):

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

          datainput = {"fedora_assignee": "foo"}

          output = self.app.post(

              data, {"epel_assignee": "pingou", "fedora_assignee": "foo"}

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          self.assertIsNotNone(repo.bzoverride)

              data, {"epel_assignee": "pingou", "fedora_assignee": "pingou"}

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          self.assertIsNotNone(repo.bzoverride)

      def test_reset_epel_assignees(self):

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

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

          output = self.app.post(

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          self.assertIsNotNone(repo.bzoverride)

      def test_reset_both_assignees(self):

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

          datainput = {}

          output = self.app.post(

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          self.assertIsNone(repo.bzoverride)

              )

      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

          super(DistGitAuthTests, self).tearDown()

      def create_namespaced_project(

      ):

          item = pagure.lib.model.Project(

              user_id=1,  # pingou

              is_fork=is_fork,

              parent_id=3 if is_fork else None,

              description="namespaced test project",

              namespace=namespace,

              settings=settings,

          )

          )

          self.expect_info_msg("Access to namespace rpms is restricted")

              self.session, "orphan", "orphan", ["orphan@fedoraproject.org"]

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          token = pagure.lib.query.get_api_token(self.session, "aaabbbcccddd")

          token.project = repo

          self._app.register_blueprint(plugin.DISTGIT_NS)

      def test_token_missing_ACL(self):

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

          output = self.app.post(

              "/_dg/orphan/somenamespace/test3", headers=headers

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

          datainput = {}

          output = self.app.post(

          )

          assert output.status_code == 401

      def test_empty_form(self):

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

          datainput = {}

          output = self.app.post(

          )

          assert output.status_code == 200

      def test_invalid_form(self):

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

          datainput = {"orphan_reason": "bar"}

          output = self.app.post(

          )

          assert output.status_code == 400

      def test_already_orphaned_package(self):

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

          datainput = {}

          orphan_user_obj = pagure.lib.query.get_user(self.session, "orphan")

          repo = pagure.lib.query.get_authorized_project(

          )

          repo.user = orphan_user_obj

          self.session.add(repo)

          self.session.commit()

          output = self.app.post(

          )

          assert output.status_code == 401

      @patch("pagure_distgit.plugin.pagure.lib.notify.log")

      def test_orphan_package(self, mock_log):

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

          datainput = {"orphan_reason": "Lack of time"}

          repo = pagure.lib.query.get_authorized_project(

          )

          user = repo.user

          project_user = pagure.lib.model.ProjectUser(

          )

          self.session.add(project_user)

          self.session.commit()

          output = self.app.post(

          )

          assert output.status_code == 200

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

      @patch("pagure_distgit.plugin.pagure.lib.notify.log")

      def test_orphan_package_repo_users_empty(self, mock_log):

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

          datainput = {"orphan_reason": "Lack of time"}

          repo = pagure.lib.query.get_authorized_project(

          )

          user = repo.user

          output = self.app.post(

          )

          assert output.status_code == 200

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

          assert mock_log.call_count == 1

      def test_orphan_package_repo_no_orphan_user(self):

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

          datainput = {}

          orphan_user_obj = pagure.lib.query.get_user(self.session, "orphan")

          self.session.commit()

          output = self.app.post(

          )

          assert output.status_code == 400

              self.session, "orphan", "orphan", ["orphan@fedoraproject.org"]

          )

          repo = pagure.lib.query.get_authorized_project(

          )

          token = pagure.lib.query.get_api_token(self.session, "aaabbbcccddd")

          token.project = repo

          self.assertDictEqual(data, exp)

      def test_orphaned(self):

          orphan_user_obj = pagure.lib.query.get_user(self.session, "orphan")

          repo = pagure.lib.query.get_authorized_project(

          )

          repo.user = orphan_user_obj

          reason = model.PagureOrphanReason(

          )

          self.session.add(reason)

          self.session.add(repo)

          self.assertDictEqual(data, exp)

      def test_orphaned_no_reason(self):

          orphan_user_obj = pagure.lib.query.get_user(self.session, "orphan")

          repo = pagure.lib.query.get_authorized_project(

          )

          repo.user = orphan_user_obj

          self.session.add(repo)

              description="test project #4",

              hook_token="aaabbbcccdd",

          )

          self.session.add(item)

          self.session.flush()

          tests.create_locks(self.session, item)

          pygit2.init_repository(repo_path, bare=True)

          repo = pagure.lib.query.get_authorized_project(

          )

          token = pagure.lib.query.get_api_token(self.session, "aaabbbcccddd")

          token.project = repo

          orphan_user_obj = pagure.lib.query.get_user(self.session, "orphan")

          repo.user = orphan_user_obj

          reason = model.PagureOrphanReason(

          )

          self.session.add(reason)

          self.session.add(repo)

          the `modify_project` ACL.

          """

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

          # invalid token

          assert output.status_code == 401

          """Test the take orphan endpoint with an invalid API token. """

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

          output = self.app.post(

          )

          assert output.status_code == 401

      @patch("pagure_distgit.plugin._is_active_in_pdc")

      @patch("pagure_distgit.plugin.pagure.lib.notify.log")

      def test_take_orphan(self, mock_log, mock_pdc):

          mock_pdc.return_value = True

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

          repo = pagure.lib.query.get_authorized_project(

          )

          assert repo.orphan_reason.reason == "reason"

          output = self.app.post(

          )

          assert output.status_code == 200

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

          mock_req.get.return_value = resp

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

          repo = pagure.lib.query.get_authorized_project(

          )

          reason = repo.orphan_reason

          self.session.delete(reason)

          self.session.commit()

          output = self.app.post(

          )

          assert output.status_code == 200

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

          mock_req.get.assert_called_with(

              "invalid:/component-branches/?"

              "global_component=test4&name=rawhide&type=rpm",

          )

  def main(args):

      {

        namespace: {

          package: [people watching issues],

      # Start the watchers by the main admin

      query = (

          session.query(

          )

          .filter(model.Project.user_id == model.User.id)

          .filter(model.Project.parent_id == None)

      # Add the contributors

      query = (

          session.query(

          )

          .filter(model.Project.id == model.ProjectUser.project_id)

          .filter(model.ProjectUser.user_id == model.User.id)

  def main(args):

      {

        namespace: {

          package: [people watching issues],

      # Start the owner list by the main admin

      query = (

          session.query(

          )

          .filter(model.Project.user_id == model.User.id)

          .filter(model.Project.parent_id == None)

      query = (

          session.query(

          )

          .filter(model.Project.id == model.ProjectUser.project_id)

          .filter(model.ProjectUser.user_id == model.User.id)

  def main(args):

      {

        namespace: {

          package: { main admin, epel_assignee, fedora_assignee },