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
