"""

  """

  import datetime

  import pytest

  from toddlers.exceptions import ValidationError

  class TestAcceptTopic:

      """

      method.

      """

      def test_accepts_topic_invalid(self, toddler):

          """

          ],

      )

      def test_accepts_topic_valid(self, topic, toddler):

          assert toddler.accepts_topic(topic)

  class TestProcess:

      """

      """

      def test_process_invalid_project(self, caplog, toddler):

          """

          msg = IssueNewV1(body=body)

          with patch(

          ) as mock_process_ticket:

              toddler.process({}, msg)

              mock_process_ticket.assert_not_called()

          caplog.set_level(logging.INFO)

          body = {

              "issue": {

                  "id": 100,

                  "status": "Closed",

          msg = IssueNewV1(body=body)

          with patch(

          ) as mock_process_ticket:

              toddler.process({}, msg)

          caplog.set_level(logging.INFO)

          body = {

              "issue": {

                  "id": 100,

                  "status": "Open",

          msg = IssueNewV1(body=body)

          with patch(

          ) as mock_process_ticket:

              toddler.process({}, msg)

          caplog.set_level(logging.INFO)

          body = {

              "issue": {

                  "id": 100,

                  "status": "Open",

          msg = IssueNewV1(body=body)

          with patch(

          ) as mock_process_ticket:

              toddler.process({}, msg)

              "not a first word in title"

          )

      @patch("toddlers.utils.pdc.pdc_client_for_config")

      @patch("toddlers.utils.pagure.set_pagure")

      @patch("toddlers.utils.bugzilla_system.set_bz")

      @patch("koji.ClientSession")

      def test_process_base_exception_appeared(

      ):

          """

          Assert that if base exception appeared, it will be processed correctly.

              "user": {"name": "zlopez"},

          }

          body = {

              "issue": issue,

          }

          config = {

          mock_pagure.return_value = mock_pagure_io

          with patch(

          ) as mock_process_ticket:

              mock_process_ticket.side_effect = Exception("test")

              toddler.process(config, msg)

          mock_pagure_io.add_comment_to_issue.assert_called_once()

      @patch("toddlers.utils.pdc.pdc_client_for_config")

      @patch("toddlers.utils.pagure.set_pagure")

      @patch("toddlers.utils.bugzilla_system.set_bz")

      @patch("koji.ClientSession")

          """

          Assert that message toddler will be initialized correctly, if message passes

          initial processing.

              "user": {"name": "zlopez"},

          }

          body = {

              "issue": issue,

          }

          msg = IssueNewV1(body=body)

          }

          with patch(

          ) as mock_process_ticket:

              toddler.process(config, msg)

          mock_pdc.assert_called_with(config)

          mock_pagure.assert_called_with(config)

          mock_bugzilla.assert_called_with(config)

  class TestProcessTicket:

      """

      method.

      """

          """

          Initialize toddler

          """

          self.toddler.temp_dir = Mock()

          self.toddler.git_repo = MagicMock()

          self.toddler.pagure_io = MagicMock()

          self.toddler.koji_session = MagicMock()

      @patch(

          "._is_need_to_unblock_tags_on_koji",

          return_value=True,

      )

      @patch(

          "._is_package_ready_for_unretirement"

      )

      @patch(

          "_get_branches_need_to_unretire"

      )

      @patch("tempfile.TemporaryDirectory")

      @patch(

          return_value=True,

      )

      def test_process_ticket_success(

          mock_clone_repo,

          mock_get_branches,

          mock_is_package_ready,

          mock_is_need_to_unblock_koji,

          mock_unblock_tags_koji,

          caplog,

      ):

          """

          package_url = "{0}/{1}/{2}.git".format(

              self.toddler.dist_git_base, namespace, repo

          )

          revert_message = f"Unretirement request: {issue['full_url']}"

          mock_is_url_exist.return_value = True

          self.toddler.git_repo.does_branch_exist.return_value = True

          self.toddler.git_repo.does_branch_contains_file.return_value = True

          mock_is_package_ready.return_value = True

          mock_is_need_to_unblock_koji.return_value = True

          self.toddler.pagure_io.is_project_orphaned.return_value = True

          self.toddler.process_ticket(issue)

          mock_is_url_exist.assert_called_once_with(package_url)

          mock_get_branches.assert_called_once_with(issue_body=issue["content"])

          mock_is_package_ready.assert_called_once_with(

          )

          self.toddler.git_repo.revert_last_commit.assert_called_with(

          )

          mock_unblock_tags_koji.assert_called_once_with(

          )

          self.toddler.pagure_io.is_project_orphaned.assert_called_once_with(

              namespace=namespace, repo=repo

          self.toddler.pagure_io.assign_maintainer_to_project.assert_called_with(

              namespace=namespace, repo=repo, maintainer_fas=issue["user"]["name"]

          )

          assert caplog.records[-1].message == "everything was alright!"

      # TODO mock _get_branches_need_to_unretire method

          assert caplog.records[-1].message == msg

          self.toddler.pagure_io.close_issue.assert_called_once_with(

              issue["id"],

              message=msg,

              reason=reason,

          )

          msg = (

              "Unretire can only apply to rpm packages, please add `{0}`"

              " prefix before the package name"

          reason = "Invalid"

          self.toddler.process_ticket(issue)

          assert caplog.records[-1].message == msg

          self.toddler.pagure_io.close_issue.assert_called_once_with(

              issue["id"],

              message=msg,

              reason=reason,

          )

          assert caplog.records[-1].message == msg

          self.toddler.pagure_io.close_issue.assert_called_once_with(

              issue["id"],

              message=msg,

              reason=reason,

          )

      @patch(

          return_value=False,

      )

      def test_process_ticket_package_url_doesnt_exist(self, mock_is_url_exist, caplog):

          assert caplog.records[-1].message == msg

          self.toddler.pagure_io.close_issue.assert_called_once_with(

              issue["id"],

              message=msg,

              reason=reason,

          )

      @patch("tempfile.TemporaryDirectory")

      @patch(

          return_value=True,

      )

      def test_process_ticket_git_error_happened(

          assert caplog.records[-1].message == msg

          self.toddler.pagure_io.close_issue.assert_called_once_with(

              issue["id"],

              message=msg,

              reason=reason,

          )

      @patch(

          return_value=False,

      )

      @patch(

          return_value=["rawhide"],

      )

      @patch("tempfile.TemporaryDirectory")

      @patch(

          return_value=True,

      )

      def test_process_ticket_package_is_not_ready_for_unretirement(

          mock_clone_repo,

          mock_get_branches,

          mock_is_package_ready,

          caplog,

      ):

          issue = {

          }

          self.toddler.process_ticket(issue)

  # TODO: create class for _get_branches_need_to_unretire method

  class TestIsPackageReadyForUnretirement:

      """

      ._is_package_ready_for_unretirement` method.

      """

          """

          Initialize toddler

          """

          self.toddler.pagure_io = Mock()

      @patch(

          "_verify_bugzilla_need_to_be_checked"

      )

      @patch(

          "_verify_package_not_retired_for_reason"

      )

      def test_is_package_ready_for_unretirement_success(

          err_msg = "Package was retired for a reason: legal of license issue."

          with patch(

              "._verify_package_not_retired_for_reason",

              side_effect=ValidationError(err_msg),

          ):

              )

              self.toddler.pagure_io.close_issue.assert_called_with(

                  issue_id=issue_id,

                  message=err_msg,

                  reason="Invalid",

              )

      @patch(

          "_verify_package_not_retired_for_reason"

      )

      def test_is_package_ready_for_unretirement_date_issue(self, verify_reason_mock):

          err_msg = "Couldn't get a date of the retire commit."

          with patch(

              "._verify_bugzilla_need_to_be_checked",

              side_effect=ValidationError(err_msg),

          ):

              )

              self.toddler.pagure_io.close_issue.assert_called_with(

                  issue_id=issue_id,

                  message=err_msg,

                  reason="Invalid",

              )

  class TestVerifyPackageNotRetiredForReason:

      """

      ._verify_package_not_retired_for_reason` method.

      """

          """

          Initialize toddler.

          """

          self.toddler.git_repo = Mock()

      def test_verify_package_not_retired_for_reason_success(self):

  class TestVerifyBugzillaNeedToBeChecked:

      """

      ._verify_bugzilla_need_to_be_checked` method.

      """

          """

          Initialize toddler.

          """

          self.toddler.git_repo = Mock()

      @patch(

      )

      def test_verify_bugzilla_need_to_be_checked_success(self, mock_verify_bz):

          """

          mock_verify_bz.assert_not_called()

      @patch(

      )

      def test_verify_bugzilla_need_to_be_checked_date_is_none(self, mock_verify_bz):

          """

          mock_verify_bz.assert_not_called()

      @patch(

      )

      def test_verify_bugzilla_need_to_be_checked_need_to_check_bugzilla(

          self, mock_verify_bz

  class TestVerifyBugzillaTicket:

      """

      ._verify_bugzilla_ticket` method.

      """

          """

          Initialize toddler.

          """

      def test_verify_bugzilla_ticket_success(self, get_bug_mock):

          """

          Assert that method process correctly.

              self.toddler._verify_bugzilla_ticket(issue_body)

      @patch(

          side_effect=Exception("bug error"),

      )

      def test_verify_bugzilla_ticket_get_bug_error(self, mock_get_bug):

              self.toddler._verify_bugzilla_ticket(issue_body)

      @patch(

          return_value=None,

      )

      def test_verify_bugzilla_ticket_bug_not_found(self, get_bug_mock):

          with pytest.raises(ValidationError, match=err_msg):

              self.toddler._verify_bugzilla_ticket(issue_body)

      def test_verify_bugzilla_ticket_bug_product_is_not_fedora(self, mock_get_bug):

          """

          Assert that method will raise error if the bug product is not `Fedora`.

          with pytest.raises(ValidationError, match=err_msg):

              self.toddler._verify_bugzilla_ticket(issue_body)

      def test_verify_bugzilla_ticket_bug_does_not_have_required_flag(self, get_bug_mock):

          """

          Assert that method will raise Exception if bug doesn't have required flag.

          with pytest.raises(ValidationError, match=err_msg):

              self.toddler._verify_bugzilla_ticket(issue_body)

      def test_verify_bugzilla_ticket_wrong_flag_status(self, get_bug_mock):

          """

          Assert that method will raise Exception if flag has wrong status.

  class TestBranchesNeedToUnretire:

      """

      """

      def setup_method(self):

          """

          Initialize toddler.

          """

      def test_get_branches_need_to_unretire_no_branch_names_in_issue_body(self):

          """

          assert self.toddler._get_branches_need_to_unretire(issue_body) == result

  class TestIsNeedToUnblockTagsOnKoji:

      """

      ._is_need_to_unblock_tags_on_koji` method.

      """

          """

          Initialize toddler.

          """

          self.toddler.koji_session = Mock()

      def test_is_need_to_unblock_tags_on_koji_package_does_not_have_tags(self):

  from toddlers.base import ToddlerBase

  from toddlers.exceptions import ValidationError

  # Regex for bugzilla url

  BUGZILLA_URL_REGEX = r"https:\/\/bugzilla(.+)redhat(.+)(id=\d{7})"

  _log = logging.getLogger(__name__)

      """

      Listen for new tickets in https://pagure.io/releng/issues

      and process then, either by unretiring a package or rejecting the ticket

      # Koji session object

      koji_session: koji.ClientSession

      def accepts_topic(self, topic: str) -> bool:

          """

          Returns a boolean whether this toddler is interested in messages

          _log.info("Setting up connection to PDC")

          self.pdc_client = pdc.pdc_client_for_config(config)

          _log.info("Setting up connection to Pagure")

          self.pagure_io = pagure.set_pagure(config)

          _log.info("Setting up session with Koji")

          self.koji_session = koji.ClientSession(KOJIHUB_URL)

          try:

              self.process_ticket(issue)

          except BaseException:

                  issue_body=issue_body

              )

              _log.info("Verifying that branches are actually exists.")

              valid_branches_that_need_to_be_unretired = []

                  if self.git_repo.does_branch_exist(branch):

                      valid_branches_that_need_to_be_unretired.append(branch)

              _log.info(

                  "Verifying that branches are actually retired (have a `dead.package` file)."

              )

              deadpackage_file_path = "dead.package"

              for branch in valid_branches_that_need_to_be_unretired:

                  if self.git_repo.does_branch_contains_file(

                      branch, deadpackage_file_path

                  ):

              _log.info("Verifying if package is ready for unretirement.")

              if not self._is_package_ready_for_unretirement(

                  issue_id=issue_id,

                  issue_body=issue_body,

              ):

                  return

              _log.info("Reverting retire commit")

              revert_commit_message = "Unretirement request: {0}".format(issue_url)

                  self.git_repo.revert_last_commit(

                      message=revert_commit_message, branch=branch

                  )

              _log.info("Unblocking tags on Koji.")

              _log.info("Verifying package is not orphan.")

              if self.pagure_io.is_project_orphaned(

                      namespace=namespace, repo=package_name, maintainer_fas=issue_opener

                  )

          _log.info("everything was alright!")