🚧 BB gists and requests support ; 📼 Added integration tests and cassettes

Signed-off-by: Guyzmo <guyzmo+github@m0g.net>

Author: guyzmo

git_repo/services/ext/bitbucket.py

@@ -8,56 +8,71 @@
 
 from pybitbucket.bitbucket import Client, Bitbucket
 from pybitbucket.auth import BasicAuthenticator
-from pybitbucket.repository import Repository, RepositoryForkPolicy
-from pybitbucket.snippet import Snippet
+from pybitbucket.pullrequest import PullRequest, PullRequestPayload
+from pybitbucket.repository import (
+        Repository, RepositoryPayload, RepositoryForkPayload,
+        RepositoryForkPolicy, RepositoryType
+)
+from pybitbucket.snippet import Snippet, SnippetPayload
+from pybitbucket.user import User
 
 from requests import Request, Session
 from requests.exceptions import HTTPError
-import json
+import os, json
 
 
 @register_target('bb', 'bitbucket')
 class BitbucketService(RepositoryService):
     fqdn = 'bitbucket.org'
 
     def __init__(self, *args, **kwarg):
-        self.bb_client = Client()
-        self.bb = Bitbucket(self.bb_client)
+        self.bb = Bitbucket(Client())
         super(BitbucketService, self).__init__(*args, **kwarg)
 
     def connect(self):
         if not self._privatekey:
             raise ConnectionError('Could not connect to BitBucket. Please configure .gitconfig with your bitbucket credentials.')
         if not ':' in self._privatekey:
             raise ConnectionError('Could not connect to BitBucket. Please setup your private key with login:password')
-        self.bb_client.config = BasicAuthenticator(*self._privatekey.split(':')+['z+git-repo+pub@m0g.net'])
-        self.bb_client.session = self.bb_client.config.session
+        auth = BasicAuthenticator(*self._privatekey.split(':')+['z+git-repo+pub@m0g.net'])
+        self.bb.client.config = auth
+        self.bb.client.session = self.bb.client.config.session = auth.start_http_session(self.bb.client.session)
         try:
-            self.user
+            _ = self.bb.client.config.who_am_i()
         except ResourceError as err:
             raise ConnectionError('Could not connect to BitBucket. Not authorized, wrong credentials.') from err
 
     def create(self, user, repo, add=False):
         try:
             repo = Repository.create(
-                    repo,
-                    fork_policy=RepositoryForkPolicy.ALLOW_FORKS,
-                    is_private=False,
-                    client=self.bb_client
+                    RepositoryPayload(dict(
+                        fork_policy=RepositoryForkPolicy.ALLOW_FORKS,
+                        is_private=False
+                    )),
+                    repository_name=repo,
+                    owner=user,
+                    client=self.bb.client
             )
             if add:
-                self.add(user=user, repo=repo, tracking=self.name)
+                self.add(user=user, repo=repo.name, tracking=self.name)
         except HTTPError as err:
             if '400' in err.args[0].split(' '):
                 raise ResourceExistsError('Project {} already exists on this account.'.format(repo)) from err
             raise ResourceError("Couldn't complete creation: {}".format(err)) from err
 
     def fork(self, user, repo):
-        raise NotImplementedError('No support yet by the underlying library.')
-        try:
-            self.get_repository(user, repo).fork()
-        except HTTPError as err:
-            raise ResourceError("Couldn't complete fork: {}".format(err)) from err
+        # result = self.get_repository(user, repo).fork(
+        #     RepositoryForkPayload(dict(name=repo)),
+        #     owner=user)
+        resp = self.bb.client.session.post(
+            'https://api.bitbucket.org/1.0/repositories/{}/{}/fork'.format(user, repo),
+            data={'name': repo}
+        )
+        if 404 == resp.status_code:
+            raise ResourceNotFoundError("Couldn't complete fork: {}".format(resp.content.decode('utf-8')))
+        elif 200 != resp.status_code:
+            raise ResourceError("Couldn't complete fork: {}".format(resp.content.decode('utf-8')))
+        result = resp.json()
         return '/'.join([result['owner'], result['slug']])
 
     def delete(self, repo, user=None):
