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

"""

 (c) 2015-2017 - Copyright Red Hat Inc

 Authors:

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

"""

__requires__ = ['SQLAlchemy >= 0.7']

import pkg_resources

import json

import logging

import os

import re

import resource

import shutil

import subprocess

import sys

import tempfile

import time

import unittest

logging.basicConfig(stream=sys.stderr)

# Always enable performance counting for tests

os.environ['PAGURE_PERFREPO'] = 'true'

from contextlib import contextmanager

from datetime import date

from datetime import datetime

from datetime import timedelta

from functools import wraps

from urlparse import urlparse, parse_qs

import mock

import pygit2

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker

from sqlalchemy.orm import scoped_session

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

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

import pagure

import pagure.api

import pagure.flask_app

import pagure.lib

import pagure.lib.model

import pagure.perfrepo as perfrepo

from pagure.config import config as pagure_config, reload_config

from pagure.lib.repo import PagureRepo

HERE = os.path.join(os.path.dirname(os.path.abspath(__file__)))

LOG = logging.getLogger(__name__)

LOG.setLevel(logging.INFO)

PAGLOG = logging.getLogger('pagure')

PAGLOG.setLevel(logging.CRITICAL)

PAGLOG.handlers = []

CONFIG_TEMPLATE = """

GIT_FOLDER = '%(path)s/repos'

ENABLE_DOCS = %(enable_docs)s

ENABLE_TICKETS = %(enable_tickets)s

REMOTE_GIT_FOLDER = '%(path)s/remotes'

DB_URL = '%(dburl)s'

ALLOW_PROJECT_DOWAIT = True

DEBUG = True

PAGURE_CI_SERVICES = ['jenkins']

EMAIL_SEND = False

TESTING = True

GIT_FOLDER = '%(path)s/repos'

REQUESTS_FOLDER = '%(path)s/repos/requests'

TICKETS_FOLDER = %(tickets_folder)r

DOCS_FOLDER = %(docs_folder)r

ATTACHMENTS_FOLDER = '%(path)s/attachments'

BROKER_URL = 'redis+socket://%(global_path)s/broker'

"""

LOG.info('BUILD_ID: %s', os.environ.get('BUILD_ID'))

WAIT_REGEX = re.compile("""var _url = '(\/wait\/[a-z0-9-]+\??.*)'""")

def get_wait_target(html):

    """ This parses the window.location out of the HTML for the wait page. """

    found = WAIT_REGEX.findall(html)

    if len(found) == 0:

        raise Exception("Not able to get wait target in %s" % html)

    return found[-1]

def create_maybe_waiter(method, getter):

    def maybe_waiter(*args, **kwargs):

        """ A wrapper for self.app.get()/.post() that will resolve wait's """

        result = method(*args, **kwargs)

        count = 0

        while 'We are waiting for your task to finish.' in result.data:

            # Resolve wait page

            target_url = get_wait_target(result.data)

            if count > 10:

                time.sleep(0.5)

            else:

                time.sleep(0.1)

            result = getter(target_url, follow_redirects=True)

            if count > 50:

                raise Exception('Had to wait too long')

        else:

            return result

    return maybe_waiter

@contextmanager

def user_set(APP, user):

    """ Set the provided user as fas_user in the provided application."""

    # Hack used to remove the before_request function set by

    # flask.ext.fas_openid.FAS which otherwise kills our effort to set a

    # flask.g.fas_user.

    from flask import appcontext_pushed, g

    keep = []

    for meth in APP.before_request_funcs[None]:

        if 'flask_fas_openid.FAS' in str(meth):

            continue

        keep.append(meth)

    APP.before_request_funcs[None] = keep

    def handler(sender, **kwargs):

        g.fas_user = user

        g.fas_session_id = b'123'

        g.authenticated = True

    with appcontext_pushed.connected_to(handler, APP):

        yield

tests_state = {

    "path": tempfile.mkdtemp(prefix='pagure-tests-'),

    "broker": None,

}

