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

"""

 (c) 2015-2017 - Copyright Red Hat Inc

 Authors:

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

"""

from __future__ import unicode_literals

__requires__ = ['SQLAlchemy >= 0.8']

import pkg_resources

import json

import unittest

import shutil

import sys

import tempfile

import time

import os

import re

import pygit2

import six

from mock import patch, MagicMock

from bs4 import BeautifulSoup

from datetime import datetime, timedelta

sys.path.insert(0, os.path.join(os.path.dirname(

    os.path.abspath(__file__)), '..'))

import pagure

import pagure.lib

import tests

from pagure.lib.repo import PagureRepo

def _get_commits(output):

    ''' Returns the commits message in the output. All commits must have

    been made by `Alice Author` or `PY C` to be found.

    '''

    commits = []

    save = False

    cnt = 0

    for row in output.split('\n'):

        if row.strip() in ['Alice Author', 'Alice Äuthòr', 'PY C']:

            save = True

        if save:

            cnt += 1

        if cnt == 7:

            commits.append(row.strip())

            save = False

            cnt = 0

    return commits

class PagureFlaskForktests(tests.Modeltests):

    """ Tests for flask fork controller of pagure """

    def set_up_git_repo(

            self, new_project=None, branch_from='feature', mtype='FF',

            prid=1, name_from='test'):

        """ Set up the git repo and create the corresponding PullRequest

        object.

        """

        # Create a git repo to play with

        gitrepo = os.path.join(self.path, 'repos', '%s.git' % name_from)

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

        try:

            com = repo.revparse_single('HEAD')

            prev_commit = [com.oid.hex]

        except:

            prev_commit = []

        # 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

            prev_commit

        )

        time.sleep(1)

        refname = 'refs/heads/master:refs/heads/master'

        ori_remote = clone_repo.remotes[0]

        PagureRepo.push(ori_remote, refname)

        first_commit = repo.revparse_single('HEAD')

        def compatible_signature(name, email):

            if six.PY2:

                name = name.encode("utf-8")

                email = email.encode("utf-8")

            return pygit2.Signature(name, email)

        if mtype == 'merge':

            with open(os.path.join(repopath, '.gitignore'), 'w') as stream:

                stream.write('*~')

            clone_repo.index.add('.gitignore')

            clone_repo.index.write()

            # Commits the files added

            tree = clone_repo.index.write_tree()

            author = compatible_signature(

                'Alice Äuthòr', 'alice@äuthòrs.tld')

            comitter = compatible_signature(

                'Cecil Cõmmîttër', 'cecil@cõmmîttërs.tld')

            clone_repo.create_commit(

                'refs/heads/master',

                author,

                committer,

                'Add .gitignore file for testing',

                # binary string representing the tree object ID

                tree,

                # list of binary strings representing parents of the new commit

                [first_commit.oid.hex]

            )

            refname = 'refs/heads/master:refs/heads/master'

            ori_remote = clone_repo.remotes[0]

            PagureRepo.push(ori_remote, refname)

        if mtype == 'conflicts':

            with open(os.path.join(repopath, 'sources'), 'w') as stream:

                stream.write('foo\n bar\nbaz')

            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',

                author,

                committer,

                'Add sources conflicting',

                # binary string representing the tree object ID

                tree,

                # list of binary strings representing parents of the new commit

                [first_commit.oid.hex]

            )

            refname = 'refs/heads/master:refs/heads/master'

            ori_remote = clone_repo.remotes[0]

            PagureRepo.push(ori_remote, refname)

        # Set the second repo

        new_gitrepo = repopath

        if new_project:

            # Create a new git repo to play with

            new_gitrepo = os.path.join(newpath, new_project.fullname)

            if not os.path.exists(new_gitrepo):

                os.makedirs(new_gitrepo)

                new_repo = pygit2.clone_repository(gitrepo, new_gitrepo)

        repo = pygit2.Repository(new_gitrepo)

        if mtype != 'nochanges':

            # Edit the sources file again

            with open(os.path.join(new_gitrepo, 'sources'), 'w') as stream:

                stream.write('foo\n bar\nbaz\n boose')

            repo.index.add('sources')

            repo.index.write()

            # Commits the files added

            tree = repo.index.write_tree()

            author = pygit2.Signature(

                'Alice Author', 'alice@authors.tld')

            committer = pygit2.Signature(

                'Cecil Committer', 'cecil@committers.tld')

            repo.create_commit(

                'refs/heads/%s' % branch_from,

                author,

                committer,

                'A commit on branch %s' % branch_from,

                tree,

                [first_commit.oid.hex]

            )

            refname = 'refs/heads/%s' % (branch_from)

            ori_remote = repo.remotes[0]

            PagureRepo.push(ori_remote, refname)

        # Create a PR for these changes

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

        req = pagure.lib.new_pull_request(

            session=self.session,

            repo_from=project,

            branch_from=branch_from,

            repo_to=project,

            branch_to='master',

            title='PR from the %s branch' % branch_from,

            user='pingou',

            requestfolder=None,

        )

        self.session.commit()

        self.assertEqual(req.id, prid)

        self.assertEqual(req.title, 'PR from the %s branch' % branch_from)

        shutil.rmtree(newpath)

    def test_request_pull_reference(self):

        """ Test if there is a reference created for a new PR. """

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(new_project=None, branch_from='feature')

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

        self.assertEqual(len(project.requests), 1)

        # View the pull-request

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 200)

        # Give time to the worker to process the task

        time.sleep(1)

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

        repo = pygit2.Repository(gitrepo)

        self.assertEqual(

            list(repo.listall_references()),

            ['refs/heads/feature', 'refs/heads/master', 'refs/pull/1/head']

        )

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

    def test_request_pull(self, send_email):

        """ Test the request_pull endpoint. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        # Non-existant project

        output = self.app.get('/foobar/pull-request/1')

        self.assertEqual(output.status_code, 404)

        # Project has no PR

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 404)

        self.set_up_git_repo(new_project=None, branch_from='feature')

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

        self.assertEqual(len(project.requests), 1)

        # View the pull-request

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        #self.assertIn(

            #'
PR#1\n'

            #'  PR from the feature branch\n',

            #output_text)

        self.assertIn(

            'title="View file as of 2a552b">sources', output_text)

        # Test if the `open changed file icon` is displayed.

        self.assertIn(

            'class="open_changed_file_icon_wrap">

            'class="oi open_changed_file_icon" data-glyph="eye" '

            'alt="Open changed file" title="Open changed file">'

            '', output_text)

        self.assertIn(

            '

            'pull-xs-right text-mono">+3', output_text)

        self.assertIn(

            '-1',

            output_text)

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

    def test_merge_request_pull_FF(self, send_email):

        """ Test the merge_request_pull endpoint with a FF PR. """

        send_email.return_value = True

        self.test_request_pull()

        user = tests.FakeUser()

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            csrf_token = self.get_csrf(output=output)

            # No CSRF

            output = self.app.post(

                '/test/pull-request/1/merge', data={}, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>PR#1: PR from the feature branch - test\n - '</title>

                'Pagure', output_text)

            #self.assertIn(

                #'
PR#1\n'

                #'  PR from the feature branch\n',

                #output_text)

            self.assertIn(

                'title="View file as of 2a552b">sources', output_text)

            # Wrong project

            data = {

                'csrf_token': csrf_token,

            }

            output = self.app.post(

                '/foobar/pull-request/100/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 404)

            # Wrong project

            data = {

                'csrf_token': csrf_token,

            }

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 403)

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            # Wrong request id

            data = {

                'csrf_token': csrf_token,

            }

            output = self.app.post(

                '/test/pull-request/100/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 404)

            # Project w/o pull-request

            self.session.commit()

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

            settings = repo.settings

            settings['pull_requests'] = False

            repo.settings = settings

            self.session.add(repo)

            self.session.commit()

            # Pull-request disabled

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 404)

            # Project w pull-request but only assignee can merge

            self.session.commit()

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

            settings['pull_requests'] = True

            settings['Only_assignee_can_merge_pull-request'] = True

            repo.settings = settings

            self.session.add(repo)

            self.session.commit()

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>PR#1: PR from the feature branch - test\n - '</title>

                'Pagure', output_text)

            self.assertIn(

                '
PR#1\n'

                '  PR from the feature branch\n     ',

                output_text)

            self.assertIn(

                '\n                      This request must be '

                'assigned to be merged', output_text)

            # PR assigned but not to this user

            self.session.commit()

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

            req = repo.requests[0]

            req.assignee_id = 2

            self.session.add(req)

            self.session.commit()

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
PR#1\n'

                '  PR from the feature branch\n     ',

                output_text)

            self.assertIn(

                '\n                      Only the assignee can '

                'merge this review', output_text)

            # Project w/ minimal PR score

            self.session.commit()

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

            settings['Only_assignee_can_merge_pull-request'] = False

            settings['Minimum_score_to_merge_pull-request'] = 2

            repo.settings = settings

            self.session.add(repo)

            self.session.commit()

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
PR#1\n'

                '  PR from the feature branch\n     ',

                output_text)

            self.assertIn(

                '\n                      This request does not '

                'have the minimum review score necessary to be merged',

                output_text)

            # Merge

            self.session.commit()

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

            settings['Minimum_score_to_merge_pull-request'] = -1

            repo.settings = settings

            self.session.add(repo)

            self.session.commit()

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output = self.app.get('/test/commits')

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>Commits - test - Pagure</title>', output_text)

            self.assertIn(

                'A commit on branch feature', output_text)

            self.assertNotIn(

                'Merge #1 `PR from the feature branch`', output_text)

            # Check if the closing notification was added

            output = self.app.get('/test/pull-request/1')

            self.assertIn(

                '<small>
Pull-Request has been merged by pingou
</small>',

                output.get_data(as_text=True))

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

    def test_merge_request_pull_merge(self, send_email):

        """ Test the merge_request_pull endpoint with a merge PR. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(

            new_project=None, branch_from='feature', mtype='merge')

        user = tests.FakeUser()

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            csrf_token = self.get_csrf(output=output)

            data = {

                'csrf_token': csrf_token,

            }

            # Merge

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            self.assertIn(

                '<title>Overview - test - Pagure</title>', output.get_data(as_text=True))

            # Check if the closing notification was added

            output = self.app.get('/test/pull-request/1')

            self.assertIn(

                '<small>
Pull-Request has been merged by pingou
</small>',

                output.get_data(as_text=True))

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

    def test_merge_request_pull_merge_with_delete_branch(self, send_email):

        """ Test the merge_request_pull endpoint with a merge PR and delete source branch. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(

            new_project=None, branch_from='feature-branch', mtype='merge')

        user = tests.FakeUser()

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            data = {

                'csrf_token': self.get_csrf(output=output),

                'delete_branch': True,

            }

            # Merge

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '<title>Overview - test - Pagure</title>', output_text)

            # Check the branch is not mentioned

            self.assertNotIn(

                '

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

    def test_merge_request_pull_conflicts(self, send_email):

        """ Test the merge_request_pull endpoint with a conflicting PR. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(

            new_project=None, branch_from='feature', mtype='conflicts')

        user = tests.FakeUser()

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            csrf_token = self.get_csrf(output=output)

            data = {

                'csrf_token': csrf_token,

            }

            # Merge conflicts

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
PR#1\n'

                '  PR from the feature branch\n     ',

                output_text)

            self.assertIn('Merge conflicts!', output_text)

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

    def test_merge_request_pull_conflicts_with_delete_branch(self, send_email):

        """ Test the merge_request_pull endpoint with a conflicting PR and request deletion of branch. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(

            new_project=None, branch_from='feature-branch', mtype='conflicts')

        user = tests.FakeUser()

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            data = {

                'csrf_token': self.get_csrf(output=output),

                'delete_branch': True,

            }

            # Merge conflicts

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
PR#1\n'

                '  PR from the feature-branch branch\n     ',

                output_text)

            self.assertIn('Merge conflicts!', output_text)

            # Check the branch still exists

            output = self.app.get('/test/branches')

            self.assertIn('feature-branch', output.get_data(as_text=True))

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

    def test_merge_request_pull_nochange(self, send_email):

        """ Test the merge_request_pull endpoint. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(

            new_project=None, branch_from='master', mtype='nochanges')

        user = tests.FakeUser()

        user.username = 'pingou'

        with tests.user_set(self.app.application, user):

            output = self.app.get('/test/pull-request/1')

            self.assertEqual(output.status_code, 200)

            csrf_token = self.get_csrf(output=output)

            data = {

                'csrf_token': csrf_token,

            }

            # Nothing to merge

            output = self.app.post(

                '/test/pull-request/1/merge', data=data, follow_redirects=True)

            self.assertEqual(output.status_code, 200)

            output_text = output.get_data(as_text=True)

            self.assertIn(

                '
PR#1\n'

                '  Merged',

                output_text)

            self.assertIn('Nothing to do, changes were already merged',

                          output_text)

            # Check if the closing notification was added

            output = self.app.get('/test/pull-request/1')

            self.assertIn(

                '<small>
Pull-Request has been merged by pingou
</small>',

                output.get_data(as_text=True))

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

    def test_request_pull_close(self, send_email):

        """ Test the request_pull endpoint with a closed PR. """

        send_email.return_value = True

        self.test_merge_request_pull_FF()

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            '
PR#1\n'

            '  ', output_text)

        self.assertIn('
Merged by\n', output_text)

        self.assertIn(

            'title="View file as of 2a552b">sources', output_text)

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

    def test_request_pull_disabled(self, send_email):

        """ Test the request_pull endpoint with PR disabled. """

        send_email.return_value = True

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        self.set_up_git_repo(new_project=None, branch_from='feature')

        # Project w/o pull-request

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

        settings = repo.settings

        settings['pull_requests'] = False

        repo.settings = settings

        self.session.add(repo)

        self.session.commit()

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 404)

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

    @patch('pagure.lib.git.update_pull_ref')

    def test_request_pull_empty_repo(self, send_email, update_pull_ref):

        """ Test the request_pull endpoint against an empty repo. """

        # Mock update_pull_ref or the repo won't be empty anymore

        # (the PR will have been pushed to refs/pull)

        send_email.return_value = True

        tests.create_projects(self.session)

        item = pagure.lib.model.Project(

            user_id=2,  # foo

            name='test',

            description='test project #1',

            hook_token='aaabbb',

            is_fork=True,

            parent_id=1,

        )

        self.session.add(item)

        self.session.commit()

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        tests.create_projects_git(

            os.path.join(self.path, 'repos', 'forks', 'foo'), bare=True)

        # Create a git repo to play with

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

        self.assertFalse(os.path.exists(gitrepo))

        os.makedirs(gitrepo)

        repo = pygit2.init_repository(gitrepo, bare=True)

        # Create a fork of this repo

        newpath = tempfile.mkdtemp(prefix='pagure-fork-test')

        gitrepo = os.path.join(self.path, 'repos', 'forks', 'foo', 'test.git')

        new_repo = pygit2.clone_repository(gitrepo, newpath)

        # Edit the sources file again

        with open(os.path.join(newpath, 'sources'), 'w') as stream:

            stream.write('foo\n bar\nbaz\n boose')

        new_repo.index.add('sources')

        new_repo.index.write()

        # Commits the files added

        tree = new_repo.index.write_tree()

        author = pygit2.Signature(

            'Alice Author', 'alice@authors.tld')

        committer = pygit2.Signature(

            'Cecil Committer', 'cecil@committers.tld')

        new_repo.create_commit(

            'refs/heads/feature',

            author,

            committer,

            'A commit on branch feature',

            tree,

            []

        )

        refname = 'refs/heads/feature:refs/heads/feature'

        ori_remote = new_repo.remotes[0]

        PagureRepo.push(ori_remote, refname)

        # Create a PR for these changes

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

        req = pagure.lib.new_pull_request(

            session=self.session,

            repo_from=item,

            branch_from='feature',

            repo_to=project,

            branch_to='master',

            title='PR from the feature branch',

            user='pingou',

            requestfolder=None,

        )

        self.session.commit()

        self.assertEqual(req.id, 1)

        self.assertEqual(req.title, 'PR from the feature branch')

        output = self.app.get('/test/pull-request/1')

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            '
PR#1\n'

            '  PR from the feature branch\n', output_text)

        self.assertTrue(

            output_text.count(

                '

        self.assertTrue(update_pull_ref.called)

        shutil.rmtree(newpath)

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

    def test_request_pull_empty_fork(self, send_email):

        """ Test the request_pull endpoint from an empty fork. """

        send_email.return_value = True

        tests.create_projects(self.session)

        item = pagure.lib.model.Project(

            user_id=2,  # foo

            name='test',

            description='test project #1',

            hook_token='aaabbb',

            is_fork=True,

            parent_id=1,

        )

        self.session.add(item)

        self.session.commit()

        tests.create_projects_git(

            os.path.join(self.path, 'requests'), bare=True)

        tests.create_projects_git(

            os.path.join(self.path, 'repos', 'forks', 'foo'), bare=True)

        # Create a git repo to play with

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

        self.assertFalse(os.path.exists(gitrepo))

        os.makedirs(gitrepo)

        repo = pygit2.init_repository(gitrepo, bare=True)

        # Create a fork of this repo

        newpath = tempfile.mkdtemp(prefix='pagure-fork-test')

        gitrepo = os.path.join(

            self.path, 'repos', 'forks', 'foo', 'test.git')

        new_repo = pygit2.clone_repository(gitrepo, newpath)

        # Create a PR for these "changes" (there are none, both repos are

        # empty)

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

        req = pagure.lib.new_pull_request(

            session=self.session,

            repo_from=item,

            branch_from='feature',

            repo_to=project,

            branch_to='master',

            title='PR from the feature branch',

            user='pingou',

            requestfolder=None,

        )

        self.session.commit()

        self.assertEqual(req.id, 1)

        self.assertEqual(req.title, 'PR from the feature branch')

        output = self.app.get('/test/pull-request/1', follow_redirects=True)

        self.assertEqual(output.status_code, 200)

        output_text = output.get_data(as_text=True)

        self.assertIn(

            '<title>PR#1: PR from the feature branch - test\n - Pagure</title>',

            output_text)

        self.assertIn(

            '\n                      Fork is empty, there are no '

            'commits to create a pull request with',

            output_text)

        shutil.rmtree(newpath)

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

    def test_request_pulls_order(self, send_email):

        """Test the request_pulls

        i.e Make sure that the results are displayed

        in the order required by the user"""

        send_email.return_value = True

        #Initially no project

        output = self.app.get('/test/pull-requests')

        self.assertEqual(output.status_code, 404)

        tests.create_projects(self.session)

        tests.create_projects_git(

            os.path.join(self.path, 'repos'), bare=True)

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

        item = pagure.lib.model.Project(

            user_id=2,

            name='test',

            description='test project #1',

            hook_token='aaabbb',

            is_fork=True,

            parent_id=1,

        )

        self.session.add(item)

        self.session.commit()

        # create PR's to play with

        # PR-1

        req = pagure.lib.new_pull_request(

            session=self.session,

            repo_to=repo,

            repo_from=item,

            branch_from='feature',

            branch_to='master',

            title='PR from the feature branch',

            user='pingou',

            status='Open',

            requestfolder=None,

        )

        self.session.commit()

        self.assertEqual(req.id, 1)