# -*- 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

__requires__ = ['SQLAlchemy >= 0.8']

import pkg_resources  # noqa

import datetime  # noqa

import os  # noqa

import platform  # noqa

import shutil  # noqa

import subprocess  # noqa

import sys  # noqa

import unittest  # noqa

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.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.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 = '1,3,4'

        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.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)

        # 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(