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

"""

 (c) 2017-2018 - Copyright Red Hat Inc

 Authors:

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

"""

from __future__ import unicode_literals, absolute_import

import datetime  # noqa

import os  # noqa

import platform  # noqa

import shutil  # noqa

import subprocess  # noqa

import sys  # noqa

import unittest  # noqa

import pygit2

import munch  # noqa

from mock import patch, MagicMock  # noqa

from six import StringIO  # noqa

sys.path.insert(

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

)

import pagure.config  # noqa

import pagure.exceptions  # noqa: E402

import pagure.cli.admin  # noqa

import pagure.lib.model  # noqa

import tests  # noqa

class PagureAdminAdminTokenEmptytests(tests.Modeltests):

    """ Tests for pagure-admin admin-token when there is nothing in the DB

    """

    populate_db = False

    def setUp(self):

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

        super(PagureAdminAdminTokenEmptytests, self).setUp()

        pagure.cli.admin.session = self.session

    def test_do_create_admin_token_no_user(self):

        """ Test the do_create_admin_token function of pagure-admin without

        user.

        """

        args = munch.Munch({"user": "pingou"})

        with self.assertRaises(pagure.exceptions.PagureException) as cm:

            pagure.cli.admin.do_create_admin_token(args)

        self.assertEqual(cm.exception.args[0], 'No user "pingou" found')

    def test_do_list_admin_token_empty(self):

        """ Test the do_list_admin_token function of pagure-admin when there

        are not tokens in the db.

        """

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertEqual(output, "No admin tokens found\n")

class PagureAdminAdminRefreshGitolitetests(tests.Modeltests):

    """ Tests for pagure-admin refresh-gitolite """

    populate_db = False

    def setUp(self):

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

        super(PagureAdminAdminRefreshGitolitetests, self).setUp()

        pagure.cli.admin.session = self.session

        # Create the user pingou

        item = pagure.lib.model.User(

            user="pingou",

            fullname="PY C",

            password="foo",

            default_email="bar@pingou.com",

        )

        self.session.add(item)

        item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")

        self.session.add(item)

        self.session.commit()

        # Create a couple of projects

        tests.create_projects(self.session)

        # Add a group

        msg = pagure.lib.query.add_group(

            self.session,

            group_name="foo",

            display_name="foo group",

            description=None,

            group_type="bar",

            user="pingou",

            is_admin=False,

            blacklist=[],

        )

        self.session.commit()

        self.assertEqual(msg, "User `pingou` added to the group `foo`.")

        # Make the imported pagure use the correct db session

        pagure.cli.admin.session = self.session

    @patch("pagure.cli.admin._ask_confirmation")

    @patch("pagure.lib.git_auth.get_git_auth_helper")

    def test_do_refresh_gitolite_no_args(self, get_helper, conf):

        """ Test the do_generate_acl function with no special args. """

        conf.return_value = True

        helper = MagicMock()

        get_helper.return_value = helper

        args = munch.Munch(

            {"group": None, "project": None, "all_": False, "user": None}

        )

        pagure.cli.admin.do_generate_acl(args)

        get_helper.assert_called_with()

        args = helper.generate_acls.call_args

        self.assertIsNone(args[1].get("group"))

        self.assertIsNone(args[1].get("project"))

    @patch("pagure.cli.admin._ask_confirmation")

    @patch("pagure.lib.git_auth.get_git_auth_helper")

    def test_do_refresh_gitolite_all_project(self, get_helper, conf):

        """ Test the do_generate_acl function for all projects. """

        conf.return_value = True

        helper = MagicMock()

        get_helper.return_value = helper

        args = munch.Munch(

            {"group": None, "project": None, "all_": True, "user": None}

        )

        pagure.cli.admin.do_generate_acl(args)

        get_helper.assert_called_with()

        args = helper.generate_acls.call_args

        self.assertIsNone(args[1].get("group"))

        self.assertEqual(args[1].get("project"), -1)

    @patch("pagure.cli.admin._ask_confirmation")

    @patch("pagure.lib.git_auth.get_git_auth_helper")

    def test_do_refresh_gitolite_one_project(self, get_helper, conf):

        """ Test the do_generate_acl function for a certain project. """

        conf.return_value = True

        helper = MagicMock()

        get_helper.return_value = helper

        args = munch.Munch(

            {"group": None, "project": "test", "all_": False, "user": None}

        )

        pagure.cli.admin.do_generate_acl(args)

        get_helper.assert_called_with()

        args = helper.generate_acls.call_args

        self.assertIsNone(args[1].get("group"))

        self.assertEqual(args[1].get("project").fullname, "test")

    @patch("pagure.cli.admin._ask_confirmation")

    @patch("pagure.lib.git_auth.get_git_auth_helper")

    def test_do_refresh_gitolite_one_project_and_all(self, get_helper, conf):

        """ Test the do_generate_acl function for a certain project and all.

        """

        conf.return_value = True

        helper = MagicMock()

        get_helper.return_value = helper

        args = munch.Munch(

            {"group": None, "project": "test", "all_": True, "user": None}

        )

        pagure.cli.admin.do_generate_acl(args)

        get_helper.assert_called_with()

        args = helper.generate_acls.call_args

        self.assertIsNone(args[1].get("group"))

        self.assertEqual(args[1].get("project"), -1)

    @patch("pagure.cli.admin._ask_confirmation")

    @patch("pagure.lib.git_auth.get_git_auth_helper")

    def test_do_refresh_gitolite_one_group(self, get_helper, conf):

        """ Test the do_generate_acl function for a certain group. """

        conf.return_value = True

        helper = MagicMock()

        get_helper.return_value = helper

        args = munch.Munch(

            {"group": "foo", "project": None, "all_": False, "user": None}

        )

        pagure.cli.admin.do_generate_acl(args)

        get_helper.assert_called_with()

        args = helper.generate_acls.call_args

        self.assertEqual(args[1].get("group").group_name, "foo")

        self.assertIsNone(args[1].get("project"))

