def test_repo_prs(self): repo0 = utils.create_repo(name="repo0") repo0.active = True repo0.save() utils.create_pr(title="pr0", number=1, repo=repo0) utils.create_pr(title="pr1", number=2, repo=repo0) repo1 = utils.create_repo(name="repo1") repo1.active = True repo1.save() utils.create_pr(repo=repo1) repo2 = utils.create_repo(name="repo2") repo2.active = True repo2.save() response = self.client.get(reverse('ci:num_prs')) self.assertEqual(response.status_code, 200)
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 create_records(self, recipe, branch): info = {} info["owner"] = test_utils.create_user(name=recipe["repository_owner"]) info["build_user"] = test_utils.create_user_with_token(name=recipe["build_user"]) info["repository"] = test_utils.create_repo(user=info["owner"], name=recipe["repository_name"]) info["branch"] = test_utils.create_branch(repo=info["repository"], name=branch) return info
def test_install_webhooks(self, mock_post, mock_get): repo = utils.create_repo(user=self.user) event0 = { 'events': ['pullrequest:created', 'repo:push'], 'url': 'no_url' } event1 = { 'events': ['pullrequest:created', 'repo:other_action'], 'url': 'no_url' } get_data = {'values': [event0, event1]} callback_url = urljoin( self.gapi._civet_url, reverse('ci:bitbucket:webhook', args=[self.user.build_key])) with self.settings(INSTALLED_GITSERVERS=[ utils.bitbucket_config(install_webhook=True) ]): api = self.server.api() # Failed to do an the initial get mock_get.return_value = utils.Response(status_code=404) with self.assertRaises(GitException): api.install_webhooks(self.user, repo) self.assertEqual(mock_get.call_count, 1) self.assertEqual(mock_post.call_count, 0) # with this data it should try to install the hook but there is an error mock_get.return_value = utils.Response(json_data=get_data) mock_post.return_value = utils.Response(json_data={}, status_code=404) mock_get.call_count = 0 with self.assertRaises(GitException): api.install_webhooks(self.user, repo) self.assertEqual(mock_get.call_count, 1) self.assertEqual(mock_post.call_count, 1) # with this data it should do the hook mock_get.call_count = 0 mock_post.call_count = 0 mock_post.return_value = utils.Response(json_data={}, status_code=201) api.install_webhooks(self.user, repo) self.assertEqual(mock_get.call_count, 1) self.assertEqual(mock_post.call_count, 1) # with this data the hook already exists mock_get.call_count = 0 mock_post.call_count = 0 get_data['values'][0]['url'] = callback_url api.install_webhooks(self.user, repo) self.assertEqual(mock_get.call_count, 1) self.assertEqual(mock_post.call_count, 0) # this should just return mock_get.call_count = 0 mock_post.call_count = 0 self.gapi.install_webhooks(self.user, repo) self.assertEqual(mock_get.call_count, 0) self.assertEqual(mock_post.call_count, 0)
def create_repos(self): repos = [] for i in range(3): repo = utils.create_repo(name="repo%s" % i) repo.active = True repo.save() repos.append(repo) return repos
def test_is_collaborator(self, mock_get): repo = utils.create_repo(user=self.user) # user is repo owner ret = self.gapi.is_collaborator(self.user, repo) self.assertIs(ret, True) user2 = utils.create_user('user2', server=self.server) repo = utils.create_repo(user=user2) # a collaborator mock_get.return_value = utils.Response( json_data={'values': [{ 'name': repo.name }]}, status_code=200) ret = self.gapi.is_collaborator(self.user, repo) self.assertIs(ret, True) # not a collaborator mock_get.return_value = utils.Response(status_code=404) ret = self.gapi.is_collaborator(self.user, repo) self.assertIs(ret, False)
def test_disable_repo(self): out = StringIO() with self.assertRaises(CommandError): management.call_command("disable_repo", "--dry-run", stdout=out) with self.assertRaises(CommandError): management.call_command("disable_repo", "--dry-run", "--owner", "foo", stdout=out) repo = utils.create_repo() with self.assertRaises(CommandError): management.call_command("disable_repo", "--dry-run", "--owner", repo.user.name, "--repo", "<repo>", stdout=out) repo.active = True repo.save() branch = utils.create_branch(repo=repo) branch.status = models.JobStatus.SUCCESS branch.save() pr = utils.create_pr(repo=repo) pr.closed = False pr.save() management.call_command("disable_repo", "--dry-run", "--owner", repo.user.name, "--repo", repo.name, stdout=out) repo.refresh_from_db() self.assertIs(repo.active, True) branch.refresh_from_db() self.assertEqual(branch.status, models.JobStatus.SUCCESS) pr.refresh_from_db() self.assertIs(pr.closed, False) management.call_command("disable_repo", "--owner", repo.user.name, "--repo", repo.name, stdout=out) repo.refresh_from_db() self.assertIs(repo.active, False) branch.refresh_from_db() self.assertEqual(branch.status, models.JobStatus.NOT_STARTED) pr.refresh_from_db() self.assertIs(pr.closed, True)
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 create_repo_with_prs(self, name="Repo0"): repo = utils.create_repo(name=name) branch = utils.create_branch(name="branch1", repo=repo) repo.active = True repo.save() branch.status = models.JobStatus.RUNNING branch.save() for i in range(3): pr = utils.create_pr(title="Foo {a, b} & <bar> … %s" % i, repo=repo, number=i+1) pr.status = models.JobStatus.RUNNING pr.save() return repo, branch
def test_get_branches(self, mock_get): repo = utils.create_repo(user=self.user) mock_get.return_value = utils.Response(json_data={}) branches = self.gapi.get_branches(self.user, repo) # shouldn't be any branch self.assertEqual(len(branches), 0) mock_get.return_value = utils.Response(json_data={ 'branch1': 'info', 'branch2': 'info' }) branches = self.gapi.get_branches(self.user, repo) self.assertEqual(len(branches), 2)
def test_view_owner_repo(self): # invalid repo response = self.client.get(reverse('ci:view_owner_repo', args=["foo", "bar"])) self.assertEqual(response.status_code, 404) # valid repo with branches repo = utils.create_repo() branch = utils.create_branch(repo=repo) branch.status = models.JobStatus.FAILED branch.save() utils.create_event(user=repo.user, branch1=branch, branch2=branch) response = self.client.get(reverse('ci:view_owner_repo', args=[repo.user.name, repo.name])) self.assertEqual(response.status_code, 200)
def create_default_recipes(self, recipes_dir, server_type=settings.GITSERVER_GITHUB): hostname = "github.com" if server_type == settings.GITSERVER_GITLAB: hostname = "gitlab.com" self.recipe_file = self.create_recipe_in_repo("recipe_all.cfg", "recipe.cfg", hostname=hostname) self.recipe_pr_file = self.create_recipe_in_repo("pr_dep.cfg", "pr_dep.cfg", hostname=hostname) self.recipe_push_file = self.create_recipe_in_repo("push_dep.cfg", "push_dep.cfg", hostname=hostname) self.server = test_utils.create_git_server(host_type=server_type) self.build_user = test_utils.create_user_with_token(name="moosebuild", server=self.server) self.owner = test_utils.create_user(name="idaholab", server=self.server) self.repo = test_utils.create_repo(name="civet", user=self.owner) self.branch = test_utils.create_branch(name="devel", repo=self.repo) return self.load_recipes(recipes_dir)
def create_default_recipes(self, server_type=settings.GITSERVER_GITHUB): self.set_counts() self.server = utils.create_git_server(host_type=server_type) self.build_user = utils.create_user_with_token(name="moosebuild", server=self.server) self.owner = utils.create_user(name="owner", server=self.server) self.repo = utils.create_repo(name="repo", user=self.owner) self.branch = utils.create_branch(name="devel", repo=self.repo) pr = utils.create_recipe(name="PR Base", user=self.build_user, repo=self.repo) pr1 = utils.create_recipe(name="PR With Dep", user=self.build_user, repo=self.repo) pr1.depends_on.add(pr) push = utils.create_recipe(name="Push Base", user=self.build_user, repo=self.repo, branch=self.branch, cause=models.Recipe.CAUSE_PUSH) push1 = utils.create_recipe(name="Push With Dep", user=self.build_user, repo=self.repo, branch=self.branch, cause=models.Recipe.CAUSE_PUSH) push1.depends_on.add(push) alt_pr = utils.create_recipe( name="Alt PR with dep", user=self.build_user, repo=self.repo, cause=models.Recipe.CAUSE_PULL_REQUEST_ALT) alt_pr.depends_on.add(pr) utils.create_recipe(name="Manual", user=self.build_user, repo=self.repo, branch=self.branch, cause=models.Recipe.CAUSE_MANUAL) self.compare_counts( recipes=6, deps=3, current=6, num_push_recipes=2, num_pr_recipes=2, num_manual_recipes=1, num_pr_alt_recipes=1, users=2, repos=1, branches=1, )
def test_get_open_prs(self, mock_get): repo = utils.create_repo(server=self.server) api = self.server.api() pr0 = {"title": "some title", "id": 123, "links": {"html": "some url"}} pr0_ret = { "title": "some title", "number": 123, "html_url": "some url" } mock_get.return_value = utils.Response({"values": [pr0]}) prs = api.get_open_prs(repo.user.name, repo.name) self.assertEqual([pr0_ret], prs) mock_get.side_effect = Exception("BAM!") prs = api.get_open_prs(repo.user.name, repo.name) self.assertEqual(prs, None)
def test_mooseframework(self): # no moose repo response = self.client.get(reverse('ci:mooseframework')) self.assertEqual(response.status_code, 200) user = utils.create_user(name='idaholab') repo = utils.create_repo(name='moose', user=user) utils.create_pr(repo=repo) # no master/devel branches response = self.client.get(reverse('ci:mooseframework')) self.assertEqual(response.status_code, 200) utils.create_branch(name='master', repo=repo) utils.create_branch(name='devel', repo=repo) # should be good response = self.client.get(reverse('ci:mooseframework')) self.assertEqual(response.status_code, 200)
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 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_is_collaborator(self, mock_get): # user is repo owner api = self.server.api() self.assertTrue(api.is_collaborator(self.owner, self.repo)) user2 = utils.create_user('user2', server=self.server) # a collaborator repo = utils.create_repo(user=user2) mock_get.return_value = utils.Response([{ 'username': self.build_user.name }]) self.assertTrue(api.is_collaborator(self.build_user, repo)) # not a collaborator mock_get.return_value = utils.Response([{'username': '******'}]) self.assertFalse(api.is_collaborator(self.build_user, repo)) # some random problem mock_get.side_effect = Exception("Bam!") self.assertFalse(api.is_collaborator(self.build_user, repo))
def test_close_pr(self): user = utils.get_test_user(server=self.server) repo = utils.create_repo(user=user) pr = utils.create_pr(repo=repo, number=1) pr.closed = False pr.save() views.close_pr('foo', 'bar', 1, user.server) pr.refresh_from_db() self.assertFalse(pr.closed) views.close_pr(user.name, 'bar', 1, user.server) pr.refresh_from_db() self.assertFalse(pr.closed) views.close_pr(user.name, repo.name, 0, user.server) pr.refresh_from_db() self.assertFalse(pr.closed) views.close_pr(user.name, repo.name, 1, user.server) pr.refresh_from_db() self.assertTrue(pr.closed)
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)