def _populate_db(session):

    # Create a couple of users

    item = pagure.lib.model.User(

        user='pingou',

        fullname='PY C',

        password='foo',

        default_email='bar@pingou.com',

    )

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=1,

        email='bar@pingou.com')

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=1,

        email='foo@pingou.com')

    session.add(item)

    item = pagure.lib.model.User(

        user='foo',

        fullname='foo bar',

        password='foo',

        default_email='foo@bar.com',

    )

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=2,

        email='foo@bar.com')

    session.add(item)

    session.commit()

def setUp():

    # In order to save time during local test execution, we create sqlite DB

    # file only once and then we populate it and empty it for every test case

    # (as opposed to creating DB file for every test case).

    session = pagure.lib.model.create_tables(

        'sqlite:///%s/db.sqlite' % tests_state["path"],

        acls=pagure_config.get('ACLS', {}),

    )

    tests_state["db_session"] = session

    # Create a broker

    broker_url = os.path.join(tests_state["path"], 'broker')

    tests_state["broker"] = broker = subprocess.Popen(

        ['/usr/bin/redis-server', '--unixsocket', broker_url, '--port',

         '0', '--loglevel', 'warning', '--logfile', '/dev/null'],

        stdout=None, stderr=None)

    broker.poll()

    if broker.returncode is not None:

        raise Exception('Broker failed to start')

def tearDown():

    tests_state["db_session"].close()

    broker = tests_state["broker"]

    broker.kill()

    broker.wait()

    shutil.rmtree(tests_state["path"])

class SimplePagureTest(unittest.TestCase):

    """

    Simple Test class that does not set a broker/worker

    """

    populate_db = True

    config_values = {}

    @mock.patch('pagure.lib.notify.fedmsg_publish', mock.MagicMock())

    def __init__(self, method_name='runTest'):

        """ Constructor. """

        unittest.TestCase.__init__(self, method_name)

        self.session = None

        self.path = None

        self.gitrepo = None

        self.gitrepos = None

    def perfMaxWalks(self, max_walks, max_steps):

        """ Check that we have not performed too many walks/steps. """

        num_walks = 0

        num_steps = 0

        for reqstat in perfrepo.REQUESTS:

            for walk in reqstat['walks'].values():

                num_walks += 1

                num_steps += walk['steps']

        self.assertLessEqual(num_walks, max_walks,

                             '%s git repo walks performed, at most %s allowed'

                             % (num_walks, max_walks))

        self.assertLessEqual(num_steps, max_steps,

                             '%s git repo steps performed, at most %s allowed'

                             % (num_steps, max_steps))

    def perfReset(self):

        """ Reset perfrepo stats. """

        perfrepo.reset_stats()

        perfrepo.REQUESTS = []

    def setUp(self):

        self.perfReset()

        if not self.path:

            self.path = tempfile.mkdtemp(prefix='pagure-tests-path-')

        LOG.debug('Testdir: %s', self.path)

        for folder in ['repos', 'forks', 'releases', 'remotes', 'attachments']:

            os.mkdir(os.path.join(self.path, folder))

        if hasattr(pagure, 'REDIS') and pagure.REDIS:

            pagure.REDIS.connection_pool.disconnect()

            pagure.REDIS = None

        if hasattr(pagure.lib, 'REDIS') and pagure.lib.REDIS:

            pagure.lib.REDIS.connection_pool.disconnect()

            pagure.lib.REDIS = None

        # Database

        self._prepare_db()

        # Write a config file

        config_values = {

            'path': self.path, 'dburl': self.dbpath,

            'enable_docs': True,

            'docs_folder': '%s/repos/docs' % self.path,

            'enable_tickets': True,

            'tickets_folder': '%s/repos/tickets' % self.path,

            'global_path': tests_state["path"],

        }

        config_values.update(self.config_values)

        config_path = os.path.join(self.path, 'config')

        if not os.path.exists(config_path):

            with open(config_path, 'w') as f:

                f.write(CONFIG_TEMPLATE % config_values)

        os.environ["PAGURE_CONFIG"] = config_path

        pagure_config.update(reload_config())

        reload(pagure.lib.tasks)

        reload(pagure.lib.tasks_services)

        self._app = pagure.flask_app.create_app({'DB_URL': self.dbpath})

        # Remove the log handlers for the tests

        self._app.logger.handlers = []

        self.app = self._app.test_client()

    def tearDown(self):

        self.session.rollback()

        self._clear_database()

        # Remove testdir

        try:

            shutil.rmtree(self.path)

        except:

            # Sometimes there is a race condition that makes deleting the folder

            # fail during the first attempt. So just try a second time if that's

            # the case.

            shutil.rmtree(self.path)

        self.path = None

        del self.app

        del self._app

    def shortDescription(self):

          doc = self.__str__() +": "+self._testMethodDoc

          return doc or None

    def _prepare_db(self):

        self.dbpath = 'sqlite:///%s' % os.path.join(

            tests_state["path"], 'db.sqlite')

        self.session = tests_state["db_session"]

        pagure.lib.model.create_default_status(

            self.session, acls=pagure_config.get('ACLS', {}))

        if self.populate_db:

            _populate_db(self.session)

    def _clear_database(self):

        tables = reversed(pagure.lib.model.BASE.metadata.sorted_tables)

        if self.dbpath.startswith('postgresql'):

            self.session.execute("TRUNCATE %s CASCADE" % ", ".join(

                [t.name for t in tables]))

        elif self.dbpath.startswith('sqlite'):

            for table in tables:

                self.session.execute("DELETE FROM %s" % table.name)

        elif self.dbpath.startswith('mysql'):

            self.session.execute("SET FOREIGN_KEY_CHECKS = 0")

            for table in tables:

                self.session.execute("TRUNCATE %s" % table.name)

            self.session.execute("SET FOREIGN_KEY_CHECKS = 1")

        self.session.commit()

    def get_csrf(self, url='/new', output=None):

        """Retrieve a CSRF token from given URL."""

        if output is None:

            output = self.app.get(url)

            self.assertEqual(output.status_code, 200)

        return output.data.split(

            'name="csrf_token" type="hidden" value="')[1].split('">')[0]

    def assertURLEqual(self, url_1, url_2):

        url_parsed_1 = list(urlparse(url_1))

        url_parsed_1[4] = parse_qs(url_parsed_1[4])

        url_parsed_2 = list(urlparse(url_2))

        url_parsed_2[4] = parse_qs(url_parsed_2[4])

        return self.assertListEqual(url_parsed_1, url_parsed_2)

    def assertJSONEqual(self, json_1, json_2):

        return self.assertEqual(json.loads(json_1), json.loads(json_2))

