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.

61.5 KB
Raw Blame
import re
import json
from http.cookies import Morsel
from urllib.parse import parse_qs, urlparse

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

from django.http.response import HttpResponseBase
from django.test import Client, SimpleTestCase, override_settings

import responses
from parameterized import parameterized
from requests import PreparedRequest
from rest_framework import status

from posthog.integrations import IntegrationManager
from posthog.models.integration import Integration
from posthog.models.organization import Organization, OrganizationMembership
from posthog.models.organization_integration import OrganizationIntegration
from posthog.models.organization_provisioning import OrganizationProvisioning
from posthog.models.team import Team

from ee.api.vercel.crypto import encrypt_payload
from ee.api.vercel.vercel_connect import (
    CONNECT_NONCE_COOKIE_PREFIX,
    CONNECT_SALT,
    INSTALL_STATE_COOKIE_PREFIX,
    MAX_PENDING_INSTALL_STATES,
    VercelImportError,
    _browser_nonce_cookie_name,
    _delete_orphaned_integration,
    _install_state_cookie_name,
    _load_connect_session,
    _sign_connect_session,
    _validate_next_url,
)
from ee.vercel.client import OAuthTokenResponse, OperationResult

# Hardcoded independently of ee.vercel.integration.CLIENT_ENV_PREFIXES so a dropped prefix fails these tests.
EXPECTED_ENV_PREFIXES = ["NEXT_PUBLIC_", "VITE_", "NUXT_PUBLIC_", "PUBLIC_"]

CACHED_SESSION_DATA = {
    "access_token": "vercel_token_123",
    "token_type": "Bearer",
    "installation_id": "icfg_connect_test",
    "user_id": "vercel_user_1",
    "team_id": "team_vercel_1",
    "configuration_id": "cfg_1",
    "next_url": "https://vercel.com/done",
}

CALLBACK_URL = "/connect/vercel/callback"
BROWSER_NONCE = "nonce-set-in-this-browser"
OTHER_BROWSER_NONCE = "nonce-from-another-linking-flow"
REJECTED_BROWSER_COOKIES = [("missing_cookie", None), ("cookie_from_another_flow", OTHER_BROWSER_NONCE)]
REJECTED_SESSIONS = [
    ("missing_cookie", BROWSER_NONCE, None, None, "missing_cookie"),
    ("cookie_from_another_flow", BROWSER_NONCE, OTHER_BROWSER_NONCE, OTHER_BROWSER_NONCE, "missing_cookie"),
    ("tampered_cookie", BROWSER_NONCE, BROWSER_NONCE, OTHER_BROWSER_NONCE, "nonce_mismatch"),
    ("token_without_nonce", None, BROWSER_NONCE, BROWSER_NONCE, "token_without_nonce"),
]


def _state_from_install_redirect(response: HttpResponseBase) -> str:
    return parse_qs(urlparse(response["Location"]).query)["state"][0]


def _session_token_from_redirect(location: str) -> str:
    query = parse_qs(urlparse(location).query)
    if "next" in query:
        query = parse_qs(urlparse(query["next"][0]).query)
    return query["session"][0]


def _mock_vercel_client(mock_client_class: MagicMock) -> MagicMock:
    mock_client = mock_client_class.return_value
    mock_client.oauth_token_exchange.return_value = OAuthTokenResponse(
        access_token="tok_e2e",
        token_type="Bearer",
        installation_id="icfg_e2e",
        user_id="usr_e2e",
        team_id="team_e2e",
    )
    mock_client.import_resource.return_value = OperationResult(success=True)
    return mock_client


def _grant_for_code(code: str, user_id: str = "usr_1") -> OAuthTokenResponse:
    return OAuthTokenResponse(
        access_token=f"tok_{code}",
        token_type="Bearer",
        installation_id=f"icfg_{code}",
        user_id=user_id,
        team_id="team_1",
    )


def _exchanged_codes(mock_client: MagicMock) -> list[str]:
    return [call.kwargs["code"] for call in mock_client.oauth_token_exchange.call_args_list]


MARKETPLACE_INSTALLATION = "icfg_marketplace"
INSTALL_PAGE_INSTALLATION = "icfg_install_page"


def _fake_vercel(vercel: responses.RequestsMock) -> list[str]:
    # Each OAuth code belongs to the installation of the flow that issued it. Vercel accepts the import only into
    # the Marketplace installation that opened the link popup, and answers 404 for any other installation.
    grants = {
        "code_from_marketplace": (MARKETPLACE_INSTALLATION, "tok_marketplace"),
        "code_from_install": (INSTALL_PAGE_INSTALLATION, "tok_install_page"),
    }
    imported_into: list[str] = []

    def exchange_code(request: PreparedRequest) -> tuple[int, dict[str, str], str]:
        [code] = parse_qs(str(request.body))["code"]
        if code not in grants:
            return 400, {}, json.dumps({"error": "invalid_grant"})
        installation_id, access_token = grants.pop(code)
        grant = {"access_token": access_token, "installation_id": installation_id, "user_id": "usr_e2e"}
        return 200, {}, json.dumps({**grant, "token_type": "Bearer", "team_id": "team_e2e"})

    def import_resource(request: PreparedRequest) -> tuple[int, dict[str, str], str]:
        match = re.search(r"/installations/([^/]+)/", str(request.url))
        installation_id = match.group(1) if match else ""
        if (installation_id, request.headers.get("Authorization")) != (
            MARKETPLACE_INSTALLATION,
            "Bearer tok_marketplace",
        ):
            return 404, {}, json.dumps({"error": {"code": "not_found", "message": "Integration Resource not found"}})
        imported_into.append(installation_id)
        return 200, {}, "{}"

    vercel.add_callback(responses.POST, "https://api.vercel.com/v2/oauth/access_token", callback=exchange_code)
    vercel.add_callback(
        responses.PUT, re.compile(r"https://api\.vercel\.com/v1/installations/[^/]+/resources/[^/]+"), import_resource
    )
    return imported_into


