+ """Add the pr_to_issue table

+ 

+ Revision ID: 369deb8c8b63

+ Revises: eab41ce5f92a

+ Create Date: 2018-03-12 11:38:00.955252

+ 

+ """

+ 

+ # revision identifiers, used by Alembic.

+ revision = '369deb8c8b63'

+ down_revision = 'eab41ce5f92a'

+ 

+ from alembic import op

+ import sqlalchemy as sa

+ 

+ 

+ def upgrade():

+     ''' Create the pr_to_issue table. '''

+ 

+     op.create_table(

+         'pr_to_issue',

+         sa.Column(

+             'pull_request_uid',

+             sa.String(32),

+             sa.ForeignKey(

+                 'pull_requests.uid', ondelete='CASCADE', onupdate='CASCADE',

+             ),

+             primary_key=True),

+         sa.Column(

+             'issue_uid',

+             sa.String(32),

+             sa.ForeignKey(

+                 'issues.uid', ondelete='CASCADE', onupdate='CASCADE',

+             ),

+             primary_key=True)

+     )

+ 

+ 

+ def downgrade():

+     ''' Drop the pr_to_issue table. '''

+ 

+     op.drop_table('pr_to_issue')

+             # Link tickets with pull-requests if the commit mentions it

+             pagure.lib.tasks.link_pr_to_ticket.delay(pr.uid)

+ 

+             # Inform the user about the PR

+     pagure.lib.tasks.link_pr_to_ticket.delay(request.uid)

+ 

+ 

+ 

+ def link_pr_issue(session, issue, request):

+     ''' Associate the specified issue with the specified pull-requets.

+ 

+     :arg session: The SQLAlchemy session to use

+     :type session: sqlalchemy.orm.session.Session

+     :arg issue: The issue mentioned in the commits of the pull-requests to

+         be associated with

+     :type issue: pagure.lib.model.Issue

+     :arg request: A pull-request to associate the specified issue with

+     :type request: pagure.lib.model.PullRequest

+ 

+     '''

+ 

+     associated_issues = [iss.uid for iss in request.related_issues]

+     if issue.uid not in associated_issues:

+         obj = model.PrToIssue(

+             pull_request_uid=request.uid,

+             issue_uid=issue.uid

+         )

+         session.add(obj)

+         session.flush()

+         local_branches = orig_repo.listall_branches(pygit2.GIT_BRANCH_LOCAL)

+         if not branch and local_branches:

+ class PrToIssue(BASE):

+     """ Stores the associations between issues and pull-requests.

+ 

+     Table -- pr_to_issue

+     """

+ 

+     __tablename__ = 'pr_to_issue'

+ 

+     pull_request_uid = sa.Column(

+         sa.String(32),

+         sa.ForeignKey(

+             'pull_requests.uid', ondelete='CASCADE', onupdate='CASCADE',

+         ),

+         primary_key=True)

+     issue_uid = sa.Column(

+         sa.String(32),

+         sa.ForeignKey(

+             'issues.uid', ondelete='CASCADE', onupdate='CASCADE',

+         ),

+         primary_key=True)

+ 

+ 

+     related_issues = relation(

+         "Issue",

+         secondary="pr_to_issue",

+         primaryjoin="pull_requests.c.uid==pr_to_issue.c.pull_request_uid",

+         secondaryjoin="pr_to_issue.c.issue_uid==issues.c.uid",

+         backref=backref("related_prs", order_by="pull_requests.c.id.desc()")

+     )

+ 

+ import pagure.lib.link

+ from pagure.utils import get_parent_repo_path

+         docrepo = None

+         ticketrepo = None

+                     if docrepo:

+                         shutil.rmtree(docrepo)

+                 if docrepo:

+                     shutil.rmtree(docrepo)

+                 if ticketrepo:

+                     shutil.rmtree(ticketrepo)

+ 

+ 

+ @conn.task(bind=True)

+ @pagure_task

+ def link_pr_to_ticket(self, session, pr_uid):

+     """ Link the specified pull-request against the ticket(s) mentioned in

+     the commits of the pull-request

+ 

+     """