class Modeltests(SimplePagureTest):

    """ Model tests. """

    def setUp(self):    # pylint: disable=invalid-name

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

        # Clean up test performance info

        super(Modeltests, self).setUp()

        # Start a worker

        # Using cocurrency 2 to test with some concurrency, but not be heavy

        # Using eventlet so that worker.terminate kills everything

        self.workerlog = open(os.path.join('.', 'worker.log'), 'w')

        celery_exec = 'celery'

        celery_env = os.environ.copy()

        celery_env.update({

            'PAGURE_BROKER_URL': pagure_config['BROKER_URL'],

            'PAGURE_CONFIG': os.path.join(self.path, 'config'),

            'PYTHONPATH': '.'

        })

        celery_cwd = os.path.normpath(

            os.path.join(os.path.dirname(__file__), '..')

        )

        self.worker = subprocess.Popen(

            [celery_exec, '-A', 'pagure.lib.tasks', 'worker',

             '--loglevel=info', '--concurrency=2', '--pool=eventlet',

             '--without-gossip', '--without-mingle', '--quiet'],

            env=celery_env,

            cwd=celery_cwd,

            stdout=self.workerlog,

            stderr=self.workerlog)

        self.worker.poll()

        if self.worker.returncode is not None:

            raise Exception('Worker failed to start')

        # We could do the ping below in-process:

        # pagure.lib.tasks.conn.control.ping(timeout=0.1)

        # but if we try it, Python starts raising OSError

        # with too many open files. This is probably related

        # to https://github.com/celery/celery/issues/4465

        wait_start = time.time()

        while True:

            time.sleep(0.1)

            res = subprocess.call(

                [celery_exec, '-A', 'pagure.lib.tasks',

                 'inspect', '-t=0.1', 'ping'],

                env=celery_env,

                cwd=celery_cwd,

                stdout=subprocess.PIPE,

                stderr=subprocess.PIPE

            )

            if res == 0:

                break

            if time.time() - wait_start > 5:

                raise Exception('Worker failed to initialize in 5 seconds')

        self.app.get = create_maybe_waiter(self.app.get, self.app.get)

        self.app.post = create_maybe_waiter(self.app.post, self.app.get)

    def tearDown(self):     # pylint: disable=invalid-name

        """ Remove the test.db database if there is one. """

        # Terminate worker

        # We just send a SIGKILL (kill -9), since when the test finishes, we

        #  don't really care about the output of either worker or broker

        #  anymore

        self.worker.kill()

        self.worker.wait()

        self.worker = None

        self.workerlog.close()

        self.workerlog = None

        subprocess.check_call(

            ['/usr/bin/redis-cli', '-s',

             pagure_config['BROKER_URL'][len('redis+socket://'):], 'flushall'],

            stdout=subprocess.PIPE, stderr=subprocess.PIPE)

        super(Modeltests, self).tearDown()

