async def test_active_feature(redis_cache):
sub = subscription.Subscription(
redis_cache,
123,
"friend",
frozenset([subscription.Features.PRIORITY_QUEUES]),
)
assert sub.has_feature(subscription.Features.PRIORITY_QUEUES) is True
sub = subscription.Subscription(
redis_cache,
123,
"friend",
frozenset([subscription.Features.PRIORITY_QUEUES]),
)
assert sub.has_feature(subscription.Features.PRIORITY_QUEUES) is True
sub = subscription.Subscription.from_dict(
redis_cache,
123,
{
"subscription_reason": "friend",
"features": ["private_repository"],
},
)
assert sub.has_feature(subscription.Features.PRIVATE_REPOSITORY) is True
assert sub.has_feature(subscription.Features.PRIORITY_QUEUES) is False
async def test_init(redis_cache):
subscription.Subscription(
redis_cache,
123,
"friend",
frozenset({subscription.Features.PRIVATE_REPOSITORY}),
)
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,
"We're just testing",
set(subscription.Features.PUBLIC_REPOSITORY),
)
async def test_dict(redis_cache):
owner_id = 1234
sub = subscription.Subscription(
redis_cache,
owner_id,
"friend",
frozenset({subscription.Features.PRIVATE_REPOSITORY}),
)
assert sub.from_dict(redis_cache, owner_id, sub.to_dict(), -2) == sub
async def fake_subscription(redis_cache, owner_id):
return subscription.Subscription(
self.redis_cache,
config.TESTING_ORGANIZATION_ID,
"Abuse",
frozenset(
getattr(subscription.Features, f)
for f in subscription.Features.__members__
)
if self.SUBSCRIPTION_ACTIVE
else frozenset([]),
)
async def test_subscription_db_unavailable(retrieve_subscription_from_db_mock,
redis_cache):
owner_id = 1234
sub = subscription.Subscription(
redis_cache,
owner_id,
"friend",
frozenset([subscription.Features.PUBLIC_REPOSITORY]),
)
retrieve_subscription_from_db_mock.return_value = sub
# no cache, no db -> reraise
retrieve_subscription_from_db_mock.side_effect = http.HTTPServiceUnavailable(
"boom!", response=mock.Mock(), request=mock.Mock())
with pytest.raises(http.HTTPServiceUnavailable):
await subscription.Subscription.get_subscription(redis_cache, owner_id)
retrieve_subscription_from_db_mock.assert_called_once()
# no cache, but db -> got db sub
retrieve_subscription_from_db_mock.reset_mock()
retrieve_subscription_from_db_mock.side_effect = None
rsub = await subscription.Subscription.get_subscription(
redis_cache, owner_id)
assert sub == rsub
retrieve_subscription_from_db_mock.assert_called_once()
# cache not expired and not db -> got cached sub
retrieve_subscription_from_db_mock.reset_mock()
rsub = await subscription.Subscription.get_subscription(
redis_cache, owner_id)
sub.ttl = 259200
assert rsub == sub
retrieve_subscription_from_db_mock.assert_not_called()
# cache expired and not db -> got cached sub
retrieve_subscription_from_db_mock.reset_mock()
retrieve_subscription_from_db_mock.side_effect = http.HTTPServiceUnavailable(
"boom!", response=mock.Mock(), request=mock.Mock())
await redis_cache.expire(f"subscription-cache-owner-{owner_id}", 7200)
rsub = await subscription.Subscription.get_subscription(
redis_cache, owner_id)
sub.ttl = 7200
assert rsub == sub
retrieve_subscription_from_db_mock.assert_called_once()
# cache expired and unexpected db issue -> reraise
retrieve_subscription_from_db_mock.reset_mock()
retrieve_subscription_from_db_mock.side_effect = Exception("WTF")
await redis_cache.expire(f"subscription-cache-owner-{owner_id}", 7200)
with pytest.raises(Exception):
await subscription.Subscription.get_subscription(redis_cache, owner_id)
retrieve_subscription_from_db_mock.assert_called_once()
async def fake_subscription(
redis_cache: redis_utils.RedisCache,
owner_id: github_types.GitHubAccountIdType,
) -> subscription.Subscription:
return subscription.Subscription(
self.redis_links.cache,
config.TESTING_ORGANIZATION_ID,
"Abuse",
frozenset(
getattr(subscription.Features, f)
for f in subscription.Features.__members__)
if self.SUBSCRIPTION_ACTIVE else frozenset([]),
)
async def test_save_sub(features, redis_cache):
owner_id = 1234
sub = subscription.Subscription(
redis_cache,
owner_id,
"friend",
frozenset(features),
)
await sub._save_subscription_to_cache()
rsub = await subscription.Subscription._retrieve_subscription_from_cache(
redis_cache, owner_id)
assert rsub == sub
async def test_from_dict_unknown_features(redis_cache):
assert subscription.Subscription.from_dict(
redis_cache,
123,
{
"subscription_reason": "friend",
"features": ["unknown feature"],
},
) == subscription.Subscription(
redis_cache,
123,
"friend",
frozenset(),
-2,
)
def fake_subscription(
redis_cache: redis_utils.RedisCache,
request: pytest.FixtureRequest,
) -> subscription.Subscription:
marker = request.node.get_closest_marker("subscription")
subscribed = marker is not None
return subscription.Subscription(
redis_cache,
123,
"sub or not to sub",
frozenset(
getattr(subscription.Features, f)
for f in subscription.Features.__members__) if subscribed else
frozenset([subscription.Features.PUBLIC_REPOSITORY]),
)
async def test_checks_feature_disabled(self) -> None:
self.subscription = subscription.Subscription(
self.redis_links.cache,
config.TESTING_INSTALLATION_ID,
"You're not nice",
frozenset(
getattr(subscription.Features, f)
for f in subscription.Features.__members__
if f is not subscription.Features.CUSTOM_CHECKS.value
)
if self.SUBSCRIPTION_ACTIVE
else frozenset([subscription.Features.PUBLIC_REPOSITORY]),
)
await self.subscription._save_subscription_to_cache()
rules = {
"pull_request_rules": [
{
"name": "body need sentry ticket",
"conditions": [
f"base={self.main_branch_name}",
"#title>10",
"#title<50",
"#body<4096",
"#files<100",
"body~=(?m)^(Fixes|Related|Closes) (MERGIFY-ENGINE|MRGFY)-",
"-label=ignore-guideline",
],
"actions": {"post_check": {}},
}
]
}
await self.setup_repo(yaml.dump(rules))
p = await self.create_pr()
await self.run_engine()
p = await self.get_pull(p["number"])
ctxt = await context.Context.create(self.repository_ctxt, p, [])
sorted_checks = sorted(
await ctxt.pull_engine_check_runs, key=operator.itemgetter("name")
)
assert len(sorted_checks) == 2
check = sorted_checks[0]
assert "action_required" == check["conclusion"]
assert "Custom checks are disabled" == check["output"]["title"]
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_user_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 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": "",
"html_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": "",
}
)
installation_json = github_types.GitHubInstallation(
{
"id": github_types.GitHubInstallationIdType(12345),
"target_type": gh_owner["type"],
"permissions": {},
"account": gh_owner,
}
)
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.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
# From local cache
assert not await repository.has_write_permission(user_2)
assert client.called == 2
# From redis
repository._caches.user_permissions.clear()
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": "",
"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 await repository.has_write_permission(user_2)
assert client.called == 1
# From local cache
assert await repository.has_write_permission(user_2)
assert client.called == 1
# From redis
repository._caches.user_permissions.clear()
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
)
repository._caches.user_permissions.clear()
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)
repository._caches.user_permissions.clear()
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
# From local cache
assert await repository.has_write_permission(user_2)
assert client.called == 6
# From redis
repository._caches.user_permissions.clear()
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
)
repository._caches.user_permissions.clear()
assert await repository.has_write_permission(user_2)
assert client.called == 7
async def test_team_members_cache(redis_cache: utils.RedisCache) -> None:
class FakeClient(github.AsyncGithubInstallationClient):
called: int
def __init__(self, owner: str) -> None:
super().__init__(auth=None) # type: ignore[arg-type]
self.owner = owner
self.called = 0
async def items(self, url, *args, **kwargs):
self.called += 1
if url == f"/orgs/{self.owner}/teams/team1/members":
yield {"login": "******"}
yield {"login": "******"}
elif url == f"/orgs/{self.owner}/teams/team2/members":
yield {"login": "******"}
yield {"login": "******"}
elif url == f"/orgs/{self.owner}/teams/team3/members":
return
else:
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": "",
}
)
installation_json = github_types.GitHubInstallation(
{
"id": github_types.GitHubInstallationIdType(12345),
"target_type": gh_owner["type"],
"permissions": {},
"account": gh_owner,
}
)
team_slug1 = github_types.GitHubTeamSlug("team1")
team_slug2 = github_types.GitHubTeamSlug("team2")
team_slug3 = github_types.GitHubTeamSlug("team3")
sub = subscription.Subscription(
redis_cache, 0, "", frozenset([subscription.Features.PUBLIC_REPOSITORY])
)
client = FakeClient(gh_owner["login"])
installation = context.Installation(
installation_json, sub, client, redis_cache, mock.Mock()
)
assert client.called == 0
assert (await installation.get_team_members(team_slug1)) == ["member1", "member2"]
assert client.called == 1
assert (await installation.get_team_members(team_slug1)) == ["member1", "member2"]
assert client.called == 1
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 2
# From local cache
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 2
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 2
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 3
# From local cache
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 3
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 3
await installation.clear_team_members_cache_for_team(
redis_cache, gh_owner, github_types.GitHubTeamSlug(team_slug2)
)
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 4
# From local cache
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 4
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 4
await installation.clear_team_members_cache_for_org(redis_cache, gh_owner)
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug1)) == ["member1", "member2"]
assert client.called == 5
# From local cache
assert (await installation.get_team_members(team_slug1)) == ["member1", "member2"]
assert client.called == 5
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug1)) == ["member1", "member2"]
assert client.called == 5
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 6
# From local cache
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 6
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug2)) == ["member3", "member4"]
assert client.called == 6
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 7
# From local cache
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 7
# From redis
installation._caches.team_members.clear()
assert (await installation.get_team_members(team_slug3)) == []
assert client.called == 7
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
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 dashboard(redis_cache: redis_utils.RedisCache,
request: pytest.FixtureRequest) -> DashboardFixture:
is_unittest_class = request.cls is not None
subscription_active = False
marker = request.node.get_closest_marker("subscription")
if marker:
subscription_active = marker.args[0]
elif is_unittest_class:
subscription_active = request.cls.SUBSCRIPTION_ACTIVE
api_key_admin = "a" * 64
sub = subscription.Subscription(
redis_cache,
config.TESTING_ORGANIZATION_ID,
"You're not nice",
frozenset(
getattr(subscription.Features, f)
for f in subscription.Features.__members__) if subscription_active
else frozenset([subscription.Features.PUBLIC_REPOSITORY]),
)
await sub._save_subscription_to_cache()
user_tokens = user_tokens_mod.UserTokens(
redis_cache,
config.TESTING_ORGANIZATION_ID,
[
{
"id": github_types.GitHubAccountIdType(config.ORG_ADMIN_ID),
"login": github_types.GitHubLogin("mergify-test1"),
"oauth_access_token": config.ORG_ADMIN_GITHUB_APP_OAUTH_TOKEN,
"name": None,
"email": None,
},
{
"id": github_types.GitHubAccountIdType(config.ORG_USER_ID),
"login": github_types.GitHubLogin("mergify-test4"),
"oauth_access_token": config.ORG_USER_PERSONAL_TOKEN,
"name": None,
"email": None,
},
],
)
await typing.cast(user_tokens_mod.UserTokensSaas,
user_tokens).save_to_cache()
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 sub
return subscription.Subscription(
redis_cache,
owner_id,
"We're just testing",
set(subscription.Features.PUBLIC_REPOSITORY),
)
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,
"We're just testing",
set(subscription.Features.PUBLIC_REPOSITORY),
)
patcher = mock.patch(
"mergify_engine.dashboard.subscription.Subscription._retrieve_subscription_from_db",
side_effect=fake_retrieve_subscription_from_db,
)
patcher.start()
request.addfinalizer(patcher.stop)
patcher = mock.patch(
"mergify_engine.dashboard.subscription.Subscription.get_subscription",
side_effect=fake_subscription,
)
patcher.start()
request.addfinalizer(patcher.stop)
async def fake_retrieve_user_tokens_from_db(redis_cache, owner_id):
if owner_id == config.TESTING_ORGANIZATION_ID:
return user_tokens
return user_tokens_mod.UserTokens(redis_cache, owner_id, {})
real_get_user_tokens = user_tokens_mod.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_mod.UserTokens(redis_cache, owner_id, {})
patcher = mock.patch(
"mergify_engine.dashboard.user_tokens.UserTokensSaas._retrieve_from_db",
side_effect=fake_retrieve_user_tokens_from_db,
)
patcher.start()
request.addfinalizer(patcher.stop)
patcher = mock.patch(
"mergify_engine.dashboard.user_tokens.UserTokensSaas.get",
side_effect=fake_user_tokens,
)
patcher.start()
request.addfinalizer(patcher.stop)
async def fake_application_get(redis_cache, api_access_key, api_secret_key,
account_scope):
if (api_access_key == api_key_admin[:32]
and api_secret_key == api_key_admin[32:]):
return application_mod.Application(
redis_cache,
123,
"testing application",
api_access_key,
api_secret_key,
account_scope={
"id": config.TESTING_ORGANIZATION_ID,
"login": config.TESTING_ORGANIZATION_NAME,
},
)
raise application_mod.ApplicationUserNotFound()
patcher = mock.patch(
"mergify_engine.dashboard.application.ApplicationSaas.get",
side_effect=fake_application_get,
)
patcher.start()
request.addfinalizer(patcher.stop)
return DashboardFixture(
api_key_admin,
sub,
user_tokens,
)