@@ -174,7 +189,7 @@ def gist_fetch(self, gist, fname=None):
             else:
                 raise ResourceNotFoundError('Could not find file within gist.')
 
-        return self.bb_client.session.get(
+        return self.bb.client.session.get(
                     'https://bitbucket.org/!api/2.0/snippets/{}/{}/files/{}'.format(user, gist, gist_file)
                 ).content.decode('utf-8')
 
@@ -198,8 +213,7 @@ def gist_clone(self, gist):
 
     def gist_create(self, gist_pathes, description, secret=False):
         def load_file(fname, path='.'):
-            with open(os.path.join(path, fname), 'r') as f:
-                return {'content': f.read()}
+            return open(os.path.join(path, fname), 'r')
 
         gist_files = dict()
         for gist_path in gist_pathes:
@@ -210,66 +224,130 @@ def load_file(fname, path='.'):
                     if not os.path.isdir(os.path.join(gist_path, gist_file)) and not gist_file.startswith('.'):
                         gist_files[gist_file] = load_file(gist_file, gist_path)
 
-        gist = self.gh.create_gist(
-                description=description,
+        try:
+            snippet = Snippet.create(
                 files=gist_files,
-                public=not secret # isn't it obvious? ☺
+                payload=SnippetPayload(
+                    payload=dict(
+                        title=description,
+                        scm=RepositoryType.GIT,
+                        is_private=secret
+                    )
+                ),
+                client=self.bb.client
             )
 
-        return gist.html_url
+            return snippet.links['html']['href']
+        except HTTPError as err:
+            raise ResourceError("Couldn't create snippet: {}".format(err)) from err
 
     def gist_delete(self, gist_id):
-        gist = self.gh.gist(self._format_gist(gist_id))
-        if not gist:
-            raise ResourceNotFoundError('Could not find gist')
-        gist.delete()
+        try:
+            snippet = next(self.bb.snippetByOwnerAndSnippetId(owner=self.user, snippet_id=gist_id)).delete()
+        except HTTPError as err:
+            if '404' in err.args[0].split(' '):
+                raise ResourceNotFoundError("Could not find snippet {}.".format(gist_id)) from err
+            raise ResourceError("Couldn't delete snippet: {}".format(err)) from err
 
     def request_create(self, user, repo, local_branch, remote_branch, title, description=None):
-        repository = self.gh.repository(user, repo)
-        if not repository:
-            raise ResourceNotFoundError('Could not find repository `{}/{}`!'.format(user, repo))
-        if not remote_branch:
-            remote_branch =  self.repository.active_branch.name
-        if not local_branch:
-            local_branch = repository.master_branch or 'master'
         try:
-            request = repository.create_pull(title,
-                    base=local_branch,
-                    head=':'.join([user, remote_branch]),
-                    body=description)
-        except github3.models.GitHubError as err:
-            if err.code == 422:
-                if err.message == 'Validation Failed':
-                    for error in err.errors:
-                        if 'message' in error:
-                            raise ResourceError(error['message'])
-                    raise ResourceError("Unhandled formatting error: {}".format(err.errors))
-            raise ResourceError(err.message)
-
-        return {'local': local_branch, 'remote': remote_branch, 'ref': request.number}
+            repository = next(self.bb.repositoryByOwnerAndRepositoryName(owner=user, repository_name=repo))
+            if not repository:
+                raise ResourceNotFoundError('Could not find repository `{}/{}`!'.format(user, repo))
+            if not remote_branch:
+                try:
+                    remote_branch = next(repository.branches()).name
+                except StopIteration:
+                    remote_branch = 'master'
+            if not local_branch:
+                local_branch = self.repository.active_branch.name
+            request = PullRequest.create(
+                        PullRequestPayload(
+                            payload=dict(
+                                title=title,
+                                description=description or '',
+                                destination=dict(
+                                    branch=dict(name=remote_branch)
+                                ),
+                                source=dict(
+                                    repository=dict(full_name='/'.join([self.user, repo])),
+                                    branch=dict(name=local_branch)
+                                )
+                            )
+                        ),
+                        repository_name=repo,
+                        owner=user,
+                        client=self.bb.client
+                    )
+        except HTTPError as err:
+            status_code = hasattr(err, 'code') and err.code or err.response.status_code
+            if 404 == status_code:
+                raise ResourceNotFoundError("Couldn't create request, project not found: {}".format(repo)) from err
+            elif 400 == status_code and 'branch not found' in err.format_message():
+                raise ResourceNotFoundError("Couldn't create request, branch not found: {}".format(local_branch)) from err
+            raise ResourceError("Couldn't create request: {}".format(err)) from err
+
+        return {'local': local_branch, 'remote': remote_branch, 'ref': str(request.id)}
 
     def request_list(self, user, repo):
-        repository = self.gh.repository(user, repo)
-        for pull in repository.iter_pulls():
-            yield ( str(pull.number), pull.title, pull.links['issue'] )
+        requests = set(
+            (
+                str(r.id),
+                r.title,
+                r.links['html']['href']
+            ) for r in self.bb.repositoryPullRequestsInState(
+                owner=user,
+                repository_name=repo,
+                state='open'
+            ) if not isinstance(r, dict) # if no PR is empty, result is a dict
+        )
+        for pull in sorted(requests):
+            try:
+                yield pull
+            except Exception as err:
+                log.warn('Error while fetching request information: {}'.format(pull))
 
     def request_fetch(self, user, repo, request, pull=False):
+        log.warn('Bitbucket does not support fetching of PR using git. Use this command at your own risk.')
+        if 'y' not in input('Are you sure to continue? [yN]> '):
+            raise ResourceError('Command aborted.')
         if pull:
             raise NotImplementedError('Pull operation on requests for merge are not yet supported')
         try:
-            for remote in self.repository.remotes:
-                if remote.name == self.name:
-                    local_branch_name = 'request/{}'.format(request)
-                    self.fetch(
-                        remote,
-                        'pull/{}/head'.format(request),
-                        local_branch_name
-                    )
-                    return local_branch_name
-            else:
-                raise ResourceNotFoundError('Could not find remote {}'.format(self.name))
+            repository = self.get_repository(user, repo)
+            if self.repository.is_dirty():
+                raise ResourceError('Please use this command after stashing your changes.')
+            local_branch_name = 'requests/bitbucket/{}'.format(request)
+            index = self.repository.index
+            log.info('» Fetching pull request {}'.format(request))
+            request = next(bb.repositoryPullRequestByPullRequestId(
+                owner=user,
+                repository_name=repo,
+                pullrequest_id=request
+            ))
+            commit = self.repository.rev_parse(request['destination']['commit']['hash'])
+            self.repository.head.reference = commit
+            log.info('» Creation of requests branch {}'.format(local_branch_name))
+            # create new branch
+            head = self.repository.create_head(local_branch_name)
+            head.checkout()
+            # fetch and apply patch
+            log.info('» Fetching and writing the patch in current directory')
+            patch = bb.client.session.get(request['links']['diff']['href']).content.decode('utf-8')
+            with open('.tmp.patch', 'w') as f:
+                f.write(patch)
+            log.info('» Applying the patch')
+            git.cmd.Git().apply('.tmp.patch', stat=True)
+            os.unlink('.tmp.patch')
+            log.info('» Going back to original branch')
+            index.checkout() # back to former branch
+            return local_branch_name
+        except HTTPError as err:
+            if '404' in err.args[0].split(' '):
+                raise ResourceNotFoundError("Could not find snippet {}.".format(gist_id)) from err
+            raise ResourceError("Couldn't delete snippet: {}".format(err)) from err
         except GitCommandError as err:
-            if 'Error when fetching: fatal: Couldn\'t find remote ref' in err.command[0]:
+            if 'Error when fetching: fatal: ' in err.command[0]:
                 raise ResourceNotFoundError('Could not find opened request #{}'.format(request)) from err
             raise err
 

tests/helpers.py

@@ -671,8 +671,10 @@ def action_request_fetch(self, namespace, repository, request, pull=False, fail=
                 self.service.request_fetch(repository, namespace, request)
 
     def action_request_create(self,
-            namespace, repository, branch,
+            namespace, repository,
             title, description,
+            source_branch='pr-test',
+            target_branch='master',
             create_repository='test_create_requests',
             create_branch='pr-test'):
         '''
@@ -709,21 +711,25 @@ def prepare_project_for_test():
                 # let's create a project and add it to current repository
                 self.service.create(namespace, create_repository, add=True)
                 # make a modification, commit and push it
-                with open(os.path.join(self.repository.working_dir, 'first_file'), 'w') as test:
-                    test.write('he who makes a beast of himself gets rid of the pain of being a man. Dr Johnson')
-                self.repository.git.add('first_file')
-                self.repository.git.commit(message='First commit')
+            with open(os.path.join(self.repository.working_dir, 'first_file'), 'w') as test:
+                test.write('he who makes a beast of himself gets rid of the pain of being a man. Dr Johnson')
+            self.repository.git.config('user.name', 'travis')
+            self.repository.git.config('user.email', 'travis@fake.host')
+            self.repository.git.add('first_file')
+            self.repository.git.commit(message='First commit')
+            if will_record:
                 self.repository.git.push(self.service.name, 'master')
-                # create a new branch
-                new_branch = self.repository.create_head(create_branch, 'HEAD')
-                self.repository.head.reference = new_branch
-                self.repository.head.reset(index=True, working_tree=True)
-                # make a modification, commit and push it to that branch
-                with open(os.path.join(self.repository.working_dir, 'second_file'), 'w') as test:
-                    test.write('La meilleure façon de ne pas avancer est de suivre une idée fixe. J.Prévert')
-                self.repository.git.add('second_file')
-                self.repository.git.commit(message='Second commit')
-                self.repository.git.push('github', create_branch)
+            # create a new branch
+            new_branch = self.repository.create_head(create_branch, 'HEAD')
+            self.repository.head.reference = new_branch
+            self.repository.head.reset(index=True, working_tree=True)
+            # make a modification, commit and push it to that branch
+            with open(os.path.join(self.repository.working_dir, 'second_file'), 'w') as test:
+                test.write('La meilleure façon de ne pas avancer est de suivre une idée fixe. J.Prévert')
+            self.repository.git.add('second_file')
+            self.repository.git.commit(message='Second commit')
+            if will_record:
+                self.repository.git.push(self.service.name, create_branch)
             yield
             if will_record:
                 self.service.delete(create_repository)
@@ -735,7 +741,8 @@ def prepare_project_for_test():
                 request = self.service.request_create(
                         namespace,
                         repository,
-                        branch,
+                        source_branch,
+                        target_branch,
                         title,
                         description
                 )
@@ -753,19 +760,19 @@ def action_gist_list(self, gist=None, gist_list_data=[]):
                 for i, gf in enumerate(gist_list_data):
                     assert gist_files[i] == gf
 
-    def action_gist_clone(self, gist):
+    def action_gist_clone(self, gist, clone_url=None):
         with self.mockup_git(None, None):
             self.set_mock_popen_commands([
                 ('git version', b'git version 2.8.0', b'', 0),
-                ('git remote add gist {}.git'.format(gist), b'', b'', 0),
+                ('git remote add gist {}.git'.format(clone_url or gist), b'', b'', 0),
                 ('git pull --progress -v gist master', b'', b'\n'.join([
                     b'POST git-upload-pack (140 bytes)',
                     b'remote: Counting objects: 8318, done.',
                     b'remote: Compressing objects: 100% (3/3), done.',
                     b'remote: Total 8318 (delta 0), reused 0 (delta 0), pack-reused 8315',
                     b'Receiving objects: 100% (8318/8318), 3.59 MiB | 974.00 KiB/s, done.',
                     b'Resolving deltas: 100% (5126/5126), done.',
-                    bytes('From {}'.format(gist), 'utf-8'),
+                    bytes('From {}'.format(clone_url or gist), 'utf-8'),
                     b' * branch            master     -> FETCH_HEAD']),
                 0),
             ])