async def test_get_mergify_config_invalid( invalid: str, redis_cache: utils.RedisCache) -> None: with pytest.raises(InvalidRules): async def item(*args, **kwargs): return github_types.GitHubContentFile({ "content": encodebytes(invalid.encode()).decode(), "path": ".mergify.yml", "type": "file", "sha": "azertyu", }) client = mock.Mock() client.item.return_value = item() installation = context.Installation( github_types.GitHubAccountIdType(0), github_types.GitHubLogin("foobar"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository( installation, github_types.GitHubRepositoryName("xyz"), github_types.GitHubRepositoryIdType(0), ) config_file = await repository.get_mergify_config_file() assert config_file is not None get_mergify_config(config_file)
async def test_get_mergify_config_location_from_cache( redis_cache: utils.RedisCache, ) -> None: client = mock.AsyncMock() client.auth.owner = "foo" client.item.side_effect = [ http.HTTPNotFound("Not Found", request=mock.Mock(), response=mock.Mock()), http.HTTPNotFound("Not Found", request=mock.Mock(), response=mock.Mock()), github_types.GitHubContentFile({ "content": encodebytes("whatever".encode()).decode(), "type": "file", "path": ".github/mergify.yml", "sha": github_types.SHAType("zeazeaze"), }), ] installation = context.Installation( github_types.GitHubAccountIdType(0), github_types.GitHubLogin("foo"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository(installation, github_types.GitHubRepositoryName("bar")) await repository.get_mergify_config_file() assert client.item.call_count == 3 client.item.assert_has_calls([ mock.call("/repos/foo/bar/contents/.mergify.yml"), mock.call("/repos/foo/bar/contents/.mergify/config.yml"), mock.call("/repos/foo/bar/contents/.github/mergify.yml"), ]) client.item.reset_mock() client.item.side_effect = [ github_types.GitHubContentFile({ "content": encodebytes("whatever".encode()).decode(), "type": "file", "path": ".github/mergify.yml", "sha": github_types.SHAType("zeazeaze"), }), ] repository._cache = context.RepositoryCache() await repository.get_mergify_config_file() assert client.item.call_count == 1 client.item.assert_has_calls([ mock.call("/repos/foo/bar/contents/.github/mergify.yml"), ])
async def test_disabled(redis_cache): action = request_reviews.RequestReviewsAction.get_schema()( { "random_count": 2, "teams": { "foobar": 2, "foobaz": 1, }, "users": { "jd": 2, "sileht": 1, }, }, ) client = mock.MagicMock() client.auth.installation.__getitem__.return_value = 123 sub = subscription.Subscription( redis_cache, 123, False, "No sub", {}, frozenset({}), ) installation = context.Installation(123, "Mergifyio", sub, client, redis_cache) repository = context.Repository(installation, "demo") ctxt = await context.Context.create( repository, { "number": 123, "state": None, "mergeable_state": "ok", "merged_by": None, "merged": None, "merged_at": None, "base": { "sha": "sha", "ref": "main", "user": { "login": { "Mergifyio", }, }, "repo": { "name": "demo", "private": False, "owner": { "login": "******", }, }, }, }, ) result = await action.run(ctxt, None) assert result.conclusion == check_api.Conclusion.ACTION_REQUIRED assert result.title == "Random request reviews are disabled" assert result.summary == ( "⚠ The [subscription](https://dashboard.mergify.io/github/Mergifyio/subscription) " "needs to be updated to enable this feature." )
async def _simulator(redis_cache, pull_request_rules, owner, repo, pull_number, token): try: if token: auth = github.GithubTokenAuth(token) else: auth = github.get_auth(owner) async with github.aget_client(auth=auth) as client: try: data = await client.item(f"/repos/{owner}/{repo}/pulls/{pull_number}") except http.HTTPNotFound: raise PullRequestUrlInvalid( message=f"Pull request {owner}/{repo}/pulls/{pull_number} not found" ) sub = await subscription.Subscription.get_subscription( redis_cache, data["base"]["user"]["id"] ) installation = context.Installation( data["base"]["user"]["id"], owner, sub, client, redis_cache, ) repository = context.Repository(installation, data["base"]["repo"]) ctxt = await repository.get_pull_request_context(data["number"], data) ctxt.sources = [{"event_type": "mergify-simulator", "data": []}] match = await pull_request_rules.get_pull_request_rule(ctxt) return await actions_runner.gen_summary(ctxt, pull_request_rules, match) except exceptions.MergifyNotInstalled: raise PullRequestUrlInvalid( message=f"Mergify not installed on repository '{owner}/{repo}'" )
async def prepare_context(client, redis_cache, subscribed=True): sub = subscription.Subscription( redis_cache, 123, subscribed, "sub or not to sub", frozenset( getattr(subscription.Features, f) for f in subscription.Features.__members__) if subscribed else frozenset(), ) installation = context.Installation(123, "Mergifyio", sub, client, redis_cache) repository = context.Repository(installation, "demo", 123) return await context.Context.create( repository, { "id": 12345, "number": 123, "state": None, "mergeable_state": "ok", "merged_by": None, "merged": None, "merged_at": None, "user": { "login": "******" }, "requested_reviewers": [{ "login": "******" }, { "login": "******" }], "requested_teams": [{ "slug": "foobar" }, { "slug": "foobaz" }], "base": { "sha": "sha", "ref": "main", "user": { "login": { "Mergifyio", }, }, "repo": { "full_name": "Mergifyio/demo", "name": "demo", "private": False, "owner": { "login": "******", }, }, }, }, )
async def test_merge_commit_message_undefined(body): pull = PR.copy() pull["body"] = body client = mock.MagicMock() installation = context.Installation(123, "whatever", {}, client, None) repository = context.Repository(installation, "whatever", 123) pr = await context.Context.create(repository=repository, pull=pull) with pytest.raises(context.RenderTemplateFailure) as x: await merge.MergeAction._get_commit_message(pr.pull_request) assert str(x) == "foobar"
async def test_merge_commit_message_syntax_error(body, error, redis_cache): pull = PR.copy() pull["body"] = body client = mock.MagicMock() installation = context.Installation(123, "whatever", {}, client, redis_cache) repository = context.Repository(installation, "whatever") pr = await context.Context.create(repository=repository, pull=pull) with pytest.raises(context.RenderTemplateFailure) as rmf: await merge.MergeAction._get_commit_message(pr.pull_request) assert str(rmf) == error
async def _create_context(redis_cache, client): sub = subscription.Subscription( redis_cache, 123, True, "", {}, frozenset({}), ) installation = context.Installation(123, "Mergifyio", sub, client, redis_cache) repository = context.Repository(installation, "demo", 123) return await context.Context.create( repository, { "number": 789, "state": "open", "title": "Amazing new feature", "user": { "login": "******", "id": 1, }, "mergeable_state": "ok", "merged_by": None, "merged": None, "merged_at": None, "base": { "sha": "sha", "ref": "main", "user": { "login": { "Mergifyio", }, }, "repo": { "name": "demo", "private": False, "owner": { "login": "******", "id": 123, }, "permissions": { "admin": False, "push": False, "pull": True, }, }, }, }, [], )
def repository(redis_cache, fake_client): installation = context.Installation( github_types.GitHubAccountIdType(123), github_types.GitHubLogin("user"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), fake_client, redis_cache, ) return context.Repository( installation, github_types.GitHubRepositoryName("name"), github_types.GitHubRepositoryIdType(123), )
def fake_repository( redis_links: redis_utils.RedisLinks, fake_subscription: subscription.Subscription, ) -> context.Repository: gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("Mergifyio"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "Mergifyio/mergify-engine", "name": github_types.GitHubRepositoryName("mergify-engine"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("main"), }) installation_json = github_types.GitHubInstallation({ "id": github_types.GitHubInstallationIdType(12345), "target_type": gh_owner["type"], "permissions": {}, "account": gh_owner, }) fake_client = mock.Mock() installation = context.Installation(installation_json, fake_subscription, fake_client, redis_links) return context.Repository(installation, gh_repo)
def fake_repository( redis_cache: utils.RedisCache, fake_subscription: subscription.Subscription, ) -> context.Repository: gh_owner = github_types.GitHubAccount( { "login": github_types.GitHubLogin("Mergifyio"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", } ) gh_repo = github_types.GitHubRepository( { "full_name": "Mergifyio/mergify-engine", "name": github_types.GitHubRepositoryName("mergify-engine"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("main"), } ) installation_json = github_types.GitHubInstallation( { "id": github_types.GitHubInstallationIdType(12345), "target_type": gh_owner["type"], "permissions": {}, "account": gh_owner, } ) fake_client = redis_queue = mock.Mock() # NOTE(Syffe): Since redis_queue is not used in fake_repository, we simply mock it, # otherwise a fixture is needed for it. This might change with future use of redis_queue. installation = context.Installation( installation_json, fake_subscription, fake_client, redis_cache, redis_queue ) return context.Repository(installation, gh_repo)
async def test_pull_behind(commits_tree_generator, redis_cache): expected, commits = commits_tree_generator async def get_commits(*args, **kwargs): for c in commits: yield c async def item(*args, **kwargs): return {"commit": {"sha": "base"}} client = mock.Mock() client.items.return_value = get_commits() # /pulls/X/commits client.item.return_value = item() # /branch/#foo installation = context.Installation(123, "user", {}, client, redis_cache) repository = context.Repository(installation, "name", 0) ctxt = await context.Context.create( repository, { "number": 1, "mergeable_state": "clean", "state": "open", "merged": False, "merged_at": None, "merged_by": None, "base": { "ref": "#foo", "repo": { "name": "foobar", "private": False }, "sha": "miaou", "user": { "login": "******" }, }, }, {}, ) assert expected == await ctxt.is_behind
def repository(redis_cache, fake_client): gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "user/name", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }) installation = context.Installation( github_types.GitHubAccountIdType(123), github_types.GitHubLogin("user"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), fake_client, redis_cache, ) return context.Repository(installation, gh_repo)
async def test_merge_commit_message(body, title, message, mode): pull = PR.copy() pull["body"] = body client = mock.MagicMock() installation = context.Installation(123, "whatever", {}, client, None) repository = context.Repository(installation, "whatever", 123) ctxt = await context.Context.create(repository=repository, pull=pull) ctxt._cache["pull_statuses"] = [ github_types.GitHubStatus({ "target_url": "http://example.com", "context": "my CI", "state": "success", "description": "foobar", "avatar_url": "", }) ] ctxt._cache["pull_check_runs"] = [] pr = ctxt.pull_request assert await merge.MergeAction._get_commit_message(pr, mode=mode) == ( title, message, )
async def test_summary_synchronization_cache( redis_cache: utils.RedisCache, ) -> None: gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "id": github_types.GitHubRepositoryIdType(456), "full_name": "user/ref", "name": github_types.GitHubRepositoryName("name"), "private": False, "owner": gh_owner, }) async def items(*args, **kwargs): if False: yield return async def post_check(*args, **kwargs): return mock.Mock() client = mock.AsyncMock() client.auth.get_access_token.return_value = "<token>" client.items = items client.post.side_effect = post_check sub = subscription.Subscription(redis_cache, 0, False, "", frozenset()) installation = context.Installation( gh_owner["id"], gh_owner["login"], sub, client, redis_cache, ) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) ctxt = await context.Context.create( repository, { "title": "", "id": github_types.GitHubPullRequestId(0), "maintainer_can_modify": False, "rebaseable": False, "draft": False, "merge_commit_sha": None, "labels": [], "number": github_types.GitHubPullRequestNumber(6), "commits": 1, "merged": True, "state": "closed", "changed_files": 1, "html_url": "<html_url>", "base": { "label": "", "sha": github_types.SHAType("sha"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "ref": github_types.GitHubRefType("ref"), "label": "", "repo": gh_repo, }, "head": { "label": "", "sha": github_types.SHAType("old-sha-one"), "ref": github_types.GitHubRefType("fork"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "repo": { "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "id": github_types.GitHubRepositoryIdType(123), "full_name": "fork/other", "name": github_types.GitHubRepositoryName("other"), "private": False, "owner": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, }, }, "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "merged_by": None, "merged_at": None, "mergeable_state": "clean", }, ) assert await ctxt.get_cached_last_summary_head_sha() is None await ctxt.set_summary_check( check_api.Result(check_api.Conclusion.SUCCESS, "foo", "bar")) assert await ctxt.get_cached_last_summary_head_sha() == "old-sha-one" await ctxt.clear_cached_last_summary_head_sha() assert await ctxt.get_cached_last_summary_head_sha() is None
async def test_configuration_initial( github_server: httpserver.HTTPServer, redis_cache: utils.RedisCache, ) -> None: github_server.expect_oneshot_request( f"{BASE_URL}/pulls/1", ).respond_with_json( GH_PULL, status=200, ) github_server.expect_oneshot_request( f"{BASE_URL}/contents/.mergify.yml", ).respond_with_data(status=404) github_server.expect_oneshot_request( f"{BASE_URL}/contents/.mergify/config.yml", ).respond_with_data( status=404) github_server.expect_oneshot_request( f"{BASE_URL}/contents/.github/mergify.yml", ).respond_with_data( status=404) github_server.expect_oneshot_request( f"{BASE_URL}/contents/.mergify.yml", query_string={ "ref": GH_PULL["head"]["sha"] }, ).respond_with_json( github_types.GitHubContentFile({ "type": "file", "content": FAKE_MERGIFY_CONTENT, "path": ".mergify.yml", "sha": github_types.SHAType("739e5ec79e358bae7a150941a148b4131233ce2c"), }), status=200, ) github_server.expect_oneshot_request( f"{BASE_URL}/commits/{GH_PULL['head']['sha']}/check-runs" ).respond_with_json({"check_runs": []}, status=200) github_server.expect_oneshot_request(f"{BASE_URL}/check-runs", method="POST").respond_with_json( {}, status=200) async with github.AsyncGithubInstallationClient( github.get_auth(GH_OWNER["login"])) as client: installation = context.Installation( GH_OWNER["id"], GH_OWNER["login"], subscription.Subscription(redis_cache, 0, False, "", frozenset(), 0), client, redis_cache, ) repository = context.Repository(installation, GH_REPO) ctxt = await repository.get_pull_request_context( github_types.GitHubPullRequestNumber(1)) main_config_file = await repository.get_mergify_config_file() assert main_config_file is None changed = await engine._check_configuration_changes( ctxt, main_config_file) assert changed github_server.check_assertions()
async def test_team_permission_cache(redis_cache: utils.RedisCache) -> None: class FakeClient(github.AsyncGithubInstallationClient): called: int def __init__(self, owner, repo): super().__init__(auth=None) self.owner = owner self.repo = repo self.called = 0 async def get(self, url, *args, **kwargs): self.called += 1 if (url == f"/orgs/{self.owner}/teams/team-ok/repos/{self.owner}/{self.repo}" ): return {} elif (url == f"/orgs/{self.owner}/teams/team-nok/repos/{self.owner}/{self.repo}" ): raise http.HTTPNotFound(message="Not found", request=mock.ANY, response=mock.ANY) elif (url == f"/orgs/{self.owner}/teams/team-also-nok/repos/{self.owner}/{self.repo}" ): raise http.HTTPNotFound(message="Not found", request=mock.ANY, response=mock.ANY) raise ValueError(f"Unknown test URL `{url}`") gh_owner = github_types.GitHubAccount({ "id": github_types.GitHubAccountIdType(123), "login": github_types.GitHubLogin("jd"), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test"), "private": False, }) team_slug1 = github_types.GitHubTeamSlug("team-ok") team_slug2 = github_types.GitHubTeamSlug("team-nok") team_slug3 = github_types.GitHubTeamSlug("team-also-nok") sub = subscription.Subscription(redis_cache, 0, False, "", frozenset()) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation(gh_owner["id"], gh_owner["login"], sub, client, redis_cache) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) assert client.called == 0 assert await repository.team_has_read_permission(team_slug1) assert client.called == 1 assert await repository.team_has_read_permission(team_slug1) assert client.called == 1 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 2 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 2 assert not await repository.team_has_read_permission(team_slug3) assert client.called == 3 gh_repo = github_types.GitHubRepository({ "id": github_types.GitHubRepositoryIdType(1), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test2"), "private": False, }) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation(gh_owner["id"], gh_owner["login"], sub, client, redis_cache) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) assert client.called == 0 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 1 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 1 assert await repository.team_has_read_permission(team_slug1) assert client.called == 2 await context.Repository.clear_team_permission_cache_for_repo( redis_cache, gh_owner, gh_repo) assert await repository.team_has_read_permission(team_slug1) assert client.called == 3 assert not await repository.team_has_read_permission(team_slug3) assert client.called == 4 await context.Repository.clear_team_permission_cache_for_org( redis_cache, gh_owner) assert not await repository.team_has_read_permission(team_slug3) assert client.called == 5 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 6 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 6 await context.Repository.clear_team_permission_cache_for_team( redis_cache, gh_owner, team_slug2) assert not await repository.team_has_read_permission(team_slug2) assert client.called == 7
async def test_user_permission_cache(redis_cache: utils.RedisCache) -> None: class FakeClient(github.AsyncGithubInstallationClient): called: int def __init__(self, owner, repo): super().__init__(auth=None) self.owner = owner self.repo = repo self.called = 0 async def item(self, url, *args, **kwargs): self.called += 1 if self.repo == "test": if (url == f"/repos/{self.owner}/{self.repo}/collaborators/foo/permission" ): return {"permission": "admin"} elif url.startswith( f"/repos/{self.owner}/{self.repo}/collaborators/"): return {"permission": "loser"} elif self.repo == "test2": if (url == f"/repos/{self.owner}/{self.repo}/collaborators/bar/permission" ): return {"permission": "admin"} elif url.startswith( f"/repos/{self.owner}/{self.repo}/collaborators/"): return {"permission": "loser"} raise ValueError(f"Unknown test URL `{url}` for repo {self.repo}") gh_owner = github_types.GitHubAccount({ "id": github_types.GitHubAccountIdType(123), "login": github_types.GitHubLogin("jd"), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test"), "private": False, }) user_1 = github_types.GitHubAccount({ "id": github_types.GitHubAccountIdType(1), "login": github_types.GitHubLogin("foo"), "type": "User", "avatar_url": "", }) user_2 = github_types.GitHubAccount({ "id": github_types.GitHubAccountIdType(2), "login": github_types.GitHubLogin("bar"), "type": "User", "avatar_url": "", }) user_3 = github_types.GitHubAccount({ "id": github_types.GitHubAccountIdType(3), "login": github_types.GitHubLogin("baz"), "type": "User", "avatar_url": "", }) sub = subscription.Subscription(redis_cache, 0, False, "", frozenset()) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation(gh_owner["id"], gh_owner["login"], sub, client, redis_cache) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) assert client.called == 0 assert await repository.has_write_permission(user_1) assert client.called == 1 assert await repository.has_write_permission(user_1) assert client.called == 1 assert not await repository.has_write_permission(user_2) assert client.called == 2 assert not await repository.has_write_permission(user_2) assert client.called == 2 assert not await repository.has_write_permission(user_3) assert client.called == 3 gh_repo = github_types.GitHubRepository({ "id": github_types.GitHubRepositoryIdType(1), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test2"), "private": False, }) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation(gh_owner["id"], gh_owner["login"], sub, client, redis_cache) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) assert client.called == 0 assert await repository.has_write_permission(user_2) assert client.called == 1 assert await repository.has_write_permission(user_2) assert client.called == 1 assert not await repository.has_write_permission(user_1) assert client.called == 2 await context.Repository.clear_user_permission_cache_for_repo( redis_cache, gh_owner, gh_repo) assert not await repository.has_write_permission(user_1) assert client.called == 3 assert not await repository.has_write_permission(user_3) assert client.called == 4 await context.Repository.clear_user_permission_cache_for_org( redis_cache, gh_owner) assert not await repository.has_write_permission(user_3) assert client.called == 5 assert await repository.has_write_permission(user_2) assert client.called == 6 assert await repository.has_write_permission(user_2) assert client.called == 6 await context.Repository.clear_user_permission_cache_for_user( redis_cache, gh_owner, gh_repo, user_2) assert await repository.has_write_permission(user_2) assert client.called == 7
async def test_team_permission_cache(redis_cache: utils.RedisCache) -> None: class FakeClient(github.AsyncGithubInstallationClient): called: int def __init__(self, owner: str, repo: str) -> None: super().__init__(auth=None) # type: ignore[arg-type] self.owner = owner self.repo = repo self.called = 0 async def get(self, url: str, *args: typing.Any, **kwargs: typing.Any) -> typing.Any: # type: ignore[override] self.called += 1 if ( url == f"/orgs/{self.owner}/teams/team-ok/repos/{self.owner}/{self.repo}" ): return {} elif ( url == f"/orgs/{self.owner}/teams/team-nok/repos/{self.owner}/{self.repo}" ): raise http.HTTPNotFound( message="Not found", request=mock.ANY, response=mock.ANY ) elif ( url == f"/orgs/{self.owner}/teams/team-also-nok/repos/{self.owner}/{self.repo}" ): raise http.HTTPNotFound( message="Not found", request=mock.ANY, response=mock.ANY ) raise ValueError(f"Unknown test URL `{url}`") gh_owner = github_types.GitHubAccount( { "id": github_types.GitHubAccountIdType(123), "login": github_types.GitHubLogin("jd"), "type": "User", "avatar_url": "", } ) gh_repo = github_types.GitHubRepository( { "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test"), "private": False, } ) installation_json = github_types.GitHubInstallation( { "id": github_types.GitHubInstallationIdType(12345), "target_type": gh_owner["type"], "permissions": {}, "account": gh_owner, } ) team_slug1 = github_types.GitHubTeamSlug("team-ok") team_slug2 = github_types.GitHubTeamSlug("team-nok") team_slug3 = github_types.GitHubTeamSlug("team-also-nok") sub = subscription.Subscription( redis_cache, 0, "", frozenset([subscription.Features.PUBLIC_REPOSITORY]) ) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation( installation_json, sub, client, redis_cache, mock.Mock() ) repository = context.Repository(installation, gh_repo) assert client.called == 0 assert await repository.team_has_read_permission(team_slug1) assert client.called == 1 assert await repository.team_has_read_permission(team_slug1) assert client.called == 1 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 2 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 2 assert not await repository.team_has_read_permission(team_slug3) assert client.called == 3 gh_repo = github_types.GitHubRepository( { "id": github_types.GitHubRepositoryIdType(1), "owner": gh_owner, "full_name": "", "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType(""), "name": github_types.GitHubRepositoryName("test2"), "private": False, } ) client = FakeClient(gh_owner["login"], gh_repo["name"]) installation = context.Installation( installation_json, sub, client, redis_cache, mock.Mock() ) repository = context.Repository(installation, gh_repo) assert client.called == 0 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 1 # From local cache assert not await repository.team_has_read_permission(team_slug2) assert client.called == 1 # From redis repository._caches.team_has_read_permission.clear() assert not await repository.team_has_read_permission(team_slug2) assert client.called == 1 assert await repository.team_has_read_permission(team_slug1) assert client.called == 2 await context.Repository.clear_team_permission_cache_for_repo( redis_cache, gh_owner, gh_repo ) repository._caches.team_has_read_permission.clear() assert await repository.team_has_read_permission(team_slug1) assert client.called == 3 assert not await repository.team_has_read_permission(team_slug3) assert client.called == 4 await context.Repository.clear_team_permission_cache_for_org(redis_cache, gh_owner) repository._caches.team_has_read_permission.clear() assert not await repository.team_has_read_permission(team_slug3) assert client.called == 5 assert not await repository.team_has_read_permission(team_slug2) assert client.called == 6 # From local cache assert not await repository.team_has_read_permission(team_slug2) assert client.called == 6 # From redis repository._caches.team_has_read_permission.clear() assert not await repository.team_has_read_permission(team_slug2) assert client.called == 6 repository._caches.team_has_read_permission.clear() await context.Repository.clear_team_permission_cache_for_team( redis_cache, gh_owner, team_slug2 ) repository._caches.team_has_read_permission.clear() assert not await repository.team_has_read_permission(team_slug2) assert client.called == 7
async def report( url: str, ) -> typing.Union[context.Context, github.AsyncGithubInstallationClient, None]: redis_cache = utils.create_aredis_for_cache(max_idle_time=0) try: owner, repo, pull_number = _url_parser(url) except ValueError: print(f"{url} is not valid") return None try: client = github.aget_client(owner) except exceptions.MergifyNotInstalled: print(f"* Mergify is not installed on account {owner}") return None # Do a dumb request just to authenticate await client.get("/") if client.auth.installation is None: print("No installation detected") return None print(f"* INSTALLATION ID: {client.auth.installation['id']}") if client.auth.owner_id is None: raise RuntimeError("Unable to get owner_id") if repo is None: slug = None else: slug = owner + "/" + repo cached_sub = await subscription.Subscription.get_subscription( redis_cache, client.auth.owner_id) db_sub = await subscription.Subscription._retrieve_subscription_from_db( redis_cache, client.auth.owner_id) cached_tokens = await user_tokens.UserTokens.get(redis_cache, client.auth.owner_id) db_tokens = await user_tokens.UserTokens._retrieve_from_db( redis_cache, client.auth.owner_id) print(f"* SUBSCRIBED (cache/db): {cached_sub.active} / {db_sub.active}") print("* Features (cache):") for f in db_sub.features: print(f" - {f.value}") print("* Features (db):") for f in cached_sub.features: print(f" - {f.value}") await report_dashboard_synchro(client.auth.installation["id"], cached_sub, cached_tokens, "ENGINE-CACHE", slug) await report_dashboard_synchro(client.auth.installation["id"], db_sub, db_tokens, "DASHBOARD", slug) await report_worker_status(owner) installation = context.Installation(client.auth.owner_id, owner, cached_sub, client, redis_cache) if repo is not None: repo_info: github_types.GitHubRepository = await client.item( f"/repos/{owner}/{repo}") repository = context.Repository(installation, repo_info["name"], repo_info["id"]) print( f"* REPOSITORY IS {'PRIVATE' if repo_info['private'] else 'PUBLIC'}" ) print("* CONFIGURATION:") mergify_config = None config_file = await repository.get_mergify_config_file() if config_file is None: print(".mergify.yml is missing") else: print(f"Config filename: {config_file['path']}") print(config_file["decoded_content"].decode()) try: mergify_config = rules.get_mergify_config(config_file) except rules.InvalidRules as e: # pragma: no cover print(f"configuration is invalid {str(e)}") else: mergify_config["pull_request_rules"].rules.extend( engine.MERGIFY_BUILTIN_CONFIG["pull_request_rules"].rules) if pull_number is None: async for branch in typing.cast( typing.AsyncGenerator[github_types.GitHubBranch, None], client.items(f"/repos/{owner}/{repo}/branches"), ): # TODO(sileht): Add some informations on the train q: queue.QueueBase = naive.Queue(repository, branch["name"]) await report_queue("QUEUES", q) q = merge_train.Train(repository, branch["name"]) await q.load() await report_queue("TRAIN", q) else: repository = context.Repository( installation, github_types.GitHubRepositoryName(repo)) ctxt = await repository.get_pull_request_context( github_types.GitHubPullRequestNumber(int(pull_number))) # FIXME queues could also be printed if no pull number given # TODO(sileht): display train if any q = await naive.Queue.from_context(ctxt) print( f"* QUEUES: {', '.join([f'#{p}' for p in await q.get_pulls()])}" ) q = await merge_train.Train.from_context(ctxt) print( f"* TRAIN: {', '.join([f'#{p}' for p in await q.get_pulls()])}" ) print("* PULL REQUEST:") pr_data = await ctxt.pull_request.items() pprint.pprint(pr_data, width=160) is_behind = await ctxt.is_behind print(f"is_behind: {is_behind}") print(f"mergeable_state: {ctxt.pull['mergeable_state']}") print("* MERGIFY LAST CHECKS:") for c in await ctxt.pull_engine_check_runs: print( f"[{c['name']}]: {c['conclusion']} | {c['output'].get('title')}" ) print("> " + "\n> ".join( ("No Summary", ) if c["output"]["summary"] is None else c["output"]["summary"].split("\n"))) if mergify_config is not None: print("* MERGIFY LIVE MATCHES:") match = await mergify_config["pull_request_rules" ].get_pull_request_rule(ctxt) summary_title, summary = await actions_runner.gen_summary( ctxt, match) print(f"[Summary]: success | {summary_title}") print("> " + "\n> ".join(summary.strip().split("\n"))) return ctxt return client
async def test_get_mergify_config_invalid( invalid: str, redis_cache: utils.RedisCache) -> None: with pytest.raises(InvalidRules): async def item(*args, **kwargs): return github_types.GitHubContentFile({ "content": encodebytes(invalid.encode()).decode(), "path": ".mergify.yml", "type": "file", "sha": "azertyu", }) client = mock.Mock() client.item.return_value = item() gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("foobar"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "foobar/xyz", "name": github_types.GitHubRepositoryName("xyz"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }) installation = context.Installation( github_types.GitHubAccountIdType(0), github_types.GitHubLogin("foobar"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository( installation, gh_repo, ) config_file = await repository.get_mergify_config_file() assert config_file is not None get_mergify_config(config_file)
async def test_get_mergify_config_with_defaults( redis_cache: utils.RedisCache) -> None: config = """ defaults: actions: comment: bot_account: foo-bot rebase: bot_account: test-bot-account pull_request_rules: - name: ahah conditions: - base=master actions: comment: message: I love Mergify rebase: {} """ async def item(*args, **kwargs): return github_types.GitHubContentFile({ "content": encodebytes(config.encode()).decode(), "path": ".mergify.yml", "type": "file", "sha": "azertyu", }) client = mock.Mock() client.item.return_value = item() installation = context.Installation( github_types.GitHubAccountIdType(0), github_types.GitHubLogin("foobar"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository( installation, github_types.GitHubRepositoryName("xyz"), github_types.GitHubRepositoryIdType(0), ) config_file = await repository.get_mergify_config_file() assert config_file is not None schema = get_mergify_config(config_file) assert isinstance(schema, dict) assert len(schema["pull_request_rules"].rules) == 1 comment = schema["pull_request_rules"].rules[0].actions["comment"].config assert comment == {"message": "I love Mergify", "bot_account": "foo-bot"} rebase = schema["pull_request_rules"].rules[0].actions["rebase"].config assert rebase == {"bot_account": "test-bot-account"} config = """ defaults: actions: comment: message: I love Mergify bot_account: AutoBot pull_request_rules: - name: ahah conditions: - base=master actions: comment: message: I really love Mergify """ client = mock.Mock() client.item.return_value = item() installation = context.Installation( github_types.GitHubAccountIdType(0), github_types.GitHubLogin("foobar"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository( installation, github_types.GitHubRepositoryName("xyz"), github_types.GitHubRepositoryIdType(0), ) config_file = await repository.get_mergify_config_file() assert config_file is not None schema = get_mergify_config(config_file) assert isinstance(schema, dict) assert len(schema["pull_request_rules"].rules) == 1 comment = schema["pull_request_rules"].rules[0].actions["comment"].config assert comment == { "message": "I really love Mergify", "bot_account": "AutoBot" }
async def prepare_context(client, redis_cache, subscribed=True): sub = subscription.Subscription( redis_cache, 123, subscribed, "sub or not to sub", frozenset( getattr(subscription.Features, f) for f in subscription.Features.__members__) if subscribed else frozenset(), ) gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "user/name", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }) installation = context.Installation(123, "Mergifyio", sub, client, redis_cache) repository = context.Repository(installation, gh_repo) return await context.Context.create( repository, { "id": 12345, "number": 123, "state": None, "mergeable_state": "ok", "merged_by": None, "merged": None, "merged_at": None, "user": { "login": "******" }, "requested_reviewers": [{ "login": "******" }, { "login": "******" }], "requested_teams": [{ "slug": "foobar" }, { "slug": "foobaz" }], "base": { "sha": "sha", "ref": "main", "user": { "login": { "Mergifyio", }, }, "repo": { "full_name": "Mergifyio/demo", "name": "demo", "private": False, "owner": { "login": "******", }, }, }, }, )
async def test_get_pull_request_rule(redis_cache: utils.RedisCache) -> None: client = mock.Mock() get_reviews = [{ "user": { "login": "******", "id": 12321, "type": "User" }, "state": "APPROVED", "author_association": "MEMBER", }] get_files = [{"filename": "README.rst"}, {"filename": "setup.py"}] get_team_members = [{ "login": "******", "id": 12321 }, { "login": "******", "id": 2644 }] get_checks: typing.List[github_types.GitHubCheckRun] = [] get_statuses: typing.List[github_types.GitHubStatus] = [{ "context": "continuous-integration/fake-ci", "state": "success", "description": "foobar", "target_url": "http://example.com", "avatar_url": "", }] async def client_item(url, *args, **kwargs): if url == "/repos/another-jd/name/collaborators/sileht/permission": return {"permission": "write"} elif url == "/repos/another-jd/name/collaborators/jd/permission": return {"permission": "write"} raise RuntimeError(f"not handled url {url}") client.item.side_effect = client_item async def client_items(url, *args, **kwargs): if url == "/repos/another-jd/name/pulls/1/reviews": for r in get_reviews: yield r elif url == "/repos/another-jd/name/pulls/1/files": for f in get_files: yield f elif url == "/repos/another-jd/name/commits/<sha>/check-runs": for c in get_checks: yield c elif url == "/repos/another-jd/name/commits/<sha>/status": for s in get_statuses: yield s elif url == "/orgs/another-jd/teams/my-reviewers/members": for tm in get_team_members: yield tm else: raise RuntimeError(f"not handled url {url}") client.items.side_effect = client_items installation = context.Installation( github_types.GitHubAccountIdType(2644), github_types.GitHubLogin("another-jd"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository( installation, github_types.GitHubRepositoryName("name"), github_types.GitHubRepositoryIdType(123321), ) ctxt = await context.Context.create( repository, github_types.GitHubPullRequest({ "id": github_types.GitHubPullRequestId(0), "number": github_types.GitHubPullRequestNumber(1), "commits": 1, "html_url": "<html_url>", "merge_commit_sha": None, "maintainer_can_modify": True, "rebaseable": True, "state": "closed", "merged_by": None, "merged_at": None, "merged": False, "draft": False, "mergeable_state": "unstable", "labels": [], "changed_files": 1, "base": { "label": "repo", "ref": github_types.GitHubRefType("master"), "repo": { "id": github_types.GitHubRepositoryIdType(123321), "name": github_types.GitHubRepositoryName("name"), "full_name": "another-jd/name", "private": False, "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "owner": { "login": github_types.GitHubLogin("another-jd"), "id": github_types.GitHubAccountIdType(2644), "type": "User", "avatar_url": "", }, }, "user": { "login": github_types.GitHubLogin("another-jd"), "id": github_types.GitHubAccountIdType(2644), "type": "User", "avatar_url": "", }, "sha": github_types.SHAType("mew"), }, "head": { "label": "foo", "ref": github_types.GitHubRefType("myfeature"), "sha": github_types.SHAType("<sha>"), "repo": { "id": github_types.GitHubRepositoryIdType(123321), "name": github_types.GitHubRepositoryName("head"), "full_name": "another-jd/head", "private": False, "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "owner": { "login": github_types.GitHubLogin("another-jd"), "id": github_types.GitHubAccountIdType(2644), "type": "User", "avatar_url": "", }, }, "user": { "login": github_types.GitHubLogin("another-jd"), "id": github_types.GitHubAccountIdType(2644), "type": "User", "avatar_url": "", }, }, "title": "My awesome job", "user": { "login": github_types.GitHubLogin("another-jd"), "id": github_types.GitHubAccountIdType(2644), "type": "User", "avatar_url": "", }, }), ) # Empty conditions pull_request_rules = rules.PullRequestRules([ rules.Rule(name="default", conditions=rules.RuleConditions([]), actions={}) ]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert [ rules.EvaluatedRule.from_rule(r, rules.RuleMissingConditions([]), []) for r in match.rules ] == match.matching_rules for rule in match.rules: assert rule.actions == {} pull_request_rules = pull_request_rule_from_list([{ "name": "hello", "conditions": ["base:master"], "actions": {} }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["hello"] assert [r.name for r in match.matching_rules] == ["hello"] assert [ rules.EvaluatedRule.from_rule(r, rules.RuleMissingConditions([]), []) for r in match.rules ] == match.matching_rules for rule in match.rules: assert rule.actions == {} pull_request_rules = pull_request_rule_from_list([ { "name": "hello", "conditions": ["base:master"], "actions": {} }, { "name": "backport", "conditions": ["base:master"], "actions": {} }, ]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["hello", "backport"] assert [r.name for r in match.matching_rules] == ["hello", "backport"] assert [ rules.EvaluatedRule.from_rule(r, rules.RuleMissingConditions([]), []) for r in match.rules ] == match.matching_rules for rule in match.rules: assert rule.actions == {} pull_request_rules = pull_request_rule_from_list([ { "name": "hello", "conditions": ["author:foobar"], "actions": {} }, { "name": "backport", "conditions": ["base:master"], "actions": {} }, ]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["hello", "backport"] assert [r.name for r in match.matching_rules] == ["backport"] for rule in match.rules: assert rule.actions == {} pull_request_rules = pull_request_rule_from_list([ { "name": "hello", "conditions": ["author:another-jd"], "actions": {} }, { "name": "backport", "conditions": ["base:master"], "actions": {} }, ]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["hello", "backport"] assert [r.name for r in match.matching_rules] == ["hello", "backport"] assert [ rules.EvaluatedRule.from_rule(r, rules.RuleMissingConditions([]), []) for r in match.rules ] == match.matching_rules for rule in match.rules: assert rule.actions == {} # No match pull_request_rules = pull_request_rule_from_list([{ "name": "merge", "conditions": [ "base=xyz", "check-success=continuous-integration/fake-ci", "#approved-reviews-by>=1", ], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["merge"] assert [r.name for r in match.matching_rules] == [] pull_request_rules = pull_request_rule_from_list([{ "name": "merge", "conditions": [ "base=master", "check-success=continuous-integration/fake-ci", "#approved-reviews-by>=1", ], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["merge"] assert [r.name for r in match.matching_rules] == ["merge"] assert [ rules.EvaluatedRule.from_rule(r, rules.RuleMissingConditions([]), []) for r in match.rules ] == match.matching_rules for rule in match.rules: assert rule.actions == {} pull_request_rules = pull_request_rule_from_list([ { "name": "merge", "conditions": [ "base=master", "check-success=continuous-integration/fake-ci", "#approved-reviews-by>=2", ], "actions": {}, }, { "name": "fast merge", "conditions": [ "base=master", "label=fast-track", "check-success=continuous-integration/fake-ci", "#approved-reviews-by>=1", ], "actions": {}, }, { "name": "fast merge with alternate ci", "conditions": [ "base=master", "label=fast-track", "check-success=continuous-integration/fake-ci-bis", "#approved-reviews-by>=1", ], "actions": {}, }, { "name": "fast merge from a bot", "conditions": [ "base=master", "author=mybot", "check-success=continuous-integration/fake-ci", ], "actions": {}, }, ]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == [ "merge", "fast merge", "fast merge with alternate ci", "fast merge from a bot", ] assert [r.name for r in match.matching_rules] == [ "merge", "fast merge", "fast merge with alternate ci", ] for rule in match.rules: assert rule.actions == {} assert match.matching_rules[0].name == "merge" assert len(match.matching_rules[0].missing_conditions) == 1 assert (str(match.matching_rules[0].missing_conditions[0]) == "#approved-reviews-by>=2") assert match.matching_rules[1].name == "fast merge" assert len(match.matching_rules[1].missing_conditions) == 1 assert str( match.matching_rules[1].missing_conditions[0]) == "label=fast-track" assert match.matching_rules[2].name == "fast merge with alternate ci" assert len(match.matching_rules[2].missing_conditions) == 2 assert str( match.matching_rules[2].missing_conditions[0]) == "label=fast-track" assert (str(match.matching_rules[2].missing_conditions[1]) == "check-success=continuous-integration/fake-ci-bis") # Team conditions with one review missing pull_request_rules = pull_request_rule_from_list([{ "name": "default", "conditions": [ "approved-reviews-by=@another-jd/my-reviewers", "#approved-reviews-by>=2", ], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 1 assert (str(match.matching_rules[0].missing_conditions[0]) == "#approved-reviews-by>=2") get_reviews.append({ "user": { "login": "******", "id": 2644, "type": "User" }, "state": "APPROVED", "author_association": "MEMBER", }) del ctxt._cache["reviews"] del ctxt._cache["consolidated_reviews"] # Team conditions with no review missing pull_request_rules = pull_request_rule_from_list([{ "name": "default", "conditions": [ "approved-reviews-by=@another-jd/my-reviewers", "#approved-reviews-by>=2", ], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 0 # Forbidden labels, when no label set pull_request_rules = pull_request_rule_from_list([{ "name": "default", "conditions": ["-label~=^(status/wip|status/blocked|review/need2)$"], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 0 # Forbidden labels, when forbiden label set ctxt.pull["labels"] = [{ "id": 0, "color": "#1234", "default": False, "name": "status/wip" }] match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 1 assert str(match.matching_rules[0].missing_conditions[0]) == ( "-label~=^(status/wip|status/blocked|review/need2)$") # Forbidden labels, when other label set ctxt.pull["labels"] = [{ "id": 0, "color": "#1234", "default": False, "name": "allowed" }] match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 0 # Test team expander pull_request_rules = pull_request_rule_from_list([{ "name": "default", "conditions": ["author~=^(user1|user2|another-jd)$"], "actions": {}, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default"] assert [r.name for r in match.matching_rules] == ["default"] assert match.matching_rules[0].name == "default" assert len(match.matching_rules[0].missing_conditions) == 0 # branch protection async def client_item_with_branch_protection_enabled(url, *args, **kwargs): if url == "/repos/another-jd/name/branches/master": return { "protection": { "enabled": True, "required_status_checks": { "contexts": ["awesome-ci"] }, }, } raise RuntimeError(f"not handled url {url}") client.item.side_effect = client_item_with_branch_protection_enabled pull_request_rules = pull_request_rule_from_list([{ "name": "default", "conditions": [], "actions": { "merge": {}, "comment": { "message": "yo" } }, }]) match = await pull_request_rules.get_pull_request_rule(ctxt) assert [r.name for r in match.rules] == ["default", "default"] assert list(match.matching_rules[0].actions.keys()) == ["merge"] assert [str(c) for c in match.matching_rules[0].conditions ] == ["check-success=awesome-ci"] assert [str(c) for c in match.matching_rules[0].missing_conditions ] == ["check-success=awesome-ci"] assert list(match.matching_rules[1].actions.keys()) == ["comment"] assert match.matching_rules[1].conditions == []
async def test_get_commits_to_cherry_pick_merge( commits: mock.PropertyMock, redis_cache: utils.RedisCache, ) -> None: c1 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("c1f"), "parents": [], "commit": { "message": "foobar" }, }) c2 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("c2"), "parents": [c1], "commit": { "message": "foobar" }, }) async def fake_commits(): return [c1, c2] commits.return_value = fake_commits() client = mock.Mock() client.auth.get_access_token.return_value = "<token>" gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "user/name", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }) installation = context.Installation( github_types.GitHubAccountIdType(123), github_types.GitHubLogin("user"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository(installation, gh_repo) ctxt = await context.Context.create( repository, { "number": github_types.GitHubPullRequestNumber(6), "commits": 1, "merged": True, "state": "closed", "html_url": "<html_url>", "id": github_types.GitHubPullRequestId(0), "maintainer_can_modify": True, "labels": [], "rebaseable": True, "draft": True, "merge_commit_sha": None, "title": "foobar", "changed_files": 1, "base": { "label": "user:ref", "sha": github_types.SHAType("sha"), "ref": github_types.GitHubRefType("ref"), "user": gh_owner, "repo": github_types.GitHubRepository( { "full_name": "user/ref", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }), }, "head": { "label": "user:ref", "sha": github_types.SHAType("sha"), "user": gh_owner, "ref": github_types.GitHubRefType("fork"), "repo": github_types.GitHubRepository( { "full_name": "fork/other", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }), }, "user": gh_owner, "merged_at": None, "merged_by": None, "mergeable_state": "clean", }, ) base_branch = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("base_branch"), "parents": [], "commit": { "message": "foobar" }, }) merge_commit = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("merge_commit"), "parents": [base_branch, c2], "commit": { "message": "foobar" }, }) assert await duplicate_pull._get_commits_to_cherrypick(ctxt, merge_commit) == [ c1, c2, ]
async def test_signals(redis_cache): gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "id": github_types.GitHubRepositoryIdType(456), "full_name": "user/ref", "name": github_types.GitHubRepositoryName("name"), "private": False, "owner": gh_owner, }) client = mock.AsyncMock() client.auth.get_access_token.return_value = "<token>" sub = subscription.Subscription(redis_cache, 0, False, "", frozenset()) installation = context.Installation( gh_owner["id"], gh_owner["login"], sub, client, redis_cache, ) repository = context.Repository(installation, gh_repo["name"], gh_repo["id"]) ctxt = await context.Context.create( repository, { "title": "", "id": github_types.GitHubPullRequestId(0), "maintainer_can_modify": False, "rebaseable": False, "draft": False, "merge_commit_sha": None, "labels": [], "number": github_types.GitHubPullRequestNumber(6), "commits": 1, "merged": True, "state": "closed", "changed_files": 1, "html_url": "<html_url>", "base": { "label": "", "sha": github_types.SHAType("sha"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "ref": github_types.GitHubRefType("ref"), "label": "", "repo": gh_repo, }, "head": { "label": "", "sha": github_types.SHAType("old-sha-one"), "ref": github_types.GitHubRefType("fork"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "repo": { "archived": False, "url": "", "default_branch": github_types.GitHubRefType(""), "id": github_types.GitHubRepositoryIdType(123), "full_name": "fork/other", "name": github_types.GitHubRepositoryName("other"), "private": False, "owner": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, }, }, "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "merged_by": None, "merged_at": None, "mergeable_state": "clean", }, ) assert len(signals.SIGNALS) == 0 signals.setup() assert len(signals.SIGNALS) == 1 with mock.patch( "mergify_engine_signals.noop.Signal.__call__") as signal_method: await signals.send(ctxt, "action.update") signal_method.assert_called_once_with(ctxt, "action.update")
async def asyncSetUp(self): super(FunctionalTestBase, self).setUp() self.existing_labels: typing.List[str] = [] self.protected_branches: typing.Set[str] = set() self.pr_counter: int = 0 self.git_counter: int = 0 self.cassette_library_dir = os.path.join(CASSETTE_LIBRARY_DIR_BASE, self.__class__.__name__, self._testMethodName) # Recording stuffs if RECORD: if os.path.exists(self.cassette_library_dir): shutil.rmtree(self.cassette_library_dir) os.makedirs(self.cassette_library_dir) self.recorder = vcr.VCR( cassette_library_dir=self.cassette_library_dir, record_mode="all" if RECORD else "none", match_on=["method", "uri"], ignore_localhost=True, filter_headers=[ ("Authorization", "<TOKEN>"), ("X-Hub-Signature", "<SIGNATURE>"), ("User-Agent", None), ("Accept-Encoding", None), ("Connection", None), ], before_record_response=self.response_filter, ) if RECORD: github.CachedToken.STORAGE = {} else: # Never expire token during replay mock.patch.object(github_app, "get_or_create_jwt", return_value="<TOKEN>").start() mock.patch.object( github.GithubAppInstallationAuth, "get_access_token", return_value="<TOKEN>", ).start() # NOTE(sileht): httpx pyvcr stubs does not replay auth_flow as it directly patch client.send() # So anything occurring during auth_flow have to be mocked during replay def get_auth(owner_name=None, owner_id=None, auth=None): if auth is None: auth = github.get_auth(owner_name, owner_id) auth.installation = { "id": config.INSTALLATION_ID, } auth.permissions_need_to_be_updated = False auth.owner_id = config.TESTING_ORGANIZATION_ID auth.owner = config.TESTING_ORGANIZATION return auth def github_aclient(owner_name=None, owner_id=None, auth=None): return github.AsyncGithubInstallationClient( get_auth(owner_name, owner_id, auth)) mock.patch.object(github, "aget_client", github_aclient).start() mock.patch.object(branch_updater.gitter, "Gitter", self.get_gitter).start() mock.patch.object(duplicate_pull.gitter, "Gitter", self.get_gitter).start() if not RECORD: # NOTE(sileht): Don't wait exponentialy during replay mock.patch.object(context.Context._ensure_complete.retry, "wait", None).start() # Web authentification always pass mock.patch("hmac.compare_digest", return_value=True).start() branch_prefix_path = os.path.join(self.cassette_library_dir, "branch_prefix") if RECORD: self.BRANCH_PREFIX = datetime.datetime.utcnow().strftime( "%Y%m%d%H%M%S") with open(branch_prefix_path, "w") as f: f.write(self.BRANCH_PREFIX) else: with open(branch_prefix_path, "r") as f: self.BRANCH_PREFIX = f.read() self.master_branch_name = self.get_full_branch_name("master") self.git = self.get_gitter(LOG) await self.git.init() self.addAsyncCleanup(self.git.cleanup) await root.startup() self.app = httpx.AsyncClient(app=root.app, base_url="http://localhost") await self.clear_redis_cache() self.redis_cache = utils.create_aredis_for_cache(max_idle_time=0) self.subscription = subscription.Subscription( self.redis_cache, config.TESTING_ORGANIZATION_ID, self.SUBSCRIPTION_ACTIVE, "You're not nice", frozenset( getattr(subscription.Features, f) for f in subscription.Features.__members__) if self.SUBSCRIPTION_ACTIVE else frozenset(), ) await self.subscription._save_subscription_to_cache() self.user_tokens = user_tokens.UserTokens( self.redis_cache, config.TESTING_ORGANIZATION_ID, { "mergify-test1": config.ORG_ADMIN_GITHUB_APP_OAUTH_TOKEN, "mergify-test3": config.ORG_USER_PERSONAL_TOKEN, }, ) await self.user_tokens.save_to_cache() # Let's start recording cassette = self.recorder.use_cassette("http.json") cassette.__enter__() self.addCleanup(cassette.__exit__) self.client_integration = github.aget_client( config.TESTING_ORGANIZATION, config.TESTING_ORGANIZATION_ID) self.client_admin = github.AsyncGithubInstallationClient( auth=github.GithubTokenAuth(token=config.ORG_ADMIN_PERSONAL_TOKEN)) self.client_fork = github.AsyncGithubInstallationClient( auth=github.GithubTokenAuth(token=self.FORK_PERSONAL_TOKEN)) self.addAsyncCleanup(self.client_integration.aclose) self.addAsyncCleanup(self.client_admin.aclose) self.addAsyncCleanup(self.client_fork.aclose) await self.client_admin.item("/user") await self.client_fork.item("/user") if RECORD: assert self.client_admin.auth.owner == "mergify-test1" assert self.client_fork.auth.owner == "mergify-test2" else: self.client_admin.auth.owner = "mergify-test1" self.client_fork.auth.owner = "mergify-test2" self.url_main = f"/repos/mergifyio-testing/{self.REPO_NAME}" self.url_fork = f"/repos/{self.client_fork.auth.owner}/{self.REPO_NAME}" self.git_main = f"{config.GITHUB_URL}/mergifyio-testing/{self.REPO_NAME}" self.git_fork = ( f"{config.GITHUB_URL}/{self.client_fork.auth.owner}/{self.REPO_NAME}" ) self.installation_ctxt = context.Installation( config.TESTING_ORGANIZATION_ID, config.TESTING_ORGANIZATION, self.subscription, self.client_integration, self.redis_cache, ) self.repository_ctxt = context.Repository(self.installation_ctxt, self.REPO_NAME, self.REPO_ID) real_get_subscription = subscription.Subscription.get_subscription async def fake_retrieve_subscription_from_db(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return self.subscription return subscription.Subscription( redis_cache, owner_id, False, "We're just testing", set(), ) async def fake_subscription(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return await real_get_subscription(redis_cache, owner_id) return subscription.Subscription( redis_cache, owner_id, False, "We're just testing", set(), ) mock.patch( "mergify_engine.subscription.Subscription._retrieve_subscription_from_db", side_effect=fake_retrieve_subscription_from_db, ).start() mock.patch( "mergify_engine.subscription.Subscription.get_subscription", side_effect=fake_subscription, ).start() async def fake_retrieve_user_tokens_from_db(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return self.user_tokens return user_tokens.UserTokens(redis_cache, owner_id, {}) real_get_user_tokens = user_tokens.UserTokens.get async def fake_user_tokens(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return await real_get_user_tokens(redis_cache, owner_id) return user_tokens.UserTokens(redis_cache, owner_id, {}) mock.patch( "mergify_engine.user_tokens.UserTokens._retrieve_from_db", side_effect=fake_retrieve_user_tokens_from_db, ).start() mock.patch( "mergify_engine.user_tokens.UserTokens.get", side_effect=fake_user_tokens, ).start() self._event_reader = EventReader(self.app) await self._event_reader.drain() # NOTE(sileht): Prepare a fresh redis await self.clear_redis_stream()
async def test_configuration_initial( github_server: respx.MockRouter, redis_cache: utils.RedisCache ) -> None: github_server.get("/user/12345/installation").respond( 200, json={ "id": 12345, "permissions": { "checks": "write", "contents": "write", "pull_requests": "write", }, "target_type": GH_OWNER["type"], "account": GH_OWNER, }, ) github_server.get(f"{BASE_URL}/pulls/1",).respond( 200, json=typing.cast(typing.Dict[typing.Any, typing.Any], GH_PULL), ) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.mergify.yml") & ~respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond(404) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.mergify/config.yml") & ~respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond(404) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.github/mergify.yml") & ~respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond(404) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.mergify.yml") & respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond( 200, json=typing.cast( typing.Dict[typing.Any, typing.Any], github_types.GitHubContentFile( { "type": "file", "content": FAKE_MERGIFY_CONTENT, "path": ".mergify.yml", "sha": github_types.SHAType( "739e5ec79e358bae7a150941a148b4131233ce2c" ), } ), ), ) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.github/mergify.yml") & respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond(404) github_server.route( respx.patterns.M(method="GET", path=f"{BASE_URL}/contents/.mergify/config.yml") & respx.patterns.M(params__contains={"ref": GH_PULL["merge_commit_sha"]}) ).respond(404) github_server.get( f"{BASE_URL}/commits/{GH_PULL['head']['sha']}/check-runs" ).respond(200, json={"check_runs": []}) github_server.post(f"{BASE_URL}/check-runs").respond( 200, json=typing.cast(typing.Dict[typing.Any, typing.Any], CHECK_RUN) ) installation_json = await github.get_installation_from_account_id(GH_OWNER["id"]) async with github.AsyncGithubInstallationClient( github.GithubAppInstallationAuth(installation_json) ) as client: installation = context.Installation( installation_json, subscription.Subscription( redis_cache, 0, "", frozenset([subscription.Features.PUBLIC_REPOSITORY]), 0, ), client, redis_cache, mock.Mock(), ) repository = context.Repository(installation, GH_REPO) ctxt = await repository.get_pull_request_context( github_types.GitHubPullRequestNumber(1) ) main_config_file = await repository.get_mergify_config_file() assert main_config_file is None changed = await engine._check_configuration_changes(ctxt, main_config_file) assert changed
async def test_get_commits_to_cherry_pick_rebase( commits: mock.PropertyMock, redis_cache: utils.RedisCache, ) -> None: gh_owner = github_types.GitHubAccount({ "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }) gh_repo = github_types.GitHubRepository({ "full_name": "user/name", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": gh_owner, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType("ref"), }) c1 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("c1f"), "parents": [], "commit": { "message": "foobar" }, }) c2 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("c2"), "parents": [c1], "commit": { "message": "foobar" }, }) commits.return_value = [c1, c2] client = mock.Mock() client.auth.get_access_token.return_value = "<token>" client.items.side_effect = fake_get_github_pulls_from_sha installation = context.Installation( github_types.GitHubAccountIdType(123), github_types.GitHubLogin("user"), subscription.Subscription(redis_cache, 0, False, "", frozenset()), client, redis_cache, ) repository = context.Repository(installation, gh_repo) ctxt = await context.Context.create( repository, { "labels": [], "draft": False, "merge_commit_sha": github_types.SHAType(""), "title": "", "commits": 1, "rebaseable": False, "maintainer_can_modify": False, "id": github_types.GitHubPullRequestId(0), "number": github_types.GitHubPullRequestNumber(6), "merged": True, "state": "closed", "html_url": "<html_url>", "changed_files": 1, "base": { "label": "", "sha": github_types.SHAType("sha"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "ref": github_types.GitHubRefType("ref"), "repo": { "full_name": "user/ref", "name": github_types.GitHubRepositoryName("name"), "private": False, "id": github_types.GitHubRepositoryIdType(0), "owner": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType(""), }, }, "head": { "label": "", "sha": github_types.SHAType("sha"), "ref": github_types.GitHubRefType("fork"), "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "repo": { "full_name": "fork/other", "name": github_types.GitHubRepositoryName("other"), "private": False, "archived": False, "url": "", "html_url": "", "default_branch": github_types.GitHubRefType(""), "id": github_types.GitHubRepositoryIdType(0), "owner": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, }, }, "user": { "login": github_types.GitHubLogin("user"), "id": github_types.GitHubAccountIdType(0), "type": "User", "avatar_url": "", }, "merged_by": None, "merged_at": None, "mergeable_state": "clean", }, ) base_branch = github_types.GitHubBranchCommitParent( {"sha": github_types.SHAType("base_branch")}) rebased_c1 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("rebased_c1"), "parents": [base_branch], "commit": { "message": "hello c1" }, }) rebased_c2 = github_types.GitHubBranchCommit({ "sha": github_types.SHAType("rebased_c2"), "parents": [rebased_c1], "commit": { "message": "hello c2" }, }) async def fake_get_github_commit_from_sha(url, api_version=None): if url.endswith("/commits/rebased_c1"): return rebased_c1 if url.endswith("/commits/rebased_c2"): return rebased_c2 raise RuntimeError(f"Unknown URL {url}") client.item.side_effect = fake_get_github_commit_from_sha assert await duplicate_pull._get_commits_to_cherrypick(ctxt, rebased_c2) == [ rebased_c1, rebased_c2, ]
async def test_configuration_check_not_needed_with_configuration_deleted( github_server: respx.MockRouter, redis_cache: utils.RedisCache ) -> None: github_server.get("/user/12345/installation").respond( 200, json={ "id": 12345, "permissions": { "checks": "write", "contents": "write", "pull_requests": "write", }, "target_type": GH_OWNER["type"], "account": GH_OWNER, }, ) github_server.get(f"{BASE_URL}/pulls/1",).respond( 200, json=typing.cast(typing.Dict[typing.Any, typing.Any], GH_PULL), ) github_server.get(f"{BASE_URL}/contents/.mergify.yml").respond( 200, json=typing.cast( typing.Dict[typing.Any, typing.Any], github_types.GitHubContentFile( { "type": "file", "content": FAKE_MERGIFY_CONTENT, "path": ".mergify.yml", "sha": github_types.SHAType( "739e5ec79e358bae7a150941a148b4131233ce2c" ), } ), ), ) # Summary is present, no need to redo the check github_server.get( f"{BASE_URL}/commits/{GH_PULL['head']['sha']}/check-runs" ).respond( 200, json={"check_runs": [SUMMARY_CHECK, CONFIGURATION_DELETED_CHECK]}, ) installation_json = await github.get_installation_from_account_id(GH_OWNER["id"]) async with github.AsyncGithubInstallationClient( github.GithubAppInstallationAuth(installation_json) ) as client: installation = context.Installation( installation_json, subscription.Subscription( redis_cache, 0, "", frozenset([subscription.Features.PUBLIC_REPOSITORY]), 0, ), client, redis_cache, mock.Mock(), ) repository = context.Repository(installation, GH_REPO) ctxt = await repository.get_pull_request_context( github_types.GitHubPullRequestNumber(1) ) main_config_file = await repository.get_mergify_config_file() changed = await engine._check_configuration_changes(ctxt, main_config_file) assert changed