def create_repository(username,
repository_name,
fork_policy,
is_private,
scm=None,
name=None,
description=None,
language=None,
has_issues=None,
has_wiki=None,
client=Client()):
template = ('{+bitbucket_url}' +
'/2.0/repositories/{username}/{repository_name}')
url = expand(
template, {
'bitbucket_url': client.get_bitbucket_url(),
'username': username,
'repository_name': repository_name
})
payload = Repository.make_new_repository_payload(
fork_policy, is_private, scm, name, description, language,
has_issues, has_wiki)
response = client.session.post(url, data=payload)
Client.expect_ok(response)
return client.convert_to_object(response.json())
def content(self, filename):
if not self.files.get(filename):
return
url = self.files[filename]['links']['self']['href']
response = self.client.session.get(url)
Client.expect_ok(response)
return response.content
def test_client_construction(self):
client = Client(FakeAuth())
assert 'https://staging.bitbucket.org/api' == \
client.get_bitbucket_url()
url = client.get_bitbucket_url() + '/1.0/user'
httpretty.register_uri(httpretty.GET, url)
response = client.session.get(url)
assert 200 == response.status_code
def test_expect_ok(self):
a = FakeAuth()
httpretty.register_uri(httpretty.GET, a.server_base_uri)
session = a.start_http_session()
response = session.get(a.server_base_uri)
try:
Client.expect_ok(response)
except Exception:
assert False
def content(self, filename):
"""
A method for obtaining the contents of a file on a snippet.
If the filename is not on the snippet, no content is returned.
"""
if not self.files.get(filename):
return
url = self.files[filename]['links']['self']['href']
response = self.client.session.get(url)
Client.expect_ok(response)
return response.content
def remove_all_team_repo_access(self, user_name, team_name):
"""Remove all access of the user of the given username
"""
try:
delete_access_url = entrypoint_url_delete_team_access_of_a_user(
team=team_name, username=user_name)
response = self.client.session.delete(url=delete_access_url)
Client.expect_ok(response, 201)
except Exception as e:
self.logger.error(e)
return False
return True
def create_comment(content, snippet_id, username=None, client=Client()):
if username is None:
username = client.get_username()
template = ('{+bitbucket_url}' +
'/2.0/snippets/{username}/{snippet_id}' + '/comments')
api_url = expand(
template, {
'bitbucket_url': client.get_bitbucket_url(),
'username': username,
'snippet_id': snippet_id,
})
payload = Comment.make_payload(content)
response = client.session.post(api_url, data=payload)
Client.expect_ok(response)
return Comment(response.json(), client=client)
def create_snippet(files,
is_private=None,
title=None,
scm=None,
client=Client()):
template = '{+bitbucket_url}/2.0/snippets{/username}'
url = expand(
template, {
'bitbucket_url': client.get_bitbucket_url(),
'username': client.get_username()
})
payload = Snippet.make_payload(is_private, title, scm)
response = client.session.post(url, data=payload, files=files)
Client.expect_ok(response)
return Snippet(response.json(), client=client)
def __init__(self, data, client=Client()):
super(PullRequest, self).__init__(data, client=client)
self.attr_from_subchild(
'source_commit', 'source', 'commit')
self.attr_from_subchild(
'source_repository', 'source', 'repository')
self.attr_from_subchild(
'destination_commit', 'destination', 'commit')
self.attr_from_subchild(
'destination_repository', 'destination', 'repository')
# Special treatment for approve, decline, merge, and diff
if data.get('links', {}).get('approve', {}).get('href', {}):
url = data['links']['approve']['href']
# Approve is a POST on the approve link
setattr(self, 'approve', partial(
self.post_approval, template=url))
# Unapprove is a DELETE on the approve link
setattr(self, 'unapprove', partial(
self.delete_approval, template=url))
if data.get('links', {}).get('decline', {}).get('href', {}):
url = data['links']['decline']['href']
# Decline is a POST
setattr(self, 'decline', partial(
self.post, client=client, url=url, json=None))
if data.get('links', {}).get('merge', {}).get('href', {}):
url = data['links']['merge']['href']
# Merge is a POST
setattr(self, 'merge', partial(
self.post, client=client, url=url, json=None))
if data.get('links', {}).get('diff', {}).get('href', {}):
url = data['links']['diff']['href']
# Diff returns plain text
setattr(self, 'diff', partial(
self.content, url=url))
def find_hooks_in_repository(owner, repository_name, client=Client()):
"""
A convenience method for finding hooks by repo name.
The method is a generator for Hook objects
"""
return Bitbucket(client=client).repositoryHooks(
owner=owner, repository_name=repository_name)
def create(cls, payload, client=None):
"""Create a new consumer.
:param payload: the options for creating the new consumer
:type payload: ConsumerPayload
:param client: the configured connection to Bitbucket.
If not provided, assumes an Anonymous connection.
:type client: bitbucket.Client
:returns: the new consumer object.
:rtype: Consumer
:raises: ValueError
"""
client = client or Client()
owner = client.get_username()
if not owner:
raise ValueError('owner is required')
data = payload.validate().build()
templates = cls.extract_templates_from_json()
api_url = expand(templates['create'], {
'bitbucket_url': client.get_bitbucket_url(),
'username': owner
})
# Note: This Bitbucket API expects a urlencoded-form, not json.
# Hence, use `data` instead of `json`.
return cls.post(api_url, data=data, client=client)
def get_bitbucket_users(self):
uname = self.conf['username']
appwd = self.conf['password']
email = self.conf['email']
auth = BasicAuthenticator(uname, appwd, email)
bitbucket = Client(auth)
teams = Team.find_teams_for_role(role="admin", client=bitbucket)
for t in teams:
for m in t.members():
pprint(m)
login = m['nickname']
name = m['display_name']
email = ''
self.init_user(login, name, email)
r = requests.get("{}/users/{}/ssh-keys".format(
BitbucketConn.v1url, login),
auth=(uname, appwd))
if r.status_code == 200:
key_response = r.json()
for keyvalue in key_response['values']:
key = sshpubkeys.SSHKey(keyvalue['key'])
fingerprint = key.hash_md5()
self.user_list[login][PUBKEYS][fingerprint] = keyvalue[
'key']
else:
print(r.status_code)
def find_bitbucket_repository(user, password, email):
bitbucket = Client(
BasicAuthenticator(user, password, email)
)
try:
print("Finding run project in bitbucket...")
repository = Repository.find_repository_by_name_and_owner(
repository_name="run",
client=bitbucket
)
except HTTPError:
print("Project not found")
print("Creating project run...")
repository = Repository.create(
payload=RepositoryPayload({
"name": "run",
"is_private": True,
"fork_policy": RepositoryForkPolicy.NO_FORKS,
}),
client=bitbucket
)
for link in repository.links["clone"]:
if link["name"] == "https":
return link["href"]
def find_teams_for_role(role=TeamRole.ADMIN, client=Client()):
"""
A convenience method for finding teams by the user's role.
The method is a generator Team objects.
"""
TeamRole.expect_valid_value(role)
return Bitbucket(client=client).teamsForRole(role=role)
def setup_class(cls):
cls.test_dir, current_file = path.split(path.abspath(__file__))
cls.client = Client(FakeAuth())
example_commit = json.loads(data_from_file(cls.test_dir,
'Commit.json'))
cls.commit = cls.client.convert_to_object(example_commit)
def __init__(self, data, client=Client()):
super(Repository, self).__init__(data, client=client)
if data.get('links', {}).get('clone'):
self.clone = {
clone_method['name']: clone_method['href']
for clone_method in data['links']['clone']
}
def find_consumers(client=Client()):
url = expand(
Consumer.get_link_template('consumers'), {
'bitbucket_url': client.get_bitbucket_url(),
'username': client.get_username()
})
return client.remote_relationship(url)
def create_pullrequest(
username,
repository_name,
title,
source_branch_name,
destination_branch_name,
close_source_branch=None,
description=None,
reviewers=None,
client=Client()):
template = (
'{+bitbucket_url}' +
'/2.0/repositories{/username,repository_name}/pullrequests')
api_url = expand(
template,
{
'bitbucket_url': client.get_bitbucket_url(),
'username': username,
'repository_name': repository_name
})
payload = PullRequest.make_new_pullrequest_payload(
title,
source_branch_name,
(username + '/' + repository_name),
destination_branch_name,
close_source_branch,
description,
reviewers)
return PullRequest.post(api_url, json=payload, client=client)
def find_snippets_for_role(role=SnippetRole.OWNER, client=Client()):
"""
A convenience method for finding snippets by the user's role.
The method is a generator Snippet objects.
"""
SnippetRole.expect_valid_value(role)
return Bitbucket(client=client).snippetsForRole(role=role)
def create_buildstatus(owner,
repository_name,
revision,
key,
state,
url,
name=None,
description=None,
client=Client()):
template = ('{+bitbucket_url}' +
'/2.0/repositories{/owner,repository_name}' +
'/commit{/revision}/statuses/build')
# owner, repository_name, and revision are required
api_url = expand(
template, {
'bitbucket_url': client.get_bitbucket_url(),
'owner': owner,
'repository_name': repository_name,
'revision': revision
})
payload = BuildStatus.make_payload(key=key,
state=state,
url=url,
name=name,
description=description)
return BuildStatus.post(api_url, json=payload, client=client)
def create(cls, payload, repository_name=None, owner=None, client=None):
"""Create a new branch-restriction.
:param payload: the options for creating the new Branch Restriction
:type payload: BranchRestrictionPayload
:param repository_name: name of the destination repository,
also known as repo_slug. Optional, if provided in the payload.
:type repository_name: str
:param owner: the owner of the destination repository.
If not provided, assumes the current user.
:type owner: str
:param client: the configured connection to Bitbucket.
If not provided, assumes an Anonymous connection.
:type client: bitbucket.Client
:returns: the new BranchRestriction object.
:rtype: BranchRestriction
:raises: MultipleInvalid, Invalid
"""
client = client or Client()
owner = owner or payload.owner
repository_name = repository_name or payload.repository_name
if not (owner and repository_name):
raise Invalid('owner and repository_name are required')
json = payload.validate().build()
api_url = expand(
cls.templates['create'], {
'bitbucket_url': client.get_bitbucket_url(),
'owner': owner,
'repository_name': repository_name,
})
return cls.post(api_url, json=json, client=client)
def find_refs_in_repository(owner, repository_name, client=Client()):
"""
A convenience method for finding refs in a repository.
The method is a generator Ref subtypes of Tag and Branch.
"""
return Bitbucket(client=client).repositoryRefs(
owner=owner, repository_name=repository_name)
def find_branchrestrictions_for_repository(repository_name,
owner=None,
client=Client()):
if (owner is None):
owner = client.get_username()
return Bitbucket(client=client).repositoryBranchRestrictions(
owner=owner, repository_name=repository_name)
def find_user_by_username(username, client=Client()):
"""
A convenience method for finding a specific user.
In contrast to the pure hypermedia driven method on the Bitbucket
class, this method returns a User object, instead of the
generator.
"""
return next(Bitbucket(client=client).userByUsername(username=username))
def find_current_user(client=Client()):
"""
A convenience method for finding the current user.
In contrast to the pure hypermedia driven method on the Bitbucket
class, this method returns a User object, instead of the
generator.
"""
return next(Bitbucket(client=client).userForMyself())
def find_tags_in_repository(repository_name, owner=None, client=Client()):
"""
A convenience method for finding tags in a repository.
The method is a generator Tag objects.
"""
owner = owner or client.get_username()
return Bitbucket(client=client).repositoryTags(
owner=owner, repository_name=repository_name)
def find_repository_by_full_name(repository_full_name, client=Client()):
if '/' not in repository_full_name:
raise NameError(
"Repository full name must be in the form: username/name")
owner, repository_name = repository_full_name.split('/')
return Repository.find_repository_by_owner_and_name(owner,
repository_name,
client=client)
def find_buildstatuses_for_repository_commit(repository_name,
revision,
owner=None,
client=Client()):
if (owner is None):
owner = client.get_username()
return Bitbucket(client=client).repositoryCommitBuildStatuses(
owner=owner, repository_name=repository_name, revision=revision)
def __init__(self, data, client=Client()):
super(Consumer, self).__init__(data, client=client)
expanded_links = self.expand_link_urls(
bitbucket_url=client.get_bitbucket_url(),
username=client.get_username(),
consumer_id=data.get('id'))
self.links = expanded_links.get('_links', {})
self.add_remote_relationship_methods(expanded_links)
def find_consumer_by_id(consumer_id, client=Client()):
url = expand(
Consumer.get_link_template('self'), {
'bitbucket_url': client.get_bitbucket_url(),
'username': client.get_username(),
'consumer_id': consumer_id,
})
return next(client.remote_relationship(url))
