def test_update_pr_status(self, mock_post):
mock_post.return_value = utils.Response()
ev = utils.create_event(user=self.build_user)
pr = utils.create_pr(server=self.server)
ev.pull_request = pr
ev.save()
# no state is set so just run for coverage
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
mock_post.return_value = utils.Response(status_code=200,
content="some content")
api = self.server.api()
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 1)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context',
api.STATUS_CONTINUE_RUNNING)
self.assertEqual(mock_post.call_count, 1)
# Not updated
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_START_RUNNING)
self.assertEqual(mock_post.call_count, 1)
mock_post.return_value = utils.Response(
json_data={"error": "some error"}, status_code=404)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 2)
mock_post.return_value = utils.Response(
json_data={"error": "some error"}, status_code=205)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 3)
mock_post.side_effect = Exception('BAM!')
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 4)
# This should just return
api = self.server.api()
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event', 'desc',
'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 4)
def test_pr_comment(self, mock_post):
# no real state that we can check, so just go for coverage
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
mock_post.return_value = utils.Response(json_data="some json")
api = self.server.api()
# valid post
api.pr_comment('url', 'message')
# bad post
mock_post.side_effect = Exception("BAM!")
api.pr_comment('url', 'message')
# should just return
api.pr_comment('url', 'message')
def test_edit_pr_comment(self, mock_edit):
# should just return
api = self.server.api()
api.edit_pr_comment(None, None)
self.assertEqual(mock_edit.call_count, 0)
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
comment = {"url": "some_url"}
api = self.server.api()
# bad response
mock_edit.return_value = utils.Response(status_code=400)
api.edit_pr_comment(comment, "new msg")
self.assertEqual(mock_edit.call_count, 1)
# good response
mock_edit.return_value = utils.Response()
api.edit_pr_comment(comment, "new msg")
self.assertEqual(mock_edit.call_count, 2)
def test_install_webhooks(self, mock_post, mock_get):
get_data = []
webhook_url = reverse('ci:gitlab:webhook',
args=[self.build_user.build_key])
base = self.server.server_config().get("civet_base_url", "")
callback_url = "%s%s" % (base, webhook_url)
get_data.append({
'merge_requests_events': 'true',
'push_events': 'true',
'url': 'no_url'
})
mock_get.return_value = utils.Response(get_data)
mock_post.return_value = utils.Response({'errors': 'error'},
status_code=404)
# with this data it should try to install the hook but there is an error
api = self.server.api()
with self.assertRaises(GitException):
api.install_webhooks(self.build_user, self.repo)
# with this data it should do the hook
mock_post.return_value = utils.Response()
api.install_webhooks(self.build_user, self.repo)
# with this data the hook already exists
get_data.append({
'merge_requests_events': 'true',
'push_events': 'true',
'url': callback_url
})
api.install_webhooks(self.build_user, self.repo)
with self.settings(INSTALLED_GITSERVERS=[
utils.gitlab_config(install_webhook=False)
]):
# this should just return
api = self.server.api()
mock_get.call_count = 0
api.install_webhooks(self.build_user, self.repo)
self.assertEqual(mock_get.call_count, 0)
'name': repo.name,
'commit': {'id': commit},
'ssh_url_to_repo': 'testUrl',
}
super(PrResponse, self).__init__(json_data=data, *args, **kwargs)
class PushResponse(utils.Response):
def __init__(self, user, repo, *args, **kwargs):
data = {
'name': repo.name,
'namespace': {'name': user.name},
}
super(PushResponse, self).__init__(data, *args, **kwargs)
@override_settings(INSTALLED_GITSERVERS=[utils.gitlab_config()])
class Tests(DBTester.DBTester):
def setUp(self):
super(Tests, self).setUp()
self.create_default_recipes(server_type=settings.GITSERVER_GITLAB)
def get_data(self, fname):
p = '{}/{}'.format(os.path.dirname(__file__), fname)
with open(p, 'r') as f:
contents = f.read()
return contents
def client_post_json(self, url, data):
json_data = json.dumps(data)
return self.client.post(url, json_data, content_type='application/json')
def test_create_or_update_issue(self, mock_get, mock_post, mock_put,
mock_rget, mock_rput):
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
get_data = [{"title": "foo", "iid": 1}]
mock_get.return_value = utils.Response(get_data)
mock_post.return_value = utils.Response({"web_url": "<some url>"})
mock_put.return_value = utils.Response({"web_url": "<some url>"})
api = self.build_user.api()
# No existing issue, so create it creates a new one
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(api.errors(), [])
get_data.append({"title": "Some title", "iid": 2})
mock_get.call_count = 0
mock_post.call_count = 0
# An existing issue, so just update it
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 1)
self.assertEqual(api.errors(), [])
# An existing issue, but want a new comment
mock_get.call_count = 0
mock_put.call_count = 0
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", True)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(api.errors(), [])
mock_get.call_count = 0
mock_put.call_count = 0
mock_post.call_count = 0
# API doesn't have a user, no problem
api = self.server.api()
mock_rget.return_value = utils.Response(get_data)
mock_rput.return_value = utils.Response({"web_url": "<some url>"})
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 0)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(mock_rget.call_count, 1)
self.assertEqual(mock_rput.call_count, 1)
api = self.build_user.api()
mock_get.call_count = 0
mock_put.call_count = 0
# remote_update=False so nothing happens
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 0)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 0)
class Tests(DBTester.DBTester):
def setUp(self):
super(Tests, self).setUp()
self.create_default_recipes(server_type=settings.GITSERVER_GITLAB)
utils.simulate_login(self.client.session, self.build_user)
def get_json_file(self, filename):
dirname, fname = os.path.split(os.path.abspath(__file__))
with open(dirname + '/' + filename, 'r') as f:
js = f.read()
return js
def test_misc(self):
# Just get some basic coverage
api = self.server.api(token="1234")
self.build_user.token = json.dumps({'access_token': 1234})
self.build_user.save()
api = self.build_user.api()
api.sign_in_url()
api.branch_html_url("owner", "repo", "branch")
api.repo_html_url("owner", "repo")
api.commit_html_url("owner", "repo", "sha")
@patch.object(requests, 'get')
def test_get_repos(self, mock_get):
api = self.server.api()
mock_get.return_value = utils.Response([])
repos = api.get_repos(self.client.session)
# shouldn't be any repos
self.assertEqual(len(repos), 0)
data = [
{
'path_with_namespace': "%s/repo2" % self.build_user.name
},
{
'path_with_namespace': "%s/repo2" % self.build_user.name
},
]
mock_get.return_value = utils.Response(data)
repos = api.get_repos(self.client.session)
self.assertEqual(len(repos), 2)
session = self.client.session
session[api._repos_key] = ['repo1']
session.save()
repos = api.get_repos(self.client.session)
self.assertEqual(len(repos), 1)
self.assertEqual(repos[0], 'repo1')
@patch.object(requests, 'get')
def test_get_user_org_repos(self, mock_get):
mock_get.return_value = utils.Response(status_code=404)
api = self.server.api()
repos = api._get_user_org_repos(self.build_user)
self.assertEqual(repos, [])
data = [
{
'path_with_namespace': "name/repo2"
},
{
'path_with_namespace': "name/repo1"
},
]
mock_get.return_value = utils.Response(data)
repos = api._get_user_org_repos(self.build_user)
self.assertEqual(repos, ["name/repo1", "name/repo2"])
@patch.object(requests, 'get')
def test_get_all_repos(self, mock_get):
mock_get.return_value = utils.Response([])
api = self.server.api()
repos = api.get_all_repos(self.build_user.name)
# shouldn't be any repos
self.assertEqual(len(repos), 0)
data = [
{
'path_with_namespace': "name/repo1"
},
{
'path_with_namespace': "name/repo2"
},
{
'path_with_namespace': "other/repo1"
},
{
'path_with_namespace': "other/repo2"
},
]
mock_get.return_value = utils.Response(data)
repos = api.get_all_repos("name")
self.assertEqual(len(repos), 4)
@patch.object(requests, 'get')
def test_get_branches(self, mock_get):
mock_get.return_value = utils.Response([])
api = self.server.api()
path_with_namespace = '%s/%s' % (self.owner.name, self.repo.name)
branches = api.get_branches(path_with_namespace)
# shouldn't be any branch
self.assertEqual(len(branches), 0)
data = [{'name': 'branch1'}, {'name': 'branch2'}]
mock_get.return_value = utils.Response(data)
branches = api.get_branches(path_with_namespace)
self.assertEqual(len(branches), 2)
@patch.object(requests, 'get')
def test_is_group_member(self, mock_get):
mock_get.return_value = utils.Response([{
'username':
self.build_user.name
}])
api = self.server.api()
ret = api._is_group_member(42, self.build_user.name)
self.assertIs(ret, True)
mock_get.return_value = utils.Response([])
ret = api._is_group_member(42, self.build_user.name)
self.assertIs(ret, False)
@patch.object(requests, 'get')
def test_is_collaborator(self, mock_get):
# user is repo owner
api = self.server.api()
self.assertTrue(api.is_collaborator(self.owner, self.repo))
user2 = utils.create_user('user2', server=self.server)
# a collaborator
repo = utils.create_repo(user=user2)
mock_get.return_value = utils.Response([{
'username':
self.build_user.name
}])
self.assertTrue(api.is_collaborator(self.build_user, repo))
# not a collaborator
mock_get.return_value = utils.Response([{'username': '******'}])
self.assertFalse(api.is_collaborator(self.build_user, repo))
# some random problem
mock_get.side_effect = Exception("Bam!")
self.assertFalse(api.is_collaborator(self.build_user, repo))
@patch.object(requests, 'get')
def test_last_sha(self, mock_get):
data = {"commit": {"id": "123"}}
mock_get.return_value = utils.Response(data)
api = self.server.api()
sha = api.last_sha(self.build_user, self.branch.repository,
self.branch)
self.assertEqual(sha, '123')
mock_get.return_value = utils.Response(status_code=404)
sha = api.last_sha(self.build_user, self.branch.repository,
self.branch)
self.assertEqual(sha, None)
mock_get.side_effect = Exception("Bam!")
sha = api.last_sha(self.build_user, self.branch.repository,
self.branch)
self.assertEqual(sha, None)
@patch.object(requests, 'get')
@patch.object(requests, 'post')
@override_settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(install_webhook=True)])
def test_install_webhooks(self, mock_post, mock_get):
get_data = []
webhook_url = reverse('ci:gitlab:webhook',
args=[self.build_user.build_key])
base = self.server.server_config().get("civet_base_url", "")
callback_url = "%s%s" % (base, webhook_url)
get_data.append({
'merge_requests_events': 'true',
'push_events': 'true',
'url': 'no_url'
})
mock_get.return_value = utils.Response(get_data)
mock_post.return_value = utils.Response({'errors': 'error'},
status_code=404)
# with this data it should try to install the hook but there is an error
api = self.server.api()
with self.assertRaises(GitException):
api.install_webhooks(self.build_user, self.repo)
# with this data it should do the hook
mock_post.return_value = utils.Response()
api.install_webhooks(self.build_user, self.repo)
# with this data the hook already exists
get_data.append({
'merge_requests_events': 'true',
'push_events': 'true',
'url': callback_url
})
api.install_webhooks(self.build_user, self.repo)
with self.settings(INSTALLED_GITSERVERS=[
utils.gitlab_config(install_webhook=False)
]):
# this should just return
api = self.server.api()
mock_get.call_count = 0
api.install_webhooks(self.build_user, self.repo)
self.assertEqual(mock_get.call_count, 0)
@patch.object(requests, 'post')
def test_pr_comment(self, mock_post):
# no real state that we can check, so just go for coverage
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
mock_post.return_value = utils.Response(json_data="some json")
api = self.server.api()
# valid post
api.pr_comment('url', 'message')
# bad post
mock_post.side_effect = Exception("BAM!")
api.pr_comment('url', 'message')
# should just return
api.pr_comment('url', 'message')
@patch.object(requests, 'post')
def test_update_pr_status(self, mock_post):
mock_post.return_value = utils.Response()
ev = utils.create_event(user=self.build_user)
pr = utils.create_pr(server=self.server)
ev.pull_request = pr
ev.save()
# no state is set so just run for coverage
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
mock_post.return_value = utils.Response(status_code=200,
content="some content")
api = self.server.api()
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 1)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context',
api.STATUS_CONTINUE_RUNNING)
self.assertEqual(mock_post.call_count, 1)
# Not updated
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_START_RUNNING)
self.assertEqual(mock_post.call_count, 1)
mock_post.return_value = utils.Response(
json_data={"error": "some error"}, status_code=404)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 2)
mock_post.return_value = utils.Response(
json_data={"error": "some error"}, status_code=205)
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 3)
mock_post.side_effect = Exception('BAM!')
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event',
'desc', 'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 4)
# This should just return
api = self.server.api()
api.update_pr_status(ev.base, ev.head, api.PENDING, 'event', 'desc',
'context', api.STATUS_JOB_STARTED)
self.assertEqual(mock_post.call_count, 4)
def test_status_str(self):
api = self.server.api()
self.assertEqual(api._status_str(api.SUCCESS), 'success')
self.assertEqual(api._status_str(1000), None)
@patch.object(requests, 'get')
def test_get_pr_changed_files(self, mock_get):
api = self.server.api()
pr = utils.create_pr(repo=self.repo)
mock_get.return_value = utils.Response({"changes": []})
files = api._get_pr_changed_files(self.repo.user.name, self.repo.name,
pr.number)
# shouldn't be any files
self.assertEqual(len(files), 0)
file_json = self.get_json_file("files.json")
file_data = json.loads(file_json)
mock_get.return_value = utils.Response(file_data)
files = api._get_pr_changed_files(self.repo.user.name, self.repo.name,
pr.number)
self.assertEqual(["other/path/to/file1", "path/to/file0"], files)
# simulate a bad request
mock_get.return_value = utils.Response(file_data, status_code=400)
files = api._get_pr_changed_files(self.repo.user.name, self.repo.name,
pr.number)
self.assertEqual(files, [])
# simulate a request timeout
mock_get.side_effect = Exception("Bam!")
files = api._get_pr_changed_files(self.repo.user.name, self.repo.name,
pr.number)
self.assertEqual(files, [])
@patch.object(requests, 'get')
def test_get_project_access_level(self, mock_get):
# Can't get user information
api = self.server.api()
empty_response = utils.Response({})
mock_get.return_value = empty_response
path_with_namespace = '%s/%s' % (self.repo.user.name, self.repo.name)
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Unknown")
user_json = self.get_json_file("user.json")
user_data = json.loads(user_json)
mock_get.return_value = None
namespace_data = {"namespace": {"id": 999}}
user_response = utils.Response(user_data)
bad_response = utils.Response({}, status_code=400)
namespace_response = utils.Response(namespace_data)
# Got user information but failed to get member information
# Then failed to get namespace information
mock_get.side_effect = [user_response, bad_response, bad_response]
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Unknown")
# Got user information but failed to get member information
# Then got namespace information but failed to get member information
mock_get.side_effect = [
user_response, bad_response, namespace_response, bad_response
]
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Unknown")
members_json = self.get_json_file("project_member.json")
members_data = json.loads(members_json)
members_response = utils.Response(members_data)
# Got user information but failed to get member information
# Then got namespace information and group information
mock_get.side_effect = [
user_response, bad_response, namespace_response, members_response
]
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Reporter")
# Got user information and user is a member
mock_get.side_effect = [user_response, members_response]
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Reporter")
# Make sure differenct access levels work
members_data["access_level"] = 30
mock_get.side_effect = [user_response, utils.Response(members_data)]
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Developer")
mock_get.side_effect = Exception("Bam!")
level = api._get_project_access_level(path_with_namespace)
self.assertEqual(level, "Unknown")
@patch.object(requests, 'get')
def test_get_pr_comments(self, mock_get):
# bad response, should return empty list
mock_get.return_value = utils.Response(status_code=400)
comment_re = r"^some message"
api = self.server.api()
ret = api.get_pr_comments("some_url", self.build_user.name, comment_re)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(ret, [])
c0 = {
"author": {
"username": self.build_user.name
},
"body": "some message",
"id": 1
}
c1 = {
"author": {
"username": self.build_user.name
},
"body": "other message",
"id": 1
}
c2 = {
"author": {
"username": "******"
},
"body": "some message",
"id": 1
}
mock_get.return_value = utils.Response(json_data=[c0, c1, c2])
ret = api.get_pr_comments("some_url", self.build_user.name, comment_re)
self.assertEqual(ret, [c0]) # the RE only matched 1 of them
@patch.object(requests, 'delete')
def test_remove_pr_comment(self, mock_del):
# should just return
api = self.server.api()
api.remove_pr_comment(None)
self.assertEqual(mock_del.call_count, 0)
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
comment = {"url": "some_url"}
api = self.server.api()
# bad response
mock_del.return_value = utils.Response(status_code=400)
api.remove_pr_comment(comment)
self.assertEqual(mock_del.call_count, 1)
# good response
mock_del.return_value = utils.Response()
api.remove_pr_comment(comment)
self.assertEqual(mock_del.call_count, 2)
@patch.object(requests, 'put')
def test_edit_pr_comment(self, mock_edit):
# should just return
api = self.server.api()
api.edit_pr_comment(None, None)
self.assertEqual(mock_edit.call_count, 0)
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
comment = {"url": "some_url"}
api = self.server.api()
# bad response
mock_edit.return_value = utils.Response(status_code=400)
api.edit_pr_comment(comment, "new msg")
self.assertEqual(mock_edit.call_count, 1)
# good response
mock_edit.return_value = utils.Response()
api.edit_pr_comment(comment, "new msg")
self.assertEqual(mock_edit.call_count, 2)
@patch.object(requests, 'get')
def test_is_member(self, mock_get):
# Username should match
api = self.server.api()
ret = api.is_member(self.build_user.name, self.build_user)
self.assertTrue(ret)
# Is a member
mock_get.return_value = utils.Response([{
'username':
self.build_user.name
}])
ret = api.is_member("foo", self.build_user)
self.assertIs(ret, True)
# Not a member
mock_get.return_value = utils.Response([{'username': "******"}])
ret = api.is_member("foo", self.build_user)
self.assertIs(ret, False)
def test_unimplemented(self):
"""
Just get coverage on the warning messages for the unimplementd functions
"""
api = self.server.api()
api.add_pr_label(None, None, None)
api.remove_pr_label(None, None, None)
api.pr_review_comment(None, None, None, None, None)
api.automerge(None, None)
@patch.object(requests, 'get')
def test_get_open_prs(self, mock_get):
repo = utils.create_repo(server=self.server)
api = self.server.api()
pr0 = {"title": "some title", "iid": 123, "web_url": "some url"}
pr0_ret = {
"title": "some title",
"number": 123,
"html_url": "some url"
}
mock_get.return_value = utils.Response([pr0])
prs = api.get_open_prs(repo.user.name, repo.name)
self.assertEqual([pr0_ret], prs)
mock_get.side_effect = Exception("BAM!")
prs = api.get_open_prs(repo.user.name, repo.name)
self.assertEqual(prs, None)
@patch.object(requests, 'put')
@patch.object(requests, 'get')
@patch.object(OAuth2Session, 'put')
@patch.object(OAuth2Session, 'post')
@patch.object(OAuth2Session, 'get')
def test_create_or_update_issue(self, mock_get, mock_post, mock_put,
mock_rget, mock_rput):
with self.settings(
INSTALLED_GITSERVERS=[utils.gitlab_config(
remote_update=True)]):
get_data = [{"title": "foo", "iid": 1}]
mock_get.return_value = utils.Response(get_data)
mock_post.return_value = utils.Response({"web_url": "<some url>"})
mock_put.return_value = utils.Response({"web_url": "<some url>"})
api = self.build_user.api()
# No existing issue, so create it creates a new one
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(api.errors(), [])
get_data.append({"title": "Some title", "iid": 2})
mock_get.call_count = 0
mock_post.call_count = 0
# An existing issue, so just update it
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 1)
self.assertEqual(api.errors(), [])
# An existing issue, but want a new comment
mock_get.call_count = 0
mock_put.call_count = 0
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", True)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(api.errors(), [])
mock_get.call_count = 0
mock_put.call_count = 0
mock_post.call_count = 0
# API doesn't have a user, no problem
api = self.server.api()
mock_rget.return_value = utils.Response(get_data)
mock_rput.return_value = utils.Response({"web_url": "<some url>"})
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 0)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 0)
self.assertEqual(mock_rget.call_count, 1)
self.assertEqual(mock_rput.call_count, 1)
api = self.build_user.api()
mock_get.call_count = 0
mock_put.call_count = 0
# remote_update=False so nothing happens
api.create_or_update_issue(self.repo.user.name, self.repo.name,
"Some title", "Some body", False)
self.assertEqual(mock_get.call_count, 0)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_put.call_count, 0)