def _flow_cookie(response: HttpResponseBase) -> Morsel:
    [cookie] = [cookie for name, cookie in response.cookies.items() if name.startswith(CONNECT_NONCE_COOKIE_PREFIX)]
    return cookie


class VercelConnectTestBase(APIBaseTest):
    def setUp(self):
        super().setUp()
        self.organization_membership.level = OrganizationMembership.Level.ADMIN
        self.organization_membership.save()

    def _seed_session(self) -> str:
        self._set_nonce_cookie(BROWSER_NONCE)
        return _sign_connect_session(CACHED_SESSION_DATA, browser_nonce=BROWSER_NONCE)

    def _callback_through_vercel_install(
        self,
        params: dict[str, str],
        browser: Client | None = None,
        host: str = "testserver",
        marketplace_params: dict[str, str] | None = None,
    ) -> HttpResponseBase:
        browser = browser or self.client
        install_redirect = browser.get(
            CALLBACK_URL, {"code": "code_from_marketplace", **(marketplace_params or {})}, HTTP_HOST=host
        )
        return browser.get(
            CALLBACK_URL, {**params, "state": _state_from_install_redirect(install_redirect)}, HTTP_HOST=host
        )

    def _set_nonce_cookie(self, flow_nonce: str | None, value: str | None = None) -> None:
        for name in [name for name in self.client.cookies if name.startswith(CONNECT_NONCE_COOKIE_PREFIX)]:
            del self.client.cookies[name]
        if flow_nonce is not None:
            self.client.cookies[_browser_nonce_cookie_name(flow_nonce)] = value or flow_nonce


