def test_repo_prs(self):
repo0 = utils.create_repo(name="repo0")
repo0.active = True
repo0.save()
utils.create_pr(title="pr0", number=1, repo=repo0)
utils.create_pr(title="pr1", number=2, repo=repo0)
repo1 = utils.create_repo(name="repo1")
repo1.active = True
repo1.save()
utils.create_pr(repo=repo1)
repo2 = utils.create_repo(name="repo2")
repo2.active = True
repo2.save()
response = self.client.get(reverse('ci:num_prs'))
self.assertEqual(response.status_code, 200)
def setUp(self):
self.client = Client()
self.factory = RequestFactory()
for i in range(5):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.status = models.JobStatus.SUCCESS
repo.save()
for j in range(2):
b = utils.create_branch(name="branch%s" % j, repo=repo)
b.status = models.JobStatus.SUCCESS
b.save()
for j in range(3):
b = repo.branches.first()
pr = utils.create_pr(title="pr%s" % j, number=j+1, repo=repo)
pr.closed = False
pr.status = models.JobStatus.SUCCESS
pr.save()
ev = utils.create_event(user=repo.user, branch1=b, branch2=b, commit1="%s" % j)
ev.pull_request = pr
ev.save()
for k in range(3):
r = utils.create_recipe(name="%s%s" % (repo.name, k), repo=repo, branch=b)
r.private = False
r.save()
job = utils.create_job(recipe=r, event=ev)
job.status = models.JobStatus.SUCCESS
job.client = utils.create_client(name="client%s/%s" % (repo.name, k))
job.save()
utils.create_step_result(job=job)
utils.create_osversion()
utils.create_loadedmodule()
def create_records(self, recipe, branch):
info = {}
info["owner"] = test_utils.create_user(name=recipe["repository_owner"])
info["build_user"] = test_utils.create_user_with_token(name=recipe["build_user"])
info["repository"] = test_utils.create_repo(user=info["owner"], name=recipe["repository_name"])
info["branch"] = test_utils.create_branch(repo=info["repository"], name=branch)
return info
def test_install_webhooks(self, mock_post, mock_get):
repo = utils.create_repo(user=self.user)
event0 = {
'events': ['pullrequest:created', 'repo:push'],
'url': 'no_url'
}
event1 = {
'events': ['pullrequest:created', 'repo:other_action'],
'url': 'no_url'
}
get_data = {'values': [event0, event1]}
callback_url = urljoin(
self.gapi._civet_url,
reverse('ci:bitbucket:webhook', args=[self.user.build_key]))
with self.settings(INSTALLED_GITSERVERS=[
utils.bitbucket_config(install_webhook=True)
]):
api = self.server.api()
# Failed to do an the initial get
mock_get.return_value = utils.Response(status_code=404)
with self.assertRaises(GitException):
api.install_webhooks(self.user, repo)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 0)
# with this data it should try to install the hook but there is an error
mock_get.return_value = utils.Response(json_data=get_data)
mock_post.return_value = utils.Response(json_data={},
status_code=404)
mock_get.call_count = 0
with self.assertRaises(GitException):
api.install_webhooks(self.user, repo)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
# with this data it should do the hook
mock_get.call_count = 0
mock_post.call_count = 0
mock_post.return_value = utils.Response(json_data={},
status_code=201)
api.install_webhooks(self.user, repo)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 1)
# with this data the hook already exists
mock_get.call_count = 0
mock_post.call_count = 0
get_data['values'][0]['url'] = callback_url
api.install_webhooks(self.user, repo)
self.assertEqual(mock_get.call_count, 1)
self.assertEqual(mock_post.call_count, 0)
# this should just return
mock_get.call_count = 0
mock_post.call_count = 0
self.gapi.install_webhooks(self.user, repo)
self.assertEqual(mock_get.call_count, 0)
self.assertEqual(mock_post.call_count, 0)
def create_repos(self):
repos = []
for i in range(3):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.save()
repos.append(repo)
return repos
def test_is_collaborator(self, mock_get):
repo = utils.create_repo(user=self.user)
# user is repo owner
ret = self.gapi.is_collaborator(self.user, repo)
self.assertIs(ret, True)
user2 = utils.create_user('user2', server=self.server)
repo = utils.create_repo(user=user2)
# a collaborator
mock_get.return_value = utils.Response(
json_data={'values': [{
'name': repo.name
}]}, status_code=200)
ret = self.gapi.is_collaborator(self.user, repo)
self.assertIs(ret, True)
# not a collaborator
mock_get.return_value = utils.Response(status_code=404)
ret = self.gapi.is_collaborator(self.user, repo)
self.assertIs(ret, False)
def test_disable_repo(self):
out = StringIO()
with self.assertRaises(CommandError):
management.call_command("disable_repo", "--dry-run", stdout=out)
with self.assertRaises(CommandError):
management.call_command("disable_repo",
"--dry-run",
"--owner",
"foo",
stdout=out)
repo = utils.create_repo()
with self.assertRaises(CommandError):
management.call_command("disable_repo",
"--dry-run",
"--owner",
repo.user.name,
"--repo",
"<repo>",
stdout=out)
repo.active = True
repo.save()
branch = utils.create_branch(repo=repo)
branch.status = models.JobStatus.SUCCESS
branch.save()
pr = utils.create_pr(repo=repo)
pr.closed = False
pr.save()
management.call_command("disable_repo",
"--dry-run",
"--owner",
repo.user.name,
"--repo",
repo.name,
stdout=out)
repo.refresh_from_db()
self.assertIs(repo.active, True)
branch.refresh_from_db()
self.assertEqual(branch.status, models.JobStatus.SUCCESS)
pr.refresh_from_db()
self.assertIs(pr.closed, False)
management.call_command("disable_repo",
"--owner",
repo.user.name,
"--repo",
repo.name,
stdout=out)
repo.refresh_from_db()
self.assertIs(repo.active, False)
branch.refresh_from_db()
self.assertEqual(branch.status, models.JobStatus.NOT_STARTED)
pr.refresh_from_db()
self.assertIs(pr.closed, True)
def test_view_profile(self):
# invalid git server
response = self.client.get(reverse('ci:view_profile', args=[1000, "no_exist"]))
self.assertEqual(response.status_code, 404)
# not signed in should redirect to sign in
server = utils.create_git_server()
response = self.client.get(reverse('ci:view_profile', args=[server.host_type, server.name]))
self.assertEqual(response.status_code, 302) # redirect
user = utils.get_test_user()
repo1 = utils.create_repo(name='repo1', user=user)
repo2 = utils.create_repo(name='repo2', user=user)
repo3 = utils.create_repo(name='repo3', user=user)
utils.create_recipe(name='r1', user=user, repo=repo1)
utils.create_recipe(name='r2', user=user, repo=repo2)
utils.create_recipe(name='r3', user=user, repo=repo3)
# signed in
utils.simulate_login(self.client.session, user)
response = self.client.get(reverse('ci:view_profile', args=[user.server.host_type, user.server.name]))
self.assertEqual(response.status_code, 200)
def create_repo_with_prs(self, name="Repo0"):
repo = utils.create_repo(name=name)
branch = utils.create_branch(name="branch1", repo=repo)
repo.active = True
repo.save()
branch.status = models.JobStatus.RUNNING
branch.save()
for i in range(3):
pr = utils.create_pr(title="Foo {a, b} & <bar> … %s" % i, repo=repo, number=i+1)
pr.status = models.JobStatus.RUNNING
pr.save()
return repo, branch
def test_get_branches(self, mock_get):
repo = utils.create_repo(user=self.user)
mock_get.return_value = utils.Response(json_data={})
branches = self.gapi.get_branches(self.user, repo)
# shouldn't be any branch
self.assertEqual(len(branches), 0)
mock_get.return_value = utils.Response(json_data={
'branch1': 'info',
'branch2': 'info'
})
branches = self.gapi.get_branches(self.user, repo)
self.assertEqual(len(branches), 2)
def test_view_owner_repo(self):
# invalid repo
response = self.client.get(reverse('ci:view_owner_repo', args=["foo", "bar"]))
self.assertEqual(response.status_code, 404)
# valid repo with branches
repo = utils.create_repo()
branch = utils.create_branch(repo=repo)
branch.status = models.JobStatus.FAILED
branch.save()
utils.create_event(user=repo.user, branch1=branch, branch2=branch)
response = self.client.get(reverse('ci:view_owner_repo', args=[repo.user.name, repo.name]))
self.assertEqual(response.status_code, 200)
def create_default_recipes(self, recipes_dir, server_type=settings.GITSERVER_GITHUB):
hostname = "github.com"
if server_type == settings.GITSERVER_GITLAB:
hostname = "gitlab.com"
self.recipe_file = self.create_recipe_in_repo("recipe_all.cfg", "recipe.cfg", hostname=hostname)
self.recipe_pr_file = self.create_recipe_in_repo("pr_dep.cfg", "pr_dep.cfg", hostname=hostname)
self.recipe_push_file = self.create_recipe_in_repo("push_dep.cfg", "push_dep.cfg", hostname=hostname)
self.server = test_utils.create_git_server(host_type=server_type)
self.build_user = test_utils.create_user_with_token(name="moosebuild", server=self.server)
self.owner = test_utils.create_user(name="idaholab", server=self.server)
self.repo = test_utils.create_repo(name="civet", user=self.owner)
self.branch = test_utils.create_branch(name="devel", repo=self.repo)
return self.load_recipes(recipes_dir)
def create_default_recipes(self, server_type=settings.GITSERVER_GITHUB):
self.set_counts()
self.server = utils.create_git_server(host_type=server_type)
self.build_user = utils.create_user_with_token(name="moosebuild",
server=self.server)
self.owner = utils.create_user(name="owner", server=self.server)
self.repo = utils.create_repo(name="repo", user=self.owner)
self.branch = utils.create_branch(name="devel", repo=self.repo)
pr = utils.create_recipe(name="PR Base",
user=self.build_user,
repo=self.repo)
pr1 = utils.create_recipe(name="PR With Dep",
user=self.build_user,
repo=self.repo)
pr1.depends_on.add(pr)
push = utils.create_recipe(name="Push Base",
user=self.build_user,
repo=self.repo,
branch=self.branch,
cause=models.Recipe.CAUSE_PUSH)
push1 = utils.create_recipe(name="Push With Dep",
user=self.build_user,
repo=self.repo,
branch=self.branch,
cause=models.Recipe.CAUSE_PUSH)
push1.depends_on.add(push)
alt_pr = utils.create_recipe(
name="Alt PR with dep",
user=self.build_user,
repo=self.repo,
cause=models.Recipe.CAUSE_PULL_REQUEST_ALT)
alt_pr.depends_on.add(pr)
utils.create_recipe(name="Manual",
user=self.build_user,
repo=self.repo,
branch=self.branch,
cause=models.Recipe.CAUSE_MANUAL)
self.compare_counts(
recipes=6,
deps=3,
current=6,
num_push_recipes=2,
num_pr_recipes=2,
num_manual_recipes=1,
num_pr_alt_recipes=1,
users=2,
repos=1,
branches=1,
)
def test_get_open_prs(self, mock_get):
repo = utils.create_repo(server=self.server)
api = self.server.api()
pr0 = {"title": "some title", "id": 123, "links": {"html": "some url"}}
pr0_ret = {
"title": "some title",
"number": 123,
"html_url": "some url"
}
mock_get.return_value = utils.Response({"values": [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)
def test_mooseframework(self):
# no moose repo
response = self.client.get(reverse('ci:mooseframework'))
self.assertEqual(response.status_code, 200)
user = utils.create_user(name='idaholab')
repo = utils.create_repo(name='moose', user=user)
utils.create_pr(repo=repo)
# no master/devel branches
response = self.client.get(reverse('ci:mooseframework'))
self.assertEqual(response.status_code, 200)
utils.create_branch(name='master', repo=repo)
utils.create_branch(name='devel', repo=repo)
# should be good
response = self.client.get(reverse('ci:mooseframework'))
self.assertEqual(response.status_code, 200)
def test_user_repo_settings(self):
"""
testing ci:user_repo_settings
"""
repos = []
for i in range(3):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.save()
repos.append(repo)
# not signed in
url = reverse('ci:user_repo_settings')
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "form")
user = repos[0].user
utils.simulate_login(self.client.session, user)
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "form")
# post an invalid form
self.set_counts()
response = self.client.post(url, {})
self.assertEqual(response.status_code, 200)
self.compare_counts()
# post a valid form
self.set_counts()
response = self.client.post(url, {"repositories": [repos[0].pk, repos[1].pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(user.preferred_repos.count(), 2)
self.compare_counts(repo_prefs=2)
# post again with the same recipes
self.set_counts()
response = self.client.post(url, {"repositories": [repos[2].pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(user.preferred_repos.count(), 1)
self.compare_counts(repo_prefs=-1)
def create_events(self):
self.set_counts()
self.build_user = utils.create_user_with_token(name="moosebuild")
self.owner = utils.create_user(name="idaholab")
self.repo = utils.create_repo(name="civet", user=self.owner)
self.branch = utils.create_branch(name="devel", repo=self.repo)
pre = utils.create_recipe(name="Precheck", user=self.build_user, repo=self.repo)
test = utils.create_recipe(name="Test", user=self.build_user, repo=self.repo)
test1 = utils.create_recipe(name="Test1", user=self.build_user, repo=self.repo)
test.depends_on.add(pre)
test1.depends_on.add(pre)
merge = utils.create_recipe(name="Merge", user=self.build_user, repo=self.repo)
merge.depends_on.add(test)
merge.depends_on.add(test1)
pr = utils.create_pr(title="{a, b} & <c> … somereallylongwordthatshouldgettruncated", repo=self.repo)
pr.username = '******'
pr.save()
for commit in ['1234', '2345', '3456']:
e = utils.create_event(user=self.owner, commit1=commit, branch1=self.branch, branch2=self.branch)
e.pull_request = pr
e.description = "some description"
e.save()
j = utils.create_job(recipe=pre, event=e, user=self.build_user)
j.seconds = datetime.timedelta(seconds=10)
j.failed_step = 'failed step'
j.running_step = '3/5'
j.save()
utils.create_job(recipe=test, event=e, user=self.build_user)
utils.create_job(recipe=test1, event=e, user=self.build_user)
utils.create_job(recipe=merge, event=e, user=self.build_user)
self.compare_counts(recipes=4,
deps=4,
current=4,
jobs=12,
active=12,
num_pr_recipes=4,
events=3,
users=2,
repos=1,
branches=1,
commits=3,
prs=1)
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))
def test_close_pr(self):
user = utils.get_test_user(server=self.server)
repo = utils.create_repo(user=user)
pr = utils.create_pr(repo=repo, number=1)
pr.closed = False
pr.save()
views.close_pr('foo', 'bar', 1, user.server)
pr.refresh_from_db()
self.assertFalse(pr.closed)
views.close_pr(user.name, 'bar', 1, user.server)
pr.refresh_from_db()
self.assertFalse(pr.closed)
views.close_pr(user.name, repo.name, 0, user.server)
pr.refresh_from_db()
self.assertFalse(pr.closed)
views.close_pr(user.name, repo.name, 1, user.server)
pr.refresh_from_db()
self.assertTrue(pr.closed)
def test_get_user_repos_info(self):
request = self.factory.get('/')
request.session = self.client.session
repos = []
for i in range(3):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.save()
branch = utils.create_branch(name="branch0", user=repo.user, repo=repo)
branch.status = models.JobStatus.SUCCESS
branch.save()
ev = utils.create_event(branch1=branch, branch2=branch, user=repo.user)
utils.create_job(event=ev, user=repo.user)
repos.append(repo)
# user not logged in
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
# user not logged in, default enforced
request = self.factory.get('/?default')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertTrue(default)
request = self.factory.get('/')
user = repos[0].user
utils.simulate_login(self.client.session, user)
request.session = self.client.session
# user is logged in but no prefs set
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
# user is logged in, add repos to prefs
for i in range(3):
user.preferred_repos.add(repos[i])
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), i+1)
self.assertEqual(len(evinfo), i+1)
self.assertFalse(default)
# user has one pref but default is enforced
user.preferred_repos.clear()
user.preferred_repos.add(repos[0])
request = self.factory.get('/?default')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertTrue(default)
with self.settings(INSTALLED_GITSERVERS=[utils.github_config(hostname="server_does_not_exist")]):
user.preferred_repos.clear()
user.preferred_repos.add(repos[0])
request = self.factory.get('/')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
