def add_secrets(self, repo_name, secrets_to_add, secrets):
"""Adds the given secrets to the repository.
:param repo_name: The repo to add the secrets to.
:param secrets_to_add: The keys of the secrets to add
:param secrets: Key value pairs of your secrets
:return: None
"""
logging.debug(f"Adding secrets to repo '{repo_name}'.")
public_key = self.get_public_key(repo_name)
public_key_key = public_key.get("key", None)
public_key_id = public_key.get("key_id", None)
if len(secrets_to_add) == 0:
secrets_to_add = secrets.keys()
for key in secrets_to_add:
value = secrets[key]
encrypted = self._encrypt_secret(public_key_key, value)
response = self._put_encrypted_secret(repo_name, public_key_id,
key, encrypted)
if response.status_code != 204 and not response.ok:
raise GithubException(response.status_code, response.json())
def test_create_branch(self):
self.provider.create_branch(self.repo, "base branch", "new branch")
self.repo.get_git_ref.assert_called_once_with("heads/base branch")
self.repo.get_git_ref.side_effect = GithubException(data="", status=1)
with self.assertRaises(errors.BranchExistsError):
self.provider.create_branch(self.repo, "base branch", "new branch")
def test_raises_other_github_exception(self, mock_get_user, mock_logging_error):
mock_get_user.side_effect = GithubException(400, "Failure")
self.rli_github.create_repo(*self.create_repo_args)
mock_get_user.assert_called_once()
mock_logging_error.assert_called_with("There was an exception when creating your repository.")
def test_raises_name_taken_github_exception(self, mock_get_user, mock_logging_error):
mock_get_user.side_effect = GithubException(422, "Failure")
self.rli_github.create_repo(*self.create_repo_args)
mock_get_user.assert_called_once()
mock_logging_error.assert_called_with("Repository name is taken.")
def get_branch_mock(branch_name):
if branch_name == 'master':
branch_mock = Mock()
branch_mock.commit = Mock()
branch_mock.commit.sha = 'aaaaaaa'
return branch_mock
raise GithubException(None, None)
def test_get_user_repo_failure(self):
mock = MagicMock()
mock_user = MagicMock()
mock_user.get_repo.side_effect = GithubException(404, "Not Found")
mock.get_user.return_value = mock_user
client = SourceControlClient(mock, mock, mock)
user_repo = client.get_user_repository("mf-doom", "mm.. food")
self.assertFalse(user_repo)
def test_get_org_repo_failure(self):
mock = MagicMock()
mock_org = MagicMock()
mock_org.get_repo.side_effect = GithubException(404, "Not Found")
mock.get_organization.return_value = mock_org
client = SourceControlClient(mock, mock, mock)
org_repo = client.get_organisation_repository("tribe-called-quest", "midnight-marauders")
self.assertFalse(org_repo)
def test_get_repository_failing(self, github_mock):
"""Should raise a GitProviderError error."""
instance = github_mock.return_value
instance.get_repo.side_effect = GithubException(500, "fake error")
github_provider = GitHubGitProvider()
with self.assertRaises(GitProviderError):
github_provider._get_repository("organization", "fake-project")
def test_org_get_teams_exception(self):
"""Test GithubInterface method org_get_teams with exception raised."""
self.mock_org.get_teams.side_effect = GithubException("status", "data")
try:
self.test_interface.org_get_teams()
assert False
except GithubAPIException:
pass
def test_get_user_info_failing(self, github_mock):
"""Should raise a GitProviderError when failing."""
instance = github_mock.return_value
instance.get_user.side_effect = GithubException(500, "fake error")
github_provider = GitHubGitProvider()
with self.assertRaises(GitProviderError):
github_provider.get_user_info()
def _get_installation_access_token(self, installation_id):
"""
Get an access token for the given installation id.
POSTs https://api.github.com/installations/<installation_id>/access_tokens
:param user_id: int
:param installation_id: int
:return: :class:`github.InstallationAuthorization.InstallationAuthorization`
"""
conn = HTTPSConnection("api.github.com")
conn.request(
method="POST",
url="/installations/{}/access_tokens".format(installation_id),
headers={
"Authorization": "Bearer {}".format(self._create_jwt().decode()),
"Accept": "application/vnd.github.machine-man-preview+json",
"User-Agent": "LaraTUB/lara"
}
)
response = conn.getresponse()
response_text = response.read()
response_text = response_text.decode('utf-8')
conn.close()
if response.status == 201:
data = json.loads(response_text)
return InstallationAuthorization.InstallationAuthorization(
requester=None, # not required, this is a NonCompletableGithubObject
headers={}, # not required, this is a NonCompletableGithubObject
attributes=data,
completed=True
).token
elif response.status == 403:
raise GithubException.BadCredentialsException(
status=response.status,
data=response_text
)
elif response.status == 404:
raise GithubException.UnknownObjectException(
status=response.status,
data=response_text
)
raise GithubException.GithubException(
status=response.status,
data=response_text
)
def get_branch_mock(branch_name):
if branch_name == "master":
branch_mock = Mock()
branch_mock.commit = Mock()
branch_mock.commit.sha = "aaaaaaa"
return branch_mock
raise GithubException(None, None)
def test_protect_branch_failing(self, get_branch_mock, _github_mock):
"""Should raise a GitProviderError when an unhandled error occurs."""
github_provider = GitHubGitProvider()
get_branch_mock.side_effect = GithubException(500, "fake error")
with self.assertRaises(GitProviderError):
github_provider.protect_branch(
"organization", "fake-project", "fake-branch", "user_login"
)
def test_setup_exception(self):
"""Test GithubInterface setup with exception raised."""
self.mock_github. \
get_organization.side_effect = GithubException("status", "data")
try:
GithubInterface(self.mock_factory, "ubclaunchpad")
assert False
except GithubAPIException:
pass
def test_get_commits_by_branch_branch_not_found(self):
self.repo_mock.get_branch.side_effect = GithubException(
404, {
'documentation_url':
'https://developer.github.com/v3/repos/#get-branch',
'message': 'Branch not found'
})
self.assertRaises(GithubException, self.api.get_commits_by_branch,
'blah')
def test_org_create_team_exception(self):
"""Test GithubInterface method org_create_team w/ exception raised."""
self.mock_org.create_team. \
side_effect = GithubException("status", "data")
try:
self.test_interface.org_create_team("brussel sprouts")
assert False
except GithubAPIException:
pass
def test_if_environment_does_not_exists(github):
control_repository = ControlRepository('test_organization',
'test_repository',
'some-token')
repository = github().get_organization().get_repo()
repository.get_branch.side_effect = GithubException('badstatus',
'missing')
with pytest.raises(EnvironmentNotFoundException):
control_repository.get_environment('environment')
def test_try_twice_add_admin(self):
"""Test org_add_admin() where the first try gives 401."""
mock_user = MagicMock(NamedUser.NamedUser)
self.mock_github.get_user.side_effect = [
GithubException(401, ''), mock_user
]
self.test_interface.org_add_admin('*****@*****.**')
self.mock_org.add_to_members.\
assert_called_once_with(mock_user, 'admin')
def test_get_repo_create(mocker, mock_api_wrapper):
"""get_repo should create the repo if a 404 is returned"""
mock_api_wrapper.org.get_repo.side_effect = [
GithubException(status=404, data={}, headers={}),
mocker.Mock(),
]
mock_api_wrapper.get_repo()
mock_api_wrapper.org.create_repo.assert_called_once_with(
mock_api_wrapper.website.short_id, auto_init=True)
def test_create_label_fails(self):
# label does not exist, need to create it
self.repo.get_label.side_effect = UnknownObjectException(None, None)
self.repo.create_label.side_effect = GithubException(None, None)
label = self.provider.get_or_create_label(self.repo, "another-label")
self.assertIsNone(label)
self.repo.get_label.assert_called_once_with(name="another-label")
self.repo.create_label.assert_called_once_with(name="another-label",
color="1BB0CE")
def test_iter_git_tree(self):
mocked_items = [Mock(type="type", path="path")]
self.repo.get_git_tree().tree = mocked_items
items = list(self.provider.iter_git_tree(self.repo, "some branch"))
self.assertEqual(items, [("type", "path")])
self.repo.get_git_tree.side_effect = GithubException(data="",
status=999)
with self.assertRaises(GithubException):
list(self.provider.iter_git_tree(self.repo, "some branch"))
def test_get_pull_request_permissions(self):
user = Mock()
user.login = "******"
self.provider.get_pull_request_permissions(user, self.repo)
self.repo.add_to_collaborators.assert_called_once_with("some-dude")
self.repo.add_to_collaborators.side_effect = GithubException(data="",
status=1)
with self.assertRaises(errors.NoPermissionError):
self.provider.get_pull_request_permissions(user, self.repo)
def test_get_org_commit_fail(self):
mock = MagicMock()
mock_repo = MagicMock()
mock_org = MagicMock()
mock_repo.get_commit.side_effect = GithubException(404, "Not Found")
mock_org.get_repo.return_value = mock_repo
mock.get_organization.return_value = mock_org
client = SourceControlClient(mock, mock, mock)
org_commit = client.get_organisation_commit("tribe-called-quest", "midnight-marauders", "yahyah")
self.assertFalse(org_commit)
def test_org_edit_team_exception(self):
"""Test GithubInterface method org_edit_team with exception raised."""
try:
mock_team: MagicMock = MagicMock(Team.Team)
mock_team.edit.side_effect = GithubException("status", "data")
self.mock_org.get_team.return_value = mock_team
self.test_interface.org_edit_team(234111, "brussels", "web team")
assert False
except GithubAPIException:
pass
def test_get_file(self):
content, obj = self.provider.get_file(self.repo, "path", "branch")
self.assertIsNotNone(content)
self.assertIsNotNone(obj)
self.repo.get_contents.assert_called_with("path", ref="branch")
self.repo.get_contents.side_effect = GithubException(data="", status=1)
content, obj = self.provider.get_file(self.repo, "path", "branch")
self.assertIsNone(content)
self.assertIsNone(obj)
def test_get_repository_on_non_existing_repository(self, github_mock):
"""Should raise a GitResourceNotFoundError error."""
instance = github_mock.return_value
instance.get_repo.side_effect = GithubException(404, "fake error")
github_provider = GitHubGitProvider()
with self.assertRaises(GitResourceNotFoundError) as context:
github_provider._get_repository("organization", "fake-project")
self.assertEqual(context.exception.resource, GitResource.REPOSITORY)
def test_org_has_member_exception(self):
"""Test GithubInterface method org_has_member with exception raised."""
self.mock_org.has_in_members. \
side_effect = GithubException("status", "data")
try:
mock_user: MagicMock = MagicMock(NamedUser.NamedUser)
self.mock_github.get_user.return_value = mock_user
self.test_interface.org_has_member("*****@*****.**")
assert False
except GithubAPIException:
pass
def test_org_delete_team_exception(self):
"""Test GithubInterface method org_delete_team w/ exception raised."""
try:
mock_team = Mock(id=234111)
self.mock_org.get_team.return_value = mock_team
mock_team.delete. \
side_effect = GithubException("status", "data")
self.test_interface.org_delete_team(234111)
assert False
except GithubAPIException:
pass
def test_create_repo_again(mocker, mock_api_wrapper):
""" Test that the create_repo function will try retrieving a repo if api.create_repo fails"""
mock_log = mocker.patch("content_sync.apis.github.log.debug")
mock_api_wrapper.org.create_repo.side_effect = GithubException(status=422,
data={},
headers={})
new_repo = mock_api_wrapper.create_repo()
assert new_repo is not None
assert mock_api_wrapper.org.get_repo.call_count == 1
mock_log.assert_called_once_with("Repo already exists: %s",
mock_api_wrapper.website.name)
def _setup_create_tag_mocks(self, status_code, msg, return_sha):
"""
Setup the mocks for the create_tag calls below.
"""
mock_user = Mock(NamedUser, email='*****@*****.**')
mock_user.name = 'test_name'
self.repo_mock.create_git_tag = Mock()
self.repo_mock.create_git_ref = Mock(
side_effect=GithubException(status_code, {'message': msg}))
self.repo_mock.get_git_ref = get_tag_mock = Mock()
get_tag_mock.return_value = Mock(object=Mock(sha=return_sha))
return mock_user