class TestVercelConnectCallback(VercelConnectTestBase):
    def setUp(self):
        super().setUp()
        self.url = "/connect/vercel/callback"

    def test_missing_code_returns_400(self):
        response = self.client.get(self.url)

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    def test_missing_client_config_returns_500(self):
        response = self.client.get(self.url, {"code": "test_code"})

        assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_failed_token_exchange_returns_401(self, mock_client_class):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.oauth_token_exchange.return_value = OAuthTokenResponse(
            access_token="",
            token_type="",
            installation_id="",
            user_id="",
            error="invalid_code",
            error_description="Code expired",
        )

        response = self.client.get(self.url, {"code": "bad_code"})

        assert response.status_code == status.HTTP_401_UNAUTHORIZED

    @parameterized.expand(
        [
            ("next_on_install_return", {}, {"next": "https://vercel.com/done"}, "https://vercel.com/done"),
            (
                "install_return_omits_next",
                {"next": "https://vercel.com/marketplace"},
                {},
                "https://vercel.com/marketplace",
            ),
            (
                "install_return_sends_other_next",
                {"next": "https://vercel.com/marketplace"},
                {"next": "https://vercel.com/install-page"},
                "https://vercel.com/marketplace",
            ),
        ]
    )
    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_successful_exchange_redirects_authenticated_user_to_link(
        self,
        _name: str,
        marketplace_params: dict[str, str],
        return_params: dict[str, str],
        expected_next_url: str,
        mock_client_class: MagicMock,
    ) -> None:
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.oauth_token_exchange.side_effect = lambda **kwargs: _grant_for_code(kwargs["code"])

        response = self._callback_through_vercel_install(
            {"code": "code_from_install", "configurationId": "icfg_code_from_install", **return_params},
            marketplace_params={"configurationId": "icfg_code_from_marketplace", **marketplace_params},
        )

        assert response.status_code == 302
        location = response["Location"]
        assert location.startswith("/connect/vercel/link?")
        parsed = parse_qs(urlparse(location).query)
        assert "session" in parsed
        assert "next" not in parsed
        session_data = _load_connect_session(parsed["session"][0])
        assert session_data["next_url"] == expected_next_url
        assert [session_data["access_token"], session_data["installation_id"], session_data["configuration_id"]] == [
            "tok_code_from_marketplace",
            "icfg_code_from_marketplace",
            "icfg_code_from_marketplace",
        ]

    @parameterized.expand(
        [
            ("evil_domain", "https://evil.com/phish"),
            ("javascript_uri", "javascript:alert(document.cookie)"),
            ("data_uri", "data:text/html,<script>alert(1)</script>"),
            ("vbscript_uri", "vbscript:MsgBox('xss')"),
            ("protocol_relative", "//evil.com/path"),
        ]
    )
    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_malicious_next_url_is_rejected(self, _name, malicious_url, mock_client_class):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.oauth_token_exchange.return_value = OAuthTokenResponse(
            access_token="tok_123",
            token_type="Bearer",
            installation_id="icfg_new",
            user_id="usr_1",
        )

        response = self._callback_through_vercel_install({"code": "good_code", "next": malicious_url})

        assert response.status_code == 302
        parsed = parse_qs(urlparse(response["Location"]).query)
        assert "next" not in parsed
        session_data = _load_connect_session(parsed["session"][0])
        assert session_data["next_url"] == ""

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_unauthenticated_user_redirected_to_login(self, mock_client_class):
        self.client.logout()
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.oauth_token_exchange.return_value = OAuthTokenResponse(
            access_token="tok_123",
            token_type="Bearer",
            installation_id="icfg_new",
            user_id="usr_1",
        )

        response = self._callback_through_vercel_install({"code": "good_code"})

        assert response.status_code == 302
        assert response["Location"].startswith("/login?next=")

    @parameterized.expand(
        [
            ("us_cloud", "us.posthog.com", "posthog.com"),
            ("eu_cloud", "eu.posthog.com", "posthog.com"),
            ("self_hosted", "posthog.example.com", ""),
            ("local_dev", "localhost:8000", ""),
        ]
    )
    @override_settings(
        VERCEL_CLIENT_INTEGRATION_ID="client_id",
        VERCEL_CLIENT_INTEGRATION_SECRET="secret",
        SESSION_COOKIE_SECURE=True,
    )
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_callback_binds_session_to_browser_cookie(
        self, _name: str, host: str, expected_domain: str, mock_client_class: MagicMock
    ) -> None:
        self.client.logout()
        _mock_vercel_client(mock_client_class)

        response = self._callback_through_vercel_install({"code": "good_code"}, host=host)

        cookie = _flow_cookie(response)
        assert cookie["domain"] == expected_domain
        assert cookie["path"] == "/api/vercel/connect"
        assert cookie["max-age"] == 600
        assert cookie["httponly"] is True
        assert cookie["secure"] is True
        assert cookie["samesite"] == "Lax"

    @override_settings(
        VERCEL_CLIENT_INTEGRATION_ID="client_id",
        VERCEL_CLIENT_INTEGRATION_SECRET="secret",
        VERCEL_INTEGRATION_SLUG="posthog-test",
        SESSION_COOKIE_SECURE=False,
    )
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_callback_without_state_restarts_install_through_vercel(self, mock_client_class: MagicMock) -> None:
        mock_client = _mock_vercel_client(mock_client_class)

        response = self.client.get(
            self.url,
            {"code": "code_from_marketplace", "configurationId": "icfg_marketplace"},
            HTTP_HOST="us.posthog.com",
        )

        assert response.status_code == 302
        location = urlparse(response["Location"])
        assert (
            f"{location.scheme}://{location.netloc}{location.path}"
            == "https://vercel.com/integrations/posthog-test/new"
        )
        state = _state_from_install_redirect(response)
        cookie = response.cookies[_install_state_cookie_name(state)]
        assert cookie.key.startswith("__Host-")
        assert cookie.value == state
        assert cookie["path"] == "/"
        assert cookie["secure"] is True
        assert cookie["domain"] == ""
        assert cookie["httponly"] is True
        assert cookie["samesite"] == "Lax"
        assert _exchanged_codes(mock_client) == ["code_from_marketplace"]

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_callback_without_state_caps_pending_install_cookies(self, mock_client_class: MagicMock) -> None:
        _mock_vercel_client(mock_client_class)
        for flow in range(MAX_PENDING_INSTALL_STATES + 3):
            self.client.cookies[_install_state_cookie_name(f"pending-{flow}")] = f"pending-{flow}"

        self.client.get(self.url, {"code": "unvalidated_code"})

        pending = [
            name
            for name, cookie in self.client.cookies.items()
            if name.startswith(INSTALL_STATE_COOKIE_PREFIX) and cookie.value
        ]
        assert len(pending) == MAX_PENDING_INSTALL_STATES

    @parameterized.expand(
        [
            ("marketplace", {"source": "marketplace"}, status.HTTP_302_FOUND, ["code_without_state"], []),
            ("source_absent", {}, status.HTTP_302_FOUND, ["code_without_state"], []),
            (
                "returned_from_install",
                {"source": "external"},
                status.HTTP_400_BAD_REQUEST,
                [],
                ["missing_state_after_install_redirect"],
            ),
        ]
    )
    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_callback_without_state_leaves_pending_install_usable(
        self,
        _name: str,
        params: dict[str, str],
        expected_status: int,
        expected_stateless_exchanges: list[str],
        expected_reasons: list[str],
        mock_client_class: MagicMock,
        mock_capture_exception: MagicMock,
    ) -> None:
        mock_client = _mock_vercel_client(mock_client_class)
        pending_state = _state_from_install_redirect(
            self.client.get(self.url, {"code": "code_from_marketplace", "source": "marketplace"})
        )

        response = self.client.get(self.url, {"code": "code_without_state", **params})
        pending_install = self.client.get(
            self.url, {"code": "code_from_install", "source": "external", "state": pending_state}
        )

        assert [response.status_code, pending_install.status_code] == [expected_status, status.HTTP_302_FOUND]
        assert _exchanged_codes(mock_client) == [
            "code_from_marketplace",
            *expected_stateless_exchanges,
            "code_from_install",
        ]
        assert [call.args[1]["reason"] for call in mock_capture_exception.call_args_list] == expected_reasons

    @parameterized.expand(
        [
            ("state_from_another_browser", None, "missing_state_cookie"),
            ("cookie_value_differs", "value-set-by-another-site", "state_mismatch"),
        ]
    )
    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_rejects_state_this_browser_was_not_given(
        self,
        _name: str,
        cookie_value: str | None,
        expected_reason: str,
        mock_client_class: MagicMock,
        mock_capture_exception: MagicMock,
    ) -> None:
        mock_client = _mock_vercel_client(mock_client_class)
        other_browser = Client()
        state = _state_from_install_redirect(other_browser.get(self.url, {"code": "code_from_marketplace"}))
        if cookie_value is not None:
            self.client.cookies[_install_state_cookie_name(state)] = cookie_value

        response = self.client.get(self.url, {"code": "code_for_other_installation", "state": state})

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert _exchanged_codes(mock_client) == ["code_from_marketplace"]
        assert mock_capture_exception.call_args.args[1]["reason"] == expected_reason

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_rejects_install_page_signed_in_as_another_vercel_user(
        self, mock_client_class: MagicMock, mock_capture_exception: MagicMock
    ) -> None:
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.oauth_token_exchange.side_effect = [
            _grant_for_code("attacker_marketplace_code", user_id="usr_attacker"),
            _grant_for_code("victim_install_code", user_id="usr_victim"),
        ]

        response = self._callback_through_vercel_install({"code": "victim_install_code", "source": "external"})

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert mock_capture_exception.call_args.args[1]["reason"] == "install_user_mismatch"

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_install_state_works_once(self, mock_client_class: MagicMock) -> None:
        mock_client = _mock_vercel_client(mock_client_class)
        state = _state_from_install_redirect(self.client.get(self.url, {"code": "code_from_marketplace"}))

        first = self.client.get(self.url, {"code": "first_code", "state": state})
        replay = self.client.get(self.url, {"code": "second_code", "state": state})

        assert [first.status_code, replay.status_code] == [302, status.HTTP_400_BAD_REQUEST]
        assert _exchanged_codes(mock_client) == ["code_from_marketplace", "first_code"]

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_retry_after_failed_exchange_keeps_marketplace_next(self, mock_client_class: MagicMock) -> None:
        mock_client = _mock_vercel_client(mock_client_class)
        mock_client.oauth_token_exchange.side_effect = [
            mock_client.oauth_token_exchange.return_value,
            OAuthTokenResponse(access_token="", token_type="", installation_id="", user_id="", error="server_error"),
            mock_client.oauth_token_exchange.return_value,
        ]
        state = _state_from_install_redirect(
            self.client.get(self.url, {"code": "code_from_marketplace", "next": "https://vercel.com/marketplace"})
        )
        install_return = {"code": "code_from_install", "source": "external", "state": state}

        failed = self.client.get(self.url, install_return)
        retried = self.client.get(self.url, install_return)

        assert [failed.status_code, retried.status_code] == [status.HTTP_401_UNAUTHORIZED, 302]
        session = _load_connect_session(_session_token_from_redirect(retried["Location"]))
        assert session["next_url"] == "https://vercel.com/marketplace"

    @override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_cache_failure_after_exchange_still_reaches_link_page(
        self, mock_client_class: MagicMock, _mock_capture_exception: MagicMock
    ) -> None:
        _mock_vercel_client(mock_client_class)
        state = _state_from_install_redirect(self.client.get(self.url, {"code": "code_from_marketplace"}))

        with patch("ee.api.vercel.vercel_connect.cache.delete", side_effect=ConnectionError("cache unavailable")):
            response = self.client.get(self.url, {"code": "code_from_install", "source": "external", "state": state})

        assert response.status_code == 302
        assert response["Location"].startswith("/connect/vercel/link?")


