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_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_repo_branches_status(self):
# bad repo
url = reverse('ci:ajax:repo_branches_status', args=["foo", "bar"])
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# branch not active
branch = utils.create_branch()
url = reverse(
'ci:ajax:repo_branches_status',
args=[branch.repository.user.name, branch.repository.name])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertEqual(len(json_data["branches"]), 0)
# should be OK
branch.status = models.JobStatus.RUNNING
branch.save()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertEqual(len(json_data["branches"]), 1)
self.assertEqual(json_data["branches"][0]["name"], branch.name)
self.assertEqual(json_data["branches"][0]["status"],
branch.status_slug())
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 test_view_repo_branch(self):
# invalid branch
response = self.client.get(reverse('ci:view_repo_branch', args=["owner", "repo", "branch"]))
self.assertEqual(response.status_code, 404)
# Valid
b = utils.create_branch()
response = self.client.get(reverse('ci:view_repo_branch', args=[b.repository.user.name, b.repository.name, b.name]))
self.assertEqual(response.status_code, 200)
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_bad_branch(self):
other_branch = utils.create_branch(name="foo", user=self.build_user)
manual = self.create_data(branch=other_branch)
# Make sure if there is a manual event and there are no recipes for the branch
# we don't leave anything around
# This shouldn't create an event or any jobs.
self.set_counts()
manual.save()
self.compare_counts()
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_view_branch(self):
response = self.client.get(reverse('ci:view_branch', args=[1000,]))
self.assertEqual(response.status_code, 404)
obj = utils.create_branch()
response = self.client.get(reverse('ci:view_branch', args=[obj.pk]))
self.assertEqual(response.status_code, 200)
args = {"do_filter": 1, "filter_events": [models.Event.PULL_REQUEST]}
response = self.client.get(reverse('ci:view_branch', args=[obj.pk]), args)
self.assertEqual(response.status_code, 200)
# POST not allowed
response = self.client.post(reverse('ci:view_branch', args=[obj.pk]), args)
self.assertEqual(response.status_code, 405)
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, 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 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 test_new_branch(self):
repo, branch = self.create_repo_with_prs()
self.get()
self.check_repos()
self.check_events()
self.wait_for_js()
branch2 = utils.create_branch(name="branch2", repo=repo)
branch2.status = models.JobStatus.SUCCESS
branch2.save()
self.wait_for_js()
self.check_js_error()
self.check_repos()
self.check_events()
def test_last_sha(self, mock_get):
branch = utils.create_branch(user=self.user)
mock_get.return_value = utils.Response(
json_data={branch.name: {
'raw_node': '123'
}})
sha = self.gapi.last_sha(self.user.name, branch.repository.name,
branch.name)
self.assertEqual(sha, '123')
mock_get.return_value = utils.Response({})
sha = self.gapi.last_sha(self.user.name, branch.repository.name,
branch.name)
self.assertEqual(sha, None)
mock_get.side_effect = Exception("Bam!")
sha = self.gapi.last_sha(self.user.name, branch.repository.name,
branch.name)
self.assertEqual(sha, None)
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_branch_status(self):
# only GET allowed
url = reverse('ci:branch_status', args=[1000])
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
# bad pk
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# Not active
branch = utils.create_branch()
url = reverse('ci:branch_status', args=[branch.pk])
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# OK
branch.status = models.JobStatus.SUCCESS
branch.save()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response["Content-Type"], "image/svg+xml")
def test_repo_branch_status(self):
# only GET allowed
args = ["owner", "repo", "branch"]
url = reverse('ci:repo_branch_status', args=args)
response = self.client.post(url)
self.assertEqual(response.status_code, 405)
# bad branch
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# Not active
branch = utils.create_branch()
args = [branch.repository.user.name, branch.repository.name, branch.name]
url = reverse('ci:repo_branch_status', args=args)
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
# OK
branch.status = models.JobStatus.SUCCESS
branch.save()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response["Content-Type"], "image/svg+xml")
def test_manual(self, mock_get, user_mock):
get_data = {"commit": {"sha": "1234"}}
mock_get.return_value = utils.Response(get_data)
self.set_counts()
response = self.client.get(reverse('ci:manual_branch', args=[1000,1000]))
# only post allowed
self.assertEqual(response.status_code, 405)
self.compare_counts()
other_branch = utils.create_branch(name="other", repo=self.repo)
# no recipes for that branch
user_mock.return_value = self.build_user.server.auth().start_session_for_user(self.build_user)
url = reverse('ci:manual_branch', args=[self.build_user.build_key, other_branch.pk])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Success')
self.compare_counts()
# branch exists, but no jobs matching label
url = reverse('ci:manual_branch', args=[self.build_user.build_key, self.branch.pk, "some_label"])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Success')
self.compare_counts()
# branch exists, jobs will get created
url = reverse('ci:manual_branch', args=[self.build_user.build_key, self.branch.pk])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Success')
self.compare_counts(jobs=1, events=1, ready=1, commits=1, active=1, active_repos=1)
ev = models.Event.objects.first()
self.assertTrue(ev.update_branch_status)
# Make sure the redirect works
response = self.client.post( url, {'next': reverse('ci:main'), })
self.assertEqual(response.status_code, 302) # redirect
# Nothing should happen
self.set_counts()
response = self.client.post( url)
self.assertEqual(response.status_code, 200)
self.compare_counts()
# Nothing should happen
self.set_counts()
response = self.client.post( url, {'force': 0, })
self.assertEqual(response.status_code, 200)
self.compare_counts()
# We are forcing a new run. A duplicate event should be created
self.set_counts()
response = self.client.post( url, {'force': 1, 'update_branch_status': 0})
self.assertEqual(response.status_code, 200)
self.compare_counts(jobs=1, events=1, ready=1, active=1)
ev = models.Event.objects.first()
self.assertEqual(ev.duplicates, 1)
self.assertFalse(ev.update_branch_status)
mock_get.return_value = utils.Response(status_code=404)
self.set_counts()
response = self.client.post(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
user_mock.side_effect = Exception("Boom!")
self.set_counts()
response = self.client.post(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Error')
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)