class FakeGroup(object):    # pylint: disable=too-few-public-methods

    """ Fake object used to make the FakeUser object closer to the

    expectations.

    """

    def __init__(self, name):

        """ Constructor.

        :arg name: the name given to the name attribute of this object.

        """

        self.name = name

        self.group_type = 'cla'

class FakeUser(object):     # pylint: disable=too-few-public-methods

    """ Fake user used to test the fedocallib library. """

    def __init__(self, groups=None, username='username', cla_done=True, id=1):

        """ Constructor.

        :arg groups: list of the groups in which this fake user is

            supposed to be.

        """

        if isinstance(groups, basestring):

            groups = [groups]

        self.id = id

        self.groups = groups or []

        self.user = username

        self.username = username

        self.name = username

        self.email = 'foo@bar.com'

        self.approved_memberships = [

            FakeGroup('packager'),

            FakeGroup('design-team')

        ]

        self.dic = {}

        self.dic['timezone'] = 'Europe/Paris'

        self.login_time = datetime.utcnow()

        self.cla_done = cla_done

    def __getitem__(self, key):

        return self.dic[key]

def create_projects(session):

    """ Create some projects in the database. """

    item = pagure.lib.model.Project(

        user_id=1,  # pingou

        name='test',

        description='test project #1',

        hook_token='aaabbbccc',

    )

    item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']

    session.add(item)

    item = pagure.lib.model.Project(

        user_id=1,  # pingou

        name='test2',

        description='test project #2',

        hook_token='aaabbbddd',

    )

    item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']

    session.add(item)

    item = pagure.lib.model.Project(

        user_id=1,  # pingou

        name='test3',

        description='namespaced test project',

        hook_token='aaabbbeee',

        namespace='somenamespace',

    )

    item.close_status = ['Invalid', 'Insufficient data', 'Fixed', 'Duplicate']

    session.add(item)

    session.commit()

def create_projects_git(folder, bare=False):

    """ Create some projects in the database. """

    repos = []

    for project in ['test.git', 'test2.git',

                    os.path.join('somenamespace', 'test3.git')]:

        repo_path = os.path.join(folder, project)

        repos.append(repo_path)

        if not os.path.exists(repo_path):

            os.makedirs(repo_path)

        pygit2.init_repository(repo_path, bare=bare)

    return repos

def create_tokens(session, user_id=1, project_id=1):

    """ Create some tokens for the project in the database. """

    item = pagure.lib.model.Token(

        id='aaabbbcccddd',

        user_id=user_id,

        project_id=project_id,

        expiration=datetime.utcnow() + timedelta(days=30)

    )

    session.add(item)

    item = pagure.lib.model.Token(

        id='foo_token',

        user_id=user_id,

        project_id=project_id,

        expiration=datetime.utcnow() + timedelta(days=30)

    )

    session.add(item)

    item = pagure.lib.model.Token(

        id='expired_token',

        user_id=user_id,

        project_id=project_id,

        expiration=datetime.utcnow() - timedelta(days=1)

    )

    session.add(item)

    session.commit()

