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"),
github_types.GitHubRepositoryIdType(0),
)
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_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)
def test_seats_renamed_account_repo() -> None:
user1 = count_seats.SeatAccount(
github_types.GitHubAccountIdType(123),
github_types.GitHubLogin("user1"),
)
user1bis = count_seats.SeatAccount(
github_types.GitHubAccountIdType(123),
github_types.GitHubLogin("user1bis"),
)
user2 = count_seats.SeatAccount(
github_types.GitHubAccountIdType(456),
github_types.GitHubLogin("user2"),
)
user2bis = count_seats.SeatAccount(
github_types.GitHubAccountIdType(456),
github_types.GitHubLogin("user2bis"),
)
users = {user1, user2, user2bis, user1bis}
assert len(users) == 2
assert list(users)[0].login == "user2"
assert list(users)[1].login == "user1"
repo1 = count_seats.SeatRepository(
github_types.GitHubRepositoryIdType(123),
github_types.GitHubRepositoryName("repo1"),
)
repo1bis = count_seats.SeatRepository(
github_types.GitHubRepositoryIdType(123),
github_types.GitHubRepositoryName("repo1bis"),
)
repo2 = count_seats.SeatRepository(
github_types.GitHubRepositoryIdType(456),
github_types.GitHubRepositoryName("repo2"),
)
repo2bis = count_seats.SeatRepository(
github_types.GitHubRepositoryIdType(456),
github_types.GitHubRepositoryName("repo2bis"),
)
repos = {repo1, repo2, repo2bis, repo1bis}
assert repos == {repo1, repo2}
async def iter_trains(
cls, installation: context.Installation
) -> typing.AsyncIterator["Train"]:
for train_name in await installation.redis.keys(
cls.get_redis_key_for(installation.owner_id, "*", "*")):
train_name_split = train_name.split("~")
repo_id = github_types.GitHubRepositoryIdType(
int(train_name_split[2]))
ref = github_types.GitHubRefType(train_name_split[3])
repository = await installation.get_repository_by_id(repo_id)
yield cls(repository, ref)
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),
)
async def send(
redis_stream: utils.RedisStream,
redis_cache: utils.RedisCache,
) -> None:
score = date.utcnow().timestamp()
keys = await redis_cache.zrangebyscore(DELAYED_REFRESH_KEY, "-inf", score)
if not keys:
return
pipe = await redis_stream.pipeline()
keys_to_delete = set()
for subkey in keys:
(
owner_id_str,
owner_login,
repository_id_str,
repository_name,
pull_request_number_str,
) = subkey.split("~")
owner_id = github_types.GitHubAccountIdType(int(owner_id_str))
repository_id = github_types.GitHubRepositoryIdType(
int(repository_id_str))
pull_request_number = github_types.GitHubPullRequestNumber(
int(pull_request_number_str))
LOG.info(
"sending delayed pull request refresh",
gh_owner=owner_login,
gh_repo=repository_name,
action="internal",
source="delayed-refresh",
)
await worker.push(
pipe,
owner_id,
owner_login,
repository_id,
repository_name,
pull_request_number,
"refresh",
{
"action": "internal",
"ref": None,
"source": "delayed-refresh",
}, # type: ignore[typeddict-item]
)
keys_to_delete.add(subkey)
await pipe.execute()
await redis_cache.zrem(DELAYED_REFRESH_KEY, *keys_to_delete)
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)
async def _refresh(
owner: github_types.GitHubLogin,
repo: str,
action: github_types.GitHubEventRefreshActionType = "user",
ref: typing.Optional[github_types.GitHubRefType] = None,
pull_request: typing.Optional[github_types.GitHubPullRequest] = None,
) -> responses.Response:
data = github_types.GitHubEventRefresh({
"action": action,
"organization": {
"login": owner,
"id": github_types.GitHubAccountIdType(0),
"type": "Organization",
},
"installation": {
"id": 0,
"account": {
"login": owner,
"id": github_types.GitHubAccountIdType(0),
"type": "Organization",
},
},
"repository": {
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(0),
"private": False,
"archived": False,
"url": "",
"name": repo,
"owner": {
"login": owner,
"id": github_types.GitHubAccountIdType(0),
"type": "Organization",
},
"full_name": f"{owner}/{repo}",
},
"sender": {
"login": github_types.GitHubLogin("<internal>"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
"ref": ref,
"pull_request": pull_request,
})
await github_events.filter_and_dispatch(_AREDIS_STREAM, "refresh",
str(uuid.uuid4()), data)
return responses.Response("Refresh queued", status_code=202)
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)
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 populate_with_active_users(
self,
redis_cache: redis_utils.RedisCache,
owner_id: typing.Optional[github_types.GitHubAccountIdType] = None,
) -> None:
async for key in get_active_users_keys(
redis_cache, owner_id="*" if owner_id is None else owner_id):
_, _owner_id, owner_login, repo_id, repo_name = key.split("~")
org = SeatAccount(
github_types.GitHubAccountIdType(int(_owner_id)),
github_types.GitHubLogin(owner_login),
)
repo = SeatRepository(
github_types.GitHubRepositoryIdType(int(repo_id)),
github_types.GitHubRepositoryName(repo_name),
)
active_users = await get_active_users(redis_cache, key)
repo_seats = self.seats[org][repo]
if repo_seats["active_users"] is None:
repo_seats["active_users"] = active_users
else:
repo_seats["active_users"] |= active_users
"User",
"avatar_url":
"",
})
GH_REPO = github_types.GitHubRepository({
"archived":
False,
"url":
"",
"html_url":
"",
"default_branch":
github_types.GitHubRefType("main"),
"id":
github_types.GitHubRepositoryIdType(456),
"full_name":
"user/ref",
"name":
github_types.GitHubRepositoryName("name"),
"private":
False,
"owner":
GH_OWNER,
})
GH_PULL = github_types.GitHubPullRequest(
{
"title": "",
"id": github_types.GitHubPullRequestId(0),
"maintainer_can_modify": False,
"rebaseable": False,
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
def a_pull_request() -> github_types.GitHubPullRequest:
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": "",
"html_url": "",
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(456),
"full_name": "user/repo",
"name": github_types.GitHubRepositoryName("repo"),
"private": False,
"owner": gh_owner,
}
)
return github_types.GitHubPullRequest(
{
"node_id": "42",
"locked": False,
"assignees": [],
"requested_reviewers": [],
"requested_teams": [],
"milestone": None,
"title": "",
"updated_at": github_types.ISODateTimeType("2021-06-01T18:41:39Z"),
"created_at": github_types.ISODateTimeType("2021-06-01T18:41:39Z"),
"closed_at": None,
"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"),
"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": "",
"html_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",
"mergeable": True,
"body": None,
}
)
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 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_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 _prepare_repo(self) -> count_seats.Seats:
await self.setup_repo()
await self.create_pr()
await self.run_engine()
# NOTE(sileht): we add active users only on the repository used for
# recording the fixture
repos = (await self.client_admin.get(
url=f"{config.GITHUB_REST_API_URL}/orgs/mergifyio-testing/repos"
)).json()
members = (await self.client_admin.get(
url=f"{config.GITHUB_REST_API_URL}/orgs/mergifyio-testing/members"
)).json()
write_users = {
count_seats.SeatAccount(
github_types.GitHubAccountIdType(member["id"]),
github_types.GitHubLogin(member["login"]),
)
for member in members
}
organization = {}
for repo in repos:
active_users = None
key_repo = count_seats.SeatRepository(
github_types.GitHubRepositoryIdType(repo["id"]),
github_types.GitHubRepositoryName(repo["name"]),
)
if repo["id"] == self.repository_ctxt.repo["id"]:
active_users = {
count_seats.ActiveUser(
github_types.GitHubAccountIdType(
config.TESTING_MERGIFY_TEST_1_ID),
github_types.GitHubLogin("mergify-test1"),
),
count_seats.ActiveUser(
github_types.GitHubAccountIdType(
config.TESTING_MERGIFY_TEST_2_ID),
github_types.GitHubLogin("mergify-test2"),
),
}
write_users_used: typing.Union[typing.Set[count_seats.SeatAccount],
mock.ANY]
if repo["name"] == "functional-testing-repo":
write_users_used = write_users
else:
write_users_used = mock.ANY
organization[key_repo] = count_seats.CollaboratorsSetsT({
"write_users":
write_users_used,
"active_users":
active_users,
})
collaborators = {
count_seats.SeatAccount(
github_types.GitHubAccountIdType(config.TESTING_ORGANIZATION_ID),
github_types.GitHubLogin(config.TESTING_ORGANIZATION_NAME),
):
organization
}
return count_seats.Seats(collaborators)
async def test_summary_synchronization_cache() -> None:
client = mock.MagicMock()
client.auth.get_access_token.return_value = "<token>"
ctxt = context.Context(
client,
{
"id": github_types.GitHubPullRequestId(github_types.GitHubIssueId(0)),
"maintainer_can_modify": False,
"rebaseable": False,
"draft": False,
"merge_commit_sha": None,
"labels": [],
"number": github_types.GitHubPullRequestNumber(
github_types.GitHubIssueNumber(6)
),
"merged": True,
"state": "closed",
"html_url": "<html_url>",
"base": {
"label": "",
"sha": github_types.SHAType("sha"),
"user": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
"ref": github_types.GitHubRefType("ref"),
"label": "",
"repo": {
"archived": False,
"url": "",
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(456),
"full_name": "user/ref",
"name": "name",
"private": False,
"owner": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
},
},
"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",
},
"repo": {
"archived": False,
"url": "",
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(123),
"full_name": "fork/other",
"name": "other",
"private": False,
"owner": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
},
},
"user": {
"login": github_types.GitHubLogin("user"),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
"merged_by": None,
"merged_at": None,
"mergeable_state": "clean",
},
subscription.Subscription(1, False, "", {}, frozenset()),
)
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"
ctxt.clear_cached_last_summary_head_sha()
assert await ctxt.get_cached_last_summary_head_sha() is None
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"),
}),
]
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)
await repository.get_mergify_config_file()
assert client.item.call_count == 3
client.item.assert_has_calls([
mock.call("/repos/foobar/xyz/contents/.mergify.yml", params={}),
mock.call("/repos/foobar/xyz/contents/.mergify/config.yml", params={}),
mock.call("/repos/foobar/xyz/contents/.github/mergify.yml", params={}),
])
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/foobar/xyz/contents/.github/mergify.yml", params={}),
])
async def refresh_pull(
owner: github_types.GitHubLogin,
repo: str,
pull_request_number: github_types.GitHubPullRequestNumber,
action: github_types.GitHubEventRefreshActionType = "user",
) -> responses.Response:
action = RefreshActionSchema(action)
return await _refresh(
owner,
repo,
action=action,
pull_request=github_types.GitHubPullRequest({
"number":
pull_request_number,
"id":
github_types.GitHubPullRequestId(github_types.GitHubIssueId(0)),
"maintainer_can_modify":
False,
"base": {
"label": "",
"ref": github_types.GitHubRefType(""),
"sha": github_types.SHAType(""),
"repo": {
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(0),
"owner": {
"id": github_types.GitHubAccountIdType(0),
"login": github_types.GitHubLogin(""),
"type": "User",
},
"private": False,
"name": "",
"full_name": "",
"archived": False,
"url": "",
},
"user": {
"login": github_types.GitHubLogin(""),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
},
"head": {
"label": "",
"ref": github_types.GitHubRefType(""),
"sha": github_types.SHAType(""),
"repo": {
"default_branch": github_types.GitHubRefType(""),
"id": github_types.GitHubRepositoryIdType(0),
"owner": {
"id": github_types.GitHubAccountIdType(0),
"login": github_types.GitHubLogin(""),
"type": "User",
},
"private": False,
"name": "",
"full_name": "",
"archived": False,
"url": "",
},
"user": {
"login": github_types.GitHubLogin(""),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
},
},
"state":
"open",
"user": {
"id": github_types.GitHubAccountIdType(0),
"login": github_types.GitHubLogin(""),
"type": "User",
},
"labels": [],
"merged":
False,
"merged_by":
None,
"merged_at":
None,
"rebaseable":
False,
"draft":
False,
"merge_commit_sha":
None,
"mergeable_state":
"unknown",
"html_url":
"",
}),
)
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_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 == []
def test_user_permission_cache() -> None:
class FakeClient(github.GithubInstallationClient):
called: int
def __init__(self, owner, repo):
super().__init__(auth=None)
self.owner = owner
self.repo = repo
self.called = 0
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}")
owner = github_types.GitHubAccount({
"id":
github_types.GitHubAccountIdType(123),
"login":
github_types.GitHubLogin("jd"),
"type":
"User",
})
repo = github_types.GitHubRepository({
"id":
github_types.GitHubRepositoryIdType(0),
"owner":
owner,
"full_name":
"",
"archived":
False,
"url":
"",
"default_branch":
github_types.GitHubRefType(""),
"name":
"test",
"private":
False,
})
def make_pr(
repo: github_types.GitHubRepository,
owner: github_types.GitHubAccount
) -> github_types.GitHubPullRequest:
return github_types.GitHubPullRequest({
"id":
github_types.GitHubPullRequestId(github_types.GitHubIssueId(0)),
"maintainer_can_modify":
False,
"head": {
"user": owner,
"label": "",
"ref": github_types.GitHubRefType(""),
"sha": github_types.SHAType(""),
"repo": repo,
},
"user":
owner,
"number":
github_types.GitHubPullRequestNumber(
github_types.GitHubIssueNumber(0)),
"rebaseable":
False,
"draft":
False,
"merge_commit_sha":
None,
"html_url":
"",
"state":
"closed",
"mergeable_state":
"unknown",
"merged_by":
None,
"merged":
False,
"merged_at":
None,
"labels": [],
"base": {
"ref": github_types.GitHubRefType("main"),
"sha": github_types.SHAType(""),
"label": "",
"repo": repo,
"user": owner,
},
})
user_1 = github_types.GitHubAccount({
"id":
github_types.GitHubAccountIdType(1),
"login":
github_types.GitHubLogin("foo"),
"type":
"User",
})
user_2 = github_types.GitHubAccount({
"id":
github_types.GitHubAccountIdType(2),
"login":
github_types.GitHubLogin("bar"),
"type":
"User",
})
user_3 = github_types.GitHubAccount({
"id":
github_types.GitHubAccountIdType(3),
"login":
github_types.GitHubLogin("baz"),
"type":
"User",
})
sub = subscription.Subscription(0, False, "", {}, frozenset())
client = FakeClient(owner["login"], repo["name"])
c = context.Context(client, make_pr(repo, owner), sub)
assert client.called == 0
assert c.has_write_permission(user_1)
assert client.called == 1
assert c.has_write_permission(user_1)
assert client.called == 1
assert not c.has_write_permission(user_2)
assert client.called == 2
assert not c.has_write_permission(user_2)
assert client.called == 2
assert not c.has_write_permission(user_3)
assert client.called == 3
repo = github_types.GitHubRepository({
"id":
github_types.GitHubRepositoryIdType(1),
"owner":
owner,
"full_name":
"",
"archived":
False,
"url":
"",
"default_branch":
github_types.GitHubRefType(""),
"name":
"test2",
"private":
False,
})
client = FakeClient(owner["login"], repo["name"])
c = context.Context(client, make_pr(repo, owner), sub)
assert client.called == 0
assert c.has_write_permission(user_2)
assert client.called == 1
assert c.has_write_permission(user_2)
assert client.called == 1
assert not c.has_write_permission(user_1)
assert client.called == 2
context.Context.clear_user_permission_cache_for_repo(owner, repo)
assert not c.has_write_permission(user_1)
assert client.called == 3
assert not c.has_write_permission(user_3)
assert client.called == 4
context.Context.clear_user_permission_cache_for_org(owner)
assert not c.has_write_permission(user_3)
assert client.called == 5
assert c.has_write_permission(user_2)
assert client.called == 6
assert c.has_write_permission(user_2)
assert client.called == 6
context.Context.clear_user_permission_cache_for_user(owner, repo, user_2)
assert c.has_write_permission(user_2)
assert client.called == 7
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_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")
"base": {
"user": {
"id": github_types.GitHubAccountIdType(0),
"login": github_types.GitHubLogin(""),
"type": "User",
"avatar_url": "",
},
"label": "",
"ref": github_types.GitHubRefType(""),
"sha": github_types.SHAType(""),
"repo": {
"url": "",
"default_branch": github_types.GitHubRefType(""),
"full_name": "",
"archived": False,
"id": github_types.GitHubRepositoryIdType(0),
"private": False,
"name": github_types.GitHubRepositoryName(""),
"owner": {
"login": github_types.GitHubLogin(""),
"id": github_types.GitHubAccountIdType(0),
"type": "User",
"avatar_url": "",
},
},
},
"head": {
"user": {
"id": github_types.GitHubAccountIdType(0),
"login": github_types.GitHubLogin(""),
"type": "User",
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_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"
}
