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)