def create_tokens_acl(session, token_id='aaabbbcccddd', acl_name=None):

    """ Create some ACLs for the token. If acl_name is not set, the token will

    have all the ACLs enabled.

    """

    if acl_name is None:

        for aclid in range(len(pagure_config['ACLS'])):

            token_acl = pagure.lib.model.TokenAcl(

                token_id=token_id,

                acl_id=aclid + 1,

            )

            session.add(token_acl)

    else:

        acl = session.query(pagure.lib.model.ACL).filter_by(

            name=acl_name).one()

        token_acl = pagure.lib.model.TokenAcl(

            token_id=token_id,

            acl_id=acl.id,

        )

        session.add(token_acl)

    session.commit()

def add_content_git_repo(folder, branch='master'):

    """ Create some content for the specified git repo. """

    if not os.path.exists(folder):

        os.makedirs(folder)

    brepo = pygit2.init_repository(folder, bare=True)

    newfolder = tempfile.mkdtemp(prefix='pagure-tests')

    repo = pygit2.clone_repository(folder, newfolder)

    # Create a file in that git repo

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

        stream.write('foo\n bar')

    repo.index.add('sources')

    repo.index.write()

    parents = []

    commit = None

    try:

        commit = repo.revparse_single(

            'HEAD' if branch == 'master' else branch)

    except KeyError:

        pass

    if commit:

        parents = [commit.oid.hex]

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

        parents,

    )

    parents = []

    commit = None

    try:

        commit = repo.revparse_single(

            'HEAD' if branch == 'master' else branch)

    except KeyError:

        pass

    if commit:

        parents = [commit.oid.hex]

    subfolder = os.path.join('folder1', 'folder2')

    if not os.path.exists(os.path.join(newfolder, subfolder)):

        os.makedirs(os.path.join(newfolder, subfolder))

    # Create a file in that git repo

    with open(os.path.join(newfolder, subfolder, 'file'), 'w') as stream:

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

    repo.index.add(os.path.join(subfolder, 'file'))

    with open(os.path.join(newfolder, subfolder, 'fileŠ'), 'w') as stream:

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

    repo.index.add(os.path.join(subfolder, 'fileŠ'))

    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,  # the name of the reference to update

        author,

        committer,

        'Add some directory and a file for more testing',

        # binary string representing the tree object ID

        tree,

        # list of binary strings representing parents of the new commit

        parents

    )

    # Push to origin

    ori_remote = repo.remotes[0]

    master_ref = repo.lookup_reference(

        'HEAD' if branch == 'master' else 'refs/heads/%s' % branch).resolve()

    refname = '%s:%s' % (master_ref.name, master_ref.name)

    PagureRepo.push(ori_remote, refname)

    shutil.rmtree(newfolder)

def add_readme_git_repo(folder):

    """ Create a README file for the specified git repo. """

    if not os.path.exists(folder):

        os.makedirs(folder)

    brepo = pygit2.init_repository(folder, bare=True)

    newfolder = tempfile.mkdtemp(prefix='pagure-tests')

    repo = pygit2.clone_repository(folder, newfolder)

    content = """Pagure

======

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

Pagure is a light-weight git-centered forge based on pygit2.

Currently, Pagure offers a web-interface for git repositories, a ticket

system and possibilities to create new projects, fork existing ones and

create/merge pull-requests across or within projects.

Homepage: https://github.com/pypingou/pagure

Dev instance: http://209.132.184.222/ (/!\\ May change unexpectedly, it's a dev instance ;-))

"""

    parents = []

    commit = None

    try:

        commit = repo.revparse_single('HEAD')

    except KeyError:

        pass

    if commit:

        parents = [commit.oid.hex]

    # Create a file in that git repo

    with open(os.path.join(newfolder, 'README.rst'), 'w') as stream:

        stream.write(content)

    repo.index.add('README.rst')

    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/master',  # the name of the reference to update

        author,

        committer,

        'Add a README file',

        # binary string representing the tree object ID

        tree,

        # list of binary strings representing parents of the new commit

        parents

    )

    # Push to origin

    ori_remote = repo.remotes[0]

    master_ref = repo.lookup_reference('HEAD').resolve()

    refname = '%s:%s' % (master_ref.name, master_ref.name)

    PagureRepo.push(ori_remote, refname)

    shutil.rmtree(newfolder)