@override_settings(VERCEL_CLIENT_INTEGRATION_SECRET="secret")
class TestVercelConnectSessionInfo(VercelConnectTestBase):
    def setUp(self):
        super().setUp()
        self.url = "/api/vercel/connect/session"

    def test_missing_session_returns_400(self):
        response = self.client.get(self.url)

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_expired_session_returns_400(self):
        response = self.client.get(self.url, {"session": "bogus-token"})

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    def test_returns_orgs_where_user_is_admin(self):
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        data = response.json()
        assert data["next_url"] == "https://vercel.com/done"
        assert len(data["organizations"]) == 1
        assert data["organizations"][0]["name"] == self.organization.name
        assert data["organizations"][0]["already_linked"] is False

    @patch("ee.api.vercel.vercel_connect._is_installation_orphaned", return_value=False)
    def test_marks_already_linked_orgs(self, _mock_orphaned):
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_existing",
            config={"credentials": {"access_token": "tok"}},
            created_by=self.user,
        )
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        assert response.json()["organizations"][0]["already_linked"] is True

    @patch("ee.api.vercel.vercel_connect._is_installation_orphaned", return_value=True)
    def test_orphaned_integration_cleaned_up_in_session(self, _mock_orphaned):
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_orphaned",
            config={"credentials": {"access_token": "tok_dead"}},
            created_by=self.user,
        )
        Integration.objects.create(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
            integration_id=str(self.team.pk),
            config={"type": "connectable"},
        )
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        assert response.json()["organizations"][0]["already_linked"] is False
        assert not OrganizationIntegration.objects.filter(integration_id="icfg_orphaned").exists()
        assert not Integration.objects.filter(team=self.team, kind=Integration.IntegrationKind.VERCEL).exists()

    @parameterized.expand(REJECTED_SESSIONS)
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.api.vercel.vercel_connect._is_installation_orphaned", return_value=True)
    def test_rejects_other_browser_before_cleaning_up_orphans(
        self,
        _name: str,
        token_nonce: str | None,
        cookie_flow_nonce: str | None,
        cookie_value: str | None,
        expected_reason: str,
        _mock_orphaned: MagicMock,
        mock_capture_exception: MagicMock,
    ) -> None:
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_orphaned",
            config={"credentials": {"access_token": "tok_dead"}},
            created_by=self.user,
        )
        session_token = (
            _sign_connect_session(CACHED_SESSION_DATA, browser_nonce=token_nonce)
            if token_nonce
            else encrypt_payload(CACHED_SESSION_DATA, salt=CONNECT_SALT, jti=True)
        )
        self._set_nonce_cookie(cookie_flow_nonce, cookie_value)

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "Session expired or invalid" in response.json()["detail"]
        assert OrganizationIntegration.objects.filter(integration_id="icfg_orphaned").exists()
        assert mock_capture_exception.call_args.args[1]["reason"] == expected_reason

    def test_excludes_orgs_where_user_is_member_not_admin(self):
        other_org = Organization.objects.create(name="Other Org")
        OrganizationMembership.objects.create(
            user=self.user,
            organization=other_org,
            level=OrganizationMembership.Level.MEMBER,
        )
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        org_names = [o["name"] for o in response.json()["organizations"]]
        assert "Other Org" not in org_names

    def test_unauthenticated_returns_403(self):
        self.client.logout()
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)


