def test_view_client(self):
user = utils.get_test_user()
with self.settings(INSTALLED_GITSERVERS=[utils.github_config(authorized_users=[])]):
url = reverse('ci:view_client', args=[1000,])
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
client = utils.create_client()
# not logged in
url = reverse('ci:view_client', args=[client.pk,])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You are not allowed")
# logged in but not on the authorized list
utils.simulate_login(self.client.session, user)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "You are not allowed")
with self.settings(INSTALLED_GITSERVERS=[utils.github_config(authorized_users=[user.name])]):
# logged in and on the authorized list
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "You are not allowed")
# Should be cached
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "You are not allowed")
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 setUp(self):
self.client = Client()
self.factory = RequestFactory()
self.server = utils.create_git_server(
host_type=settings.GITSERVER_BITBUCKET)
self.user = utils.create_user_with_token(server=self.server)
utils.simulate_login(self.client.session, self.user)
self.gapi = self.server.api()
def test_main(self):
"""
testing ci:main
"""
response = self.client.get(reverse('ci:main'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Sign in')
self.assertNotContains(response, 'Sign out')
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
auth = user.auth()
self.assertIn(auth._user_key, self.client.session)
response = self.client.get(reverse('ci:main'))
self.assertContains(response, 'Sign out')
self.assertNotContains(response, 'Sign in')
def test_user_repo_settings(self):
"""
testing ci:user_repo_settings
"""
repos = []
for i in range(3):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.save()
repos.append(repo)
# not signed in
url = reverse('ci:user_repo_settings')
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "form")
user = repos[0].user
utils.simulate_login(self.client.session, user)
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.assertContains(response, "form")
# post an invalid form
self.set_counts()
response = self.client.post(url, {})
self.assertEqual(response.status_code, 200)
self.compare_counts()
# post a valid form
self.set_counts()
response = self.client.post(url, {"repositories": [repos[0].pk, repos[1].pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(user.preferred_repos.count(), 2)
self.compare_counts(repo_prefs=2)
# post again with the same recipes
self.set_counts()
response = self.client.post(url, {"repositories": [repos[2].pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(user.preferred_repos.count(), 1)
self.compare_counts(repo_prefs=-1)
def test_view_event(self, mock_collab):
"""
testing ci:view_event
"""
mock_collab.return_value = False
#invalid event
response = self.client.get(reverse('ci:view_event', args=[1000,]))
self.assertEqual(response.status_code, 404)
#valid event
ev = utils.create_event()
response = self.client.get(reverse('ci:view_event', args=[ev.pk]))
self.assertEqual(response.status_code, 200)
#valid event while signed in
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
response = self.client.get(reverse('ci:view_event', args=[ev.pk]))
self.assertEqual(response.status_code, 200)
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 test_view_profile(self):
# invalid git server
response = self.client.get(reverse('ci:view_profile', args=[1000, "no_exist"]))
self.assertEqual(response.status_code, 404)
# not signed in should redirect to sign in
server = utils.create_git_server()
response = self.client.get(reverse('ci:view_profile', args=[server.host_type, server.name]))
self.assertEqual(response.status_code, 302) # redirect
user = utils.get_test_user()
repo1 = utils.create_repo(name='repo1', user=user)
repo2 = utils.create_repo(name='repo2', user=user)
repo3 = utils.create_repo(name='repo3', user=user)
utils.create_recipe(name='r1', user=user, repo=repo1)
utils.create_recipe(name='r2', user=user, repo=repo2)
utils.create_recipe(name='r3', user=user, repo=repo3)
# signed in
utils.simulate_login(self.client.session, user)
response = self.client.get(reverse('ci:view_profile', args=[user.server.host_type, user.server.name]))
self.assertEqual(response.status_code, 200)
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_view_pr_matched(self, mock_collab):
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
mock_collab.return_value = True
with self.settings(INSTALLED_GITSERVERS=[utils.github_config(recipe_label_activation=utils.default_labels())]):
self.set_label_on_recipes()
changed_files = ["docs/foo", "docs/bar"]
self.set_counts()
self.create_pr_data(pr_num=2, changed_files=changed_files)
self.compare_counts(jobs=2, active=2, events=1, ready=1, prs=1, num_pr_alts=1, active_repos=1)
pr = models.PullRequest.objects.get(number=2)
self.assertEqual(pr.alternate_recipes.count(), 1)
url = reverse('ci:view_pr', args=[pr.pk,])
# try adding a default recipe
recipes = models.Recipe.objects.order_by('created').filter(cause = models.Recipe.CAUSE_PULL_REQUEST)
self.assertEqual(recipes.count(), 2)
self.set_counts()
data = {"recipes": [pr.alternate_recipes.first().pk], "default_recipes": [recipes[1].pk,]}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 200)
self.compare_counts(jobs=1, active=1)
# shouldn't be able to remove one of the default
self.set_counts()
data["default_recipes"] = []
response = self.client.post(url, data)
self.assertEqual(response.status_code, 200)
self.compare_counts()
# try the original again, should give a form error (which we can't detect)
data["default_recipes"] = [recipes[1].pk,]
self.set_counts()
response = self.client.post(url, data)
self.assertEqual(response.status_code, 200)
self.compare_counts()
def test_user_repo_settings(self):
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
self.check_url(reverse("ci:user_repo_settings"))
def test_activate_job(self, mock_collab):
# only posts are allowed
response = self.client.get(reverse('ci:activate_job', args=[1000]))
self.assertEqual(response.status_code, 405)
response = self.client.post(reverse('ci:activate_job', args=[1000]))
self.assertEqual(response.status_code, 404)
job = utils.create_job()
job.active = False
job.save()
self.set_counts()
url = reverse('ci:activate_job', args=[job.pk])
self.assertEqual(job.event.base.branch.status, models.JobStatus.NOT_STARTED)
response = self.client.post(url)
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(url)
self.compare_counts()
# not a collaborator
job = models.Job.objects.get(pk=job.pk)
self.assertEqual(response.status_code, 403)
self.assertFalse(job.active)
mock_collab.return_value = True
# A collaborator
self.set_counts()
response = self.client.post(url)
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)
# make sure activating a job doesn't mark it as ready
r1 = utils.create_recipe(name='r1')
job.recipe.depends_on.add(r1)
j1 = utils.create_job(recipe=r1)
job.active = False
job.ready = False
job.save()
j1.active = False
j1.ready = False
j1.save()
self.set_counts()
response = self.client.post(url)
self.compare_counts(active=1, num_changelog=1)
self.assertEqual(response.status_code, 302) # redirect
job.refresh_from_db()
self.assertTrue(job.active)
self.assertFalse(job.ready)
# now it should be marked as ready
j1.ready = True
j1.complete = True
j1.status = models.JobStatus.SUCCESS
j1.save()
job.ready = False
job.active = False
job.save()
self.set_counts()
response = self.client.post(url)
# The branch is now set to RUNNING since there is an already finished job
self.compare_counts(ready=1, active=1, num_changelog=1, active_branches=1)
self.assertEqual(response.status_code, 302) # redirect
job.refresh_from_db()
job.event.base.branch.refresh_from_db()
self.assertEqual(job.event.base.branch.status, models.JobStatus.RUNNING)
self.assertTrue(job.active)
self.assertTrue(job.ready)
# Calling activate on an already active job shouldn't do anything
self.set_counts()
response = self.client.post(url)
self.compare_counts()
self.assertEqual(response.status_code, 302) # redirect
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 setUp(self):
super(Tests, self).setUp()
self.create_default_recipes(server_type=settings.GITSERVER_GITLAB)
utils.simulate_login(self.client.session, self.build_user)
def test_view_pr(self, mock_collab):
"""
testing ci:view_pr
"""
# bad pr
url = reverse('ci:view_pr', args=[1000,])
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
pr = utils.create_pr()
ev = utils.create_event()
ev.pull_request = pr
ev.save()
utils.create_job(event=ev)
user = utils.get_test_user()
utils.simulate_login(self.client.session, user)
# user not a collaborator, no alternate recipe form
mock_collab.return_value = False
url = reverse('ci:view_pr', args=[pr.pk,])
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
# user a collaborator, they get alternate recipe form
mock_collab.return_value = True
r0 = utils.create_recipe(name="Recipe 0", repo=ev.base.branch.repository, cause=models.Recipe.CAUSE_PULL_REQUEST_ALT)
r1 = utils.create_recipe(name="Recipe 1", repo=ev.base.branch.repository, cause=models.Recipe.CAUSE_PULL_REQUEST_ALT)
self.set_counts()
response = self.client.get(url)
self.compare_counts()
self.assertEqual(response.status_code, 200)
self.set_counts()
# post an invalid alternate recipe form
response = self.client.post(url, {})
self.assertEqual(response.status_code, 200)
self.assertEqual(pr.alternate_recipes.count(), 0)
self.compare_counts()
utils.simulate_login(self.client.session, user)
# post a valid alternate recipe form
self.set_counts()
response = self.client.post(url, {"recipes": [r0.pk, r1.pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(pr.alternate_recipes.count(), 2)
# The original job plus the two alternate jobs are ready
self.compare_counts(jobs=2, ready=3, active=2, num_pr_alts=2)
# post again with the same recipes
self.set_counts()
response = self.client.post(url, {"recipes": [r0.pk, r1.pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(pr.alternate_recipes.count(), 2)
self.compare_counts()
# post again different recipes. We don't auto cancel jobs.
self.set_counts()
response = self.client.post(url, {"recipes": [r0.pk]})
self.assertEqual(response.status_code, 200)
self.assertEqual(pr.alternate_recipes.count(), 1)
self.compare_counts(num_pr_alts=-1)
# clear alt recipes
self.set_counts()
response = self.client.post(url, {"recipes": []})
self.assertEqual(response.status_code, 200)
self.assertEqual(pr.alternate_recipes.count(), 0)
self.compare_counts(num_pr_alts=-1)
def test_get_user_repos_info(self):
request = self.factory.get('/')
request.session = self.client.session
repos = []
for i in range(3):
repo = utils.create_repo(name="repo%s" % i)
repo.active = True
repo.save()
branch = utils.create_branch(name="branch0", user=repo.user, repo=repo)
branch.status = models.JobStatus.SUCCESS
branch.save()
ev = utils.create_event(branch1=branch, branch2=branch, user=repo.user)
utils.create_job(event=ev, user=repo.user)
repos.append(repo)
# user not logged in
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
# user not logged in, default enforced
request = self.factory.get('/?default')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertTrue(default)
request = self.factory.get('/')
user = repos[0].user
utils.simulate_login(self.client.session, user)
request.session = self.client.session
# user is logged in but no prefs set
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
# user is logged in, add repos to prefs
for i in range(3):
user.preferred_repos.add(repos[i])
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), i+1)
self.assertEqual(len(evinfo), i+1)
self.assertFalse(default)
# user has one pref but default is enforced
user.preferred_repos.clear()
user.preferred_repos.add(repos[0])
request = self.factory.get('/?default')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertTrue(default)
with self.settings(INSTALLED_GITSERVERS=[utils.github_config(hostname="server_does_not_exist")]):
user.preferred_repos.clear()
user.preferred_repos.add(repos[0])
request = self.factory.get('/')
repo_status, evinfo, default = views.get_user_repos_info(request)
self.assertEqual(len(repo_status), 3)
self.assertEqual(len(evinfo), 3)
self.assertFalse(default)