def add_commit_git_repo(folder, ncommits=10, filename='sources',

                        branch='master'):

    """ Create some more commits for the specified git repo. """

    if not os.path.exists(folder):

        os.makedirs(folder)

        pygit2.init_repository(folder, bare=True)

    newfolder = tempfile.mkdtemp(prefix='pagure-tests')

    repo = pygit2.clone_repository(folder, newfolder)

    for index in range(ncommits):

        # Create a file in that git repo

        with open(os.path.join(newfolder, filename), 'a') as stream:

            stream.write('Row %s\n' % index)

        repo.index.add(filename)

        repo.index.write()

        parents = []

        commit = None

        try:

            commit = repo.revparse_single('HEAD')

        except KeyError:

            pass

        if commit:

            parents = [commit.oid.hex]

        # 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/master',

            author,

            committer,

            'Add row %s to %s file' % (index, filename),

            # binary string representing the tree object ID

            tree,

            # list of binary strings representing parents of the new commit

            parents,

        )

    # Push to origin

    ori_remote = repo.remotes[0]

    PagureRepo.push(ori_remote, 'HEAD:refs/heads/%s' % branch)

    shutil.rmtree(newfolder)

def add_content_to_git(folder, filename='sources', content='foo'):

    """ Create some more commits for the specified git repo. """

    if not os.path.exists(folder):

        os.makedirs(folder)

    brepo = pygit2.init_repository(folder, bare=True)

    newfolder = tempfile.mkdtemp(prefix='pagure-tests')

    repo = pygit2.clone_repository(folder, newfolder)

    # Create a file in that git repo

    with open(os.path.join(newfolder, filename), 'a') as stream:

        stream.write('%s\n' % content)

    repo.index.add(filename)

    repo.index.write()

    parents = []

    commit = None

    try:

        commit = repo.revparse_single('HEAD')

    except KeyError:

        pass

    if commit:

        parents = [commit.oid.hex]

    # 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/master',  # the name of the reference to update

        author,

        committer,

        'Add content to file %s' % (filename),

        # binary string representing the tree object ID

        tree,

        # list of binary strings representing parents of the new commit

        parents,

    )

    # Push to origin

    ori_remote = repo.remotes[0]

    master_ref = repo.lookup_reference('HEAD').resolve()

    refname = '%s:%s' % (master_ref.name, master_ref.name)

    PagureRepo.push(ori_remote, refname)

    shutil.rmtree(newfolder)

def add_binary_git_repo(folder, filename):

    """ Create a fake image file for the specified git repo. """

    if not os.path.exists(folder):

        os.makedirs(folder)

    brepo = pygit2.init_repository(folder, bare=True)

    newfolder = tempfile.mkdtemp(prefix='pagure-tests')

    repo = pygit2.clone_repository(folder, newfolder)

    content = b"""\x00\x00\x01\x00\x01\x00\x18\x18\x00\x00\x01\x00 \x00\x88

\t\x00\x00\x16\x00\x00\x00(\x00\x00\x00\x18\x00x00\x00\x01\x00 \x00\x00\x00

\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00

00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7lM\x01\xa6kM\t\xa6kM\x01

\xa4fF\x04\xa2dE\x95\xa2cD8\xa1a

"""

    parents = []

    commit = None

    try:

        commit = repo.revparse_single('HEAD')

    except KeyError:

        pass

    if commit:

        parents = [commit.oid.hex]

    # Create a file in that git repo

    with open(os.path.join(newfolder, filename), 'wb') as stream:

        stream.write(content)

    repo.index.add(filename)

    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/master',  # the name of the reference to update

        author,

        committer,

        'Add a fake image file',

        # binary string representing the tree object ID