Skip to content

: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.

16.2 KB
Raw Blame
from datetime import UTC, datetime, timedelta

from posthog.test.base import APIBaseTest, BaseTest
from unittest.mock import MagicMock, patch

import jwt
import requests as req
from rest_framework import status
from rest_framework.test import APIClient

from posthog.models.organization import Organization
from posthog.models.organization_integration import OrganizationIntegration
from posthog.test.authentication_checks import covers_authentication

from ee.api.authentication import BillingServiceAuthentication
from ee.models import License


@patch("ee.api.authentication.get_cached_instance_license")
class TestVercelProxyAPI(APIBaseTest):
    def setUp(self):
        super().setUp()
        self.license_key = "test_license_id::test_license_secret"
        self.license = License.objects.create(key=self.license_key, plan="enterprise", valid_until=datetime.now(UTC))

        self.installation_id = "icfg_9bceb8ccT32d3U417ezb5c8p"
        self.vercel_access_token = "vercel_test_token_123"

        self.integration = OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id=self.installation_id,
            config={
                "billing_plan_id": "free",
                "scopes": ["read", "write"],
            },
            sensitive_config={
                "credentials": {"access_token": self.vercel_access_token, "token_type": "Bearer"},
            },
            created_by=self.user,
        )

        # Use unauthenticated client for these tests
        self.unauthenticated_client = APIClient()

    def _create_billing_service_token(
        self,
        organization_id: str | None = None,
        audience: str = BillingServiceAuthentication.EXPECTED_AUDIENCE,
        expired: bool = False,
    ) -> str:
        secret = self.license_key.split("::")[1]
        exp = datetime.now(UTC) + timedelta(minutes=-5 if expired else 15)

        payload = {
            "exp": exp,
            "aud": audience,
        }
        if organization_id is not None:
            payload["organization_id"] = organization_id

        return jwt.encode(payload, secret, algorithm="HS256")

    def _get_auth_headers(self, token: str | None = None) -> dict:
        if token is None:
            token = self._create_billing_service_token(organization_id=str(self.organization.id))
        return {"HTTP_AUTHORIZATION": f"Bearer {token}"}

    @patch("ee.api.vercel.vercel_proxy.forward_to_vercel")
    def test_proxy_forwards_request_to_vercel(self, mock_forward, mock_license):
        mock_license.return_value = self.license

        mock_response = MagicMock()
        mock_response.ok = True
        mock_response.status_code = 200
        mock_response.json.return_value = {"invoice_id": "inv_123"}
        mock_forward.return_value = mock_response

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {"amount": 100},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_200_OK
        assert response.json() == {"invoice_id": "inv_123"}

        mock_forward.assert_called_once_with(
            config_id=self.installation_id,
            access_token=self.vercel_access_token,
            path="/billing/invoices",
            method="POST",
            body={"amount": 100},
        )

    @patch("ee.api.vercel.vercel_proxy.forward_to_vercel")
    def test_proxy_returns_vercel_error_status(self, mock_forward, mock_license):
        mock_license.return_value = self.license

        mock_response = MagicMock()
        mock_response.ok = False
        mock_response.status_code = 400
        mock_response.text = "Bad request"
        mock_response.json.return_value = {"error": "Invalid invoice data"}
        mock_forward.return_value = mock_response

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert response.json() == {"error": "Invalid invoice data"}

    @patch("ee.api.vercel.vercel_proxy.forward_to_vercel")
    def test_proxy_returns_vercel_204_without_body(self, mock_forward, mock_license):
        mock_license.return_value = self.license

        vercel_response = req.Response()
        vercel_response.status_code = status.HTTP_204_NO_CONTENT
        vercel_response._content = b""
        mock_forward.return_value = vercel_response

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices/inv_123/actions",
                "method": "POST",
                "body": {"action": "refund", "reason": "Duplicate charge", "total": "10.00"},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_204_NO_CONTENT
        assert response.headers.get("Content-Length", "0") == "0"

    def test_proxy_rejects_missing_token(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
        )

        # DRF may return 401 or 403 depending on auth flow
        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)

    def test_proxy_rejects_expired_token(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_billing_service_token(organization_id=str(self.organization.id), expired=True)

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(token),
        )

        # DRF may return 401 or 403 depending on auth flow
        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)

    def test_proxy_rejects_wrong_audience(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_billing_service_token(
            organization_id=str(self.organization.id),
            audience="wrong:audience",
        )

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(token),
        )

        # DRF may return 401 or 403 depending on auth flow
        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)

    def test_proxy_rejects_missing_organization_id(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_billing_service_token(organization_id=None)

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(token),
        )

        # DRF may return 401 or 403 depending on auth flow
        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)

    def test_proxy_returns_404_when_no_vercel_integration(self, mock_license):
        mock_license.return_value = self.license

        other_org = Organization.objects.create(name="Other Org")
        token = self._create_billing_service_token(organization_id=str(other_org.id))

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(token),
        )

        assert response.status_code == status.HTTP_404_NOT_FOUND
        assert response.json() == {"error": "No Vercel integration found for this organization"}

    def test_proxy_returns_500_when_no_access_token_in_config(self, mock_license):
        mock_license.return_value = self.license

        self.integration.config = {}
        self.integration.sensitive_config = {"credentials": {}}
        self.integration.save()

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
        assert response.json() == {"error": "Failed to retrieve Vercel credentials"}

    def test_proxy_validates_request_body(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "method" in response.json()

    def test_proxy_validates_http_method(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/invoices",
                "method": "INVALID",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "method" in response.json()

    def test_proxy_rejects_path_not_in_allowlist(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/some/other/path",
                "method": "POST",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "path" in response.json()
        assert "allowlist" in str(response.json()["path"])

    def test_proxy_rejects_path_traversal(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/../../../etc/passwd",
                "method": "GET",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "path" in response.json()

    def test_proxy_rejects_url_encoded_path_traversal(self, mock_license):
        mock_license.return_value = self.license

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {
                "path": "/billing/%2e%2e/%2e%2e/etc/passwd",
                "method": "GET",
                "body": {},
            },
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "path" in response.json()

    @patch("ee.api.vercel.vercel_proxy.forward_to_vercel")
    def test_proxy_handles_network_errors(self, mock_forward, mock_license):
        mock_license.return_value = self.license
        mock_forward.side_effect = req.RequestException("Network error")

        response = self.unauthenticated_client.post(
            "/api/vercel/proxy/",
            {"path": "/billing/invoices", "method": "POST", "body": {}},
            format="json",
            **self._get_auth_headers(),
        )

        assert response.status_code == status.HTTP_502_BAD_GATEWAY
        assert response.json() == {"error": "Failed to reach Vercel API"}


@patch("ee.api.authentication.get_cached_instance_license")
class TestBillingServiceAuthentication(BaseTest):
    def setUp(self):
        super().setUp()
        self.license_key = "test_license_id::test_license_secret"
        self.license = License.objects.create(key=self.license_key, plan="enterprise", valid_until=datetime.now(UTC))
        self.auth = BillingServiceAuthentication()

    def _create_token(
        self,
        organization_id: str = "test-org-id",
        audience: str = BillingServiceAuthentication.EXPECTED_AUDIENCE,
        expired: bool = False,
        secret: str | None = None,
    ) -> str:
        if secret is None:
            secret = self.license_key.split("::")[1]

        exp = datetime.now(UTC) + timedelta(minutes=-5 if expired else 15)

        payload = {
            "exp": exp,
            "organization_id": organization_id,
            "aud": audience,
        }

        return jwt.encode(payload, secret, algorithm="HS256")

    @covers_authentication(BillingServiceAuthentication)
    def test_valid_token_authenticates(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_token(organization_id="org_123")
        request = MagicMock()
        request.headers = {"authorization": f"Bearer {token}"}

        result = self.auth.authenticate(request)

        assert result is not None
        user, _ = result
        assert user.organization_id == "org_123"
        assert user.is_authenticated is True

    def test_expired_token_fails(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_token(expired=True)
        request = MagicMock()
        request.headers = {"authorization": f"Bearer {token}"}

        from rest_framework.exceptions import AuthenticationFailed

        with self.assertRaises(AuthenticationFailed) as context:
            self.auth.authenticate(request)

        assert "expired" in str(context.exception.detail).lower()

    def test_wrong_audience_fails(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_token(audience="wrong:audience")
        request = MagicMock()
        request.headers = {"authorization": f"Bearer {token}"}

        from rest_framework.exceptions import AuthenticationFailed

        with self.assertRaises(AuthenticationFailed) as context:
            self.auth.authenticate(request)

        assert "audience" in str(context.exception.detail).lower()

    def test_wrong_secret_fails(self, mock_license):
        mock_license.return_value = self.license

        token = self._create_token(secret="wrong_secret")
        request = MagicMock()
        request.headers = {"authorization": f"Bearer {token}"}

        from rest_framework.exceptions import AuthenticationFailed

        with self.assertRaises(AuthenticationFailed):
            self.auth.authenticate(request)

    def test_missing_token_fails(self, mock_license):
        mock_license.return_value = self.license

        request = MagicMock()
        request.headers = {}

        from rest_framework.exceptions import AuthenticationFailed

        with self.assertRaises(AuthenticationFailed) as context:
            self.auth.authenticate(request)

        assert "missing" in str(context.exception.detail).lower()

    def test_no_license_fails(self, mock_license):
        mock_license.return_value = None

        token = self._create_token()
        request = MagicMock()
        request.headers = {"authorization": f"Bearer {token}"}

        from rest_framework.exceptions import AuthenticationFailed

        with self.assertRaises(AuthenticationFailed) as context:
            self.auth.authenticate(request)

        assert "license" in str(context.exception.detail).lower()