@override_settings(VERCEL_CLIENT_INTEGRATION_SECRET="secret")
class TestVercelConnectComplete(VercelConnectTestBase):
    def setUp(self):
        super().setUp()
        self.url = "/api/vercel/connect/complete"

    def test_expired_session_returns_400(self):
        response = self.client.post(
            self.url,
            {
                "session": "bogus-token",
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_successful_link_creates_integration_and_resource(self, mock_client_class, mock_vercel_integration):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_201_CREATED
        data = response.json()
        assert data["status"] == "linked"
        assert data["organization_name"] == self.organization.name

        org_integration = OrganizationIntegration.objects.get(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        )
        assert org_integration.config["type"] == "connectable"
        assert org_integration.sensitive_config["credentials"]["access_token"] == "vercel_token_123"
        assert org_integration.integration_id == "icfg_connect_test"
        assert not OrganizationProvisioning.objects.filter(organization=self.organization).exists()

        resource = Integration.objects.get(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
        )
        assert resource.integration_id == str(self.team.pk)
        assert resource.config["type"] == "connectable"

        mock_client.import_resource.assert_called_once()
        call_kwargs = mock_client.import_resource.call_args[1]
        assert call_kwargs["integration_config_id"] == "icfg_connect_test"
        assert call_kwargs["resource_id"] == str(resource.pk)
        assert call_kwargs["product_id"] == "posthog"
        assert call_kwargs["name"] == self.team.name
        mock_vercel_integration.bulk_sync_feature_flags_to_vercel.assert_called_once_with(self.team)

        secrets = call_kwargs["secrets"]
        secrets_by_name = {secret["name"]: secret for secret in secrets}
        assert set(secrets_by_name) == {
            "NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN",
            "NEXT_PUBLIC_POSTHOG_HOST",
            "VITE_POSTHOG_PROJECT_TOKEN",
            "VITE_POSTHOG_HOST",
            "NUXT_PUBLIC_POSTHOG_PROJECT_TOKEN",
            "NUXT_PUBLIC_POSTHOG_HOST",
            "PUBLIC_POSTHOG_PROJECT_TOKEN",
            "PUBLIC_POSTHOG_HOST",
        }
        assert secrets[0]["name"] == "NEXT_PUBLIC_POSTHOG_PROJECT_TOKEN"
        for prefix in EXPECTED_ENV_PREFIXES:
            token_secret = secrets_by_name[f"{prefix}POSTHOG_PROJECT_TOKEN"]
            assert token_secret["value"] == self.team.api_token
            assert "environmentOverrides" not in token_secret

            host_secret = secrets_by_name[f"{prefix}POSTHOG_HOST"]
            assert host_secret["value"].startswith(("https://", "http://"))
            assert "environmentOverrides" not in host_secret

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_link_with_different_environments_sets_overrides_on_every_prefix(
        self, mock_client_class, mock_vercel_integration
    ):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)

        preview_team = Team.objects.create(
            organization=self.organization, name="Preview Team", api_token="preview_token"
        )
        development_team = Team.objects.create(
            organization=self.organization, name="Development Team", api_token="development_token"
        )
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {
                    "production": self.team.pk,
                    "preview": preview_team.pk,
                    "development": development_team.pk,
                },
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_201_CREATED

        call_kwargs = mock_client.import_resource.call_args[1]
        secrets_by_name = {secret["name"]: secret for secret in call_kwargs["secrets"]}

        for prefix in EXPECTED_ENV_PREFIXES:
            token_secret = secrets_by_name[f"{prefix}POSTHOG_PROJECT_TOKEN"]
            assert token_secret["value"] == self.team.api_token
            assert token_secret["environmentOverrides"] == {
                "preview": "preview_token",
                "development": "development_token",
            }

            host_secret = secrets_by_name[f"{prefix}POSTHOG_HOST"]
            assert "environmentOverrides" not in host_secret

    def test_non_member_returns_403(self):
        other_org = Organization.objects.create(name="Not My Org")
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(other_org.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_403_FORBIDDEN

    def test_member_not_admin_returns_403(self):
        other_org = Organization.objects.create(name="Member Org")
        OrganizationMembership.objects.create(
            user=self.user,
            organization=other_org,
            level=OrganizationMembership.Level.MEMBER,
        )
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(other_org.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_403_FORBIDDEN

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_replay_returns_400(self, mock_client_class, _mock_vercel_integration):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)
        session_token = self._seed_session()

        self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )
        self._set_nonce_cookie(BROWSER_NONCE)

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "already used" in response.json()["detail"]

    @parameterized.expand(REJECTED_BROWSER_COOKIES)
    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_rejected_browser_leaves_session_usable_by_its_own_browser(
        self,
        _name: str,
        browser_nonce: str | None,
        mock_client_class: MagicMock,
        _mock_vercel_integration: MagicMock,
    ) -> None:
        mock_client_class.return_value.import_resource.return_value = OperationResult(success=True)
        session_token = self._seed_session()
        body = {
            "session": session_token,
            "organization_id": str(self.organization.id),
            "environment_mapping": {"production": self.team.pk},
        }

        self._set_nonce_cookie(browser_nonce)
        rejected_response = self.client.post(self.url, body, content_type="application/json")
        self._set_nonce_cookie(BROWSER_NONCE)
        accepted_response = self.client.post(self.url, body, content_type="application/json")

        assert rejected_response.status_code == status.HTTP_400_BAD_REQUEST
        assert "Session expired or invalid" in rejected_response.json()["detail"]
        assert accepted_response.status_code == status.HTTP_201_CREATED

    @patch("ee.api.vercel.vercel_connect._is_installation_orphaned", return_value=False)
    def test_already_linked_org_returns_400(self, _mock_orphaned):
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_existing",
            config={"credentials": {"access_token": "tok_old"}},
            created_by=self.user,
        )
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "already has a Vercel integration" in response.json()["detail"]
        assert OrganizationIntegration.objects.filter(integration_id="icfg_existing").exists()

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    @patch("ee.api.vercel.vercel_connect._is_installation_orphaned", return_value=True)
    def test_stale_integration_deleted_and_new_one_created(
        self, _mock_orphaned, mock_client_class, _mock_vercel_integration
    ):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_stale",
            config={"credentials": {"access_token": "tok_stale"}},
            created_by=self.user,
        )
        stale_resource = Integration.objects.create(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
            integration_id=str(self.team.pk),
            config={"type": "connectable"},
        )
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_201_CREATED
        assert response.json()["status"] == "linked"
        assert not OrganizationIntegration.objects.filter(integration_id="icfg_stale").exists()
        new_integration = OrganizationIntegration.objects.get(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        )
        assert new_integration.integration_id == "icfg_connect_test"
        assert not Integration.objects.filter(pk=stale_resource.pk).exists()
        assert Integration.objects.filter(team=self.team, kind=Integration.IntegrationKind.VERCEL).exists()

    def test_unauthenticated_returns_403(self):
        self.client.logout()
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code in (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN)

    def test_invalid_team_id_returns_400(self):
        session_token = self._seed_session()
        other_org = Organization.objects.create(name="Other Org")
        other_team = Team.objects.create(organization=other_org, name="Other Team")

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": other_team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "does not belong to this organization" in response.json()["detail"]
        assert not OrganizationIntegration.objects.filter(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        ).exists()

    def test_duplicate_team_integration_returns_400(self):
        Integration.objects.create(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
            integration_id=str(self.team.pk),
            config={"type": "connectable"},
            created_by=self.user,
        )
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert "already has a Vercel integration" in response.json()["detail"]

    def test_rollback_on_integration_create_failure(self):
        session_token = self._seed_session()

        with patch.object(IntegrationManager.vercel.oauth, "create", side_effect=Exception("db error")):
            response = self.client.post(
                self.url,
                {
                    "session": session_token,
                    "organization_id": str(self.organization.id),
                    "environment_mapping": {"production": self.team.pk},
                },
                content_type="application/json",
            )

        assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
        assert not OrganizationIntegration.objects.filter(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        ).exists()
        assert not Integration.objects.filter(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
        ).exists()

    @parameterized.expand(
        [
            ("with_status", OperationResult(success=False, error="HTTP error", status_code=403), "HTTP 403"),
            ("without_status", OperationResult(success=False, error="Network error"), "Network error"),
        ]
    )
    @patch("ee.api.vercel.vercel_connect.capture_exception")
    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_failed_import_rolls_back_and_returns_400(
        self,
        _name: str,
        import_result: OperationResult,
        expected_detail: str,
        mock_client_class: MagicMock,
        mock_vercel_integration: MagicMock,
        mock_capture: MagicMock,
    ) -> None:
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = import_result
        session_token = self._seed_session()

        response = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_400_BAD_REQUEST
        assert expected_detail in response.json()["detail"]
        assert not OrganizationIntegration.objects.filter(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        ).exists()
        assert not Integration.objects.filter(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
        ).exists()
        mock_vercel_integration.bulk_sync_feature_flags_to_vercel.assert_not_called()
        mock_capture.assert_called_once()
        exception, properties = mock_capture.call_args[0]
        assert isinstance(exception, VercelImportError)
        assert properties["status_code"] == import_result.status_code
        assert properties["installation_id"] == CACHED_SESSION_DATA["installation_id"]
        assert properties["resource_id"] == mock_client.import_resource.call_args.kwargs["resource_id"]

        mock_client.import_resource.return_value = OperationResult(success=True)
        retry = self.client.post(
            self.url,
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )
        assert retry.status_code == status.HTTP_201_CREATED


