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)