: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
import uuid
from datetime import timedelta
from urllib.parse import urlencode
from unittest.mock import patch
from django.core.cache import cache
from django.utils import timezone
from parameterized import parameterized
from posthog.api.id_jag import JWT_BEARER_GRANT_TYPE
from posthog.api.oauth.client_assertion import PRIVATE_KEY_REQUIRED_MESSAGE
from posthog.constants import AvailableFeature
from posthog.models.oauth import OAuthAccessToken, OAuthApplication, OAuthRefreshToken
from posthog.models.organization import OrganizationMembership
from posthog.models.team.team import Team
from products.access_control.backend.models.access_control import AccessControl
from ee.api.agentic_provisioning.constants import AUTH_CODE_CACHE_PREFIX
from ee.api.agentic_provisioning.test.base import (
TEST_PARTNER_CLIENT_SECRET,
TEST_PARTNER_SCOPES,
ProvisioningTestBase,
provisioning_config,
)
TOKEN_URL = "/api/agentic/oauth/token"
OAUTH_TOKEN_URL = "/oauth/token/"
class TestOAuthTokenExchange(ProvisioningTestBase):
def _set_app_ceiling(self, scopes: list[str]) -> None:
OAuthApplication.objects.filter(id=self.partner.id).update(scopes=scopes)
def _mint_code_with_overrides(self, scopes: list[str] | None = None, **overrides) -> tuple[str, str]:
code, verifier = self._mint_auth_code(scopes=scopes)
key = f"{AUTH_CODE_CACHE_PREFIX}{code}"
data = cache.get(key)
for field, value in overrides.items():
if value is None:
data.pop(field, None)
else:
data[field] = value
cache.set(key, data, timeout=300)
return code, verifier
def _exchange_code(self, code: str, verifier: str, partner: OAuthApplication | None = None):
return self._post_api(
TOKEN_URL,
{
"grant_type": "authorization_code",
"code": code,
"code_verifier": verifier,
**self._client_auth(partner),
},
)
def _refresh(self, refresh_token: str, partner: OAuthApplication | None = None):
return self._post_api(
TOKEN_URL,
{"grant_type": "refresh_token", "refresh_token": refresh_token, **self._client_auth(partner)},
)
def _stamp_session_revoke(self, when=None) -> None:
OAuthApplication.objects.filter(id=self.partner.id).update(sessions_revoked_at=when or timezone.now())
def _public_partner(self, **provisioning: bool) -> OAuthApplication:
return OAuthApplication.objects.create(
client_id="pkce-token-partner",
name="PKCE Token Partner",
client_secret="",
client_type=OAuthApplication.CLIENT_PUBLIC,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
scopes=TEST_PARTNER_SCOPES,
is_provisioning_partner=True,
_provisioning_config=provisioning_config(active=True, **provisioning),
)
def _client_secret_partner(self, **provisioning: bool) -> OAuthApplication:
return OAuthApplication.objects.create(
client_id="client-secret-token-partner",
name="Client Secret Token Partner",
client_secret=TEST_PARTNER_CLIENT_SECRET,
client_type=OAuthApplication.CLIENT_CONFIDENTIAL,
authorization_grant_type=OAuthApplication.GRANT_AUTHORIZATION_CODE,
redirect_uris="https://partner.example.com/callback",
algorithm="RS256",
scopes=TEST_PARTNER_SCOPES,
is_provisioning_partner=True,
_provisioning_config=provisioning_config(active=True, **provisioning),
)
def test_valid_code_exchange_returns_tokens(self):
res = self._request_bearer_token()
assert res.status_code == 200
data = res.json()
assert data["token_type"] == "bearer"
assert data["access_token"].startswith("pha_")
assert data["refresh_token"].startswith("phr_")
assert data["expires_in"] > 0
assert "scope" not in data
assert data["account"]["id"] == str(self.organization.id)
assert len(data["account"]["available_teams"]) >= 1
team_entry = data["account"]["available_teams"][0]
assert "id" in team_entry
assert "name" in team_entry
assert "organization_id" in team_entry
def test_available_teams_exclude_acl_restricted_teams(self):
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()
restricted_team = Team.objects.create_with_data(
initiating_user=self.user, organization=self.organization, name="Restricted team"
)
AccessControl.objects.create(
team=restricted_team,
access_level="none",
resource="project",
resource_id=str(restricted_team.id),
)
data = self._request_bearer_token().json()
listed = data["account"]["available_teams"]
assert self.team.id in [team["id"] for team in listed]
assert restricted_team.id not in [team["id"] for team in listed]
assert restricted_team.name not in [team["name"] for team in listed]
def test_code_is_single_use(self):
code, verifier = self._mint_auth_code()
assert self._exchange_code(code, verifier).status_code == 200
res = self._exchange_code(code, verifier)
assert res.status_code == 400
assert res.json()["error"] == "invalid_grant"
@parameterized.expand(
[
(
"invalid_code",
{"grant_type": "authorization_code", "code": "nonexistent", "code_verifier": "x"},
"invalid_grant",
),
("missing_code", {"grant_type": "authorization_code"}, "invalid_request"),
("unsupported_grant_type", {"grant_type": "client_credentials"}, "unsupported_grant_type"),
("invalid_refresh_token", {"grant_type": "refresh_token", "refresh_token": "phr_invalid"}, "invalid_grant"),
]
)
def test_rejected_grants(self, _name, params, error):
res = self._post_api(TOKEN_URL, params)
assert res.status_code == 400
assert res.json()["error"] == error
def test_code_without_challenge_requires_authentication(self):
code, verifier = self._mint_code_with_overrides(code_challenge=None, code_challenge_method=None)
res = self._exchange_code(code, verifier)
assert res.status_code == 401
assert res.json() == {"error": "invalid_request", "error_description": "Authentication required"}
def test_missing_code_verifier_returns_401(self):
code, _verifier = self._mint_auth_code()
res = self._post_api(TOKEN_URL, {"grant_type": "authorization_code", "code": code})
assert res.status_code == 401
assert res.json()["error_description"] == "code_verifier is required for PKCE"
@parameterized.expand(
[
("missing_credentials", None),
("wrong_secret", "not-the-real-secret"),
]
)
def test_confidential_partner_without_valid_secret_cannot_exchange_code(self, _name, secret):
partner = self._client_secret_partner(can_create_accounts=False)
code, verifier = self._mint_auth_code(partner=partner)
body = {"grant_type": "authorization_code", "code": code, "code_verifier": verifier}
if secret is not None:
body.update(self._client_auth(partner, secret=secret))
res = self._post_api(TOKEN_URL, body)
assert res.status_code == 401
assert res.json()["error"] == "invalid_client"
# Client authentication runs before the code is consumed, so a rejected attempt must
# leave the caller able to retry with the right secret.
assert self._exchange_code(code, verifier, partner).status_code == 200
def test_confidential_partner_without_valid_secret_cannot_refresh(self):
partner = self._client_secret_partner(can_create_accounts=False)
refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
res = self._post_api(
TOKEN_URL,
{
"grant_type": "refresh_token",
"refresh_token": refresh_token,
**self._client_auth(partner, secret="not-the-real-secret"),
},
)
assert res.status_code == 401
assert res.json()["error"] == "invalid_client"
# The rejected refresh must not have revoked the caller's only token.
assert self._refresh(refresh_token, partner).status_code == 200
def test_pkce_partner_exchanges_code_without_a_secret(self):
# PKCE partners are public clients: code_verifier is their only client authentication,
# so requiring a secret from confidential partners must not reach them.
code, verifier = self._mint_auth_code(partner=self._public_partner(can_create_accounts=False))
res = self._post_api(TOKEN_URL, {"grant_type": "authorization_code", "code": code, "code_verifier": verifier})
assert res.status_code == 200
assert res.json()["access_token"].startswith("pha_")
@parameterized.expand(
[
("public_code_exchange", True, {}, "authorization_code", TOKEN_URL, 401),
("public_refresh", True, {}, "refresh_token", TOKEN_URL, 401),
("client_secret_refresh", False, {}, "refresh_token", TOKEN_URL, 401),
(
"paying_public_refresh",
True,
{"can_create_accounts": False, "pays_for_customers": True},
"refresh_token",
TOKEN_URL,
401,
),
("public_refresh_at_oauth_token", True, {}, "refresh_token", OAUTH_TOKEN_URL, 401),
("client_secret_refresh_at_oauth_token", False, {}, "refresh_token", OAUTH_TOKEN_URL, 401),
("exempt_public_refresh", True, {"can_create_accounts": False}, "refresh_token", TOKEN_URL, 200),
(
"exempt_public_refresh_at_oauth_token",
True,
{"can_create_accounts": False},
"refresh_token",
OAUTH_TOKEN_URL,
200,
),
# The Wizard's production shape: a client secret, and no account creation.
("exempt_client_secret_refresh", False, {"can_create_accounts": False}, "refresh_token", TOKEN_URL, 200),
(
"exempt_client_secret_refresh_at_oauth_token",
False,
{"can_create_accounts": False},
"refresh_token",
OAUTH_TOKEN_URL,
200,
),
]
)
def test_unsigned_token_request(
self,
_name: str,
public: bool,
capabilities: dict[str, bool],
grant_type: str,
url: str,
expected_status: int,
) -> None:
# Starts exempt so it can hold a refresh token, as a partner granted a capability later would.
exempt = {"can_create_accounts": False}
partner = self._public_partner(**exempt) if public else self._client_secret_partner(**exempt)
credentials = self._client_auth(partner) if not public else {"client_id": partner.client_id}
if grant_type == "authorization_code":
code, verifier = self._mint_auth_code(partner=partner)
body = {"grant_type": grant_type, "code": code, "code_verifier": verifier, **credentials}
else:
refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
body = {"grant_type": grant_type, "refresh_token": refresh_token, **credentials}
partner.update_provisioning(**{"can_create_accounts": True, **capabilities})
with patch("posthoganalytics.capture") as capture:
res = self._post_api(url, body)
assert res.status_code == expected_status, res.json()
tags = {call.kwargs.get("properties", {}).get("provisioning_signing") for call in capture.call_args_list}
assert ("refused" if expected_status == 401 else "unsigned_exempt") in tags
if expected_status == 401:
assert res.json()["error"] == "invalid_client"
assert res.json()["error_description"] == PRIVATE_KEY_REQUIRED_MESSAGE
@parameterized.expand([("public", True), ("client_secret", False)])
def test_refused_partner_can_still_revoke_its_tokens(self, _name: str, public: bool) -> None:
exempt = {"can_create_accounts": False}
partner = self._public_partner(**exempt) if public else self._client_secret_partner(**exempt)
credentials = {"client_id": partner.client_id} if public else self._client_auth(partner)
refresh_token = self._request_bearer_token(partner=partner).json()["refresh_token"]
partner.update_provisioning(can_create_accounts=True)
res = self._post_api(
"/oauth/revoke/",
urlencode({"token": refresh_token, "token_type_hint": "refresh_token", **credentials}).encode(),
content_type="application/x-www-form-urlencoded",
)
assert res.status_code == 200, res.content
assert not OAuthRefreshToken.objects.filter(token=refresh_token, revoked__isnull=True).exists()
def test_refused_partner_gets_a_401_from_the_jwt_bearer_grant(self):
partner = self._client_secret_partner()
res = self._post_api(
OAUTH_TOKEN_URL,
{"grant_type": JWT_BEARER_GRANT_TYPE, "assertion": "not-an-id-jag", **self._client_auth(partner)},
)
assert res.status_code == 401
assert res.json()["error"] == "invalid_client"
def test_pkce_mismatch_returns_400_without_consuming_code(self):
code, verifier = self._mint_auth_code()
res = self._exchange_code(code, "wrong_verifier_" + "a" * 32)
assert res.status_code == 400
assert res.json()["error"] == "invalid_grant"
# Verification runs before the code is consumed, so a failed attempt must not burn it.
assert self._exchange_code(code, verifier).status_code == 200
@parameterized.expand([("unknown_partner", str(uuid.uuid4())), ("missing_partner", "")])
def test_code_without_resolvable_partner_returns_invalid_grant(self, _name, partner_id):
code, verifier = self._mint_code_with_overrides(partner_id=partner_id)
res = self._exchange_code(code, verifier)
assert res.status_code == 400
assert res.json() == {
"error": "invalid_grant",
"error_description": "Unknown application for this authorization code",
}
def test_code_with_empty_scopes_rejected(self):
code, verifier = self._mint_auth_code(scopes=[])
res = self._exchange_code(code, verifier)
assert res.status_code == 400
assert res.json()["error"] == "invalid_scope"
def test_omitted_request_scopes_resolve_to_app_ceiling(self):
verifier, challenge = self._pkce_pair()
res = self._post_as_partner(
"/api/agentic/provisioning/account_requests",
data={
"id": "req_scopeless",
"email": "[email protected]",
"code_challenge": challenge,
"code_challenge_method": "S256",
},
)
assert res.status_code == 200
code = res.json()["oauth"]["code"]
exchange = self._exchange_code(code, verifier)
assert exchange.status_code == 200
token = OAuthAccessToken.objects.get(token=exchange.json()["access_token"])
assert set(token.scope.split()) == set(TEST_PARTNER_SCOPES)
def test_refresh_token_rotation_is_single_use(self):
first = self._request_bearer_token().json()
res = self._refresh(first["refresh_token"])
assert res.status_code == 200
rotated = res.json()
assert rotated["access_token"].startswith("pha_")
assert rotated["refresh_token"].startswith("phr_")
assert rotated["access_token"] != first["access_token"]
assert rotated["refresh_token"] != first["refresh_token"]
replay = self._refresh(first["refresh_token"])
assert replay.status_code == 400
assert replay.json()["error"] == "invalid_grant"
def test_direct_mint_within_ceiling_grants_requested_scopes(self):
self._set_app_ceiling(["query:read", "project:read"])
code, verifier = self._mint_auth_code(scopes=["query:read"])
res = self._exchange_code(code, verifier)
assert res.status_code == 200
token = OAuthAccessToken.objects.get(token=res.json()["access_token"])
assert token.scope == "query:read"
def test_direct_mint_outside_ceiling_returns_invalid_scope(self):
self._set_app_ceiling(["query:read"])
code, verifier = self._mint_auth_code(scopes=["query:read", "insight:write"])
res = self._exchange_code(code, verifier)
assert res.status_code == 400
assert res.json()["error"] == "invalid_scope"
def test_refresh_narrows_to_tightened_ceiling(self):
self._set_app_ceiling(["query:read", "insight:write"])
first = self._request_bearer_token(scopes=["query:read", "insight:write"]).json()
self._set_app_ceiling(["query:read"])
res = self._refresh(first["refresh_token"])
assert res.status_code == 200
token = OAuthAccessToken.objects.get(token=res.json()["access_token"])
assert token.scope == "query:read"
def test_refresh_rejected_when_scopes_outside_ceiling(self):
self._set_app_ceiling(["insight:write"])
first = self._request_bearer_token(scopes=["insight:write"]).json()
self._set_app_ceiling(["query:read"])
res = self._refresh(first["refresh_token"])
assert res.status_code == 400
assert res.json()["error"] == "invalid_grant"
def test_refresh_rejected_when_token_predates_session_revoke(self):
# Stamp without sweeping, simulating a refresh token the bulk revoke missed.
first = self._request_bearer_token().json()
self._stamp_session_revoke()
tokens_before = OAuthAccessToken.objects.count()
res = self._refresh(first["refresh_token"])
assert res.status_code == 400
body = res.json()
assert body["error"] == "invalid_grant"
assert "revoked" in body["error_description"]
assert OAuthAccessToken.objects.count() == tokens_before
def test_refresh_rejected_when_user_deactivated(self):
first = self._request_bearer_token().json()
self.user.is_active = False
self.user.save()
res = self._refresh(first["refresh_token"])
assert res.status_code == 400
assert res.json()["error"] == "invalid_grant"
def test_refresh_allowed_when_token_postdates_session_revoke(self):
self._stamp_session_revoke(timezone.now() - timedelta(hours=1))
first = self._request_bearer_token()
assert first.status_code == 200
res = self._refresh(first.json()["refresh_token"])
assert res.status_code == 200
@parameterized.expand(
[
("issued_before_revoke", -120, 400),
("missing_issued_at", None, 400),
("issued_after_revoke", 120, 200),
]
)
def test_code_exchange_against_session_revoke_stamp(self, _name, issued_offset_seconds, expected_status):
issued_at = (
(timezone.now() + timedelta(seconds=issued_offset_seconds)).isoformat()
if issued_offset_seconds is not None
else None
)
code, verifier = self._mint_code_with_overrides(issued_at=issued_at)
self._stamp_session_revoke()
res = self._exchange_code(code, verifier)
assert res.status_code == expected_status
if expected_status == 400:
assert res.json()["error"] == "invalid_grant"