@override_settings(VERCEL_CLIENT_INTEGRATION_ID="client_id", VERCEL_CLIENT_INTEGRATION_SECRET="secret")
class TestVercelConnectEndToEnd(VercelConnectTestBase):
    @parameterized.expand(
        [
            ("same_host_signed_in", "testserver", "testserver", True, ""),
            ("us_callback_eu_link_after_login", "us.posthog.com", "eu.posthog.com", False, "posthog.com"),
        ]
    )
    @patch("ee.vercel.integration.VercelIntegration")
    def test_end_to_end_callback_to_complete(
        self,
        _name: str,
        callback_host: str,
        link_host: str,
        signed_in_at_callback: bool,
        expected_cookie_domain: str,
        _mock_vercel_integration: MagicMock,
    ) -> None:
        if not signed_in_at_callback:
            self.client.logout()

        with responses.RequestsMock() as vercel:
            imported_into = _fake_vercel(vercel)
            callback_response = self._callback_through_vercel_install(
                {"code": "code_from_install", "configurationId": INSTALL_PAGE_INSTALLATION, "source": "external"},
                host=callback_host,
                marketplace_params={"configurationId": MARKETPLACE_INSTALLATION, "source": "marketplace"},
            )
            session_token = _session_token_from_redirect(callback_response["Location"])

            self.client.force_login(self.user)
            session_response = self.client.get(
                "/api/vercel/connect/session", {"session": session_token}, HTTP_HOST=link_host
            )
            complete_response = self.client.post(
                "/api/vercel/connect/complete",
                {
                    "session": session_token,
                    "organization_id": str(self.organization.id),
                    "environment_mapping": {"production": self.team.pk},
                },
                content_type="application/json",
                HTTP_HOST=link_host,
            )

        assert callback_response.status_code == 302
        assert session_response.status_code == status.HTTP_200_OK
        assert complete_response.status_code == status.HTTP_201_CREATED, complete_response.json()
        assert complete_response.json()["status"] == "linked"
        assert imported_into == [MARKETPLACE_INSTALLATION]
        link = OrganizationIntegration.objects.get(organization=self.organization)
        assert [link.integration_id, link.config["configuration_id"]] == [MARKETPLACE_INSTALLATION] * 2
        cleared_cookie = _flow_cookie(complete_response)
        assert cleared_cookie["max-age"] == 0
        assert cleared_cookie["domain"] == expected_cookie_domain
        assert cleared_cookie["path"] == "/api/vercel/connect"

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_session_from_another_browser_is_rejected(
        self, mock_client_class: MagicMock, _mock_vercel_integration: MagicMock
    ) -> None:
        mock_client = _mock_vercel_client(mock_client_class)
        attacker_browser = Client()

        callback_response = self._callback_through_vercel_install({"code": "attacker_code"}, browser=attacker_browser)
        session_token = _session_token_from_redirect(callback_response["Location"])

        session_response = self.client.get("/api/vercel/connect/session", {"session": session_token})
        complete_response = self.client.post(
            "/api/vercel/connect/complete",
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert [session_response.status_code, complete_response.status_code] == [400, 400]
        assert not OrganizationIntegration.objects.filter(organization=self.organization).exists()
        mock_client.import_resource.assert_not_called()

    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_two_link_flows_in_one_browser_both_stay_usable(self, mock_client_class: MagicMock) -> None:
        _mock_vercel_client(mock_client_class)
        session_tokens = [
            _session_token_from_redirect(self._callback_through_vercel_install({"code": code})["Location"])
            for code in ("first_code", "second_code")
        ]

        responses = [self.client.get("/api/vercel/connect/session", {"session": token}) for token in session_tokens]

        assert [response.status_code for response in responses] == [status.HTTP_200_OK, status.HTTP_200_OK]

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.api.vercel.vercel_connect.VercelAPIClient")
    def test_token_survives_session_flush(self, mock_client_class, _mock_vercel_integration):
        _mock_vercel_client(mock_client_class)

        response = self._callback_through_vercel_install({"code": "good_code"})
        assert response.status_code == 302
        parsed = parse_qs(urlparse(response["Location"]).query)
        session_token = parsed["session"][0]

        # Simulate SSO login: flush destroys session, then user re-authenticates
        self.client.session.flush()
        self.client.force_login(self.user)

        complete_response = self.client.post(
            "/api/vercel/connect/complete",
            {
                "session": session_token,
                "organization_id": str(self.organization.id),
                "environment_mapping": {"production": self.team.pk},
            },
            content_type="application/json",
        )

        assert complete_response.status_code == status.HTTP_201_CREATED
        assert complete_response.json()["status"] == "linked"


@override_settings(VERCEL_CLIENT_INTEGRATION_SECRET="secret")
class TestVercelConnectSessionInfoTeams(VercelConnectTestBase):
    def setUp(self):
        super().setUp()
        self.url = "/api/vercel/connect/session"
        self.second_team = Team.objects.create(organization=self.organization, name="Second Team")

    def test_session_info_returns_teams_per_org(self):
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        data = response.json()
        org_data = data["organizations"][0]
        assert "teams" in org_data
        team_ids = {t["id"] for t in org_data["teams"]}
        assert self.team.pk in team_ids
        assert self.second_team.pk in team_ids
        for t in org_data["teams"]:
            assert "id" in t
            assert "name" in t
            assert "already_linked" in t

    def test_session_info_marks_already_linked_team(self):
        Integration.objects.create(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
            integration_id=str(self.team.pk),
            config={"type": "connectable"},
            created_by=self.user,
        )
        session_token = self._seed_session()

        response = self.client.get(self.url, {"session": session_token})

        assert response.status_code == status.HTTP_200_OK
        teams = response.json()["organizations"][0]["teams"]
        team_map = {t["id"]: t for t in teams}
        assert team_map[self.team.pk]["already_linked"] is True
        assert team_map[self.second_team.pk]["already_linked"] is False


class TestSafeVercelSyncSelfHealing(VercelConnectTestBase):
    @patch("ee.vercel.integration.VercelAPIClient")
    @patch("ee.vercel.integration.VercelIntegration._build_secrets", return_value=[{"name": "TOKEN", "value": "tok"}])
    def test_self_healing_creates_missing_integration_resource(self, _mock_secrets, mock_client_class):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_selfheal",
            config={"type": "connectable"},
            sensitive_config={"credentials": {"access_token": "tok_selfheal"}},
            created_by=self.user,
        )
        assert not Integration.objects.filter(team=self.team, kind=Integration.IntegrationKind.VERCEL).exists()

        from ee.vercel.integration import _safe_vercel_sync

        sync_called = MagicMock()
        _safe_vercel_sync("test op", "item_1", self.team, sync_called)

        resource = Integration.objects.get(team=self.team, kind=Integration.IntegrationKind.VERCEL)
        assert resource.integration_id == str(self.team.pk)
        assert resource.config["type"] == "connectable"
        mock_client.import_resource.assert_called_once_with(
            integration_config_id="icfg_selfheal",
            resource_id=str(resource.pk),
            product_id="posthog",
            name=self.team.name,
            secrets=[{"name": "TOKEN", "value": "tok"}],
        )
        sync_called.assert_called_once()

    def test_self_healing_skipped_when_no_installation(self):
        assert not OrganizationIntegration.objects.filter(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
        ).exists()

        from ee.vercel.integration import _safe_vercel_sync

        sync_called = MagicMock()
        _safe_vercel_sync("test op", "item_1", self.team, sync_called)

        assert not Integration.objects.filter(team=self.team, kind=Integration.IntegrationKind.VERCEL).exists()
        sync_called.assert_not_called()


