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, )