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_invalidate(self, mock_collab):
# only post is allowed
url = reverse('ci:invalidate', args=[1000])
self.set_counts()
response = self.client.get(url)
self.assertEqual(response.status_code, 405) # not allowed
self.compare_counts()
# invalid job
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # not found
self.compare_counts()
# can't invalidate
step_result = utils.create_step_result()
job = step_result.job
job.event.pull_request = utils.create_pr()
job.event.comments_url = "some url"
job.event.save()
mock_collab.return_value = False
url = reverse('ci:invalidate', args=[job.pk])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 403) # forbidden
self.compare_counts()
# valid
client = utils.create_client()
job.client = client
job.save()
post_data = {"post_to_pr": "on",
"comment": "some comment",
"same_client": None,
}
mock_collab.return_value = True
self.set_counts()
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(ready=1, invalidated=1, num_changelog=1)
job.refresh_from_db()
redir_url = reverse('ci:view_job', args=[job.pk])
self.assertRedirects(response, redir_url)
self.check_job_invalidated(job)
post_data["same_client"] = "on"
utils.create_step_result(job=job)
job.client = client
job.save()
self.set_counts()
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(num_changelog=1)
job.refresh_from_db()
self.assertRedirects(response, redir_url)
self.check_job_invalidated(job, True, client)
def test_set_passed(self):
result = utils.create_step_result()
result.save()
context = {}
start = (TimeUtils.get_local_time() -
datetime.timedelta(days=1)).replace(hour=0, minute=0)
bins = Stats.get_bins(start, datetime.timedelta(days=1))
p = Stats.set_passed(start, "day",
"Passed tests in last 6 months, by day", context,
"month_chart", "%m/%d", bins)
# no models.JobTestStatistics records
for j in p[1:]:
self.assertEqual(j[1], 0)
self.assertIn("month_chart", context)
context = {}
models.JobTestStatistics.objects.create(job=result.job,
passed=20,
skipped=30,
failed=40)
p = Stats.set_passed(start, "day",
"Passed tests in last 6 months, by day", context,
"month_chart", "%m/%d", bins)
self.assertNotEqual(context, {})
self.assertEqual(len(p), 3)
self.assertEqual(p[2][1], 20)
self.assertIn("month_chart", context)
def test_num_tests(self):
result = utils.create_step_result()
models.JobTestStatistics.objects.create(job=result.job,
passed=20,
skipped=30,
failed=40)
response = self.client.get(reverse('ci:num_tests'))
self.assertEqual(response.status_code, 200)
def create_running_job(self):
user = utils.get_test_user()
job = utils.create_job(user=user)
result = utils.create_step_result(job=job)
client = utils.create_client()
job.client = client
job.event.cause = models.Event.PULL_REQUEST
job.status = models.JobStatus.RUNNING
job.save()
return job, result
def test_create_event_summary(self, mock_get, mock_post):
mock_get.return_value = utils.Response()
mock_post.return_value = utils.Response()
ev = utils.create_event()
ev.comments_url = 'url'
ev.save()
j0 = utils.create_job(event=ev)
config = utils.create_build_config("config1")
j0.recipe.build_configs.add(config)
utils.create_job(event=ev, recipe=j0.recipe, config=config)
r1 = utils.create_recipe(name="r1")
j1 = utils.create_job(recipe=r1, event=ev)
j0.recipe.depends_on.add(r1)
with self.settings(INSTALLED_GITSERVERS=[
utils.github_config(post_event_summary=False,
remote_update=True)
]):
# Not posting the summary so we should not do anything
UpdateRemoteStatus.create_event_summary(ev)
self.assertEqual(mock_post.call_count, 0)
self.assertEqual(mock_get.call_count, 0)
with self.settings(INSTALLED_GITSERVERS=[
utils.github_config(post_event_summary=True,
remote_update=True)
]):
# Configured to post the summary
UpdateRemoteStatus.create_event_summary(ev)
self.assertEqual(mock_post.call_count, 1) # 1 for adding comment
self.assertEqual(mock_get.call_count,
1) # 1 for getting current comments
utils.update_job(j1,
status=models.JobStatus.FAILED,
complete=True,
invalidated=True)
utils.create_step_result(job=j1, status=models.JobStatus.FAILED)
self.assertEqual(len(ev.get_unrunnable_jobs()), 2)
UpdateRemoteStatus.create_event_summary(ev)
self.assertEqual(mock_post.call_count, 2)
self.assertEqual(mock_get.call_count, 2)
def create_step_result(self, output):
result = utils.create_step_result()
result.output = output
result.save()
ev = result.job.event
ev.pull_request = utils.create_pr()
ev.pull_request.review_comments_url = "review_comments"
ev.pull_request.save()
ev.comments_url = "url"
ev.save()
return result
def check_output(self, output, os_name, os_version, os_other, mods):
user = utils.get_test_user()
job = utils.create_job(user=user)
step_result = utils.create_step_result(job=job)
step_result.output = output
step_result.save()
client = utils.create_client()
job.client = client
job.save()
ParseOutput.set_job_info(job)
job.refresh_from_db()
self.assertEqual(job.operating_system.name, os_name)
self.assertEqual(job.operating_system.version, os_version)
self.assertEqual(job.operating_system.other, os_other)
self.check_modules(job, mods)
def test_set_job_stats(self):
job = utils.create_job()
ParseOutput.set_job_stats(job)
self.assertEqual(models.JobTestStatistics.objects.count(), 0)
step_result = utils.create_step_result(job=job)
ParseOutput.set_job_stats(job)
self.assertEqual(models.JobTestStatistics.objects.count(), 0)
step_result.output = "foo\n\33[1m\33[32m123 passed\33[0m, \33[1m456 skipped\33[0m, \33[1m0 pending\33[0m, \33[1m789 failed\33[0m"
step_result.save()
ParseOutput.set_job_stats(job)
self.assertEqual(models.JobTestStatistics.objects.count(), 1)
js = models.JobTestStatistics.objects.first()
self.assertEqual(js.passed, 123)
self.assertEqual(js.skipped, 456)
self.assertEqual(js.failed, 789)
def test_cancel_job(self, mock_collab):
# only post is allowed
url = reverse('ci:cancel_job', args=[1000])
self.set_counts()
response = self.client.get(url)
self.assertEqual(response.status_code, 405) # not allowed
self.compare_counts()
# invalid job
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # not found
self.compare_counts()
# can't cancel
step_result = utils.create_step_result()
job = step_result.job
mock_collab.return_value = False
self.set_counts()
url = reverse('ci:cancel_job', args=[job.pk])
response = self.client.post(url)
self.assertEqual(response.status_code, 403) # forbidden
self.compare_counts()
# valid
mock_collab.return_value = True
post_data = {"post_to_pr": "on",
"comment": "some comment"
}
self.set_counts()
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(canceled=1,
events_canceled=1,
num_events_completed=1,
num_jobs_completed=1,
num_changelog=1,
active_branches=1)
job = models.Job.objects.get(pk=job.pk)
job_url = reverse('ci:view_job', args=[job.pk])
self.assertRedirects(response, job_url)
self.assertEqual(job.status, models.JobStatus.CANCELED)
self.assertEqual(job.event.base.branch.status, models.JobStatus.CANCELED)
def test_cancel_event(self, mock_collab):
# only post is allowed
url = reverse('ci:cancel_event', args=[1000])
self.set_counts()
response = self.client.get(url)
self.assertEqual(response.status_code, 405) # not allowed
self.compare_counts()
# invalid event
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # not found
self.compare_counts()
# can't cancel
step_result = utils.create_step_result()
job = step_result.job
job.event.pull_request = utils.create_pr()
job.event.comments_url = "some url"
job.event.save()
mock_collab.return_value = False
url = reverse('ci:cancel_event', args=[job.event.pk])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 302) # redirect with error message
self.compare_counts()
# valid
mock_collab.return_value = True
post_data = {"post_to_pr": "on",
"comment": "some comment"
}
self.set_counts()
response = self.client.post(url, post_data)
self.compare_counts(canceled=1, events_canceled=1, num_events_completed=1, num_jobs_completed=1, num_changelog=1)
self.assertEqual(response.status_code, 302) #redirect
ev_url = reverse('ci:view_event', args=[job.event.pk])
self.assertRedirects(response, ev_url)
job = models.Job.objects.get(pk=job.pk)
self.assertEqual(job.status, models.JobStatus.CANCELED)
self.assertEqual(job.event.status, models.JobStatus.CANCELED)
def test_job_finished_unrunnable(self, mock_status):
user = utils.get_test_user()
r0 = utils.create_recipe(name='recipe0', user=user)
r1 = utils.create_recipe(name='recipe1', user=user)
r2 = utils.create_recipe(name='recipe2', user=user)
r2.depends_on.add(r1)
r1.depends_on.add(r0)
j0 = utils.create_job(user=user, recipe=r0)
utils.create_job(user=user, recipe=r1)
utils.create_job(user=user, recipe=r2)
post_data = {'seconds': 0, 'complete': True}
client = utils.create_client()
j0.client = client
j0.save()
step_result = utils.create_step_result(job=j0)
step_result.status = models.JobStatus.FAILED
step_result.save()
# should be ok
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, j0.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts(num_events_completed=1,
num_jobs_completed=1,
active_branches=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(
mock_status.call_count,
3) # 1 for the job complete update and 2 for the won't run update
step_result.status = models.JobStatus.SUCCESS
step_result.save()
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts(ready=1)
self.assertEqual(response.status_code, 200)
self.assertEqual(mock_status.call_count,
4) # 1 for the job complete update
def test_get_result_output(self, mock_is_collaborator):
mock_is_collaborator.return_value = False
url = reverse('ci:ajax:get_result_output')
# no parameters
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
result = utils.create_step_result()
result.output = 'output'
result.save()
result.job.recipe.private = False
result.job.recipe.save()
data = {'result_id': result.pk}
# should be ok since recipe isn't private
response = self.client.get(url, data)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertIn(result.output, json_data["contents"])
result.job.recipe.private = True
result.job.recipe.save()
# recipe is private and not signed in, shouldn't see it
response = self.client.get(url, data)
self.assertEqual(response.status_code, 403)
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
# recipe is private, not a collaborator
response = self.client.get(url, data)
self.assertEqual(response.status_code, 403)
mock_is_collaborator.return_value = True
# recipe is private, but a collaborator
response = self.client.get(url, data)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertIn(result.output, json_data["contents"])
def test_get_job_results(self):
# bad pk
url = reverse('ci:job_results', args=[1000])
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
user = utils.get_test_user()
job = utils.create_job(user=user)
step = utils.create_step(recipe=job.recipe, filename='common/1.sh')
sr = utils.create_step_result(job=job, step=step)
sr.output = "some output"
sr.save()
utils.create_step_environment(step=step)
url = reverse('ci:job_results', args=[job.pk])
response = self.client.get(url)
# owner doesn't have permission
self.assertEqual(response.status_code, 403)
# logged in, should get the results
utils.simulate_login(self.client.session, user)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_step_start_pr_status(self, mock_post):
user = utils.get_test_user()
job = utils.create_job(user=user)
utils.update_job(job, status=models.JobStatus.CANCELED)
results = utils.create_step_result(job=job)
results.exit_status = 1
results.save()
job.event.cause = models.Event.PUSH
job.event.save()
with self.settings(
INSTALLED_GITSERVERS=[utils.github_config(
remote_update=True)]):
# Wrong cause
UpdateRemoteStatus.step_start_pr_status(results, job)
self.assertEqual(mock_post.call_count, 0)
job.event.cause = models.Event.PULL_REQUEST
job.event.save()
# OK
UpdateRemoteStatus.step_start_pr_status(results, job)
self.assertEqual(mock_post.call_count, 1)
def test_job_finished_status(self):
user = utils.get_test_user()
recipe = utils.create_recipe(user=user)
job = utils.create_job(recipe=recipe, user=user)
step0 = utils.create_step(name='step0', recipe=recipe)
step1 = utils.create_step(name='step1', recipe=recipe, position=1)
step0_result = utils.create_step_result(step=step0, job=job)
step1_result = utils.create_step_result(step=step1, job=job)
step0_result.status = models.JobStatus.FAILED_OK
step0_result.save()
step1_result.status = models.JobStatus.SUCCESS
step1_result.save()
client = utils.create_client()
job.client = client
job.save()
job.event.comments_url = 'http://localhost'
job.event.pull_request = utils.create_pr()
job.event.save()
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, job.pk])
# A step has FAILED_OK
# So final status is FAILED_OK and we update the PR
post_data = {'seconds': 0, 'complete': True}
with patch('ci.github.api.GitHubAPI') as mock_api:
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts(num_events_completed=1, num_jobs_completed=1)
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_api.called)
self.assertTrue(mock_api.return_value.update_pr_status.called)
job.refresh_from_db()
self.assertEqual(job.status, models.JobStatus.FAILED_OK)
os_obj = models.OSVersion.objects.get(name="Other")
self.assertEqual(job.operating_system.pk, os_obj.pk)
self.assertEqual(job.loaded_modules.count(), 1)
self.assertEqual(job.loaded_modules.first().name, "None")
# A step FAILED
# So final status is FAILED and we update the PR
step0_result.status = models.JobStatus.FAILED
step0_result.save()
with patch('ci.github.api.GitHubAPI') as mock_api:
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_api.called)
self.assertTrue(mock_api.return_value.update_pr_status.called)
job.refresh_from_db()
self.assertEqual(job.status, models.JobStatus.FAILED)
step0_result.status = models.JobStatus.SUCCESS
step0_result.save()
# All steps passed
# So final status is SUCCESS and we update the PR
with patch('ci.github.api.GitHubAPI') as mock_api:
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_api.called)
self.assertTrue(mock_api.return_value.update_pr_status.called)
job.refresh_from_db()
self.assertEqual(job.status, models.JobStatus.SUCCESS)
step0_result.status = models.JobStatus.FAILED
step0_result.save()
# A step FAILED
# So final status is FAILED and we update the PR
with patch('ci.github.api.GitHubAPI') as mock_api:
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertTrue(mock_api.called)
self.assertTrue(mock_api.return_value.update_pr_status.called)
job.refresh_from_db()
self.assertEqual(job.status, models.JobStatus.FAILED)
def test_start_step_result(self):
user = utils.get_test_user()
job = utils.create_job(user=user)
result = utils.create_step_result(job=job)
client = utils.create_client()
client2 = utils.create_client(name='other_client')
job.client = client
job.event.cause = models.Event.PULL_REQUEST
job.event.pr = utils.create_pr()
job.event.save()
job.save()
post_data = {
'step_num': result.position,
'output': 'output',
'time': 5,
'complete': True,
'exit_status': 0
}
url = reverse('ci:client:start_step_result',
args=[user.build_key, client.name, result.pk])
# only post allowed
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 405) # not allowed
# bad step result
url = reverse('ci:client:start_step_result',
args=[user.build_key, client.name, 0])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# unknown client
url = reverse('ci:client:start_step_result',
args=[user.build_key, 'unknown_client', result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# bad client
url = reverse('ci:client:start_step_result',
args=[user.build_key, client2.name, result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# ok
url = reverse('ci:client:start_step_result',
args=[user.build_key, client.name, result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
result.refresh_from_db()
self.assertEqual(result.status, models.JobStatus.RUNNING)
data = response.json()
self.assertEqual(data["command"], None)
self.assertEqual(data["status"], "OK")
# If a job got canceled, make sure it sends the command to the client
job.status = models.JobStatus.CANCELED
job.save()
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
result.refresh_from_db()
self.assertEqual(result.status, models.JobStatus.CANCELED)
data = response.json()
self.assertEqual(data["command"], "cancel")
self.assertEqual(data["status"], "OK")
def test_update_step_result(self):
user = utils.get_test_user()
job = utils.create_job(user=user)
result = utils.create_step_result(job=job)
client = utils.create_client()
client2 = utils.create_client(name='other_client')
job.client = client
job.event.cause = models.Event.PULL_REQUEST
job.status = models.JobStatus.RUNNING
job.save()
post_data = {
'step_num': result.position,
'output': 'output',
'time': 5,
'complete': True,
'exit_status': 0
}
url = reverse('ci:client:update_step_result',
args=[user.build_key, client.name, result.pk])
# only post allowed
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 405) # not allowed
# bad step result
url = reverse('ci:client:update_step_result',
args=[user.build_key, client.name, 0])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# unknown client
url = reverse('ci:client:update_step_result',
args=[user.build_key, 'unknown_client', result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# bad client
url = reverse('ci:client:update_step_result',
args=[user.build_key, client2.name, result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# ok
url = reverse('ci:client:update_step_result',
args=[user.build_key, client.name, result.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertEqual(data["status"], "OK")
self.assertEqual(data["command"], None)
result.refresh_from_db()
self.assertEqual(result.status, models.JobStatus.RUNNING)
# test when the user invalidates a job while it is running
job.status = models.JobStatus.NOT_STARTED
job.save()
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
result.refresh_from_db()
data = response.json()
self.assertEqual(result.status, models.JobStatus.NOT_STARTED)
self.assertEqual(data["status"], "OK")
self.assertEqual(data["command"], "cancel")
# test when the user cancel a job while it is running
job.status = models.JobStatus.CANCELED
job.save()
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
result.refresh_from_db()
data = response.json()
self.assertEqual(result.status, models.JobStatus.CANCELED)
self.assertEqual(data["status"], "OK")
self.assertEqual(data["command"], "cancel")
# a step exited with nonzero, make sure we don't do the
# next step
job.status = models.JobStatus.RUNNING
job.save()
post_data['exit_status'] = 1
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 200)
result.refresh_from_db()
self.assertEqual(result.exit_status, 1)
self.assertEqual(result.status, models.JobStatus.RUNNING)
def test_job_results(self, mock_allowed, mock_is_collaborator):
mock_is_collaborator.return_value = False
mock_allowed.return_value = True
url = reverse('ci:ajax:job_results')
# no parameters
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
client = utils.create_client()
step_result = utils.create_step_result()
step_result.complete = True
step_result.save()
step_result.job.save()
data = {'last_request': 10, 'job_id': 0}
# not signed in, not a collaborator
response = self.client.get(url, data)
self.assertEqual(response.status_code, 404)
data['job_id'] = step_result.job.pk
recipe = step_result.job.recipe
recipe.private = True
recipe.save()
# not signed in, not a collaborator on a private recipe
response = self.client.get(url, data)
self.assertEqual(response.status_code, 403)
recipe.private = False
recipe.save()
# recipe no longer private, should work
response = self.client.get(url, data)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertEqual(json_data['job_info']['client_name'], '')
self.assertEqual(json_data['job_info']['client_url'], '')
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
mock_is_collaborator.return_value = True
recipe.private = True
recipe.save()
job = step_result.job
job.client = client
job.save()
# should work now
response = self.client.get(url, data)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertIn('job_info', json_data)
self.assertIn('results', json_data)
self.assertEqual(step_result.job.pk, json_data['job_info']['id'])
self.assertEqual(step_result.pk, json_data['results'][0]['id'])
self.assertEqual(json_data['job_info']['client_name'], client.name)
# should work now but return no results since nothing has changed
data['last_request'] = json_data['last_request'] + 10
response = self.client.get(url, data)
self.assertEqual(response.status_code, 200)
json_data = response.json()
self.assertIn('job_info', json_data)
self.assertIn('results', json_data)
# job_info is always returned
self.assertNotEqual('', json_data['job_info'])
self.assertEqual([], json_data['results'])
self.assertEqual(json_data['job_info']['client_name'], '')
def test_invalidate_event(self, mock_collab):
# only post is allowed
url = reverse('ci:invalidate_event', args=[1000])
self.set_counts()
response = self.client.get(url)
self.assertEqual(response.status_code, 405) # not allowed
self.compare_counts()
# invalid event
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 404) # not found
self.compare_counts()
# can't invalidate
j0, j1, j2, j3 = utils.create_test_jobs()
mock_collab.return_value = False
url = reverse('ci:invalidate_event', args=[j0.event.pk])
self.set_counts()
response = self.client.post(url)
self.assertEqual(response.status_code, 302) # redirect with error message
self.compare_counts()
client = utils.create_client()
for j in [j0, j1, j2, j3]:
j.client = client
j.ready = True
j.complete = True
j.status = models.JobStatus.SUCCESS
j.event.complete = False
j.save()
# valid
post_data = {'same_client': None}
mock_collab.return_value = True
self.set_counts()
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(ready=-3, num_jobs_completed=-4, invalidated=4, num_changelog=4)
redir_url = reverse('ci:view_event', args=[j0.event.pk])
for j in [j0, j1, j2, j3]:
j.refresh_from_db()
self.assertRedirects(response, redir_url)
self.assertEqual(j.step_results.count(), 0)
self.assertFalse(j.complete)
self.assertTrue(j.active)
self.assertTrue(j.invalidated)
self.assertFalse(j.same_client)
self.assertEqual(j.client, None)
self.assertEqual(j.seconds.seconds, 0)
self.assertEqual(j.status, models.JobStatus.NOT_STARTED)
self.assertFalse(j.event.complete)
self.assertEqual(j.event.status, models.JobStatus.NOT_STARTED)
self.assertTrue(j0.ready)
self.assertFalse(j1.ready)
self.assertFalse(j2.ready)
self.assertFalse(j3.ready)
# valid
for j in [j0, j1, j2, j3]:
j.client = client
j.ready = True
j.complete = True
j.status = models.JobStatus.SUCCESS
j.event.complete = False
j.save()
utils.create_step_result(job=j)
post_data = {'same_client': 'on'}
self.set_counts()
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(num_changelog=4, ready=-3, num_jobs_completed=-4)
for j in [j0, j1, j2, j3]:
j.refresh_from_db()
self.assertRedirects(response, redir_url)
self.assertEqual(j.step_results.count(), 0)
self.assertFalse(j.complete)
self.assertTrue(j.active)
self.assertTrue(j.invalidated)
self.assertTrue(j.same_client)
self.assertEqual(j.client, client)
self.assertEqual(j.seconds.seconds, 0)
self.assertEqual(j.status, models.JobStatus.NOT_STARTED)
self.assertFalse(j.event.complete)
self.assertEqual(j.event.status, models.JobStatus.NOT_STARTED)
self.assertTrue(j0.ready)
self.assertFalse(j1.ready)
self.assertFalse(j2.ready)
self.assertFalse(j3.ready)
post_data["comment"] = "some comment"
post_data["post_to_pr"] = "on"
self.set_counts()
response = self.client.post(url, data=post_data)
self.assertEqual(response.status_code, 302) #redirect
self.compare_counts(num_changelog=4)
# Make sure when the first job completes the other
# jobs will become ready
j0.complete = True
j0.status = models.JobStatus.SUCCESS
j0.save()
self.set_counts()
j0.event.make_jobs_ready()
self.compare_counts(ready=2)
self.assertFalse(j0.event.check_done())
def test_job_finished(self):
user = utils.get_test_user()
job = utils.create_job(user=user)
step_result = utils.create_step_result(job=job)
step_result.output = self.get_file("ubuntu_gcc_output.txt")
step_result.save()
client = utils.create_client()
client2 = utils.create_client(name='other_client')
job.client = client
job.save()
job.event.comments_url = 'http://localhost'
job.event.save()
post_data = {'seconds': 0, 'complete': True}
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, job.pk])
# only post allowed
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 405) # not allowed
# bad url
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, 0])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# unknown client
url = reverse('ci:client:job_finished',
args=[user.build_key, 'unknown_client', job.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# bad client
url = reverse('ci:client:job_finished',
args=[user.build_key, client2.name, job.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts()
self.assertEqual(response.status_code, 400) # bad request
# should be ok
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, job.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts(num_events_completed=1, num_jobs_completed=1)
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertIn('message', data)
self.assertEqual(data['status'], 'OK')
job.refresh_from_db()
self.assertTrue(job.complete)
self.assertEqual(job.operating_system.name, "Ubuntu")
self.assertEqual(job.operating_system.version, "14.04")
self.assertEqual(job.operating_system.other, "trusty")
self.check_modules(job, [
'moose/.gcc_4.9.1',
'moose/.tbb',
'moose/.mpich-3.1.2_gcc',
'moose/.mpich_petsc-3.6.3-gcc-superlu',
'moose-tools',
'moose/.ccache',
'moose/.vtk-6',
'moose-dev-gcc',
])
job2 = utils.create_job(event=job.event)
job2.ready = False
job2.complete = False
job2.status = models.JobStatus.NOT_STARTED
job2.active = True
job2.save()
# should be ok. Make sure jobs get ready after one is finished.
url = reverse('ci:client:job_finished',
args=[user.build_key, client.name, job.pk])
self.set_counts()
response = self.client_post_json(url, post_data)
self.compare_counts(ready=1)
self.assertEqual(response.status_code, 200)
data = response.json()
self.assertIn('message', data)
self.assertEqual(data['status'], 'OK')
job2 = models.Job.objects.get(pk=job2.pk)
self.assertTrue(job2.ready)