class TestBackfillVercelConnectableResources(VercelConnectTestBase):
    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.vercel.client.VercelAPIClient")
    def test_backfill_creates_missing_resources(self, mock_client_class, mock_vercel_integration):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        mock_client.import_resource.return_value = OperationResult(success=True)
        mock_vercel_integration._build_secrets.return_value = [{"name": "TOKEN", "value": "tok"}]
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_backfill",
            config={},
            sensitive_config={"credentials": {"access_token": "tok_backfill"}},
            created_by=self.user,
        )
        assert not Integration.objects.filter(team=self.team, kind=Integration.IntegrationKind.VERCEL).exists()

        from ee.api.vercel.tasks import backfill_vercel_connectable_resources

        backfill_vercel_connectable_resources()

        resource = Integration.objects.get(team=self.team, kind=Integration.IntegrationKind.VERCEL)
        assert resource.integration_id == str(self.team.pk)
        mock_client.import_resource.assert_called_once_with(
            integration_config_id="icfg_backfill",
            resource_id=str(resource.pk),
            product_id="posthog",
            name=self.team.name,
            secrets=mock_vercel_integration._build_secrets.return_value,
        )
        mock_vercel_integration.bulk_sync_feature_flags_to_vercel.assert_called_once_with(self.team)

    @patch("ee.vercel.integration.VercelIntegration")
    @patch("ee.vercel.client.VercelAPIClient")
    def test_backfill_skips_teams_with_existing_resources(self, mock_client_class, mock_vercel_integration):
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_backfill2",
            config={"credentials": {"access_token": "tok_backfill2"}},
            created_by=self.user,
        )
        Integration.objects.create(
            team=self.team,
            kind=Integration.IntegrationKind.VERCEL,
            integration_id=str(self.team.pk),
            config={"type": "connectable"},
            created_by=self.user,
        )

        from ee.api.vercel.tasks import backfill_vercel_connectable_resources

        backfill_vercel_connectable_resources()

        mock_client.import_resource.assert_not_called()
        mock_vercel_integration.bulk_sync_feature_flags_to_vercel.assert_not_called()