class PagureAdminAdminTokentests(tests.Modeltests):

    """ Tests for pagure-admin admin-token """

    populate_db = False

    def setUp(self):

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

        super(PagureAdminAdminTokentests, self).setUp()

        pagure.cli.admin.session = self.session

        # Create the user pingou

        item = pagure.lib.model.User(

            user="pingou",

            fullname="PY C",

            password="foo",

            default_email="bar@pingou.com",

        )

        self.session.add(item)

        item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")

        self.session.add(item)

        self.session.commit()

        # Make the imported pagure use the correct db session

        pagure.cli.admin.session = self.session

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_create_admin_token(self, conf, rinp):

        """ Test the do_create_admin_token function of pagure-admin. """

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Check the outcome

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_list_admin_token(self, conf, rinp):

        """ Test the do_list_admin_token function of pagure-admin. """

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve all tokens

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        # Retrieve pfrields's tokens

        list_args = munch.Munch(

            {

                "user": "pfrields",

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertEqual(output, "No admin tokens found\n")

    def test_do_list_admin_token_non_admin_acls(self):

        """ Test the do_list_admin_token function of pagure-admin for a token

        without any admin ACL. """

        pagure.lib.query.add_token_to_user(

            self.session,

            project=None,

            acls=["issue_assign", "pull_request_subscribe"],

            username="pingou",

        )

        # Retrieve all admin tokens

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertEqual(output, "No admin tokens found\n")

        # Retrieve all tokens

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": True,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_info_admin_token(self, conf, rinp):

        """ Test the do_info_admin_token function of pagure-admin. """

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "2,4,5"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        args = munch.Munch({"token": token})

        with tests.capture_output() as output:

            pagure.cli.admin.do_info_admin_token(args)

        output = output.getvalue()

        self.assertIn(" -- pingou -- ", output.split("\n", 1)[0])

        self.assertEqual(

            output.split("\n", 1)[1],

            """ACLs:

  - issue_create

  - pull_request_comment

  - pull_request_flag

""",

        )

    def test_do_info_admin_token_non_admin_acl(self):

        """ Test the do_info_admin_token function of pagure-admin for a

        token not having any admin ACL. """

        pagure.lib.query.add_token_to_user(

            self.session,

            project=None,

            acls=["issue_assign", "pull_request_subscribe"],

            username="pingou",

        )

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": True,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        args = munch.Munch({"token": token})

        with tests.capture_output() as output:

            pagure.cli.admin.do_info_admin_token(args)

        output = output.getvalue()

        self.assertIn(" -- pingou -- ", output.split("\n", 1)[0])

        self.assertEqual(

            output.split("\n", 1)[1],

            """ACLs:

  - issue_assign

  - pull_request_subscribe

""",

        )

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_expire_admin_token(self, conf, rinp):

        """ Test the do_expire_admin_token function of pagure-admin. """

        if "BUILD_ID" in os.environ:

            raise unittest.case.SkipTest("Skipping on jenkins/el7")

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        # Before

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": True,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, "No admin tokens found\n")

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        # Expire the token

        args = munch.Munch({"token": token})

        pagure.cli.admin.do_expire_admin_token(args)

        # After

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": True,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertEqual(output, "No admin tokens found\n")

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_update_admin_token_invalid_date(self, conf, rinp):

        """ Test the do_update_admin_token function of pagure-admin with

        an invalid date. """

        if "BUILD_ID" in os.environ:

            raise unittest.case.SkipTest("Skipping on jenkins/el7")

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        current_expiration = output.split(" ", 1)[1]

        # Set the expiration date to the token

        args = munch.Munch({"token": token, "date": "aa-bb-cc"})

        self.assertRaises(

            pagure.exceptions.PagureException,

            pagure.cli.admin.do_update_admin_token,

            args,

        )

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_update_admin_token_invalid_date2(self, conf, rinp):

        """ Test the do_update_admin_token function of pagure-admin with

        an invalid date. """

        if "BUILD_ID" in os.environ:

            raise unittest.case.SkipTest("Skipping on jenkins/el7")

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        current_expiration = output.split(" ", 1)[1]

        # Set the expiration date to the token

        args = munch.Munch({"token": token, "date": "2017-18-01"})

        self.assertRaises(

            pagure.exceptions.PagureException,

            pagure.cli.admin.do_update_admin_token,

            args,

        )

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_update_admin_token_invalid_date3(self, conf, rinp):

        """ Test the do_update_admin_token function of pagure-admin with

        an invalid date (is today). """

        if "BUILD_ID" in os.environ:

            raise unittest.case.SkipTest("Skipping on jenkins/el7")

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        current_expiration = output.split(" ", 1)[1]

        # Set the expiration date to the token

        args = munch.Munch(

            {"token": token, "date": datetime.datetime.utcnow().date()}

        )

        self.assertRaises(

            pagure.exceptions.PagureException,

            pagure.cli.admin.do_update_admin_token,

            args,

        )

    @patch("pagure.cli.admin._get_input")

    @patch("pagure.cli.admin._ask_confirmation")

    def test_do_update_admin_token(self, conf, rinp):

        """ Test the do_update_admin_token function of pagure-admin. """

        if "BUILD_ID" in os.environ:

            raise unittest.case.SkipTest("Skipping on jenkins/el7")

        # Create an admin token to use

        conf.return_value = True

        rinp.return_value = "1,2,3"

        args = munch.Munch({"user": "pingou"})

        pagure.cli.admin.do_create_admin_token(args)

        # Retrieve the token

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": False,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, 'No user "pingou" found\n')

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        token = output.split(" ", 1)[0]

        current_expiration = output.strip().split(" -- ", 2)[-1]

        # Before

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": True,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertNotEqual(output, "No admin tokens found\n")

        self.assertEqual(len(output.split("\n")), 2)

        self.assertIn(" -- pingou -- ", output)

        deadline = datetime.datetime.utcnow().date() + datetime.timedelta(

            days=3

        )

        # Set the expiration date to the token

        args = munch.Munch(

            {"token": token, "date": deadline.strftime("%Y-%m-%d")}

        )

        pagure.cli.admin.do_update_admin_token(args)

        # After

        list_args = munch.Munch(

            {

                "user": None,

                "token": None,

                "active": True,

                "expired": False,

                "all": False,

            }

        )

        with tests.capture_output() as output:

            pagure.cli.admin.do_list_admin_token(list_args)

        output = output.getvalue()

        self.assertEqual(output.split(" ", 1)[0], token)

        self.assertNotEqual(

            output.strip().split(" -- ", 2)[-1], current_expiration

        )

class PagureAdminGetWatchTests(tests.Modeltests):

    """ Tests for pagure-admin get-watch """

    populate_db = False

    def setUp(self):

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

        super(PagureAdminGetWatchTests, self).setUp()

        pagure.cli.admin.session = self.session

        # Create the user pingou

        item = pagure.lib.model.User(

            user="pingou",

            fullname="PY C",

            password="foo",

            default_email="bar@pingou.com",

        )

        self.session.add(item)

        item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")

        self.session.add(item)

        # Create the user foo

        item = pagure.lib.model.User(

            user="foo",

            fullname="foo B.",

            password="foob",

            default_email="foo@pingou.com",

        )

        self.session.add(item)

        # Create two projects for the user pingou

        item = pagure.lib.model.Project(

            user_id=1,  # pingou

            name="test",

            description="namespaced test project",

            hook_token="aaabbbeee",

            namespace="somenamespace",

        )

        self.session.add(item)

        item = pagure.lib.model.Project(

            user_id=1,  # pingou

            name="test",

            description="Test project",

            hook_token="aaabbbccc",

            namespace=None,

        )

        self.session.add(item)

        self.session.commit()

        # Make the imported pagure use the correct db session

        pagure.cli.admin.session = self.session

    def test_get_watch_get_project_unknown_project(self):

        """ Test the get-watch function of pagure-admin with an unknown

        project.

        """

        args = munch.Munch({"project": "foobar", "user": "pingou"})

        with self.assertRaises(pagure.exceptions.PagureException) as cm:

            pagure.cli.admin.do_get_watch_status(args)

        self.assertEqual(cm.exception.args[0], "No project found with: foobar")

    def test_get_watch_get_project_invalid_project(self):

        """ Test the get-watch function of pagure-admin with an invalid

        project.

        """

        args = munch.Munch({"project": "fo/o/bar", "user": "pingou"})

        with self.assertRaises(pagure.exceptions.PagureException) as cm:

            pagure.cli.admin.do_get_watch_status(args)

        self.assertEqual(

            cm.exception.args[0],

            'Invalid project name, has more than one "/": fo/o/bar',

        )

    def test_get_watch_get_project_invalid_user(self):

        """ Test the get-watch function of pagure-admin on a invalid user.

        """

        args = munch.Munch({"project": "test", "user": "beebop"})

        with self.assertRaises(pagure.exceptions.PagureException) as cm:

            pagure.cli.admin.do_get_watch_status(args)

        self.assertEqual(cm.exception.args[0], 'No user "beebop" found')

    def test_get_watch_get_project(self):

        """ Test the get-watch function of pagure-admin on a regular project.

        """

        args = munch.Munch({"project": "test", "user": "pingou"})

        with tests.capture_output() as output:

            pagure.cli.admin.do_get_watch_status(args)

        output = output.getvalue()

        self.assertEqual(

            "On test user: pingou is watching the following items: "

            "issues, pull-requests\n",

            output,

        )

    def test_get_watch_get_project_not_watching(self):

        """ Test the get-watch function of pagure-admin on a regular project.

        """

        args = munch.Munch({"project": "test", "user": "foo"})

        with tests.capture_output() as output:

            pagure.cli.admin.do_get_watch_status(args)

        output = output.getvalue()

        self.assertEqual(

            "On test user: foo is watching the following items: None\n", output

        )

    def test_get_watch_get_project_namespaced(self):

        """ Test the get-watch function of pagure-admin on a namespaced project.

        """

        args = munch.Munch({"project": "somenamespace/test", "user": "pingou"})

        with tests.capture_output() as output:

            pagure.cli.admin.do_get_watch_status(args)

        output = output.getvalue()

        self.assertEqual(

            "On somenamespace/test user: pingou is watching the following "

            "items: issues, pull-requests\n",

            output,

        )

    def test_get_watch_get_project_namespaced_not_watching(self):

        """ Test the get-watch function of pagure-admin on a namespaced project.

        """

        args = munch.Munch({"project": "somenamespace/test", "user": "foo"})

        with tests.capture_output() as output:

            pagure.cli.admin.do_get_watch_status(args)

        output = output.getvalue()

        with tests.capture_output() as _discarded:

            pagure.cli.admin.do_get_watch_status(args)

        self.assertEqual(

            "On somenamespace/test user: foo is watching the following "

            "items: None\n",

            output,

        )

class PagureAdminUpdateWatchTests(tests.Modeltests):

    """ Tests for pagure-admin update-watch """

    populate_db = False

    def setUp(self):

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

        super(PagureAdminUpdateWatchTests, self).setUp()

        pagure.cli.admin.session = self.session

        # Create the user pingou

        item = pagure.lib.model.User(

            user="pingou",

            fullname="PY C",

            password="foo",

            default_email="bar@pingou.com",

        )

        self.session.add(item)

        item = pagure.lib.model.UserEmail(user_id=1, email="bar@pingou.com")

        self.session.add(item)

        # Create the user foo

        item = pagure.lib.model.User(

            user="foo",

            fullname="foo B.",

            password="foob",

            default_email="foo@pingou.com",

        )

        self.session.add(item)