pagure/tests/test_pagure_flask_api_project.py

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

"""
 (c) 2015-2018 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import json
import unittest
import shutil
import sys
import tempfile
import os

import pygit2
from celery.result import EagerResult
from mock import patch, Mock

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.flask_app
import pagure.lib
import tests
from pagure.lib.repo import PagureRepo


class PagureFlaskApiProjecttests(tests.Modeltests):
    """ Tests for the flask API of pagure for issue """

    def setUp(self):
        super(PagureFlaskApiProjecttests, self).setUp()
        self.gga_patcher = patch(
            'pagure.lib.tasks.generate_gitolite_acls.delay')
        self.mock_gen_acls = self.gga_patcher.start()
        task_result = EagerResult('abc-1234', True, "SUCCESS")
        self.mock_gen_acls.return_value = task_result

    def tearDown(self):
        self.gga_patcher.stop()
        super(PagureFlaskApiProjecttests, self).tearDown()

    def test_api_git_tags(self):
        """ Test the api_git_tags method of the flask api. """
        tests.create_projects(self.session)

        # Create a git repo to play with
        gitrepo = os.path.join(self.path, 'repos', 'test.git')
        repo = pygit2.init_repository(gitrepo, bare=True)

        newpath = tempfile.mkdtemp(prefix='pagure-fork-test')
        repopath = os.path.join(newpath, 'test')
        clone_repo = pygit2.clone_repository(gitrepo, repopath)

        # Create a file in that git repo
        with open(os.path.join(repopath, 'sources'), 'w') as stream:
            stream.write('foo\n bar')
        clone_repo.index.add('sources')
        clone_repo.index.write()

        # Commits the files added
        tree = clone_repo.index.write_tree()
        author = pygit2.Signature(
            'Alice Author', 'alice@authors.tld')
        committer = pygit2.Signature(
            'Cecil Committer', 'cecil@committers.tld')
        clone_repo.create_commit(
            'refs/heads/master',  # the name of the reference to update
            author,
            committer,
            'Add sources file for testing',
            # binary string representing the tree object ID
            tree,
            # list of binary strings representing parents of the new commit
            []
        )
        refname = 'refs/heads/master:refs/heads/master'
        ori_remote = clone_repo.remotes[0]
        PagureRepo.push(ori_remote, refname)

        # Tag our first commit
        first_commit = repo.revparse_single('HEAD')
        tagger = pygit2.Signature('Alice Doe', 'adoe@example.com', 12347, 0)
        repo.create_tag(
            "0.0.1", first_commit.oid.hex, pygit2.GIT_OBJ_COMMIT, tagger,
            "Release 0.0.1")

        # Check tags
        output = self.app.get('/api/0/test/git/tags')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'tags': ['0.0.1'], 'total_tags': 1}
        )

        # Check tags with commits
        output = self.app.get('/api/0/test/git/tags?with_commits=True')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['tags']['0.0.1'] = 'bb8fa2aa199da08d6085e1c9badc3d83d188d38c'
        self.assertDictEqual(
            data,
            {
                u'tags': {u'0.0.1': u'bb8fa2aa199da08d6085e1c9badc3d83d188d38c'},
                u'total_tags': 1}
        )

        shutil.rmtree(newpath)

    def test_api_git_branches(self):
        """ Test the api_git_branches method of the flask api. """
        # Create a git repo to add branches to
        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos', 'test.git')
        tests.add_content_git_repo(repo_path)
        new_repo_path = tempfile.mkdtemp(prefix='pagure-api-git-branches-test')
        clone_repo = pygit2.clone_repository(repo_path, new_repo_path)

        # Create two other branches based on master
        for branch in ['pats-win-49', 'pats-win-51']:
            clone_repo.create_branch(branch, clone_repo.head.get_object())
            refname = 'refs/heads/{0}:refs/heads/{0}'.format(branch)
            PagureRepo.push(clone_repo.remotes[0], refname)

        # Check that the branches show up on the API
        output = self.app.get('/api/0/test/git/branches')
        # Delete the cloned git repo after the API call
        shutil.rmtree(new_repo_path)

        # Verify the API data
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                'branches': ['master', 'pats-win-49', 'pats-win-51'],
                'total_branches': 3
            }
        )

    def test_api_git_branches_empty_repo(self):
        """ Test the api_git_branches method of the flask api when the repo is
        empty.
        """
        # Create a git repo without any branches
        tests.create_projects(self.session)
        repo_base_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repo_base_path)

        # Check that no branches show up on the API
        output = self.app.get('/api/0/test/git/branches')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                'branches': [],
                'total_branches': 0
            }
        )

    def test_api_git_branches_no_repo(self):
        """ Test the api_git_branches method of the flask api when there is no
        repo on a project.
        """
        tests.create_projects(self.session)
        output = self.app.get('/api/0/test/git/branches')
        self.assertEqual(output.status_code, 404)

    def test_api_git_urls(self):
        """ Test the api_project_git_urls method of the flask api.
        """
        tests.create_projects(self.session)
        output = self.app.get('/api/0/test/git/urls')
        self.assertEqual(output.status_code, 200)
        expected_rv = {
            'urls': {
                'git': 'git://pagure.org/test.git',
                'ssh': 'ssh://git@pagure.org/test.git'
            },
            'total_urls': 2
        }
        data = json.loads(output.data)
        self.assertDictEqual(data, expected_rv)

    def test_api_git_urls_no_project(self):
        """ Test the api_project_git_urls method of the flask api when there is
        no project.
        """
        output = self.app.get('/api/0/test1234/git/urls')
        self.assertEqual(output.status_code, 404)
        expected_rv = {
            'error': 'Project not found',
            'error_code': 'ENOPROJECT'
        }
        data = json.loads(output.data)
        self.assertDictEqual(data, expected_rv)

    @patch.dict('pagure.config.config', {'PRIVATE_PROJECTS': True})
    def test_api_git_urls_private_project(self):
        """ Test the api_project_git_urls method of the flask api when the
        project is private.
        """
        tests.create_projects(self.session)
        tests.create_tokens(self.session)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd')
        headers = {'Authorization': 'token aaabbbcccddd'}

        test_project = pagure.lib._get_project(self.session, 'test')
        test_project.private = True
        self.session.add(test_project)
        self.session.commit()

        output = self.app.get('/api/0/test/git/urls', headers=headers)
        self.assertEqual(output.status_code, 200)
        expected_rv = {
            'urls': {
                'git': 'git://pagure.org/test.git',
                'ssh': 'ssh://git@pagure.org/test.git'
            },
            'total_urls': 2
        }
        data = json.loads(output.data)
        self.assertDictEqual(data, expected_rv)

    @patch.dict('pagure.config.config', {'PRIVATE_PROJECTS': True})
    def test_api_git_urls_private_project_no_login(self):
        """ Test the api_project_git_urls method of the flask api when the
        project is private and the user is not logged in.
        """
        tests.create_projects(self.session)
        test_project = pagure.lib._get_project(self.session, 'test')
        test_project.private = True
        self.session.add(test_project)
        self.session.commit()

        output = self.app.get('/api/0/test/git/urls')
        self.assertEqual(output.status_code, 404)
        expected_rv = {
            'error': 'Project not found',
            'error_code': 'ENOPROJECT'
        }
        data = json.loads(output.data)
        self.assertDictEqual(data, expected_rv)

    def test_api_projects_pattern(self):
        """ Test the api_projects method of the flask api. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?pattern=test')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        expected_data = {
          "args": {
            "fork": None,
            "namespace": None,
            "owner": None,
            "pattern": "test",
            "short": False,
            "tags": [],
            "username": None
          },
          "projects": [
            {
              "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
              },
              "access_users": {
                "admin": [],
                "commit": [],
                "owner": [
                  "pingou"
                ],
                "ticket": []
              },
              "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
              ],
              "custom_keys": [],
              "date_created": "1436527638",
              "date_modified": "1436527638",
              "description": "test project #1",
              "fullname": "test",
              "url_path": "test",
              "id": 1,
              "milestones": {},
              "name": "test",
              "namespace": None,
              "parent": None,
              "priorities": {},
              "tags": [],
              "user": {
                "fullname": "PY C",
                "name": "pingou"
              }
            }
          ],
          "total_projects": 1
        }
        self.assertDictEqual(data, expected_data)

    def test_api_projects_pattern_short(self):
        """ Test the api_projects method of the flask api. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?pattern=te*&short=1')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        expected_data = {
          "args": {
            "fork": None,
            "namespace": None,
            "owner": None,
            "pattern": "te*",
            "short": True,
            "tags": [],
            "username": None
          },
          "projects": [
            {
              "description": "test project #1",
              "fullname": "test",
              "name": "test",
              "namespace": None
            },
            {
              "description": "test project #2",
              "fullname": "test2",
              "name": "test2",
              "namespace": None
            },
            {
              "description": "namespaced test project",
              "fullname": "somenamespace/test3",
              "name": "test3",
              "namespace": "somenamespace"
            }
          ],
          "total_projects": 3
        }
        self.assertDictEqual(data, expected_data)

    def test_api_projects(self):
        """ Test the api_projects method of the flask api. """
        tests.create_projects(self.session)

        # Check before adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(repo.tags, [])

        # Adding a tag
        output = pagure.lib.update_tags(
            self.session, repo, 'infra', 'pingou',
            None)
        self.assertEqual(output, ['Project tagged with: infra'])

        # Check after adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(len(repo.tags), 1)
        self.assertEqual(repo.tags_text, ['infra'])

        # Check the API
        output = self.app.get('/api/0/projects?tags=inf')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "total_projects": 0,
                "projects": [],
                "args": {
                    "fork": None,
                    "namespace": None,
                    "owner": None,
                    "pattern": None,
                    "short": False,
                    "tags": ["inf"],
                    "username": None
                }
            }
        )
        output = self.app.get('/api/0/projects?tags=infra')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "pattern": None,
                "short": False,
                "tags": ["infra"],
                "username": None
            },
            "projects": [{
                "access_groups": {
                    "admin": [],
                    "commit": [],
                    "ticket": []},
                "access_users": {
                     "admin": [],
                     "commit": [],
                     "owner": ["pingou"],
                     "ticket": []},
                "close_status": [
                    "Invalid",
                    "Insufficient data",
                    "Fixed",
                    "Duplicate"
                ],
                "custom_keys": [],
                "date_created": "1436527638",
                "date_modified": "1436527638",
                "description": "test project #1",
                "fullname": "test",
                "url_path": "test",
                "id": 1,
                "milestones": {},
                "name": "test",
                "namespace": None,
                "parent": None,
                "priorities": {},
                "tags": ["infra"],
                "user": {
                    "fullname": "PY C",
                    "name": "pingou"
                }
            }],
            "total_projects": 1
        }
        self.assertDictEqual(data, expected_data)

        output = self.app.get('/api/0/projects?owner=pingou')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        data['projects'][1]['date_created'] = "1436527638"
        data['projects'][1]['date_modified'] = "1436527638"
        data['projects'][2]['date_created'] = "1436527638"
        data['projects'][2]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": "pingou",
                "pattern": None,
                "short": False,
                "tags": [],
                "username": None
            },
            "projects": [
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #1",
                    "fullname": "test",
                    "url_path": "test",
                    "id": 1,
                    "milestones": {},
                    "name": "test",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": ["infra"],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #2",
                    "fullname": "test2",
                    "url_path": "test2",
                    "id": 2,
                    "milestones": {},
                    "name": "test2",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "namespaced test project",
                    "fullname": "somenamespace/test3",
                    "url_path": "somenamespace/test3",
                    "id": 3,
                    "milestones": {},
                    "name": "test3",
                    "namespace": "somenamespace",
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                }
            ],
            "total_projects": 3
        }
        self.assertDictEqual(data, expected_data)

        output = self.app.get('/api/0/projects?username=pingou')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        data['projects'][1]['date_created'] = "1436527638"
        data['projects'][1]['date_modified'] = "1436527638"
        data['projects'][2]['date_created'] = "1436527638"
        data['projects'][2]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "pattern": None,
                "short": False,
                "tags": [],
                "username": "pingou"
            },
            "projects": [
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []},
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #1",
                    "fullname": "test",
                    "url_path": "test",
                    "id": 1,
                    "milestones": {},
                    "name": "test",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": ["infra"],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #2",
                    "fullname": "test2",
                    "url_path": "test2",
                    "id": 2,
                    "milestones": {},
                    "name": "test2",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []},
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []},
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "namespaced test project",
                    "fullname": "somenamespace/test3",
                    "url_path": "somenamespace/test3",
                    "id": 3,
                    "milestones": {},
                    "name": "test3",
                    "namespace": "somenamespace",
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                }
            ],
            "total_projects": 3
        }
        self.assertDictEqual(data, expected_data)

        output = self.app.get('/api/0/projects?username=pingou&tags=infra')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "pattern": None,
                "short": False,
                "tags": ["infra"],
                "username": "pingou",
            },
            "projects": [{
                "access_groups": {
                    "admin": [],
                    "commit": [],
                    "ticket": []
                },
                "access_users": {
                    "admin": [],
                    "commit": [],
                    "owner": ["pingou"],
                    "ticket": []},
                "close_status": [
                    "Invalid",
                    "Insufficient data",
                    "Fixed",
                    "Duplicate"],
                "custom_keys": [],
                "date_created": "1436527638",
                "date_modified": "1436527638",
                "description": "test project #1",
                "fullname": "test",
                "url_path": "test",
                "id": 1,
                "milestones": {},
                "name": "test",
                "namespace": None,
                "parent": None,
                "priorities": {},
                "tags": ["infra"],
                "user": {
                    "fullname": "PY C",
                    "name": "pingou"
                }
            }],
            "total_projects": 1
        }
        self.assertDictEqual(data, expected_data)

        output = self.app.get('/api/0/projects?namespace=somenamespace')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "owner": None,
                "namespace": "somenamespace",
                "pattern": None,
                "short": False,
                "tags": [],
                "username": None
            },
            "projects": [
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []},
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []},
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "namespaced test project",
                    "fullname": "somenamespace/test3",
                    "url_path": "somenamespace/test3",
                    "id": 3,
                    "milestones": {},
                    "name": "test3",
                    "namespace": "somenamespace",
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                }
            ],
            "total_projects": 1
        }
        self.assertDictEqual(data, expected_data)

    def test_api_project(self):
        """ Test the api_project method of the flask api. """
        tests.create_projects(self.session)

        # Check before adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(repo.tags, [])

        # Adding a tag
        output = pagure.lib.update_tags(
            self.session, repo, 'infra', 'pingou',
            gitfolder=None)
        self.assertEqual(output, ['Project tagged with: infra'])

        # Check after adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(len(repo.tags), 1)
        self.assertEqual(repo.tags_text, ['infra'])

        # Check the API

        # Non-existing project
        output = self.app.get('/api/0/random')
        self.assertEqual(output.status_code, 404)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'error_code': 'ENOPROJECT', 'error': 'Project not found'}
        )

        # Existing project
        output = self.app.get('/api/0/test')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['date_created'] = "1436527638"
        data['date_modified'] = "1436527638"
        expected_data ={
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": ["pingou"],
                "ticket": []},
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1436527638",
            "date_modified": "1436527638",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": ["infra"],
            "user": {
                "fullname": "PY C",
                "name": "pingou"
            }
        }
        self.assertDictEqual(data, expected_data)

    def test_api_project_group(self):
        """ Test the api_project method of the flask api. """
        tests.create_projects(self.session)
        repo = pagure.lib.get_authorized_project(self.session, 'test')

        # Adding a tag
        output = pagure.lib.update_tags(
            self.session, repo, 'infra', 'pingou',
            gitfolder=None)
        self.assertEqual(output, ['Project tagged with: infra'])

        # Check after adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(len(repo.tags), 1)
        self.assertEqual(repo.tags_text, ['infra'])

        # Add a group to the project
        msg = pagure.lib.add_group(
            self.session,
            group_name='some_group',
            display_name='Some Group',
            description=None,
            group_type='bar',
            user='foo',
            is_admin=False,
            blacklist=[],
        )
        self.session.commit()

        project = pagure.lib.get_authorized_project(self.session, 'test')
        group = pagure.lib.search_groups(
            self.session, group_name='some_group')

        pagure.lib.add_group_to_project(
            self.session,
            project,
            new_group='some_group',
            user='pingou',
            access='commit',
            create=False,
            is_admin=True
        )
        self.session.commit()

        # Check the API

        # Existing project
        output = self.app.get('/api/0/test?expand_group=1')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['date_created'] = "1436527638"
        data['date_modified'] = "1436527638"
        expected_data ={
            "access_groups": {
                "admin": [],
                "commit": ["some_group"],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": ["pingou"],
                "ticket": []},
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1436527638",
            "date_modified": "1436527638",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "group_details": {
              "some_group": [
                "foo"
              ]
            },
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": ["infra"],
            "user": {
                "fullname": "PY C",
                "name": "pingou"
            }
        }
        self.assertDictEqual(data, expected_data)

    def test_api_project_group_but_no_group(self):
        """ Test the api_project method of the flask api when asking for
        group details while there are none associated.
        """
        tests.create_projects(self.session)
        repo = pagure.lib.get_authorized_project(self.session, 'test')

        # Adding a tag
        output = pagure.lib.update_tags(
            self.session, repo, 'infra', 'pingou',
            gitfolder=None)
        self.assertEqual(output, ['Project tagged with: infra'])

        # Check after adding
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        self.assertEqual(len(repo.tags), 1)
        self.assertEqual(repo.tags_text, ['infra'])

        # Check the API

        # Existing project
        output = self.app.get('/api/0/test?expand_group=0')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['date_created'] = "1436527638"
        data['date_modified'] = "1436527638"
        expected_data ={
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": ["pingou"],
                "ticket": []},
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1436527638",
            "date_modified": "1436527638",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": ["infra"],
            "user": {
                "fullname": "PY C",
                "name": "pingou"
            }
        }
        self.assertDictEqual(data, expected_data)

    def test_api_projects_pagination(self):
        """ Test the api_projects method of the flask api with pagination. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=1')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        for i in range(3):
            data['projects'][i]['date_created'] = "1436527638"
            data['projects'][i]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "page": 1,
                "per_page": 20,
                "pattern": None,
                "short": False,
                "tags": [],
                "username": None
            },
            "pagination": {
                "next": None,
                "page": 1,
                "pages": 1,
                "per_page": 20,
                "prev": None
            },
            "projects": [
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []},
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #1",
                    "fullname": "test",
                    "url_path": "test",
                    "id": 1,
                    "milestones": {},
                    "name": "test",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "test project #2",
                    "fullname": "test2",
                    "url_path": "test2",
                    "id": 2,
                    "milestones": {},
                    "name": "test2",
                    "namespace": None,
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                },
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []},
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []},
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "namespaced test project",
                    "fullname": "somenamespace/test3",
                    "url_path": "somenamespace/test3",
                    "id": 3,
                    "milestones": {},
                    "name": "test3",
                    "namespace": "somenamespace",
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                }
            ],
            "total_projects": 3
        }
        # Test URLs
        self.assertURLEqual(
            data["pagination"].pop("first"),
            "http://localhost/api/0/projects?per_page=20&page=1",
        )
        self.assertURLEqual(
            data["pagination"].pop("last"),
            "http://localhost/api/0/projects?per_page=20&page=1",
        )
        self.assertDictEqual(data, expected_data)

    def test_api_projects_pagination_per_page(self):
        """ Test the api_projects method of the flask api with pagination and
        the `per_page` argument set. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=2&per_page=2')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['projects'][0]['date_created'] = "1436527638"
        data['projects'][0]['date_modified'] = "1436527638"
        expected_data = {
            "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "page": 2,
                "per_page": 2,
                "pattern": None,
                "short": False,
                "tags": [],
                "username": None
            },
            "pagination": {
                "next": None,
                "page": 2,
                "pages": 2,
                "per_page": 2,
            },
            "projects": [
                {
                    "access_groups": {
                        "admin": [],
                        "commit": [],
                        "ticket": []
                    },
                    "access_users": {
                        "admin": [],
                        "commit": [],
                        "owner": ["pingou"],
                        "ticket": []
                    },
                    "close_status": [
                        "Invalid",
                        "Insufficient data",
                        "Fixed",
                        "Duplicate"
                    ],
                    "custom_keys": [],
                    "date_created": "1436527638",
                    "date_modified": "1436527638",
                    "description": "namespaced test project",
                    "fullname": "somenamespace/test3",
                    "url_path": "somenamespace/test3",
                    "id": 3,
                    "milestones": {},
                    "name": "test3",
                    "namespace": "somenamespace",
                    "parent": None,
                    "priorities": {},
                    "tags": [],
                    "user": {
                        "fullname": "PY C",
                        "name": "pingou"
                    }
                }
            ],
            "total_projects": 3
        }
        self.assertURLEqual(
            data["pagination"].pop("first"),
            "http://localhost/api/0/projects?per_page=2&page=1",
        )
        self.assertURLEqual(
            data["pagination"].pop("prev"),
            "http://localhost/api/0/projects?per_page=2&page=1",
        )
        self.assertURLEqual(
            data["pagination"].pop("last"),
            "http://localhost/api/0/projects?per_page=2&page=2",
        )
        self.assertDictEqual(data, expected_data)

    def test_api_projects_pagination_invalid_page(self):
        """ Test the api_projects method of the flask api when an invalid page
        value is entered. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=-3')
        self.assertEqual(output.status_code, 400)

    def test_api_projects_pagination_invalid_page_str(self):
        """ Test the api_projects method of the flask api when an invalid type
        for the page value is entered. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=abcd')
        self.assertEqual(output.status_code, 400)

    def test_api_projects_pagination_invalid_per_page_too_low(self):
        """ Test the api_projects method of the flask api when a per_page
        value is below 1. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=1&per_page=0')
        self.assertEqual(output.status_code, 400)
        error = json.loads(output.data)
        self.assertEqual(
            error['error'], 'The per_page value must be between 1 and 100')

    def test_api_projects_pagination_invalid_per_page_too_high(self):
        """ Test the api_projects method of the flask api when a per_page
        value is above 100. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=1&per_page=101')
        self.assertEqual(output.status_code, 400)
        error = json.loads(output.data)
        self.assertEqual(
            error['error'], 'The per_page value must be between 1 and 100')

    def test_api_projects_pagination_invalid_per_page_str(self):
        """ Test the api_projects method of the flask api when an invalid type
        for the per_page value is entered. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=1&per_page=abcd')
        self.assertEqual(output.status_code, 400)

    def test_api_projects_pagination_beyond_last_page(self):
        """ Test the api_projects method of the flask api when a page value
        that is larger than the last page is entered. """
        tests.create_projects(self.session)

        output = self.app.get('/api/0/projects?page=99999')
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertURLEqual(
            data["pagination"].pop("first"),
            "http://localhost/api/0/projects?per_page=20&page=1",
        )
        self.assertURLEqual(
            data["pagination"].pop("last"),
            "http://localhost/api/0/projects?per_page=20&page=1",
        )
        self.assertURLEqual(
            data["pagination"].pop("prev"),
            "http://localhost/api/0/projects?per_page=20&page=99998",
        )
        self.assertEqual(
            data,
            {
              "args": {
                "fork": None,
                "namespace": None,
                "owner": None,
                "page": 99999,
                "pattern": None,
                "per_page": 20,
                "short": False,
                "tags": [],
                "username": None
              },
              "pagination": {
                "next": None,
                "page": 99999,
                "pages": 1,
                "per_page": 20,
              },
              "projects": [],
              "total_projects": 3
            }
        )

    def test_api_modify_project_main_admin(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project. """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo'})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        data['date_created'] = '1496338274'
        data['date_modified'] = '1496338274'
        expected_output = {
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": [
                  "foo"
                ],
                "ticket": []
            },
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1496338274",
            "date_modified": "1496338274",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": [],
            "user": {
                "default_email": "foo@bar.com",
                "emails": [
                    "foo@bar.com"
                ],
                "fullname": "foo bar",
                "name": "foo"
            }
        }
        self.assertEqual(data, expected_output)

    def test_api_modify_project_main_admin_retain_access(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project and retain_access
        is true. """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo', 'retain_access': True})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        data['date_created'] = '1496338274'
        data['date_modified'] = '1496338274'
        expected_output = {
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [
                    "pingou"
                ],
                "commit": [],
                "owner": [
                    "foo"
                ],
                "ticket": []
            },
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1496338274",
            "date_modified": "1496338274",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": [],
            "user": {
                "default_email": "foo@bar.com",
                "emails": [
                    "foo@bar.com"
                ],
                "fullname": "foo bar",
                "name": "foo"
            }
        }
        self.assertEqual(data, expected_output)

    def test_api_modify_project_main_admin_retain_access_already_user(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project and retain_access
        is true and the user becoming the main_admin already has access. """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        project = pagure.lib._get_project(self.session, 'test')
        pagure.lib.add_user_to_project(
            self.session, project,
            new_user='foo',
            user='pingou',
            access='commit'
        )
        self.session.commit()

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo', 'retain_access': True})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        data['date_created'] = '1496338274'
        data['date_modified'] = '1496338274'
        expected_output = {
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [
                    "pingou"
                ],
                "commit": [],
                "owner": [
                    "foo"
                ],
                "ticket": []
            },
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1496338274",
            "date_modified": "1496338274",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": [],
            "user": {
                "default_email": "foo@bar.com",
                "emails": [
                    "foo@bar.com"
                ],
                "fullname": "foo bar",
                "name": "foo"
            }
        }
        self.assertEqual(data, expected_output)

    def test_api_modify_project_main_admin_json(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project using JSON. """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd',
                   'Content-Type': 'application/json'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data=json.dumps({'main_admin': 'foo'}))
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        data['date_created'] = '1496338274'
        data['date_modified'] = '1496338274'
        expected_output = {
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": [
                  "foo"
                ],
                "ticket": []
            },
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1496338274",
            "date_modified": "1496338274",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": [],
            "user": {
                "default_email": "foo@bar.com",
                "emails": [
                    "foo@bar.com"
                ],
                "fullname": "foo bar",
                "name": "foo"
            }
        }
        self.assertEqual(data, expected_output)

    @patch.dict('pagure.config.config', {'PAGURE_ADMIN_USERS': 'foo'})
    def test_api_modify_project_main_admin_as_site_admin(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project and the user is a
        Pagure site admin. """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, user_id=2, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo'})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        data['date_created'] = '1496338274'
        data['date_modified'] = '1496338274'
        expected_output = {
            "access_groups": {
                "admin": [],
                "commit": [],
                "ticket": []
            },
            "access_users": {
                "admin": [],
                "commit": [],
                "owner": [
                  "foo"
                ],
                "ticket": []
            },
            "close_status": [
                "Invalid",
                "Insufficient data",
                "Fixed",
                "Duplicate"
            ],
            "custom_keys": [],
            "date_created": "1496338274",
            "date_modified": "1496338274",
            "description": "test project #1",
            "fullname": "test",
            "url_path": "test",
            "id": 1,
            "milestones": {},
            "name": "test",
            "namespace": None,
            "parent": None,
            "priorities": {},
            "tags": [],
            "user": {
                "default_email": "foo@bar.com",
                "emails": [
                    "foo@bar.com"
                ],
                "fullname": "foo bar",
                "name": "foo"
            }
        }
        self.assertEqual(data, expected_output)

    def test_api_modify_project_main_admin_not_main_admin(self):
        """ Test the api_modify_project method of the flask api when the
        requester is not the main_admin of the project and requests to change
        the main_admin.
        """
        tests.create_projects(self.session)
        project_user = pagure.lib.model.ProjectUser(
            project_id=1,
            user_id=2,
            access='admin',
        )
        self.session.add(project_user)
        self.session.commit()
        tests.create_tokens(self.session, project_id=None, user_id=2)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo'})
        self.assertEqual(output.status_code, 401)
        expected_error = {
            'error': ('Only the main admin can set the main admin of a '
                      'project'),
            'error_code': 'ENOTMAINADMIN'
        }
        self.assertEqual(
            json.loads(output.get_data(as_text=True)), expected_error)

    def test_api_modify_project_not_admin(self):
        """ Test the api_modify_project method of the flask api when the
        requester is not an admin of the project.
        """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None, user_id=2)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'foo'})
        self.assertEqual(output.status_code, 401)
        expected_error = {
            'error': 'You are not allowed to modify this project',
            'error_code': 'EMODIFYPROJECTNOTALLOWED'
        }
        self.assertEqual(
            json.loads(output.get_data(as_text=True)), expected_error)

    def test_api_modify_project_invalid_request(self):
        """ Test the api_modify_project method of the flask api when the
        request data is invalid.
        """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data='invalid')
        self.assertEqual(output.status_code, 400)
        expected_error = {
            'error': 'Invalid or incomplete input submitted',
            'error_code': 'EINVALIDREQ'
        }
        self.assertEqual(
            json.loads(output.get_data(as_text=True)), expected_error)

    def test_api_modify_project_invalid_keys(self):
        """ Test the api_modify_project method of the flask api when the
        request data contains an invalid key.
        """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'invalid': 'invalid'})
        self.assertEqual(output.status_code, 400)
        expected_error = {
            'error': 'Invalid or incomplete input submitted',
            'error_code': 'EINVALIDREQ'
        }
        self.assertEqual(
            json.loads(output.get_data(as_text=True)), expected_error)

    def test_api_modify_project_invalid_new_main_admin(self):
        """ Test the api_modify_project method of the flask api when the
        request is to change the main_admin of the project to a main_admin
        that doesn't exist.
        """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session, 'aaabbbcccddd', 'modify_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        output = self.app.patch(
            '/api/0/test', headers=headers,
            data={'main_admin': 'tbrady'})
        self.assertEqual(output.status_code, 400)
        expected_error = {
            'error': 'No such user found',
            'error_code': 'ENOUSER'
        }
        self.assertEqual(
            json.loads(output.get_data(as_text=True)), expected_error)

    def test_api_project_watchers(self):
        """ Test the api_project_watchers method of the flask api. """
        tests.create_projects(self.session)
        # The user is not logged in and the owner is watching issues implicitly
        output = self.app.get('/api/0/test/watchers')
        self.assertEqual(output.status_code, 200)
        expected_data = {
            "total_watchers": 1,
            "watchers": {
                "pingou": [
                    "issues"
                ]
            }
        }
        self.assertDictEqual(json.loads(output.data), expected_data)

        user = tests.FakeUser(username='pingou')
        with tests.user_set(self.app.application, user):
            # Non-existing project
            output = self.app.get('/api/0/random/watchers')
            self.assertEqual(output.status_code, 404)
            data = json.loads(output.data)
            self.assertDictEqual(
                data,
                {'error_code': 'ENOPROJECT', 'error': 'Project not found'}
            )

            # The owner is watching issues implicitly
            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 1,
                "watchers": {
                    "pingou": [
                        "issues"
                    ]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

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

            # The owner is watching issues and commits explicitly
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '3')
            self.session.commit()
            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 1,
                "watchers": {
                    "pingou": [
                        "issues",
                        "commits"
                    ]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner is watching issues explicitly
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '1')
            self.session.commit()
            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 1,
                "watchers": {
                    "pingou": [
                        "issues"
                    ]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner is watching commits explicitly
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '2')
            self.session.commit()
            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 1,
                "watchers": {
                    "pingou": [
                        "commits"
                    ]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner is watching commits explicitly and foo is watching
            # issues implicitly
            project_user = pagure.lib.model.ProjectUser(
                project_id=project.id,
                user_id=2,
                access='commit',
            )
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '2')
            self.session.add(project_user)
            self.session.commit()

            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 2,
                "watchers": {
                    "foo": ["issues"],
                    "pingou": ["commits"]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner and foo are watching issues implicitly
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '-1')
            self.session.commit()

            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 2,
                "watchers": {
                    "foo": ["issues"],
                    "pingou": ["issues"]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner and foo through group membership are watching issues
            # implicitly
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '-1')
            project_membership = self.session.query(
                pagure.lib.model.ProjectUser).filter_by(
                    user_id=2, project_id=project.id).one()
            self.session.delete(project_membership)
            self.session.commit()

            msg = pagure.lib.add_group(
                self.session,
                group_name='some_group',
                display_name='Some Group',
                description=None,
                group_type='bar',
                user='pingou',
                is_admin=False,
                blacklist=[],
            )
            self.session.commit()

            project = pagure.lib.get_authorized_project(self.session, 'test')
            group = pagure.lib.search_groups(
                self.session, group_name='some_group')
            pagure.lib.add_user_to_group(
                self.session, 'foo', group, 'pingou', False)

            pagure.lib.add_group_to_project(
                self.session,
                project,
                new_group='some_group',
                user='pingou',
                access='commit',
                create=False,
                is_admin=True
            )
            self.session.commit()

            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 2,
                "watchers": {
                    "@some_group": ["issues"],
                    "pingou": ["issues"]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

            # The owner is watching issues implicitly and foo will be watching
            # commits explicitly but is in a group with commit access
            pagure.lib.update_watch_status(
                self.session, project, 'pingou', '-1')
            pagure.lib.update_watch_status(
                self.session, project, 'foo', '2')
            self.session.commit()

            output = self.app.get('/api/0/test/watchers')
            self.assertEqual(output.status_code, 200)
            expected_data = {
                "total_watchers": 3,
                "watchers": {
                    "@some_group": ["issues"],
                    "foo": ["commits"],
                    "pingou": ["issues"]
                }
            }
            self.assertDictEqual(json.loads(output.data), expected_data)

    def test_api_new_project(self):
        """ Test the api_new_project method of the flask api. """

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'tickets'))
        tests.create_tokens(self.session)
        tests.create_tokens_acl(self.session)

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

        # Invalid token
        output = self.app.post('/api/0/new', headers=headers)
        self.assertEqual(output.status_code, 401)
        data = json.loads(output.data)
        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

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

        # No input
        output = self.app.post('/api/0/new', headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {
                "name": ["This field is required."],
                "description": ["This field is required."]
              }
            }
        )

        data = {
            'name': 'test',
        }

        # Incomplete request
        output = self.app.post(
            '/api/0/new', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"description": ["This field is required."]}
            }
        )

        data = {
            'name': 'test',
            'description': 'Just a small test project',
        }

        # Valid request but repo already exists
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "It is not possible to create the repo \"test\"",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'name': 'test_42',
            'description': 'Just another small test project',
        }

        # Valid request
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "test_42" created'}
        )

    @patch.dict('pagure.config.config', {'PRIVATE_PROJECTS': True})
    def test_api_new_project_private(self):
        """ Test the api_new_project method of the flask api to create
        a private project. """

        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'tickets'))
        tests.create_tokens(self.session)
        tests.create_tokens_acl(self.session)

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

        data = {
            'name': 'test',
            'description': 'Just a small test project',
            'private': True,
        }

        # Valid request
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "pingou/test" created'}
        )

    def test_api_new_project_user_token(self):
        """ Test the api_new_project method of the flask api. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'tickets'))
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session)

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

        # Invalid token
        output = self.app.post('/api/0/new', headers=headers)
        self.assertEqual(output.status_code, 401)
        data = json.loads(output.data)
        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

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

        # No input
        output = self.app.post('/api/0/new', headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {
                "name": ["This field is required."],
                "description": ["This field is required."]
              }
            }
        )

        data = {
            'name': 'test',
        }

        # Incomplete request
        output = self.app.post(
            '/api/0/new', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"description": ["This field is required."]}
            }
        )

        data = {
            'name': 'test',
            'description': 'Just a small test project',
        }

        # Valid request but repo already exists
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "It is not possible to create the repo \"test\"",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'name': 'test_42',
            'description': 'Just another small test project',
        }

        # Valid request
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "test_42" created'}
        )

        # Project with a namespace
        pagure.config.config['ALLOWED_PREFIX'] = ['rpms']
        data = {
            'name': 'test_42',
            'namespace': 'pingou',
            'description': 'Just another small test project',
        }

        # Invalid namespace
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Invalid or incomplete input submitted",
                "error_code": "EINVALIDREQ",
                "errors": {
                    "namespace": [
                        "Not a valid choice"
                    ]
                }
            }
        )

        data = {
            'name': 'test_42',
            'namespace': 'rpms',
            'description': 'Just another small test project',
        }

        # All good
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "rpms/test_42" created'}
        )

    @patch.dict('pagure.config.config', {'USER_NAMESPACE': True})
    def test_api_new_project_user_ns(self):
        """ Test the api_new_project method of the flask api. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(self.path, 'tickets'))
        tests.create_tokens(self.session)
        tests.create_tokens_acl(self.session)

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

        # Create a project with the user namespace feature on
        data = {
            'name': 'testproject',
            'description': 'Just another small test project',
        }

        # Valid request
        output = self.app.post(
            '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "pingou/testproject" created'}
        )

        # Create a project with a namespace and the user namespace feature on
        data = {
            'name': 'testproject2',
            'namespace': 'testns',
            'description': 'Just another small test project',
        }

        # Valid request
        with patch.dict('pagure.config.config', {'ALLOWED_PREFIX': ['testns']}):
            output = self.app.post(
                '/api/0/new/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {'message': 'Project "testns/testproject2" created'}
        )

    def test_api_fork_project(self):
        """ Test the api_fork_project method of the flask api. """
        tests.create_projects(self.session)
        for folder in ['docs', 'tickets', 'requests', 'repos']:
            tests.create_projects_git(
                os.path.join(self.path, folder), bare=True)
        tests.create_tokens(self.session)
        tests.create_tokens_acl(self.session)

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

        # Invalid token
        output = self.app.post('/api/0/fork', headers=headers)
        self.assertEqual(output.status_code, 401)
        data = json.loads(output.data)
        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

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

        # No input
        output = self.app.post('/api/0/fork', headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"repo": ["This field is required."]}
            }
        )

        data = {
            'name': 'test',
        }

        # Incomplete request
        output = self.app.post(
            '/api/0/fork', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"repo": ["This field is required."]}
            }
        )

        data = {
            'repo': 'test',
        }

        # Valid request
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "message": "Repo \"test\" cloned to \"pingou/test\""
            }
        )

        data = {
            'repo': 'test',
        }

        # project already forked
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Repo \"forks/pingou/test\" already exists",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'repo': 'test',
            'username': 'pingou',
        }

        # Fork already exists
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Repo \"forks/pingou/test\" already exists",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'repo': 'test',
            'namespace': 'pingou',
        }

        # Repo does not exists
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 404)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Project not found",
                "error_code": "ENOPROJECT"
            }
        )

    def test_api_fork_project_user_token(self):
        """ Test the api_fork_project method of the flask api. """
        tests.create_projects(self.session)
        for folder in ['docs', 'tickets', 'requests', 'repos']:
            tests.create_projects_git(
                os.path.join(self.path, folder), bare=True)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(self.session)

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

        # Invalid token
        output = self.app.post('/api/0/fork', headers=headers)
        self.assertEqual(output.status_code, 401)
        data = json.loads(output.data)
        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

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

        # No input
        output = self.app.post('/api/0/fork', headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"repo": ["This field is required."]}
            }
        )

        data = {
            'name': 'test',
        }

        # Incomplete request
        output = self.app.post(
            '/api/0/fork', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
              "error": "Invalid or incomplete input submitted",
              "error_code": "EINVALIDREQ",
              "errors": {"repo": ["This field is required."]}
            }
        )

        data = {
            'repo': 'test',
        }

        # Valid request
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "message": "Repo \"test\" cloned to \"pingou/test\""
            }
        )

        data = {
            'repo': 'test',
        }

        # project already forked
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Repo \"forks/pingou/test\" already exists",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'repo': 'test',
            'username': 'pingou',
        }

        # Fork already exists
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Repo \"forks/pingou/test\" already exists",
                "error_code": "ENOCODE"
            }
        )

        data = {
            'repo': 'test',
            'namespace': 'pingou',
        }

        # Repo does not exists
        output = self.app.post(
            '/api/0/fork/', data=data, headers=headers)
        self.assertEqual(output.status_code, 404)
        data = json.loads(output.data)
        self.assertDictEqual(
            data,
            {
                "error": "Project not found",
                "error_code": "ENOPROJECT"
            }
        )

    def test_api_generate_acls(self):
        """ Test the api_generate_acls method of the flask api """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'generate_acls_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        user = pagure.lib.get_user(self.session, 'pingou')
        output = self.app.post(
            '/api/0/test/git/generateacls', headers=headers,
            data={'wait': False})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        expected_output = {
            'message': 'Project ACL generation queued',
            'taskid': 'abc-1234'
        }
        self.assertEqual(data, expected_output)
        self.mock_gen_acls.assert_called_once_with(
            name='test', namespace=None, user=None, group=None)

    def test_api_generate_acls_json(self):
        """ Test the api_generate_acls method of the flask api using JSON """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'generate_acls_project')
        headers = {'Authorization': 'token aaabbbcccddd',
                   'Content-Type': 'application/json'}

        user = pagure.lib.get_user(self.session, 'pingou')
        output = self.app.post(
            '/api/0/test/git/generateacls', headers=headers,
            data=json.dumps({'wait': False}))
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        expected_output = {
            'message': 'Project ACL generation queued',
            'taskid': 'abc-1234'
        }
        self.assertEqual(data, expected_output)
        self.mock_gen_acls.assert_called_once_with(
            name='test', namespace=None, user=None, group=None)

    def test_api_generate_acls_wait_true(self):
        """ Test the api_generate_acls method of the flask api when wait is
        set to True """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'generate_acls_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        task_result = Mock()
        task_result.id = 'abc-1234'
        self.mock_gen_acls.return_value = task_result

        user = pagure.lib.get_user(self.session, 'pingou')
        output = self.app.post(
            '/api/0/test/git/generateacls', headers=headers,
            data={'wait': True})
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.get_data(as_text=True))
        expected_output = {
            'message': 'Project ACLs generated',
        }
        self.assertEqual(data, expected_output)
        self.mock_gen_acls.assert_called_once_with(
            name='test', namespace=None, user=None, group=None)
        self.assertTrue(task_result.get.called)

    def test_api_generate_acls_no_project(self):
        """ Test the api_generate_acls method of the flask api when the project
        doesn't exist """
        tests.create_projects(self.session)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'generate_acls_project')
        headers = {'Authorization': 'token aaabbbcccddd'}

        user = pagure.lib.get_user(self.session, 'pingou')
        output = self.app.post(
            '/api/0/test12345123/git/generateacls', headers=headers,
            data={'wait': False})
        self.assertEqual(output.status_code, 404)
        data = json.loads(output.get_data(as_text=True))
        expected_output = {
            'error_code': 'ENOPROJECT',
            'error': 'Project not found'
        }
        self.assertEqual(data, expected_output)

    def test_api_new_git_branch(self):
        """ Test the api_new_branch method of the flask api """
        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repo_path, bare=True)
        tests.add_content_git_repo(os.path.join(repo_path, 'test.git'))
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'create_branch')
        headers = {'Authorization': 'token aaabbbcccddd'}
        args = {'branch': 'test123'}
        output = self.app.post('/api/0/test/git/branch', headers=headers,
                               data=args)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        expected_output = {
            'message': 'Project branch was created',
        }
        self.assertEqual(data, expected_output)
        git_path = os.path.join(self.path, 'repos', 'test.git')
        repo_obj = pygit2.Repository(git_path)
        self.assertIn('test123', repo_obj.listall_branches())


    def test_api_new_git_branch_json(self):
        """ Test the api_new_branch method of the flask api """
        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repo_path, bare=True)
        tests.add_content_git_repo(os.path.join(repo_path, 'test.git'))
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'create_branch')
        headers = {'Authorization': 'token aaabbbcccddd',
                   'Content-Type': 'application/json'}
        args = {'branch': 'test123'}
        output = self.app.post('/api/0/test/git/branch', headers=headers,
                               data=json.dumps(args))
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        expected_output = {
            'message': 'Project branch was created',
        }
        self.assertEqual(data, expected_output)
        git_path = os.path.join(self.path, 'repos', 'test.git')
        repo_obj = pygit2.Repository(git_path)
        self.assertIn('test123', repo_obj.listall_branches())

    def test_api_new_git_branch_from_branch(self):
        """ Test the api_new_branch method of the flask api """
        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repo_path, bare=True)
        tests.add_content_git_repo(os.path.join(repo_path, 'test.git'))
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'create_branch')
        git_path = os.path.join(self.path, 'repos', 'test.git')
        repo_obj = pygit2.Repository(git_path)
        parent = pagure.lib.git.get_branch_ref(repo_obj, 'master').get_object()
        repo_obj.create_branch('dev123', parent)
        headers = {'Authorization': 'token aaabbbcccddd'}
        args = {'branch': 'test123', 'from_branch': 'dev123'}
        output = self.app.post('/api/0/test/git/branch', headers=headers,
                               data=args)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        expected_output = {
            'message': 'Project branch was created',
        }
        self.assertEqual(data, expected_output)
        self.assertIn('test123', repo_obj.listall_branches())

    def test_api_new_git_branch_already_exists(self):
        """ Test the api_new_branch method of the flask api when branch already
        exists """
        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repo_path, bare=True)
        tests.add_content_git_repo(os.path.join(repo_path, 'test.git'))
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'create_branch')
        headers = {'Authorization': 'token aaabbbcccddd'}
        args = {'branch': 'master'}
        output = self.app.post('/api/0/test/git/branch', headers=headers,
                               data=args)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        expected_output = {
            'error': 'The branch "master" already exists',
            'error_code': 'ENOCODE'
        }
        self.assertEqual(data, expected_output)

    def test_api_new_git_branch_from_commit(self):
        """ Test the api_new_branch method of the flask api """
        tests.create_projects(self.session)
        repos_path = os.path.join(self.path, 'repos')
        tests.create_projects_git(repos_path, bare=True)
        git_path = os.path.join(repos_path, 'test.git')
        tests.add_content_git_repo(git_path)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'create_branch')
        repo_obj = pygit2.Repository(git_path)
        from_commit = repo_obj.revparse_single('HEAD').oid.hex
        headers = {'Authorization': 'token aaabbbcccddd'}
        args = {'branch': 'test123', 'from_commit': from_commit}
        output = self.app.post('/api/0/test/git/branch', headers=headers,
                               data=args)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        expected_output = {
            'message': 'Project branch was created',
        }
        self.assertEqual(data, expected_output)
        self.assertIn('test123', repo_obj.listall_branches())


