Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
"""Rendered connected-account flows use provider-owned capabilities and identity."""
import time
import pytest
from playwright.sync_api import Dialog, Page, Route, expect
from e2e.provider_support import api_key_input, open_provider
from free_claude_code.application.connected_accounts import (
ConnectedAccountLoginMode,
ConnectedAccountState,
ConnectedAccountStatus,
)
from free_claude_code.core.json_types import JsonObject
def _status(provider_id: str, *, connected: bool = False) -> JsonObject:
return ConnectedAccountStatus(
provider_id=provider_id,
state=(
ConnectedAccountState.CONNECTED
if connected
else ConnectedAccountState.DISCONNECTED
),
connected=connected,
revision=1,
display_identity="octocat"
if connected and provider_id == "github_copilot"
else None,
email="[email protected]" if connected and provider_id == "openai" else None,
model_count=14 if connected else 0,
supported_login_modes=(
(ConnectedAccountLoginMode.DEVICE,)
if provider_id == "github_copilot"
else (ConnectedAccountLoginMode.BROWSER, ConnectedAccountLoginMode.DEVICE)
),
default_login_mode=(
ConnectedAccountLoginMode.DEVICE
if provider_id == "github_copilot"
else ConnectedAccountLoginMode.BROWSER
),
).as_dict()
class _Accounts:
def __init__(self, base_url: str) -> None:
self.base_url = base_url
self.statuses = {
provider_id: _status(provider_id)
for provider_id in ("openai", "github_copilot")
}
self.login_requests: list[tuple[str, str]] = []
self.cancelled: list[str] = []
self.disconnected: list[str] = []
self.hold_status: set[str] = set()
self.pending_status: list[Route] = []
self.hold_login = False
self.pending_login: list[Route] = []
def take_pending_status(self, page: Page) -> Route:
deadline = time.monotonic() + 5
while not self.pending_status:
if time.monotonic() >= deadline:
pytest.fail("Account status request did not reach the route handler")
# Pump Playwright events so the route handler can enqueue the request.
page.wait_for_timeout(10)
return self.pending_status.pop(0)
def take_pending_login(self, page: Page) -> Route:
deadline = time.monotonic() + 5
while not self.pending_login:
if time.monotonic() >= deadline:
pytest.fail("Account login request did not reach the route handler")
page.wait_for_timeout(10)
return self.pending_login.pop(0)
def config(self, route: Route) -> None:
response = route.fetch()
config = response.json()
assert isinstance(config, dict)
providers = config["provider_status"]
assert isinstance(providers, list)
originals = {
provider["provider_id"]: provider
for provider in providers
if isinstance(provider, dict)
}
config["provider_status"] = [
provider
for provider in providers
if isinstance(provider, dict)
and provider.get("provider_id") not in self.statuses
] + [
{
**originals[provider_id],
"provider_id": provider_id,
"display_name": name,
"kind": "connected_account",
"status": "disconnected",
"label": "Not connected",
"settings_keys": ["OPENAI_PROXY"] if provider_id == "openai" else [],
}
for provider_id, name in (
("openai", "OpenAI / ChatGPT"),
("github_copilot", "GitHub Copilot"),
)
]
route.fulfill(response=response, json=config)
def startup(self, route: Route) -> None:
data = route.fetch().json()
for provider_id, status in self.statuses.items():
if status["connected"]:
model_count = status["model_count"]
assert isinstance(model_count, int)
data["startup"]["providers"][provider_id] = "ready"
data["cached_models"][provider_id] = [
f"model-{index}" for index in range(model_count)
]
route.fulfill(json=data)
def auth(self, route: Route) -> None:
request = route.request
provider_id = request.url.split("/providers/", 1)[1].split("/", 1)[0]
if request.method == "GET":
if provider_id in self.hold_status:
self.pending_status.append(route)
return
elif request.url.endswith("/login"):
payload = request.post_data_json
assert isinstance(payload, dict)
mode = payload["mode"]
assert isinstance(mode, str)
self.login_requests.append((provider_id, mode))
status = _status(
provider_id, connected=bool(self.statuses[provider_id]["connected"])
)
status.update(state="connecting", mode=mode, attempt_id="safe-test-attempt")
if mode == "browser":
status["authorization_url"] = f"{self.base_url}/account-test-sign-in"
else:
status["verification_url"] = "https://github.com/login/device"
status["user_code"] = "ABCD-1234"
self.statuses[provider_id] = status
if self.hold_login:
self.pending_login.append(route)
return
elif request.url.endswith("/cancel"):
self.cancelled.append(provider_id)
self.statuses[provider_id] = _status(provider_id)
elif request.method == "DELETE":
self.disconnected.append(provider_id)
self.statuses[provider_id] = _status(provider_id)
else:
raise AssertionError(f"Unexpected account operation: {request.method}")
route.fulfill(json=self.statuses[provider_id])
@pytest.fixture
def accounts(page: Page, admin_base_url: str) -> _Accounts:
result = _Accounts(admin_base_url)
page.route("**/admin/api/config", result.config)
page.route("**/admin/api/status", result.startup)
page.route("**/admin/api/providers/*/auth**", result.auth)
page.context.route(
"**/account-test-sign-in",
lambda route: route.fulfill(content_type="text/html", body="Test sign-in"),
)
page.add_init_script(
"""Object.defineProperty(navigator, 'clipboard', {
value: { writeText: async (text) => { window.copiedDeviceCode = text; } }
});"""
)
return result
def _open(page: Page, admin_base_url: str) -> None:
page.goto(f"{admin_base_url}/admin")
expect(page.locator("#messageArea")).to_have_text("")
def test_account_modes_wait_for_status_and_recover_after_load_failure(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
accounts.hold_status.add("github_copilot")
page.goto(f"{admin_base_url}/admin")
copilot = page.locator('[data-provider="github_copilot"]')
openai = page.locator('[data-provider="openai"]')
expect(copilot.get_by_role("button", name="Loading…", exact=True)).to_be_disabled()
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_have_count(0)
expect(openai.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
accounts.take_pending_status(page).fulfill(
status=503, json={"detail": "Account status unavailable."}
)
expect(copilot.locator(".provider-meta")).to_have_text(
"Account status unavailable."
)
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_have_count(0)
copilot.get_by_role("button", name="Retry", exact=True).click()
expect(copilot.get_by_role("button", name="Loading…", exact=True)).to_be_disabled()
retry = accounts.take_pending_status(page)
accounts.hold_status.clear()
retry.fulfill(json=accounts.statuses["github_copilot"])
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
expect(copilot.get_by_role("button", name="Use device code")).to_have_count(0)
expect(openai.get_by_role("button", name="Use device code")).to_have_count(0)
expect(copilot.locator(".provider-meta")).to_contain_text("GitHub Copilot")
assert "ChatGPT" not in copilot.inner_text()
def test_device_code_connect_copy_and_cancel_ignore_an_old_poll(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
_open(page, admin_base_url)
copilot = page.locator('[data-provider="github_copilot"]')
copilot.get_by_role("button", name="Connect", exact=True).click()
expect(copilot.locator(".provider-meta")).to_have_text(
"Enter code ABCD-1234 at https://github.com/login/device"
)
assert accounts.login_requests == [("github_copilot", "device")]
assert len(page.context.pages) == 1
expect(copilot.get_by_role("button", name="Open sign-in")).to_be_visible()
copilot.get_by_role("button", name="Copy code").click()
assert page.evaluate("window.copiedDeviceCode") == "ABCD-1234"
stale_status = dict(accounts.statuses["github_copilot"])
accounts.hold_status.add("github_copilot")
with page.expect_request("**/admin/api/providers/github_copilot/auth"):
pass
copilot.get_by_role("button", name="Cancel sign-in", exact=True).click()
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
assert accounts.cancelled == ["github_copilot"]
assert len(accounts.pending_status) == 1
accounts.hold_status.clear()
with page.expect_response("**/admin/api/providers/github_copilot/auth") as response:
accounts.pending_status.pop().fulfill(json=stale_status)
response.value.finished()
page.evaluate("() => new Promise(requestAnimationFrame)")
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
expect(copilot.get_by_role("button", name="Copy code")).to_have_count(0)
def test_openai_connect_uses_browser_login(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
accounts.hold_login = True
_open(page, admin_base_url)
openai = page.locator('[data-provider="openai"]')
expect(openai.get_by_role("button", name="Use device code")).to_have_count(0)
with page.expect_popup() as opened:
openai.get_by_role("button", name="Connect", exact=True).click()
popup = opened.value
try:
assert popup.url == "about:blank"
assert popup.evaluate("window.opener === null") is True
login = accounts.take_pending_login(page)
assert accounts.login_requests == [("openai", "browser")]
assert not accounts.pending_login
login.fulfill(json=accounts.statuses["openai"])
popup.wait_for_url(f"{admin_base_url}/account-test-sign-in")
finally:
popup.close()
expect(
openai.get_by_role("button", name="Cancel sign-in", exact=True)
).to_be_visible()
expect(openai.locator(".provider-meta")).to_have_text(
"Finish signing in, then return to this page."
)
openai.get_by_role("button", name="Cancel sign-in", exact=True).click()
expect(openai.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
expect(openai.get_by_role("button", name="Use device code")).to_have_count(0)
@pytest.mark.parametrize("restart", [False, True])
def test_connected_counts_and_modes_survive_apply_and_disconnect_independently(
page: Page, admin_base_url: str, accounts: _Accounts, restart: bool
) -> None:
accounts.statuses = {
provider_id: _status(provider_id, connected=True)
for provider_id in accounts.statuses
}
page.route(
"**/admin/api/config/apply",
lambda route: route.fulfill(
json={
"applied": True,
"restart": {
"required": restart,
"automatic": restart,
"admin_url": "/admin",
"instance_id": "before-restart",
},
"credential_checks": [],
}
),
)
_open(page, admin_base_url)
open_provider(page, "nvidia_nim")
api_key_input(page, "NVIDIA_NIM_API_KEY").fill("unused-test-key")
page.get_by_role("button", name="Save", exact=True).click()
expect(page.locator("#providerDialog")).not_to_be_visible()
expect(page.locator("#messageArea")).to_have_text("Applied")
expect(page.locator("#dirtyState")).to_have_text("No changes")
copilot = page.locator('[data-provider="github_copilot"]')
openai = page.locator('[data-provider="openai"]')
expect(copilot.locator(".provider-meta")).to_have_text("14 models available")
expect(openai.locator(".provider-meta")).to_have_text("14 models available")
assert "ChatGPT" not in copilot.inner_text()
expect(page.get_by_role("button", name="Reconnect", exact=True)).to_have_count(0)
connected = page.locator(
'[data-provider-group="oauth"] [data-provider-subgroup="configured"]'
)
expect(connected.locator(".provider-title strong")).to_have_text(
["GitHub Copilot", "OpenAI / ChatGPT"]
)
confirmations: list[str] = []
def accept_disconnect(dialog: Dialog) -> None:
confirmations.append(dialog.message)
dialog.accept()
page.once("dialog", accept_disconnect)
copilot.get_by_role("button", name="Disconnect", exact=True).click()
expect(copilot.get_by_role("button", name="Connect", exact=True)).to_be_enabled()
assert confirmations == ["Disconnect this GitHub Copilot account from FCC?"]
assert accounts.disconnected == ["github_copilot"]
expect(connected.locator(".provider-title strong")).to_have_text(
["OpenAI / ChatGPT"]
)
expect(
page.locator(
'[data-provider-group="oauth"] [data-provider-subgroup="unconfigured"] .provider-title strong'
)
).to_have_text(["GitHub Copilot"])
expect(openai.get_by_role("button", name="Disconnect", exact=True)).to_have_class(
"danger-button"
)
expect(openai.locator(".provider-meta")).to_have_text("14 models available")
copilot.get_by_role("button", name="Connect", exact=True).click()
expect(copilot.get_by_role("button", name="Copy code")).to_be_visible()
assert accounts.login_requests[-1] == ("github_copilot", "device")
copilot.get_by_role("button", name="Cancel sign-in", exact=True).click()
@pytest.mark.parametrize("provider_id", ["openai", "github_copilot"])
@pytest.mark.parametrize("outcome", ["ready", "failed"])
def test_oauth_card_follows_model_discovery_without_replacing_settings(
page: Page, admin_base_url: str, accounts: _Accounts, provider_id: str, outcome: str
) -> None:
account = _status(provider_id, connected=True)
account["model_count"] = 0
accounts.statuses[provider_id] = account
phase = "starting"
def status(route: Route) -> None:
data = route.fetch().json()
data["startup"]["providers"][provider_id] = phase
data["startup"]["providers"]["open_router"] = phase
data["cached_models"][provider_id] = (
["model-a", "model-b"] if phase == "ready" else []
)
data["cached_models"]["open_router"] = data["cached_models"][provider_id]
route.fulfill(json=data)
page.route("**/admin/api/status", status)
_open(page, admin_base_url)
card = page.locator(f'[data-provider="{provider_id}"]')
other = page.locator('[data-provider-check-result="open_router"]')
expect(card.get_by_role("button", name="Disconnect", exact=True)).to_be_enabled()
expect(card.locator(".provider-meta")).to_have_text("Checking models…")
expect(other).to_have_text("Checking models…")
expect(card.locator(".provider-meta")).to_have_css(
"color", other.evaluate("element => getComputedStyle(element).color")
)
dialog = open_provider(page, "openai")
proxy = dialog.locator("#field-OPENAI_PROXY")
proxy.fill("http://pending-proxy:8080")
proxy.evaluate("input => input.setSelectionRange(7, 14)")
phase = outcome
expected_message = (
"2 models available"
if outcome == "ready"
else "Could not load models. Check the provider's settings and retry."
)
expect(card.locator(".provider-meta")).to_have_text(expected_message)
expect(other).to_have_text(expected_message)
expect(card.locator(".provider-meta")).to_have_css(
"color", other.evaluate("element => getComputedStyle(element).color")
)
expect(proxy).to_have_value("http://pending-proxy:8080")
expect(proxy).to_be_focused()
assert proxy.evaluate("input => [input.selectionStart, input.selectionEnd]") == [
7,
14,
]
def test_late_account_response_cannot_replace_discovered_model_count(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
accounts.hold_status.add("openai")
account = _status("openai", connected=True)
account["model_count"] = 0
def status(route: Route) -> None:
data = route.fetch().json()
data["startup"]["providers"]["openai"] = "ready"
data["cached_models"]["openai"] = ["model-a", "model-b"]
route.fulfill(json=data)
page.route("**/admin/api/status", status)
page.goto(f"{admin_base_url}/admin")
page.wait_for_function("state.startup?.startup?.providers?.openai === 'ready'")
pending = accounts.take_pending_status(page)
accounts.hold_status.clear()
pending.fulfill(json=account)
card = page.locator('[data-provider="openai"]')
expect(card.get_by_role("button", name="Disconnect", exact=True)).to_be_enabled()
expect(card.locator(".provider-meta")).to_have_text("2 models available")
def test_auth_status_refresh_preserves_proxy_edit_and_selection(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
accounts.hold_status.add("openai")
page.goto(f"{admin_base_url}/admin")
dialog = open_provider(page, "openai")
proxy = dialog.locator("#field-OPENAI_PROXY")
proxy.fill("http://pending-proxy:8080")
proxy.evaluate("input => input.setSelectionRange(7, 14)")
pending = accounts.take_pending_status(page)
accounts.hold_status.clear()
pending.fulfill(json=_status("openai", connected=True))
expect(
page.locator('[data-provider="openai"]').get_by_role(
"button", name="Disconnect", exact=True
)
).to_have_count(1)
expect(proxy).to_have_value("http://pending-proxy:8080")
expect(proxy).to_be_focused()
assert proxy.evaluate("input => [input.selectionStart, input.selectionEnd]") == [
7,
14,
]
expect(dialog.get_by_role("button", name="Connect", exact=True)).to_have_count(0)
def test_slow_initial_account_check_does_not_erase_a_later_save_warning(
page: Page, admin_base_url: str, accounts: _Accounts
) -> None:
accounts.hold_status.add("github_copilot")
page.route(
"**/admin/api/config/apply",
lambda route: route.fulfill(
json={
"applied": True,
"credential_checks": [
{
"index": 0,
"key": "NVIDIA_NIM_API_KEY",
"status": "unverified",
"message": "Verification unavailable.",
}
],
}
),
)
page.goto(f"{admin_base_url}/admin")
dialog = open_provider(page, "nvidia_nim")
pending = accounts.take_pending_status(page)
assert not accounts.pending_status
accounts.hold_status.clear()
api_key_input(page, "NVIDIA_NIM_API_KEY").fill("new-key")
dialog.get_by_role("button", name="Save", exact=True).click()
expect(page.locator("#messageArea")).to_contain_text("Verification unavailable.")
with page.expect_response("**/admin/api/providers/github_copilot/auth") as response:
pending.fulfill(json=_status("github_copilot"))
response.value.finished()
page.evaluate("() => new Promise(requestAnimationFrame)")
expect(page.locator("#messageArea")).to_contain_text("Verification unavailable.")