# -*- coding: utf-8 -*-

"""

 (c) 2018 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

from __future__ import unicode_literals, absolute_import

import datetime

import os

import shutil

import sys

import tempfile

import time

import unittest

import pygit2

import six

from mock import ANY, patch, MagicMock, call

sys.path.insert(

    0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")

)

import pagure.lib.tasks_services

import pagure.lib.query

import tests

import pagure.lib.tasks_services

class PagureLibTaskServicestests(tests.Modeltests):

    """ Tests for pagure.lib.task_services """

    maxDiff = None

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        super(PagureLibTaskServicestests, self).setUp()

        tests.create_projects(self.session)

        # Create a fork of test for foo

        item = pagure.lib.model.Project(

            user_id=2,  # foo

            name="test",

            is_fork=True,

            parent_id=1,

            description="test project #1",

            hook_token="aaabbbccc_foo",

        )

        item.close_status = [

            "Invalid",

            "Insufficient data",

            "Fixed",

            "Duplicate",

        ]

        self.session.add(item)

        self.session.commit()

    def test_webhook_notification_invalid_project(self):

        """ Test the webhook_notification method. """

        self.assertRaises(

            RuntimeError,

            pagure.lib.tasks_services.webhook_notification,

            topic="topic",

            msg={"payload": ["a", "b", "c"]},

            namespace=None,

            name="invalid",

            user=None,

        )

    @patch("pagure.lib.tasks_services.call_web_hooks")

    def test_webhook_notification_no_webhook(self, call_wh):

        """ Test the webhook_notification method. """

        output = pagure.lib.tasks_services.webhook_notification(

            topic="topic",

            msg={"payload": ["a", "b", "c"]},

            namespace=None,

            name="test",

            user=None,

        )

        self.assertIsNone(output)

        call_wh.assert_not_called()

    @patch("pagure.lib.git.log_commits_to_db")

    def test_log_commit_send_notifications_invalid_project(self, log):

        """ Test the log_commit_send_notifications method. """

        output = pagure.lib.tasks_services.log_commit_send_notifications(

            name="invalid",

            commits=[],

            abspath=None,

            branch=None,

            default_branch=None,

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        log.assert_not_called()

    @patch("pagure.lib.notify.notify_new_commits")

    @patch("pagure.lib.git.log_commits_to_db")

    def test_log_commit_send_notifications_valid_project(self, log, notif):

        """ Test the log_commit_send_notifications method. """

        output = pagure.lib.tasks_services.log_commit_send_notifications(

            name="test",

            commits=["hash1", "hash2"],

            abspath="/path/to/git",

            branch="master",

            default_branch="master",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        log.assert_called_once_with(

            ANY, ANY, ["hash1", "hash2"], "/path/to/git"

        )

        notif.assert_called_once_with(

            "/path/to/git", ANY, "master", ["hash1", "hash2"]

        )

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_invalid_project(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="invalid",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_not_configured_project(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        self.assertRaises(

            pagure.exceptions.PagureException,

            pagure.lib.tasks_services.trigger_ci_build,

            project_name="test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_not_configured_project_fork(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        self.assertRaises(

            pagure.exceptions.PagureException,

            pagure.lib.tasks_services.trigger_ci_build,

            project_name="forks/foo/test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.query._get_project")

    def test_load_json_commits_to_db_invalid_data_type(self, get_project):

        """ Test the load_json_commits_to_db method. """

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath="/path/to/git",

            data_type="invalid",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        get_project.assert_not_called()

    @patch("pagure.lib.tasks_services.get_files_to_load")

    def test_load_json_commits_to_db_invalid_project(self, get_files):

        """ Test the load_json_commits_to_db method. """

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="invalid",

            commits=["hash1", "hash2"],

            abspath="/path/to/git",

            data_type="ticket",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        get_files.assert_not_called()

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    def test_load_json_commits_to_db_invalid_path(self, up_issue, up_pr):

        """ Test the load_json_commits_to_db method. """

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath=self.path,

            data_type="ticket",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        up_issue.assert_not_called()

        up_pr.assert_not_called()

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    def test_load_json_commits_to_db_invalid_path_one_commit(

        self, up_issue, up_pr

    ):

        """ Test the load_json_commits_to_db method. """

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1"],

            abspath=self.path,

            data_type="ticket",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        up_issue.assert_not_called()

        up_pr.assert_not_called()

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    def test_load_json_commits_to_db_no_agent(self, up_issue, up_pr, send):

        """ Test the load_json_commits_to_db method. """

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=[],

            abspath=None,

            data_type="ticket",

            agent=None,

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        up_issue.assert_not_called()

        up_pr.assert_not_called()

        send.assert_not_called()

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    @patch("pagure.lib.git.read_git_lines")

    def test_load_json_commits_to_db_no_agent(

        self, git, up_issue, up_pr, send

    ):

        """ Test the load_json_commits_to_db method. """

        git.side_effect = [["file1"], ["file2"], ["files/image"], ["file1"]]

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath=self.path,

            data_type="ticket",

            agent=None,

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        up_issue.assert_not_called()

        up_pr.assert_not_called()

        send.assert_not_called()

    @patch("json.loads")

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    @patch("pagure.lib.git.read_git_lines")

    def test_load_json_commits_to_db_tickets(

        self, git, up_issue, up_pr, send, json_loads

    ):

        """ Test the load_json_commits_to_db method. """

        git.side_effect = [["file1"], ["file2"], ["files/image"], ["file1"]]

        json_loads.return_value = "foobar"

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath=self.path,

            data_type="ticket",

            agent=None,

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        calls = [

            call(

                ANY,

                agent=None,

                issue_uid="file1",

                json_data="foobar",

                namespace=None,

                reponame="test",

                username=None,

            ),

            call(

                ANY,

                agent=None,

                issue_uid="file2",

                json_data="foobar",

                namespace=None,

                reponame="test",

                username=None,

            ),

        ]

        self.assertEqual(calls, up_issue.mock_calls)

        up_pr.assert_not_called()

        send.assert_not_called()

    @patch("json.loads")

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    @patch("pagure.lib.git.read_git_lines")

    def test_load_json_commits_to_db_prs(

        self, git, up_issue, up_pr, send, json_loads

    ):

        """ Test the load_json_commits_to_db method. """

        git.side_effect = [["file1"], ["file2"], ["files/image"], ["file1"]]

        json_loads.return_value = "foobar"

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath=self.path,

            data_type="pull-request",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        calls = [

            call(

                ANY,

                json_data="foobar",

                namespace=None,

                reponame="test",

                request_uid="file1",

                username=None,

            ),

            call(

                ANY,

                json_data="foobar",

                namespace=None,

                reponame="test",

                request_uid="file2",

                username=None,

            ),

        ]

        up_issue.assert_not_called()

        self.assertEqual(calls, up_pr.mock_calls)

        calls = [

            call(

                "Good Morning\n\n"

                "This is the log of loading all the files pushed in the git "

                "repo into\n"

                "the database. It should ignore files that are not JSON files,"

                " this\nis fine.\n\n"

                "Loading: file1 -- 1/2 ... ... Done\n"

                "Loading: file2 -- 2/2 ... ... Done",

                "Issue import report",

                "bar@pingou.com",

            )

        ]

        self.assertEqual(calls, send.mock_calls)

    @patch("json.loads")

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    @patch("pagure.lib.git.update_ticket_from_git")

    @patch("pagure.lib.git.read_git_lines")

    def test_load_json_commits_to_db_prs_raises_error(

        self, git, up_issue, up_pr, send, json_loads

    ):

        """ Test the load_json_commits_to_db method. """

        git.side_effect = [["file1"], ["file2"], ["files/image"], ["file1"]]

        json_loads.return_value = "foobar"

        up_pr.side_effect = Exception("foo error")

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=["hash1", "hash2"],

            abspath=self.path,

            data_type="pull-request",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        calls = [

            call(

                ANY,

                json_data="foobar",

                namespace=None,

                reponame="test",

                request_uid="file1",

                username=None,

            )

        ]

        up_issue.assert_not_called()

        self.assertEqual(calls, up_pr.mock_calls)

        calls = [

            call(

                "Good Morning\n\n"

                "This is the log of loading all the files pushed in the git "

                "repo into\n"

                "the database. It should ignore files that are not JSON files,"

                " this\nis fine.\n\n"

                "Loading: file1 -- 1/2 ... ... FAILED\n",

                "Issue import report",

                "bar@pingou.com",

            )

        ]

        self.assertEqual(calls, send.mock_calls)

class PagureLibTaskServicesWithWebHooktests(tests.Modeltests):

    """ Tests for pagure.lib.task_services """

    maxDiff = None

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        super(PagureLibTaskServicesWithWebHooktests, self).setUp()

        pagure.config.config["REQUESTS_FOLDER"] = None

        self.sshkeydir = os.path.join(self.path, "sshkeys")

        pagure.config.config["MIRROR_SSHKEYS_FOLDER"] = self.sshkeydir

        tests.create_projects(self.session)

        project = pagure.lib.query._get_project(self.session, "test")

        settings = project.settings

        settings["Web-hooks"] = "http://foo.com/api/flag\nhttp://bar.org/bar"

        project.settings = settings

        self.session.add(project)

        self.session.commit()

    @patch("pagure.lib.tasks_services.call_web_hooks")

    def test_webhook_notification_no_webhook(self, call_wh):

        """ Test the webhook_notification method. """

        output = pagure.lib.tasks_services.webhook_notification(

            topic="topic",

            msg={"payload": ["a", "b", "c"]},

            namespace=None,

            name="test",

            user=None,

        )

        self.assertIsNone(output)

        project = pagure.lib.query._get_project(self.session, "test")

        call_wh.assert_called_once_with(

            ANY,

            "topic",

            {"payload": ["a", "b", "c"]},

            ["http://foo.com/api/flag", "http://bar.org/bar"],

        )

    @patch("time.time", MagicMock(return_value=2))

    @patch("uuid.uuid4", MagicMock(return_value="not_so_random"))

    @patch("datetime.datetime")

    @patch("requests.post")

    def test_webhook_notification_no_webhook(self, post, dt):

        """ Test the webhook_notification method. """

        post.return_value = False

        utcnow = MagicMock()

        utcnow.year = 2018

        dt.utcnow.return_value = utcnow

        output = pagure.lib.tasks_services.webhook_notification(

            topic="topic",

            msg={"payload": ["a", "b", "c"]},

            namespace=None,

            name="test",

            user=None,

        )

        self.assertIsNone(output)

        project = pagure.lib.query._get_project(self.session, "test")

        self.assertEqual(post.call_count, 2)

        calls = [

            call(

                "http://bar.org/bar",

                data="{"

                '"i": 1, '

                '"msg": {'

                '"pagure_instance": "http://localhost.localdomain/", '

                '"payload": ["a", "b", "c"], '

                '"project_fullname": "test"}, '

                '"msg_id": "2018-not_so_random", '

                '"timestamp": 2, '

                '"topic": "topic"}',

                headers={

                    "X-Pagure": "http://localhost.localdomain/",

                    "X-Pagure-project": "test",

                    "X-Pagure-Signature": "74b12f0b25bf7767014a0c0de9f3c10"

                    "191e943d8",

                    "X-Pagure-Signature-256": "f3d757796554466eac49a5282b2"

                    "4ee32a1ecfb65dedd6c6231fb207240a9fe58",

                    "X-Pagure-Topic": b"topic",

                    "Content-Type": "application/json",

                },

                timeout=60,

            ),

            call(

                "http://foo.com/api/flag",

                data="{"

                '"i": 1, '

                '"msg": {'

                '"pagure_instance": "http://localhost.localdomain/", '

                '"payload": ["a", "b", "c"], '

                '"project_fullname": "test"}, '

                '"msg_id": "2018-not_so_random", '

                '"timestamp": 2, '

                '"topic": "topic"}',

                headers={

                    "X-Pagure": "http://localhost.localdomain/",

                    "X-Pagure-project": "test",

                    "X-Pagure-Signature": "74b12f0b25bf7767014a0c0de9f3c10"

                    "191e943d8",

                    "X-Pagure-Signature-256": "f3d757796554466eac49a5282b2"

                    "4ee32a1ecfb65dedd6c6231fb207240a9fe58",

                    "X-Pagure-Topic": b"topic",

                    "Content-Type": "application/json",

                },

                timeout=60,

            ),

        ]

        print(post.mock_calls)

        self.assertEqual(calls, post.mock_calls)

class PagureLibTaskServicesJenkinsCItests(tests.Modeltests):

    """ Tests for pagure.lib.task_services """

    maxDiff = None

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        super(PagureLibTaskServicesJenkinsCItests, self).setUp()

        pagure.config.config["REQUESTS_FOLDER"] = None

        self.sshkeydir = os.path.join(self.path, "sshkeys")

        pagure.config.config["MIRROR_SSHKEYS_FOLDER"] = self.sshkeydir

        tests.create_projects(self.session)

        project = pagure.lib.query.get_authorized_project(self.session, "test")

        # Install the plugin at the DB level

        plugin = pagure.lib.plugins.get_plugin("Pagure CI")

        dbobj = plugin.db_object()

        dbobj.ci_url = "https://ci.server.org/"

        dbobj.ci_job = "pagure"

        dbobj.pagure_ci_token = "random_token"

        dbobj.project_id = project.id

        self.session.add(dbobj)

        self.session.commit()

        # Create a fork of test for foo

        item = pagure.lib.model.Project(

            user_id=2,  # foo

            name="test",

            is_fork=True,

            parent_id=1,

            description="test project #1",

            hook_token="aaabbbccc_foo",

        )

        item.close_status = [

            "Invalid",

            "Insufficient data",

            "Fixed",

            "Duplicate",

        ]

        self.session.add(item)

        self.session.commit()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_invalid_ci(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="travis",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_invalid_ci_fork(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="forks/foo/test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="travis",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_valid_project(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_called_once_with(

            branch="feature",

            cause="PR#ID",

            ci_password=None,

            ci_username=None,

            job="pagure",

            project_path="test.git",

            token="random_token",

            url="https://ci.server.org/",

            branch_to="master",

        )

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_valid_project_fork(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="forks/foo/test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_called_once_with(

            branch="feature",

            cause="PR#ID",

            ci_password=None,

            ci_username=None,

            job="pagure",

            project_path="forks/foo/test.git",

            token="random_token",

            url="https://ci.server.org/",

            branch_to="master",

        )

class PagureLibTaskServicesJenkinsCIAuthtests(tests.Modeltests):

    """ Tests for pagure.lib.task_services """

    maxDiff = None

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        super(PagureLibTaskServicesJenkinsCIAuthtests, self).setUp()

        pagure.config.config["REQUESTS_FOLDER"] = None

        self.sshkeydir = os.path.join(self.path, "sshkeys")

        pagure.config.config["MIRROR_SSHKEYS_FOLDER"] = self.sshkeydir

        tests.create_projects(self.session)

        project = pagure.lib.query.get_authorized_project(self.session, "test")

        # Install the plugin at the DB level

        plugin = pagure.lib.plugins.get_plugin("Pagure CI")

        dbobj = plugin.db_object()

        dbobj.ci_url = "https://ci.server.org/"

        dbobj.ci_job = "pagure"

        dbobj.ci_username = "jenkins_username"

        dbobj.ci_password = "jenkins_password"

        dbobj.pagure_ci_token = "random_token"

        dbobj.project_id = project.id

        self.session.add(dbobj)

        self.session.commit()

        # Create a fork of test for foo

        item = pagure.lib.model.Project(

            user_id=2,  # foo

            name="test",

            is_fork=True,

            parent_id=1,

            description="test project #1",

            hook_token="aaabbbccc_foo",

        )

        item.close_status = [

            "Invalid",

            "Insufficient data",

            "Fixed",

            "Duplicate",

        ]

        self.session.add(item)

        self.session.commit()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_invalid_ci(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="travis",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_invalid_ci_fork(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="forks/foo/test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="travis",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_not_called()

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_valid_project(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_called_once_with(

            branch="feature",

            cause="PR#ID",

            ci_password="jenkins_password",

            ci_username="jenkins_username",

            job="pagure",

            project_path="test.git",

            token="random_token",

            url="https://ci.server.org/",

            branch_to="master",

        )

    @patch("pagure.lib.tasks_services.trigger_jenkins_build")

    def test_trigger_ci_build_valid_project_fork(self, trigger_jenk):

        """ Test the trigger_ci_build method. """

        output = pagure.lib.tasks_services.trigger_ci_build(

            project_name="forks/foo/test",

            cause="PR#ID",

            branch="feature",

            branch_to="master",

            ci_type="jenkins",

        )

        self.assertIsNone(output)

        trigger_jenk.assert_called_once_with(

            branch="feature",

            cause="PR#ID",

            ci_password="jenkins_password",

            ci_username="jenkins_username",

            job="pagure",

            project_path="forks/foo/test.git",

            token="random_token",

            url="https://ci.server.org/",

            branch_to="master",

        )

class PagureLibTaskServicesLoadJsonTickettests(tests.Modeltests):

    """ Tests for pagure.lib.task_services """

    maxDiff = None

    def setUp(self):

        """ Set up the environnment, ran before every tests. """

        super(PagureLibTaskServicesLoadJsonTickettests, self).setUp()

        tests.create_projects(self.session)

        self.gitrepo = os.path.join(self.path, "repos", "tickets", "test.git")

        repopath = os.path.join(self.path, "repos", "tickets")

        os.makedirs(self.gitrepo)

        self.repo_obj = pygit2.init_repository(self.gitrepo, bare=True)

        project = pagure.lib.query.get_authorized_project(self.session, "test")

        # Create an issue to play with

        msg = pagure.lib.query.new_issue(

            session=self.session,

            repo=project,

            title="Test issue",

            content="We should work on this",

            user="pingou",

        )

        self.assertEqual(msg.title, "Test issue")

        issue = pagure.lib.query.search_issues(

            self.session, project, issueid=1

        )

        # Add a couple of comment on the ticket

        msg = pagure.lib.query.add_issue_comment(

            session=self.session,

            issue=issue,

            comment="Hey look a comment!",

            user="foo",

        )

        self.session.commit()

        self.assertEqual(msg, "Comment added")

        commits = [

            commit

            for commit in self.repo_obj.walk(

                self.repo_obj.head.target, pygit2.GIT_SORT_NONE

            )

        ]

        # 2 commits: creation - new comment

        self.assertEqual(len(commits), 2)

        issue = pagure.lib.query.search_issues(

            self.session, project, issueid=1

        )

        self.assertEqual(len(issue.comments), 1)

    @patch("pagure.lib.notify.send_email")

    @patch("pagure.lib.git.update_request_from_git")

    def test_loading_issue_json(self, up_pr, send):

        """ Test loading the JSON file of a ticket. """

        project = pagure.lib.query.get_authorized_project(self.session, "test")

        issue = pagure.lib.query.search_issues(

            self.session, project, issueid=1

        )

        commits = [

            commit.oid.hex

            for commit in self.repo_obj.walk(

                self.repo_obj.head.target, pygit2.GIT_SORT_NONE

            )

        ]

        output = pagure.lib.tasks_services.load_json_commits_to_db(

            name="test",

            commits=commits,

            abspath=self.gitrepo,

            data_type="ticket",

            agent="pingou",

            namespace=None,

            username=None,

        )

        self.assertIsNone(output)

        up_pr.assert_not_called()

        calls = [

            call(

                "Good Morning\n\n"

                "This is the log of loading all the files pushed in the git "

                "repo into\n"

                "the database. It should ignore files that are not JSON files,"

                " this\nis fine.\n\n"

                "Loading: %s -- 1/1 ... ... Done" % issue.uid,