:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
from parameterized import parameterized
from posthog.constants import AvailableFeature
from posthog.models.oauth import OAuthAccessToken, OAuthApplication, OAuthRefreshToken
from posthog.models.organization import Organization, OrganizationMembership
from posthog.models.team.team import Team
from posthog.models.team.team_provisioning_config import TeamProvisioningConfig
from products.access_control.backend.models.access_control import AccessControl
from ee.api.agentic_provisioning.test.base import ProvisioningTestBase
from ee.api.agentic_provisioning.tokens import compute_partner_scoped_teams
TOKEN_URL = "/api/agentic/oauth/token"
class TestPartnerTokenScopeHydration(ProvisioningTestBase):
def _provision_team(
self, application: OAuthApplication, name: str, project_id: str, organization: Organization | None = None
) -> Team:
team = Team.objects.create_with_data(
initiating_user=self.user,
organization=organization or self.organization,
name=name,
)
TeamProvisioningConfig.objects.update_or_create(
team=team,
defaults={"stripe_project_id": project_id, "application": application},
)
return team
def _restrict_team_access(self, team: Team) -> None:
AccessControl.objects.create(
team=team,
access_level="none",
resource="project",
resource_id=str(team.id),
)
def _enable_access_control_as_member(self) -> None:
self.organization.available_product_features = [
{"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL},
]
self.organization.save()
self.organization_membership.level = OrganizationMembership.Level.MEMBER
self.organization_membership.save()
def _refresh(self, refresh_token: str):
return self._post_api(
TOKEN_URL,
{"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_auth()},
)
def test_issuance_hydrates_with_previously_provisioned_teams(self):
previously_provisioned = self._provision_team(self.partner, "Previously provisioned", "proj_existing")
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
assert self.team.id in access_token.scoped_teams
assert previously_provisioned.id in access_token.scoped_teams
def test_other_partner_teams_excluded(self):
other_partner = OAuthApplication.objects.create(
name="Other Partner",
client_id="other_partner_client_id",
client_secret="",
client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://localhost",
algorithm="RS256",
)
other_partner_team = self._provision_team(other_partner, "Other partner team", "proj_other")
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
assert other_partner_team.id not in access_token.scoped_teams
def test_other_org_team_excluded_even_when_user_is_member(self):
# Same partner provisions teams in two orgs the user belongs to.
# The token is granted under org A's authorization; org B's team must
# not leak in just because the user can access it via org B membership.
other_org = Organization.objects.create(name="Other org")
OrganizationMembership.objects.create(
organization=other_org,
user=self.user,
level=OrganizationMembership.Level.ADMIN,
)
other_org_team = self._provision_team(self.partner, "Same partner, other org", "proj_other_org", other_org)
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
assert self.team.id in access_token.scoped_teams
assert other_org_team.id not in access_token.scoped_teams
def test_cross_org_teams_excluded(self):
other_org = Organization.objects.create(name="Other org")
foreign_team = self._provision_team(self.partner, "Foreign team", "proj_foreign", other_org)
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
assert foreign_team.id not in access_token.scoped_teams
def test_team_with_revoked_access_excluded(self):
self._enable_access_control_as_member()
restricted_team = self._provision_team(self.partner, "Restricted team", "proj_restricted")
self._restrict_team_access(restricted_team)
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
assert restricted_team.id not in access_token.scoped_teams
def test_issuance_rejected_when_no_accessible_teams(self):
# When the base team is gone or the user lost access, compute_partner_scoped_teams
# returns []. An empty scoped_teams is unrestricted under the standard permission
# check, so issuance must fail closed rather than mint a project-unrestricted token.
self._enable_access_control_as_member()
self._restrict_team_access(self.team)
res = self._request_bearer_token()
assert res.status_code == 400, res.content
assert res.json()["error"] == "invalid_grant"
assert not OAuthAccessToken.objects.filter(user=self.user).exists()
def test_refresh_rehydrates_with_new_teams(self):
token = self._get_bearer_token()
access_token = OAuthAccessToken.objects.get(token=token)
refresh_token = OAuthRefreshToken.objects.get(access_token=access_token)
assert access_token.scoped_teams == [self.team.id]
newly_provisioned = self._provision_team(self.partner, "Newly provisioned", "proj_new")
res = self._refresh(refresh_token.token)
assert res.status_code == 200, res.content
new_access_token = OAuthAccessToken.objects.get(token=res.json()["access_token"])
assert self.team.id in new_access_token.scoped_teams
assert newly_provisioned.id in new_access_token.scoped_teams
@parameterized.expand([("issued", False), ("stored_in_id_order", True)])
def test_consented_project_stays_first_across_refreshes_in_partner_created_org(
self, _name: str, stored_in_id_order: bool
) -> None:
TeamProvisioningConfig.objects.update_or_create(team=self.team, defaults={"application": self.partner})
consented = Team.objects.create_with_data(
initiating_user=self.user, organization=self.organization, name="Consented"
)
tokens = self._request_bearer_token(team_id=consented.id).json()
if stored_in_id_order:
OAuthRefreshToken.objects.filter(token=tokens["refresh_token"]).update(
scoped_teams=[self.team.id, consented.id]
)
for _ in range(2):
res = self._refresh(tokens["refresh_token"])
assert res.status_code == 200, res.content
tokens = res.json()
access_token = OAuthAccessToken.objects.get(token=tokens["access_token"])
assert access_token.scoped_teams == [consented.id, self.team.id]
res = self._post_with_bearer("/api/agentic/provisioning/resources", token=tokens["access_token"])
assert res.status_code == 200, res.content
assert res.json()["id"] == str(consented.id)
def test_refresh_rejected_when_access_lost_and_token_preserved(self):
# A refresh whose base team access was revoked recomputes to an empty scope.
# It must fail closed (not rotate into an unrestricted token) and, because the
# check runs before any token mutation, must leave the caller's refresh token intact.
token = self._get_bearer_token()
refresh_token = OAuthRefreshToken.objects.get(access_token__token=token)
self._enable_access_control_as_member()
self._restrict_team_access(self.team)
res = self._refresh(refresh_token.token)
assert res.status_code == 400, res.content
assert res.json()["error"] == "invalid_grant"
refresh_token.refresh_from_db()
assert refresh_token.revoked is None
assert OAuthAccessToken.objects.filter(token=token).exists()
def test_application_none_yields_empty_scope(self):
# application is never None in practice (oauthrefreshtoken.application_id is
# NOT NULL and issuance always resolves an app), so this pins the helper's
# defensive branch: an unattributed token fails closed with no scope rather
# than silently retaining the base team.
assert compute_partner_scoped_teams(None, self.user, self.team.id) == []