+     _log.info(

+         'LINK_PR_TO_TICKET: Linking ticket(s) to PR for: %s' % pr_uid)

+ 

+     request = pagure.lib.get_request_by_uid(session, pr_uid)

+     if not request:

+         _log.info('LINK_PR_TO_TICKET: Not PR found for: %s' % pr_uid)

+         return

+ 

+     if request.remote:

+         repopath = pagure.utils.get_remote_repo_path(

+             request.remote_git, request.branch_from)

+         parentpath = pagure.utils.get_repo_path(request.project)

+     else:

+         repo_from = request.project_from

+         repopath = pagure.utils.get_repo_path(repo_from)

+         parentpath = get_parent_repo_path(repo_from)

+ 

+     repo_obj = pygit2.Repository(repopath)

+     orig_repo = pygit2.Repository(parentpath)

+ 

+     diff_commits = pagure.lib.git.diff_pull_request(

+         session, request, repo_obj, orig_repo,

+         requestfolder=pagure_config['REQUESTS_FOLDER'], with_diff=False)

+ 

+     _log.info(

+         'LINK_PR_TO_TICKET: Found %s commits in that PR' % len(diff_commits))

+ 

+     name = request.project.name

+     namespace = request.project.namespace

+     user = request.project.user.user \

+         if request.project.is_fork else None

+ 

+     for line in pagure.lib.git.read_git_lines(

+             ['log', '--no-walk']

+             + [c.oid.hex for c in diff_commits]

+             + ['--'], repopath):

+ 

+         line = line.strip()

+         for issue in pagure.lib.link.get_relation(

+                 session, name, user, namespace, line, 'fixes',

+                 include_prs=False):

+             _log.info(

+                 'LINK_PR_TO_TICKET: Link ticket %s to PRs %s' % (

+                     issue, request))

+             pagure.lib.link_pr_issue(session, issue, request)

+ 

+         for issue in pagure.lib.link.get_relation(

+                 session, name, user, namespace, line, 'relates'):

+             _log.info(

+                 'LINK_PR_TO_TICKET: Link ticket %s to PRs %s' % (

+                     issue, request))

+             pagure.lib.link_pr_issue(session, issue, request)

+ 

+     try:

+         session.commit()

+     except SQLAlchemyError:

+         _log.exception('Could not link ticket to PR :(')

+         session.rollback()

+   {% if issue.related_prs %}

+   <div class="col-md-4 card-block">

+     <div class="card">

+       <div class="card-block">

+         <label><strong>Related PR(s)</strong></label>

+         <div id="pr_list">

+           <ul class="list-unstyled">

+             {% for pr in issue.related_prs %}

+             <li>

+               <a class="label label-default" href="{{ url_for(

+                   'ui_ns.request_pull',

+                   repo=pr.project.name,

+                   username=pr.project.user.user if pr.project.is_fork else none,

+                   namespace=pr.project.namespace,

+                   requestid=pr.id) }}">#{{pr.id}}</a>

+               {{ pr.status if pr.status != 'Open' else 'Last updated'

+                 }} {{ pr.last_updated | humanize }}

+             </li>

+             {% endfor %}

+           </ul>

+         </div>

+       </div>

+     </div>

+   </div>

+   {% endif %}

+ 

+ from pagure.utils import (

+     login_required, __get_file_in_tree, get_parent_repo_path)

+         parentpath = get_parent_repo_path(repo_from)

+         parentpath = get_parent_repo_path(repo)

+ 

+ 

+ def get_parent_repo_path(repo):

+     """ Return the path of the parent git repository corresponding to the

+     provided Repository object from the DB.

+     """

+     if repo.parent:

+         parentpath = os.path.join(

+             pagure_config['GIT_FOLDER'], repo.parent.path)

+     else:

+         parentpath = os.path.join(pagure_config['GIT_FOLDER'], repo.path)

+ 

+     return parentpath

+ def create_projects(session, is_fork=False, user_id=1, hook_token_suffix=''):

+         user_id=user_id,  # pingou

+         is_fork=is_fork,

+         parent_id=1 if is_fork else None,

+         hook_token='aaabbbccc' + hook_token_suffix,