class PagureFlaskApiProjectFlagtests(tests.Modeltests):
    """ Tests for the flask API of pagure for flagging commit in project
    """

    def setUp(self):
        """ Set up the environnment, ran before every tests. """
        super(PagureFlaskApiProjectFlagtests, self).setUp()

        tests.create_projects(self.session)
        repo_path = os.path.join(self.path, 'repos')
        self.git_path = os.path.join(repo_path, 'test.git')
        tests.create_projects_git(repo_path, bare=True)
        tests.add_content_git_repo(self.git_path)
        tests.create_tokens(self.session, project_id=None)
        tests.create_tokens_acl(
            self.session, 'aaabbbcccddd', 'commit_flag')

    def test_flag_commit_missing_status(self):
        """ Test flagging a commit with missing precentage. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'uid': 'jenkins_build_pagure_100+seed',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        expected_output = {
          "error": "Invalid or incomplete input submitted",
          "error_code": "EINVALIDREQ",
          "errors": {
            "status": [
              "Not a valid choice"
            ]
          }
        }
        self.assertEqual(data, expected_output)

    def test_flag_commit_missing_username(self):
        """ Test flagging a commit with missing username. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'uid': 'jenkins_build_pagure_100+seed',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        expected_output = {
          "error": "Invalid or incomplete input submitted",
          "error_code": "EINVALIDREQ",
          "errors": {
            "username": [
              "This field is required."
            ]
          }
        }
        self.assertEqual(data, expected_output)

    def test_flag_commit_missing_comment(self):
        """ Test flagging a commit with missing comment. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'uid': 'jenkins_build_pagure_100+seed',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        expected_output = {
          "error": "Invalid or incomplete input submitted",
          "error_code": "EINVALIDREQ",
          "errors": {
            "comment": [
              "This field is required."
            ]
          }
        }
        self.assertEqual(data, expected_output)

    def test_flag_commit_missing_url(self):
        """ Test flagging a commit with missing url. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'uid': 'jenkins_build_pagure_100+seed',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        expected_output = {
          "error": "Invalid or incomplete input submitted",
          "error_code": "EINVALIDREQ",
          "errors": {
            "url": [
              "This field is required."
            ]
          }
        }
        self.assertEqual(data, expected_output)

    def test_flag_commit_invalid_token(self):
        """ Test flagging a commit with missing info. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token 123'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'uid': 'jenkins_build_pagure_100+seed',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 401)
        data = json.loads(output.data)
        self.assertEqual(sorted(data.keys()), ['error', 'error_code'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.value, data['error'])
        self.assertEqual(
            pagure.api.APIERROR.EINVALIDTOK.name, data['error_code'])

    def test_flag_commit_invalid_status(self):
        """ Test flagging a commit with an invalid status. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'status': 'foobar',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertEqual(
            data,
            {
              u'errors': {u'status': [u'Not a valid choice']},
              u'error_code': u'EINVALIDREQ',
              u'error': u'Invalid or incomplete input submitted'
            }
        )

    def test_flag_commit_with_uid(self):
        """ Test flagging a commit with provided uid. """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'uid': 'jenkins_build_pagure_100+seed',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        data['flag']['date_created'] = u'1510742565'
        data['flag']['commit_hash'] = u'62b49f00d489452994de5010565fab81'
        expected_output = {
            u'flag': {
                u'comment': u'Tests passed',
                u'commit_hash': u'62b49f00d489452994de5010565fab81',
                u'date_created': u'1510742565',
                u'percent': 100,
                u'status': 'success',
                u'url': u'http://jenkins.cloud.fedoraproject.org/',
                u'user': {
                    u'default_email': u'bar@pingou.com',
                    u'emails': [u'bar@pingou.com', u'foo@pingou.com'],
                    u'fullname': u'PY C',
                    u'name': u'pingou'},
                u'username': u'Jenkins'
            },
            u'message': u'Flag added',
            u'uid': u'jenkins_build_pagure_100+seed'
        }

        self.assertEqual(data, expected_output)

    @patch('pagure.lib.notify.send_email')
    def test_flag_commit_without_uid(self, mock_email):
        """ Test flagging a commit with missing info.

        Also ensure notifications aren't sent when they are not asked for.
        """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertNotEqual(
            data['uid'],
            u'jenkins_build_pagure_100+seed'
        )
        data['flag']['date_created'] = u'1510742565'
        data['uid'] = 'b1de8f80defd4a81afe2e09f39678087'
        expected_output = {
            u'flag': {
                u'comment': u'Tests passed',
                u'commit_hash': commit.oid.hex,
                u'date_created': u'1510742565',
                u'percent': 100,
                u'status': 'success',
                u'url': u'http://jenkins.cloud.fedoraproject.org/',
                u'user': {
                    u'default_email': u'bar@pingou.com',
                    u'emails': [u'bar@pingou.com', u'foo@pingou.com'],
                    u'fullname': u'PY C',
                    u'name': u'pingou'},
                u'username': u'Jenkins'
            },
            u'message': u'Flag added',
            u'uid': u'b1de8f80defd4a81afe2e09f39678087'
        }
        self.assertEqual(data, expected_output)

        mock_email.assert_not_called()

    @patch('pagure.lib.notify.send_email')
    def test_flag_commit_with_notification(self, mock_email):
        """ Test flagging a commit with notification enabled. """

        # Enable commit notifications
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        settings = repo.settings
        settings['notify_on_commit_flag'] = True
        repo.settings = settings
        self.session.add(repo)
        self.session.commit()

        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'status': 'success',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=data)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertNotEqual(
            data['uid'],
            u'jenkins_build_pagure_100+seed'
        )
        data['flag']['date_created'] = u'1510742565'
        data['uid'] = 'b1de8f80defd4a81afe2e09f39678087'
        expected_output = {
            u'flag': {
                u'comment': u'Tests passed',
                u'commit_hash': commit.oid.hex,
                u'date_created': u'1510742565',
                u'percent': 100,
                u'status': 'success',
                u'url': u'http://jenkins.cloud.fedoraproject.org/',
                u'user': {
                    u'default_email': u'bar@pingou.com',
                    u'emails': [u'bar@pingou.com', u'foo@pingou.com'],
                    u'fullname': u'PY C',
                    u'name': u'pingou'},
                u'username': u'Jenkins'
            },
            u'message': u'Flag added',
            u'uid': u'b1de8f80defd4a81afe2e09f39678087'
        }
        self.assertEqual(data, expected_output)

        mock_email.assert_called_once_with(
            u'\nJenkins flagged the commit '
            u'`' + commit.oid.hex + u'` as success: '
            u'Tests passed\n\n'
            u'https://pagure.org/test/c/' + commit.oid.hex + u'\n',
            u'Coommit #' + commit.oid.hex + u' - Jenkins: success',
            u'bar@pingou.com',
            in_reply_to=u'test-project-1',
            mail_id=u'test-commit-1-1',
            project_name=u'test',
            user_from=u'Jenkins'
        )

    @patch.dict('pagure.config.config',
                {
                    'FLAG_STATUSES_LABELS':
                        {
                            'pend!': 'label-info',
                            'succeed!': 'label-success',
                            'fail!': 'label-danger',
                            'what?': 'label-warning',
                        },
                     'FLAG_PENDING': 'pend!',
                     'FLAG_SUCCESS': 'succeed!',
                     'FLAG_FAILURE': 'fail!',
                })
    def test_flag_commit_with_custom_flags(self):
        """ Test flagging when custom flags are set up
        """
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        headers = {'Authorization': 'token aaabbbcccddd'}
        send_data = {
            'username': 'Jenkins',
            'percent': 100,
            'comment': 'Tests passed',
            'url': 'http://jenkins.cloud.fedoraproject.org/',
            'status': 'succeed!',
        }
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=send_data)
        self.assertEqual(output.status_code, 200)
        data = json.loads(output.data)
        self.assertEqual(data['flag']['status'], 'succeed!')

        # Try invalid flag status
        send_data['status'] = 'nooooo....'
        output = self.app.post(
            '/api/0/test/c/%s/flag' % commit.oid.hex,
            headers=headers, data=send_data)
        self.assertEqual(output.status_code, 400)
        data = json.loads(output.data)
        self.assertEqual(
            data,
            {
              u'errors': {u'status': [u'Not a valid choice']},
              u'error_code': u'EINVALIDREQ',
              u'error': u'Invalid or incomplete input submitted'
            }
        )

    def test_commit_flags(self):
        """ Test retrieving commit flags. """
        repo = pagure.lib.get_authorized_project(self.session, 'test')
        repo_obj = pygit2.Repository(self.git_path)
        commit = repo_obj.revparse_single('HEAD')

        # test with no flags
        output = self.app.get('/api/0/test/c/%s/flag' % commit.oid.hex)
        self.assertEqual(json.loads(output.data), {'total_flags': 0, 'flags': []})
        self.assertEqual(output.status_code, 200)

        # add some flags and retrieve them
        pagure.lib.add_commit_flag(
            session=self.session,
            repo=repo,
            commit_hash=commit.oid.hex,
            username='simple-koji-ci',
            status='pending',
            percent=None,
            comment='Build is running',
            url='https://koji.fp.o/koji...',
            uid='uid',
            user='foo',
            token='aaabbbcccddd'
        )

        pagure.lib.add_commit_flag(
            session=self.session,
            repo=repo,
            commit_hash=commit.oid.hex,
            username='complex-koji-ci',
            status='success',
            percent=None,
            comment='Build succeeded',
            url='https://koji.fp.o/koji...',
            uid='uid2',
            user='foo',
            token='aaabbbcccddd'
        )
        self.session.commit()

        output = self.app.get('/api/0/test/c/%s/flag' % commit.oid.hex)
        data = json.loads(output.data)

        for f in data['flags']:
            f['date_created'] = u'1510742565'
            f['commit_hash'] = u'62b49f00d489452994de5010565fab81'
        expected_output = {
            u"flags": [
              {
                u"comment": u"Build is running",
                u"commit_hash": u"62b49f00d489452994de5010565fab81",
                u"date_created": u"1510742565",
                u"percent": None,
                u"status": u"pending",
                u"url": u"https://koji.fp.o/koji...",
                u"user": {
                  u"fullname": u"foo bar",
                  u"name": u"foo"
                },
                u"username": u"simple-koji-ci"
              },
              {
                u"comment": u"Build succeeded",
                u"commit_hash": u"62b49f00d489452994de5010565fab81",
                u"date_created": u"1510742565",
                u"percent": None,
                u"status": u"success",
                u"url": u"https://koji.fp.o/koji...",
                u"user": {
                  u"fullname": u"foo bar",
                  u"name": u"foo"
                },
                u"username": u"complex-koji-ci"
              }
            ],
            u"total_flags": 2
        }

        self.assertEqual(data, expected_output)


if __name__ == '__main__':
    unittest.main(verbosity=2)