class TestDeleteOrphanedIntegration(VercelConnectTestBase):
    @parameterized.expand(
        [
            ("distinct_teams", ["own"], ["other"], {"other"}),
            ("shared_team", ["own"], ["own"], {"own"}),
            ("unmapped_orphan", None, ["other"], {"other"}),
            ("unmapped_sibling", ["own"], None, {"own", "other"}),
        ]
    )
    def test_keeps_only_resources_another_installation_claims(
        self, _name, orphan_teams, sibling_teams, surviving_teams
    ):
        teams = {"own": self.team, "other": Team.objects.create(organization=self.organization, name="Other project")}

        def config(team_keys: list[str] | None) -> dict:
            if team_keys is None:
                return {"type": "connectable"}
            return {"type": "connectable", "environment_mapping": {"production": teams[team_keys[0]].pk}}

        orphaned = OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_orphaned",
            config=config(orphan_teams),
        )
        OrganizationIntegration.objects.create(
            organization=self.organization,
            kind=OrganizationIntegration.OrganizationIntegrationKind.VERCEL,
            integration_id="icfg_live",
            config=config(sibling_teams),
        )
        for team in teams.values():
            Integration.objects.create(
                team=team,
                kind=Integration.IntegrationKind.VERCEL,
                integration_id=str(team.pk),
                config={"type": "connectable"},
            )

        _delete_orphaned_integration(orphaned)

        assert not OrganizationIntegration.objects.filter(pk=orphaned.pk).exists()
        assert OrganizationIntegration.objects.filter(integration_id="icfg_live").exists()
        surviving_team_ids = set(
            Integration.objects.filter(
                team__organization=self.organization, kind=Integration.IntegrationKind.VERCEL
            ).values_list("team_id", flat=True)
        )
        assert surviving_team_ids == {teams[key].pk for key in surviving_teams}


class TestValidateNextUrl(SimpleTestCase):
    @parameterized.expand(
        [
            ("valid_vercel", "https://vercel.com/done", "https://vercel.com/done"),
            ("valid_www_vercel", "https://www.vercel.com/path", "https://www.vercel.com/path"),
            ("http_vercel", "http://vercel.com/path", "http://vercel.com/path"),
            ("empty_string", "", ""),
            ("javascript_uri", "javascript:alert(1)", ""),
            ("data_uri", "data:text/html,<script>alert(1)</script>", ""),
            ("vbscript_uri", "vbscript:MsgBox('xss')", ""),
            ("evil_domain", "https://evil.com/phish", ""),
            ("protocol_relative", "//evil.com", ""),
            ("mixed_case_scheme", "JavaScript:alert(1)", ""),
            ("ftp_scheme", "ftp://vercel.com/file", ""),
            ("no_hostname", "https://", ""),
        ]
    )
    def test_validate_next_url(self, _name, url, expected):
        assert _validate_next_url(url) == expected