+         user_id=user_id,  # pingou

+         is_fork=is_fork,

+         parent_id=2 if is_fork else None,

+         hook_token='aaabbbddd' + hook_token_suffix,

+         user_id=user_id,  # pingou

+         is_fork=is_fork,

+         parent_id=3 if is_fork else None,

+         hook_token='aaabbbeee' + hook_token_suffix,

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

+ 

+ """

+  (c) 2018 - Copyright Red Hat Inc

+ 

+  Authors:

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

+ 

+ """

+ 

+ __requires__ = ['SQLAlchemy >= 0.8']

+ import pkg_resources

+ 

+ import datetime

+ import json

+ import unittest

+ import re

+ import shutil

+ import sys

+ import tempfile

+ import time

+ import os

+ 

+ import pygit2

+ from mock import ANY, patch, MagicMock

+ 

+ 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

+ 

+ 

+ class PagureFlaskPrIssueLinkTest(tests.Modeltests):

+     """ Tests pagure when linking PRs to tickets """

+ 

+     maxDiff = None

+ 

+     def setUp(self):

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

+         super(PagureFlaskPrIssueLinkTest, self).setUp()

+ 

+         tests.create_projects(self.session)

+         tests.create_projects(

+             self.session, is_fork=True, user_id=2, hook_token_suffix='bar')

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

+         tests.create_projects_git(os.path.join(

+             self.path, 'repos', 'forks', 'foo'), bare=True)

+ 

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

+ 

+         # Create issues to play with

+         msg = pagure.lib.new_issue(

+             session=self.session,

+             repo=repo,

+             title=u'tést íssüé',

+             content='We should work on this',

+             user='pingou',

+             ticketfolder=None

+         )

+         self.session.commit()

+         self.assertEqual(msg.title, u'tést íssüé')

+ 

+         msg = pagure.lib.new_issue(

+             session=self.session,

+             repo=repo,

+             title=u'tést íssüé #2',

+             content='We should still work on this',

+             user='foo',

+             ticketfolder=None

+         )

+         self.session.commit()

+         self.assertEqual(msg.title, u'tést íssüé #2')

+ 

+         # Add a commit to the fork

+ 

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

+         repopath = os.path.join(newpath, 'test')

+         clone_repo = pygit2.clone_repository(os.path.join(

+             self.path, 'repos', 'forks', 'foo', 'test.git'), 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\n\n Relates to #2',

+             # binary string representing the tree object ID

+             tree,

+             # list of binary strings representing parents of the new commit

+             prev_commit

+         )

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

+         ori_remote = clone_repo.remotes[0]

+         PagureRepo.push(ori_remote, refname)

+ 

+         # Create the corresponding PR

+ 

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

+         fork_repo = pagure.lib.get_authorized_project(

+             self.session, 'test', user='foo')

+ 

+         request = pagure.lib.new_pull_request(

+             self.session,

+             branch_from='master',

+             repo_to=repo,

+             branch_to='master',

+             title='test PR',

+             user='foo',

+             requestfolder=None,

+             initial_comment=None,

+             repo_from=fork_repo,

+         )

+         self.session.commit()

+ 

+         pagure.lib.tasks.link_pr_to_ticket(request.uid)

+         self.assertEqual(request.id, 3)

+ 

+     def test_ticket_no_link(self):

+         """ Test that no Related PR(s) block is showing in the issue page.

+         """

+         output = self.app.get('/test/issue/1')

+         self.assertEqual(output.status_code, 200)

+         self.assertNotIn(

+             u'<strong>Related PR(s)</strong>',

+             output.data.decode('utf-8'))

+ 

+     def test_ticket_link(self):

+         """ Test that no Related PR(s) block is showing in the issue page.

+         """

+         time.sleep(1)

+         output = self.app.get('/test/issue/2')

+         print output.data.decode('utf-8')

+         self.assertEqual(output.status_code, 200)

+         self.assertIn(

+             u'<strong>Related PR(s)</strong>',

+             output.data.decode('utf-8'))

+ 

+ 

+ if __name__ == '__main__':

+     unittest.main(verbosity=2)