def test_removed(self): test_utils.create_git_server() with test_utils.RecipeDir() as recipes_dir: self.create_valid_with_check(recipes_dir) self.remove_recipe_from_repo(recipes_dir, "alt.cfg") self.set_counts() self.check_load_recipes(recipes_dir, removed=1) self.compare_counts( sha_changed=True, recipes=-1, deps=-1, current=-1, num_pr_alt_recipes=-1, num_steps=-1, num_step_envs=-4, num_recipe_envs=-1, num_prestep=-2, ) # change a recipe but now the old ones have jobs attached. # so 1 new recipe should be added build_user = models.GitUser.objects.get(name="moosebuild") for r in models.Recipe.objects.all(): test_utils.create_job(recipe=r, user=build_user) self.remove_recipe_from_repo(recipes_dir, "all.cfg") self.set_counts() self.check_load_recipes(recipes_dir, removed=1) self.compare_counts(sha_changed=True, current=-4)
def create_event_with_jobs(self, commit='1234', user=None, branch1=None, branch2=None, cause=models.Event.PULL_REQUEST): ev = utils.create_event(commit2=commit, user=user, branch1=branch1, branch2=branch2, cause=cause) ev.base.branch.repository.active = True ev.base.branch.repository.save() alt_recipe = utils.create_recipe( name="alt recipe", cause=models.Recipe.CAUSE_PULL_REQUEST_ALT) utils.create_step(name="step0_alt", recipe=alt_recipe, position=0) utils.create_step(name="step1_alt", recipe=alt_recipe, position=1) if cause == models.Event.PULL_REQUEST: pr = utils.create_pr(title="Foo {a, b} & <bar> …") pr.alternate_recipes.add(alt_recipe) ev.pull_request = pr ev.save() r0 = utils.create_recipe(name="r0", cause=cause) utils.create_step(name="step1_r0", recipe=r0, position=1) utils.create_step(name="step2_r0", recipe=r0, position=2) r1 = utils.create_recipe(name="r1", cause=cause) utils.create_step(name="step1_r1", recipe=r1, position=1) utils.create_step(name="step2_r1", recipe=r1, position=2) r1.depends_on.add(r1) utils.create_job(event=ev, recipe=r0) utils.create_job(event=ev, recipe=r1) return ev
def test_event_new_job(self): self.create_event_with_jobs() self.get() self.check_repos() self.check_events() ev = models.Event.objects.first() r2 = utils.create_recipe(name="r2") ev.save() # to trigger the update utils.create_job(event=ev, recipe=r2) self.wait_for_js() self.check_js_error() self.check_repos() self.check_events()
def test_event_new_job(self): ev = self.create_event_with_jobs() url = reverse('ci:view_repo', args=[ev.base.branch.repository.pk]) self.get(url) self.check_repos() self.check_events() ev = models.Event.objects.first() r2 = utils.create_recipe(name="r2") ev.save() # to trigger the update utils.create_job(event=ev, recipe=r2) self.wait_for_js() self.check_js_error() self.check_repos() self.check_events()
def setUp(self): super(Tests, self).setUp() self.getter = JobGetter.JobGetter(self.client_info) self.job = test_utils.create_job() self.client_info["server"] = self.live_server_url self.client_info["build_key"] = self.job.event.build_user.build_key self.client_info["build_configs"] = [self.job.config.name]
def create_job_with_nested_bash(recipe_dir, name="TestJob", sleep=10): user = utils.get_test_user() recipe = utils.create_recipe(user=user, name=name) test_job = utils.create_job(user=user, recipe=recipe) test_job.ready = True test_job.client = None test_job.status = models.JobStatus.NOT_STARTED test_job.save() step = utils.create_step(name="step0", recipe=recipe, position=0) step.filename = "step0.sh" step.save() script_filename = os.path.join(recipe_dir, step.filename) sub_script_filename = os.path.join(recipe_dir, "step0_sub.sh") sub_sub_script_filename = os.path.join(recipe_dir, "step0_sub_sub.sh") with open(script_filename, "w") as f: f.write("#!/bin/bash\necho 'Launching {0}'\n{0}\necho '{0} returned '". format(sub_script_filename)) with open(sub_script_filename, "w") as f: f.write("#!/bin/bash\necho 'Launching {0}'\n{0}\necho '{0} returned'". format(sub_sub_script_filename)) import stat st = os.stat(sub_script_filename) os.chmod(sub_script_filename, st.st_mode | stat.S_IEXEC) with open(sub_sub_script_filename, "w") as f: f.write( "#!/bin/bash\necho 'Sleeping {0}...'\nsleep {0}\necho 'Finished sleeping'" .format(sleep)) st = os.stat(sub_sub_script_filename) os.chmod(sub_sub_script_filename, st.st_mode | stat.S_IEXEC) return test_job
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_client(self, mock_collab): job = utils.create_job() client = utils.create_client() client2 = utils.create_client(name="client2") mock_collab.return_value = True url = reverse('ci:invalidate', args=[job.pk]) post_data = {} 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) self.check_job_invalidated(job) job.client = client job.save() self.set_counts() post_data["client_list"] = client.pk response = self.client.post(url, data=post_data) self.assertEqual(response.status_code, 302) #redirect self.compare_counts(num_changelog=1) self.check_job_invalidated(job, True, client) self.set_counts() post_data["client_list"] = client2.pk response = self.client.post(url, data=post_data) self.assertEqual(response.status_code, 302) #redirect self.compare_counts(num_changelog=1) self.check_job_invalidated(job, True, client2) self.set_counts() post_data["client_list"] = 0 response = self.client.post(url, data=post_data) self.assertEqual(response.status_code, 302) #redirect self.compare_counts(num_changelog=1) self.check_job_invalidated(job, False)
def test_update_remote_job_status(self, mock_collab): mock_collab.return_value = False # bad job url = reverse('ci:client:update_remote_job_status', args=[1000]) response = self.client.get(url) self.assertEqual(response.status_code, 404) response = self.client.post(url) self.assertEqual(response.status_code, 404) j = utils.create_job() j.event.comments_url = 'url' j.event.save() url = reverse('ci:client:update_remote_job_status', args=[j.pk]) response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertContains(response, "not allowed") response = self.client.post(url) self.assertEqual(response.status_code, 405) mock_collab.return_value = True response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertNotContains(response, "not allowed") response = self.client.post(url) self.assertEqual(response.status_code, 302)
def test_add_comment(self, mock_post): j = utils.create_job() j.event.cause = models.Event.PUSH j.event.save() api = j.event.build_user.api() # wrong cause UpdateRemoteStatus.add_comment(api, j.event.build_user, j) self.assertEqual(mock_post.call_count, 0) j.event.cause = models.Event.PULL_REQUEST j.event.save() # no comments_url UpdateRemoteStatus.add_comment(api, j.event.build_user, j) self.assertEqual(mock_post.call_count, 0) j.event.comments_url = 'url' j.event.save() with self.settings(INSTALLED_GITSERVERS=[ utils.github_config(post_job_status=False, remote_update=True) ]): # not posting job status UpdateRemoteStatus.add_comment(api, j.event.build_user, j) self.assertEqual(mock_post.call_count, 0) self.assertEqual(api._errors, []) with self.settings(INSTALLED_GITSERVERS=[ utils.github_config(post_job_status=True, remote_update=True) ]): # OK api = j.event.build_user.api() UpdateRemoteStatus.add_comment(api, j.event.build_user, j) self.assertEqual(mock_post.call_count, 1)
def test_job_script(self, mock_collab): # bad pk mock_collab.return_value = False response = self.client.get(reverse('ci:job_script', args=[1000])) self.assertEqual(response.status_code, 404) with utils.RecipeDir(): user = utils.get_test_user() job = utils.create_job(user=user) job.recipe.build_user = user job.recipe.save() utils.create_prestepsource(recipe=job.recipe) utils.create_recipe_environment(recipe=job.recipe) step = utils.create_step(recipe=job.recipe, filename='scripts/1.sh') utils.create_step_environment(step=step) url = reverse('ci:job_script', args=[job.pk]) response = self.client.get(url) # owner doesn't have permission self.assertEqual(response.status_code, 404) mock_collab.return_value = True utils.simulate_login(self.client.session, user) response = self.client.get(url) self.assertEqual(response.status_code, 200) self.assertContains(response, job.recipe.name)
def test_cancel_event(self): ev = utils.create_event() jobs = [] for i in range(3): r = utils.create_recipe(name="recipe %s" % i, user=ev.build_user) j = utils.create_job(recipe=r, event=ev, user=ev.build_user) jobs.append(j) msg = "Test cancel" self.set_counts() event.cancel_event(ev, msg) # The status on the branch should get updated self.compare_counts(canceled=3, events_canceled=1, num_changelog=3, num_jobs_completed=3, num_events_completed=1, active_branches=1) ev.refresh_from_db() self.assertEqual(ev.status, models.JobStatus.CANCELED) self.assertEqual(ev.complete, True) for j in jobs: j.refresh_from_db() self.assertEqual(j.status, models.JobStatus.CANCELED) self.assertTrue(j.complete)
def test_repo_update(self): url = reverse('ci:ajax:repo_update') # no parameters response = self.client.get(url) self.assertEqual(response.status_code, 400) pr_open = utils.create_pr(title='Foo <type> & bar …', number=1) ev_open = utils.create_event() pr_open.closed = False pr_open.save() ev_open.pull_request = pr_open ev_open.save() pr_closed = utils.create_pr(title='closed_pr', number=2) pr_closed.closed = True pr_closed.save() ev_closed = utils.create_event(commit1='2345') ev_closed.pull_request = pr_closed ev_closed.save() pr_open.repository.active = True pr_open.repository.save() ev_branch = utils.create_event(commit1='1', commit2='2', cause=models.Event.PUSH) ev_branch.base.branch.status = models.JobStatus.RUNNING ev_branch.base.branch.save() recipe, depends_on = utils.create_recipe_dependency() utils.create_job(recipe=recipe) utils.create_job(recipe=depends_on) data = {'last_request': 10, 'limit': 30} # missing repo id response = self.client.get(url, data) self.assertEqual(response.status_code, 400) data["repo_id"] = pr_open.repository.pk response = self.client.get(url, data) self.assertEqual(response.status_code, 200) json_data = response.json() self.assertIn('repo_status', json_data) self.assertIn('closed', json_data) self.assertEqual(len(json_data['repo_status']), 1) self.assertEqual(len(json_data['repo_status'][0]['prs']), 1) self.assertIn(escape(pr_open.title), json_data['repo_status'][0]['prs'][0]['description']) self.assertEqual(pr_closed.pk, json_data['closed'][0]['id'])
def test_view_job(self): """ testing ci:view_job """ response = self.client.get(reverse('ci:view_job', args=[1000,])) self.assertEqual(response.status_code, 404) job = utils.create_job() response = self.client.get(reverse('ci:view_job', args=[job.pk])) self.assertEqual(response.status_code, 200)
def test_recipe_events(self): response = self.client.get(reverse('ci:recipe_events', args=[1000,])) self.assertEqual(response.status_code, 404) rc = utils.create_recipe() job1 = utils.create_job(recipe=rc) job1.status = models.JobStatus.SUCCESS job1.save() response = self.client.get(reverse('ci:recipe_events', args=[rc.pk])) 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 test_view_user(self): user = utils.create_user() url = reverse('ci:view_user', args=["no_exist"]) response = self.client.get(url) self.assertEqual(response.status_code, 404) url = reverse('ci:view_user', args=[user.name]) response = self.client.get(url) self.assertEqual(response.status_code, 200) ev = utils.create_event() pr = utils.create_pr() pr.closed = True pr.username = user.name pr.save() ev.pull_request = pr ev.save() utils.create_job(event=ev) response = self.client.get(url) self.assertEqual(response.status_code, 200)
def test_changed_recipe_with_jobs(self): with test_utils.RecipeDir() as recipes_dir: # start with valid recipes self.create_valid_with_check(recipes_dir) build_user = models.GitUser.objects.get(name="moosebuild") # change a recipe but now the old ones have jobs attached. # so 1 new recipe should be added for r in models.Recipe.objects.all(): test_utils.create_job(recipe=r, user=build_user) pr_recipe = self.find_recipe_dict("recipes/pr_dep.cfg") pr_recipe["priority_pull_request"] = 99 self.write_recipe_to_repo(recipes_dir, pr_recipe, "pr_dep.cfg") self.set_counts() self.check_load_recipes(recipes_dir, changed=1) self.compare_counts(sha_changed=True, recipes=1, num_pr_recipes=1, num_steps=1, num_step_envs=4, num_recipe_envs=1, num_prestep=2) q = models.Recipe.objects.filter(filename=pr_recipe["filename"]) self.assertEqual(q.count(), 2) q = q.filter(current=True) self.assertEqual(q.count(), 1) new_r = q.first() q = models.Recipe.objects.filter(filename=new_r.filename).exclude( pk=new_r.pk) self.assertEqual(q.count(), 1) old_r = q.first() self.assertNotEqual(old_r.filename_sha, new_r.filename_sha) self.assertEqual( models.Recipe.objects.filter( depends_on__in=[old_r.pk]).count(), 0) self.assertEqual( models.Recipe.objects.filter( depends_on__in=[new_r.pk]).count(), 2)
def handle(self, *args, **options): factory = RequestFactory() client = utils.create_client() job = utils.create_job() user = job.recipe.build_user orig_recipe_dir = settings.RECIPE_BASE_DIR recipe_dir = utils.create_recipe_dir() settings.RECIPE_BASE_DIR = recipe_dir try: args = [user.build_key, client.name] request = factory.get(reverse("ci:client:ready_jobs", args=args)) reply = views.ready_jobs(request, user.build_key, client.name) args = [user.build_key, job.config.name, client.name] claim_job_url = reverse("ci:client:claim_job", args=args) data = json.dumps({"job_id": job.pk}) request = factory.post(claim_job_url, data, content_type="application/json") reply = views.claim_job(request, user.build_key, job.config.name, client.name) if reply.status_code == 200: this_file = os.path.realpath(__file__) test_dir = os.path.join(os.path.dirname(this_file), "..", "..", "..", "client", "tests") fname = os.path.join(os.path.abspath(test_dir), "claim_response.json") # to makes diffs better, hardcode job and recipe ids data = json.loads(reply.content) data["job_id"] = 1 data["job_info"]["job_id"] = 1 data["job_info"]["environment"]["job_id"] = 1 data["job_info"]["environment"]["recipe_id"] = 1 data["job_info"]["environment"]["CIVET_JOB_ID"] = 1 data["job_info"]["environment"]["CIVET_RECIPE_ID"] = 1 self.stdout.write("Writing: %s" % fname) with open(fname, "w") as f: json.dump(data, f, indent=2, sort_keys=True) f.write("\n") else: self.stderr.write(reply.status_code) self.stderr.write(reply.content) except Exception as e: self.stderr.write(traceback.format_exc()) self.stderr.write("Error occurred: %s" % e) job.recipe.delete() shutil.rmtree(recipe_dir) settings.RECIPE_BASE_DIR = orig_recipe_dir settings.RECIPE_BASE_DIR = orig_recipe_dir
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 create_client_job(recipe_dir, name="TestJob", sleep=1, n_steps=3, extra_script=''): user = utils.get_test_user() recipe = utils.create_recipe(user=user, name=name) test_job = utils.create_job(user=user, recipe=recipe) test_job.ready = True test_job.client = None test_job.status = models.JobStatus.NOT_STARTED test_job.save() # create a prestep to make sure sourcing functions work prestep0 = utils.create_prestepsource( filename="prestep0_{}.sh".format(name), recipe=recipe) with open(os.path.join(recipe_dir, prestep0.filename), "w") as f: f.write('function start_message()\n{\n echo start "$*"\n}') # create a prestep to make sure sourcing functions work prestep1 = utils.create_prestepsource( filename="prestep1_{}.sh".format(name), recipe=recipe) with open(os.path.join(recipe_dir, prestep1.filename), "w") as f: f.write('function end_message()\n{\n echo end "$*"\n}') # create a global environment variable to test env works # as well as BUILD_ROOT replacement utils.create_recipe_environment(name="GLOBAL_NAME", value="BUILD_ROOT/global", recipe=recipe) count = 0 for s in [f"step{i}".format(i) for i in range(n_steps)]: step = utils.create_step(name=s, recipe=recipe, position=count) # create a step environment variable to test env works # as well as BUILD_ROOT replacement utils.create_step_environment(name="STEP_NAME", value="BUILD_ROOT/%s" % s, step=step) step.filename = "{}_{}.sh".format(s, name) step.save() count += 1 script_filename = os.path.join(recipe_dir, step.filename) job_script = "echo $GLOBAL_NAME $CIVET_RECIPE_NAME $STEP_NAME\n" job_script += "start_message {0}:{1}\n".format(recipe.name, s) job_script += "sleep {0}\n".format(sleep) job_script += "end_message {0}:{1}\n".format(recipe.name, s) job_script += extra_script with open(script_filename, "w") as f: f.write(job_script) return test_job
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_job_info_search(self): """ testing ci:job_info_search """ url = reverse('ci:job_info_search') # no options response = self.client.get(url) self.assertEqual(response.status_code, 200) job = utils.create_job() osversion, created = models.OSVersion.objects.get_or_create(name="os", version="1") job.operating_system = osversion job.save() mod0, created = models.LoadedModule.objects.get_or_create(name="mod0") mod1, created = models.LoadedModule.objects.get_or_create(name="mod1") job.loaded_modules.add(mod0) response = self.client.get(url, {'os_versions': [osversion.pk], 'modules': [mod0.pk]}) self.assertEqual(response.status_code, 200)
def create_client_job(recipe_dir, name="TestJob", sleep=1): user = utils.get_test_user() recipe = utils.create_recipe(user=user, name=name) test_job = utils.create_job(user=user, recipe=recipe) test_job.ready = True test_job.client = None test_job.status = models.JobStatus.NOT_STARTED test_job.save() # create a prestep to make sure sourcing functions work prestep0 = utils.create_prestepsource(filename="prestep0.sh", recipe=recipe) with open(os.path.join(recipe_dir, prestep0.filename), "w") as f: f.write('function start_message()\n{\n echo start "$*"\n}') # create a prestep to make sure sourcing functions work prestep1 = utils.create_prestepsource(filename="prestep1.sh", recipe=recipe) with open(os.path.join(recipe_dir, prestep1.filename), "w") as f: f.write('function end_message()\n{\n echo end "$*"\n}') # create a global environment variable to test env works # as well as BUILD_ROOT replacement utils.create_recipe_environment(name="GLOBAL_NAME", value="BUILD_ROOT/global", recipe=recipe) count = 0 for s in ["step0", "step1", "step2"]: step = utils.create_step(name=s, recipe=recipe, position=count) # create a step environment variable to test env works # as well as BUILD_ROOT replacement utils.create_step_environment(name="STEP_NAME", value="BUILD_ROOT/%s" % s, step=step) step.filename = "%s.sh" % s step.save() count += 1 script_filename = os.path.join(recipe_dir, step.filename) with open(script_filename, "w") as f: f.write( "echo $GLOBAL_NAME $recipe_name $STEP_NAME\nstart_message {0}:{1}\nsleep {2}\nend_message {0}:{1}\n" .format(recipe.name, s, sleep)) return test_job
def test_create_issue_on_fail(self, mock_get, mock_post, mock_patch): j = utils.create_job() get_data = [{"title": "foo", "number": 1}] mock_get.return_value = utils.Response(get_data) mock_post.return_value = utils.Response({"html_url": "<html_url>"}) mock_patch.return_value = utils.Response({"html_url": "<html_url>"}) git_config = utils.github_config(remote_update=True) with self.settings(INSTALLED_GITSERVERS=[git_config]): utils.update_job(j, status=models.JobStatus.SUCCESS) j.event.cause = models.Event.PULL_REQUEST j.event.save() # Don't do anything on a PR UpdateRemoteStatus.create_issue_on_fail(j) self.assertEqual(mock_get.call_count, 0) self.assertEqual(mock_post.call_count, 0) self.assertEqual(mock_patch.call_count, 0) j.event.cause = models.Event.PUSH j.event.save() # Don't do anything unless it is a failure UpdateRemoteStatus.create_issue_on_fail(j) self.assertEqual(mock_get.call_count, 0) self.assertEqual(mock_post.call_count, 0) self.assertEqual(mock_patch.call_count, 0) utils.update_job(j, status=models.JobStatus.FAILED) # Don't do anything unless the recipe wants to create an issue UpdateRemoteStatus.create_issue_on_fail(j) self.assertEqual(mock_get.call_count, 0) self.assertEqual(mock_post.call_count, 0) self.assertEqual(mock_patch.call_count, 0) j.recipe.create_issue_on_fail = True j.recipe.create_issue_on_fail_message = "Additional message" j.recipe.save() # Should create new issue UpdateRemoteStatus.create_issue_on_fail(j) self.assertEqual(mock_get.call_count, 1) self.assertEqual(mock_post.call_count, 1) self.assertEqual(mock_patch.call_count, 0)
def test_activate_event(self, mock_collab): # only posts are allowed response = self.client.get(reverse('ci:activate_event', args=[1000])) self.assertEqual(response.status_code, 405) response = self.client.post(reverse('ci:activate_event', args=[1000])) self.assertEqual(response.status_code, 404) job = utils.create_job() job.active = False job.save() self.set_counts() response = self.client.post(reverse('ci:activate_event', args=[job.event.pk])) self.compare_counts() # not signed in self.assertEqual(response.status_code, 403) user = utils.get_test_user() utils.simulate_login(self.client.session, user) mock_collab.return_value = False self.set_counts() response = self.client.post(reverse('ci:activate_event', args=[job.event.pk])) self.compare_counts() # not a collaborator self.assertEqual(response.status_code, 403) mock_collab.return_value = True # A collaborator self.set_counts() response = self.client.post(reverse('ci:activate_event', args=[job.event.pk])) self.compare_counts(ready=1, active=1, num_changelog=1) self.assertEqual(response.status_code, 302) # redirect job.refresh_from_db() self.assertTrue(job.active) # no jobs to activate self.set_counts() response = self.client.post(reverse('ci:activate_event', args=[job.event.pk])) self.compare_counts() self.assertEqual(response.status_code, 302) # redirect job.refresh_from_db() self.assertTrue(job.active)
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_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)