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
import json
import tomllib
from itertools import groupby, pairwise
import pytest
from playwright.sync_api import expect
from free_claude_code.harnesses import claude_integration, claude_onboarding
@pytest.mark.parametrize(
"integration,button_id",
[
("claude-vscode", "openClaudeIntegration"),
("codex", "openCodexIntegration"),
("claude-desktop", "openClaudeDesktopIntegration"),
("jetbrains-acp", "openJetBrainsIntegration"),
],
)
@pytest.mark.parametrize("connected", [False, True])
def test_connection_check_uses_disabled_loading_button(
page, admin_base_url, integration, button_id, connected
):
pending = []
def hold_check(route):
pending.append(route)
page.evaluate("window.integrationChecks = (window.integrationChecks || 0) + 1")
page.route(f"**/admin/api/integrations/{integration}", hold_check)
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator(f"#{button_id}")
for visit in range(2):
if visit:
page.get_by_role("button", name="Providers", exact=True).click()
page.get_by_role("button", name="Integrations", exact=True).click()
expect(button).to_be_disabled()
expect(button).to_have_text("Loading…")
expect(button).to_have_attribute("aria-busy", "true")
expect(button).to_have_css("background-color", "rgb(23, 27, 38)")
assert (
button.evaluate(
"element => getComputedStyle(element, '::before').animationName"
)
== "integration-spinner"
)
expect(page.locator("#view-integrations .status-pill")).to_have_count(0)
page.wait_for_function(
"count => window.integrationChecks >= count", arg=visit + 1
)
assert len(pending) == 1
pending.pop().fulfill(
json={
"connected": connected,
"paths": None,
"update": {"state": "ready", "changed": False, "message": None},
}
)
expect(button).to_be_enabled()
expect(button).to_have_text("Disconnect" if connected else "Connect")
expect(button).to_have_attribute("aria-busy", "false")
@pytest.mark.parametrize("width", [1280, 1200, 390])
def test_codex_connect_disconnect_and_modal_paths(
page, admin_base_url, tmp_path, width
):
page.set_viewport_size({"width": width, "height": 900})
page.goto(f"{admin_base_url}/admin/integrations")
expect(page.locator("#openClaudeIntegration")).to_be_enabled()
expect(page.locator("#messageArea")).to_have_text("")
cards = page.locator("#view-integrations > article")
expect(cards.first).to_be_visible()
expect(page.locator("#claudeIntegrationStatus")).to_have_count(0)
expect(page.locator("#openCodexIntegration")).to_be_enabled()
expect(page.locator("#codexIntegrationStatus")).to_have_count(0)
bounds = [card.bounding_box() for card in cards.all()]
if width >= 1200:
descriptions = [
card.locator(".section-heading p").bounding_box() for card in cards.all()
]
for _, row in groupby(range(len(bounds)), key=lambda index: bounds[index]["y"]):
indices = list(row)
assert all(
bounds[right]["x"] > bounds[left]["x"]
for left, right in pairwise(indices)
)
assert len({descriptions[index]["y"] for index in indices}) == 1
assert bounds[1]["y"] == bounds[0]["y"]
else:
assert all(right["y"] > left["y"] for left, right in pairwise(bounds))
assert page.locator("body").evaluate(
"element => element.scrollWidth <= window.innerWidth"
)
opener = page.locator("#openCodexIntegration")
dialog = page.get_by_role("dialog", name="Codex in VS Code and App", exact=True)
opener.click()
expect(dialog).to_be_visible()
expect(page.locator("#claudeIntegrationDialog")).not_to_be_visible()
expect(dialog.get_by_role("button", name="Close", exact=True)).to_be_focused()
expect(dialog).to_contain_text(
"Configure Codex to use FCC. Your selected model stays unchanged."
)
assert dialog.evaluate("element => element.scrollWidth <= element.clientWidth")
path = tmp_path / ".codex" / "config.toml"
expect(dialog.locator("#codexIntegrationFiles li")).to_have_text(
[str(path.resolve())]
)
page.locator("#codexIntegrationDescription").click()
expect(dialog).to_be_visible()
dialog.get_by_role("button", name="Close", exact=True).click()
expect(dialog).not_to_be_visible()
expect(opener).to_be_focused()
opener.click()
page.keyboard.press("Escape")
expect(dialog).not_to_be_visible()
opener.click()
page.mouse.click(1, 1)
expect(dialog).not_to_be_visible()
assert not path.exists()
path.parent.mkdir()
path.write_text('model = "my-choice" # Keep this\n')
opener.click()
page.locator("#confirmCodexIntegration").click()
expect(dialog).not_to_be_visible()
expect(opener).to_have_text("Disconnect")
expect(page.locator("#codexIntegrationStatus")).to_have_count(0)
expect(opener).to_have_css("color", "rgb(239, 68, 68)")
if width >= 1200:
buttons = [
card.get_by_role("button").first.bounding_box() for card in cards.all()
]
for _, row in groupby(range(len(bounds)), key=lambda index: bounds[index]["y"]):
assert len({buttons[index]["y"] for index in row}) == 1
assert len({button["height"] for button in buttons}) == 1
expect(page.locator("#codexIntegrationMessage")).to_have_text(
"Settings saved. Restart Codex and select an FCC model."
)
assert tomllib.loads(path.read_text())["model"] == "my-choice"
assert "# Keep this" in path.read_text()
page.reload()
expect(opener).to_have_text("Disconnect")
opener.click()
expect(page.locator("#confirmCodexIntegration")).to_have_text("Disconnect")
expect(page.locator("#confirmCodexIntegration")).to_have_css(
"color", "rgb(239, 68, 68)"
)
expect(dialog.locator("#codexIntegrationFiles li")).to_have_text(
[str(path.resolve())]
)
page.locator("#confirmCodexIntegration").click()
expect(opener).to_have_text("Connect")
expect(opener).to_have_css("color", "rgb(6, 16, 11)")
expect(page.locator("#codexIntegrationStatus")).to_have_count(0)
assert tomllib.loads(path.read_text()) == {"model": "my-choice"}
assert not (tmp_path / "vscode" / "settings.json").exists()
assert not (tmp_path / ".claude.json").exists()
@pytest.mark.parametrize("width", [1280, 390])
def test_modal_shows_files_for_the_selected_action(
page, admin_base_url, tmp_path, width
):
page.set_viewport_size({"width": width, "height": 900})
page.goto(f"{admin_base_url}/admin/integrations")
page.locator("#openClaudeIntegration").click()
dialog = page.locator("#claudeIntegrationDialog")
paths = dialog.locator("#claudeIntegrationFiles li")
expect(paths).to_have_text(
[
str((tmp_path / "vscode" / "settings.json").resolve()),
str((tmp_path / ".claude.json").resolve()),
]
)
assert dialog.evaluate("element => element.scrollWidth <= element.clientWidth")
page.locator("#confirmClaudeIntegration").click()
expect(dialog).not_to_be_visible()
page.locator("#openClaudeIntegration").click()
expect(paths).to_have_text([str((tmp_path / "vscode" / "settings.json").resolve())])
page.keyboard.press("Escape")
expect(dialog).not_to_be_visible()
def test_connect_disconnect_and_modal_dismissal(page, admin_base_url, tmp_path):
path = tmp_path / "vscode" / "settings.json"
page.goto(f"{admin_base_url}/admin/integrations")
card_button = page.locator("#openClaudeIntegration")
dialog = page.locator("#claudeIntegrationDialog")
action = page.locator("#confirmClaudeIntegration")
expect(card_button).to_be_enabled()
expect(card_button).to_have_text("Connect")
for dismiss in ("close", "escape", "outside"):
card_button.click()
expect(dialog).to_be_visible()
if dismiss == "close":
dialog.get_by_role("button", name="Close", exact=True).click()
elif dismiss == "escape":
page.keyboard.press("Escape")
else:
page.mouse.click(1, 1)
expect(dialog).not_to_be_visible()
assert not path.exists()
card_button.click()
action.click()
expect(dialog).not_to_be_visible()
expect(card_button).to_have_text("Disconnect")
expect(page.locator("#claudeIntegrationStatus")).to_have_count(0)
expect(card_button).to_have_css("color", "rgb(239, 68, 68)")
expect(page.locator("#claudeIntegrationMessage")).to_contain_text("Reload VS Code")
assert json.loads(path.read_text())["claudeCode.disableLoginPrompt"] is True
state_path = tmp_path / ".claude.json"
assert json.loads(state_path.read_text())["hasCompletedOnboarding"] is True
expect(page.locator("#openClaudeOnboarding")).to_have_text("Completed")
page.reload()
expect(card_button).to_have_text("Disconnect")
card_button.click()
expect(action).to_have_text("Disconnect")
expect(action).to_have_css("color", "rgb(239, 68, 68)")
expect(page.locator("#claudeIntegrationDescription")).to_contain_text("Remove")
page.keyboard.press("Escape")
assert json.loads(path.read_text())["claudeCode.disableLoginPrompt"] is True
card_button.click()
action.click()
expect(card_button).to_have_text("Connect")
expect(card_button).to_have_css("color", "rgb(6, 16, 11)")
expect(page.locator("#claudeIntegrationStatus")).to_have_count(0)
assert json.loads(path.read_text()) == {}
assert json.loads(state_path.read_text())["hasCompletedOnboarding"] is True
def test_manual_setup_and_revisit_read_the_file(page, admin_base_url, tmp_path):
path = tmp_path / "vscode" / "settings.json"
status = page.request.get(f"{admin_base_url}/admin/api/status").json()
claude_integration.configure(
path,
f"http://localhost:{status['port']}/",
"e2e-proxy-token",
True,
)
claude_onboarding.complete(tmp_path / ".claude.json")
page.goto(f"{admin_base_url}/admin/integrations")
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
(tmp_path / ".claude.json").unlink()
page.reload()
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
page.locator("#openClaudeOnboarding").click()
page.locator("#confirmClaudeOnboarding").click()
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
page.get_by_role("button", name="Providers", exact=True).click()
path.write_text("{}")
page.get_by_role("button", name="Integrations", exact=True).click()
expect(page.locator("#openClaudeIntegration")).to_have_text("Connect")
def test_invalid_settings_error_can_be_retried_and_does_not_break_admin(
page, admin_base_url, tmp_path
):
path = tmp_path / "vscode" / "settings.json"
path.parent.mkdir()
path.write_text("{invalid}")
page.goto(f"{admin_base_url}/admin/integrations")
expect(page.locator("#claudeIntegrationMessage")).to_contain_text("Check the JSON")
expect(page.locator("#openClaudeIntegration")).to_have_text("Retry")
expect(page.locator("#openClaudeIntegration")).to_have_attribute(
"aria-busy", "false"
)
expect(page.locator("#view-integrations .status-pill")).to_have_count(0)
page.get_by_role("button", name="Providers", exact=True).click()
expect(page.locator('[data-provider="nvidia_nim"]')).to_be_visible()
page.get_by_role("button", name="Integrations", exact=True).click()
path.write_text("{}")
page.locator("#openClaudeIntegration").click()
expect(page.locator("#openClaudeIntegration")).to_have_text("Connect")
def test_save_pending_and_failure_stay_in_modal(page, admin_base_url):
page.goto(f"{admin_base_url}/admin/integrations")
page.locator("#openClaudeIntegration").click()
requests = []
def hold_save(route):
requests.append(route)
page.evaluate("window.integrationSaveIntercepted = true")
page.route(
"**/admin/api/integrations/claude-vscode/connect",
hold_save,
)
action = page.locator("#confirmClaudeIntegration")
action.click()
expect(action).to_be_disabled()
expect(action).to_have_text("Saving…")
page.wait_for_function("window.integrationSaveIntercepted === true")
requests[0].fulfill(status=503, json={"detail": "Could not save settings."})
expect(action).to_be_enabled()
expect(page.locator("#claudeIntegrationDialog")).to_be_visible()
expect(page.locator("#claudeIntegrationDialogMessage")).to_have_text(
"Could not save settings."
)
def test_codex_existing_setup_revisit_and_invalid_config_retry(
page, admin_base_url, tmp_path
):
path = tmp_path / ".codex" / "config.toml"
assert page.request.post(
f"{admin_base_url}/admin/api/integrations/codex/connect"
).ok
page.goto(f"{admin_base_url}/admin/integrations")
opener = page.locator("#openCodexIntegration")
expect(opener).to_have_text("Disconnect")
page.get_by_role("button", name="Providers", exact=True).click()
path.write_text("[invalid")
page.get_by_role("button", name="Integrations", exact=True).click()
expect(page.locator("#codexIntegrationMessage")).to_contain_text("Check the TOML")
expect(opener).to_have_text("Retry")
path.write_text("")
opener.click()
expect(opener).to_have_text("Connect")
def test_codex_save_pending_and_failure_stay_in_modal(page, admin_base_url, tmp_path):
page.goto(f"{admin_base_url}/admin/integrations")
page.locator("#openCodexIntegration").click()
action = page.locator("#confirmCodexIntegration")
def reject_save(route):
expect(action).to_be_disabled()
expect(action).to_have_text("Saving…")
expect(page.locator("#openCodexIntegration")).to_be_disabled()
route.fulfill(status=503, json={"detail": "Could not save settings."})
page.route("**/admin/api/integrations/codex/connect", reject_save)
action.click()
expect(page.locator("#codexIntegrationDialogMessage")).to_have_text(
"Could not save settings."
)
expect(action).to_be_enabled()
expect(page.locator("#codexIntegrationDialog")).to_be_visible()
assert not (tmp_path / ".codex" / "config.toml").exists()
@pytest.mark.parametrize(
"integration,prefix", [("claude-vscode", "Claude"), ("codex", "Codex")]
)
def test_background_update_spinner_failure_retry_and_completion(
page, admin_base_url, integration, prefix
):
progress = {"state": "starting", "changed": False, "message": None}
retries = []
def startup(route):
response = route.fetch()
payload = response.json()
payload["startup"]["integrations"][integration] = dict(progress)
route.fulfill(response=response, json=payload)
def status(route):
route.fulfill(
json={
"connected": True if progress["state"] == "ready" else None,
"paths": None,
"update": dict(progress),
}
)
def retry(route):
retries.append(route.request.method)
progress.update(state="starting", changed=False, message=None)
route.fulfill(json={"update": dict(progress)})
page.route("**/admin/api/status", startup)
page.route(f"**/admin/api/integrations/{integration}", status)
page.route(f"**/admin/api/integrations/{integration}/refresh", retry)
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator(f"#open{prefix}Integration")
confirm = page.locator(f"#confirm{prefix}Integration")
message = page.locator(f"#{prefix.lower()}IntegrationMessage")
expect(button).to_be_disabled()
expect(confirm).to_be_disabled()
expect(button).to_have_attribute("aria-busy", "true")
progress.update(
state="failed", message="Could not update settings. Check permissions."
)
expect(button).to_have_text("Retry")
expect(button).to_be_enabled()
expect(message).to_have_text(progress["message"])
with page.expect_response(
f"{admin_base_url}/admin/api/integrations/{integration}/refresh"
):
button.click()
expect(button).to_be_disabled()
assert retries == ["POST"]
page.wait_for_function(
"id => state.startup?.startup?.integrations[id]?.state === 'starting'",
arg=integration,
)
progress.update(state="ready", changed=True)
expect(button).to_have_text("Disconnect")
expect(button).to_be_enabled()
expect(button).to_have_css("color", "rgb(239, 68, 68)")
expect(message).to_have_text(
"Settings updated. Reload VS Code."
if prefix == "Claude"
else "Settings updated. Restart Codex."
)
@pytest.fixture
def admin_client_files(request, tmp_path):
if not getattr(request, "param", False):
return None
path = tmp_path / "vscode/settings.json"
path.parent.mkdir()
path.write_text(
json.dumps(
{
"editor.fontSize": 15,
"claudeCode.disableLoginPrompt": True,
"claudeCode.environmentVariables": [
{"name": "ANTHROPIC_BASE_URL", "value": "http://localhost:8082"},
{"name": "ANTHROPIC_AUTH_TOKEN", "value": "e2e-proxy-token"},
{
"name": "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY",
"value": "1",
},
],
}
)
)
return path
@pytest.mark.parametrize("admin_client_files", [True], indirect=True)
def test_startup_updates_before_opening_integrations(
admin_client_files, admin_base_url, page, tmp_path
):
page.goto(f"{admin_base_url}/admin")
page.wait_for_function(
"state.startup?.startup?.integrations['claude-vscode']?.state === 'ready'"
)
page.get_by_role("button", name="Integrations", exact=True).click()
button = page.locator("#openClaudeIntegration")
expect(button).to_have_text("Disconnect")
expect(page.locator("#claudeIntegrationMessage")).to_be_hidden()
saved = json.loads(admin_client_files.read_text())
assert saved["editor.fontSize"] == 15
assert any(
entry == {"name": "CLAUDE_CODE_DISABLE_ADVISOR_TOOL", "value": "1"}
for entry in saved["claudeCode.environmentVariables"]
)
assert not (tmp_path / ".claude.json").exists()
expect(page.locator("#openClaudeOnboarding")).to_have_text("Complete onboarding")
page.screenshot(path=str(tmp_path / "integration-updated.png"), full_page=True)
button.click()
page.locator("#confirmClaudeIntegration").click()
expect(button).to_have_text("Connect")
page.reload()
expect(button).to_have_text("Connect")
expect(page.locator("#claudeIntegrationMessage")).to_be_hidden()
def test_independent_onboarding_modal_and_completion(page, admin_base_url, tmp_path):
state = tmp_path / ".claude.json"
settings = tmp_path / "vscode" / "settings.json"
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator("#openClaudeOnboarding")
dialog = page.locator("#claudeOnboardingDialog")
expect(button).to_have_text("Complete onboarding")
for dismiss in ("close", "escape", "outside"):
button.click()
expect(dialog).to_be_visible()
expect(page.locator("#claudeOnboardingFiles li")).to_have_text(
[str(state.resolve())]
)
if dismiss == "close":
dialog.get_by_role("button", name="Close", exact=True).click()
elif dismiss == "escape":
page.keyboard.press("Escape")
else:
page.mouse.click(1, 1)
expect(dialog).not_to_be_visible()
assert not state.exists() and not settings.exists()
button.click()
page.locator("#confirmClaudeOnboarding").click()
expect(dialog).not_to_be_visible()
expect(button).to_have_text("Completed")
expect(button).to_be_disabled()
expect(page.locator("#openClaudeIntegration")).to_have_text("Connect")
assert json.loads(state.read_text())["hasCompletedOnboarding"] is True
assert not settings.exists()
state.write_text('{"hasCompletedOnboarding":false}')
page.get_by_role("button", name="Providers", exact=True).click()
page.get_by_role("button", name="Integrations", exact=True).click()
expect(button).to_have_text("Complete onboarding")
assert state.read_text() == '{"hasCompletedOnboarding":false}'
@pytest.mark.parametrize("completed", [False, True])
def test_onboarding_status_uses_loading_and_completed_button(
page, admin_base_url, tmp_path, completed
):
pending = []
def hold(route):
pending.append(route)
page.evaluate("window.onboardingStatusIntercepted = true")
page.route("**/admin/api/integrations/claude-onboarding", hold)
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator("#openClaudeOnboarding")
expect(button).to_have_text("Loading…")
expect(button).to_be_disabled()
expect(button).to_have_attribute("aria-busy", "true")
expect(button).to_have_css("background-color", "rgb(23, 27, 38)")
assert (
button.evaluate(
"element => getComputedStyle(element, '::before').animationName"
)
== "integration-spinner"
)
page.wait_for_function("window.onboardingStatusIntercepted === true")
pending.pop().fulfill(
json={
"completed": completed,
"paths": {"claude_state": str(tmp_path / ".claude.json")},
}
)
expect(button).to_have_text("Completed" if completed else "Complete onboarding")
expect(button).to_have_attribute("aria-busy", "false")
if completed:
expect(button).to_be_disabled()
expect(button).to_have_css("background-color", "rgb(23, 27, 38)")
else:
expect(button).to_be_enabled()
def test_onboarding_errors_retry_independently(page, admin_base_url, tmp_path):
assert page.request.post(
f"{admin_base_url}/admin/api/integrations/claude-vscode/connect"
).ok
state = tmp_path / ".claude.json"
state.write_text('{"secret-state":invalid}')
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator("#openClaudeOnboarding")
expect(button).to_have_text("Retry")
expect(page.locator("#claudeOnboardingMessage")).to_contain_text(".claude.json")
expect(page.locator("#claudeOnboardingMessage")).not_to_contain_text("secret-state")
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
state.write_text('{"hasCompletedOnboarding":false}')
button.click()
expect(button).to_have_text("Complete onboarding")
assert state.read_text() == '{"hasCompletedOnboarding":false}'
def reject(route):
route.fulfill(status=503, json={"detail": "Could not access .claude.json."})
endpoint = "**/admin/api/integrations/claude-onboarding/complete"
page.route(endpoint, reject)
button.click()
action = page.locator("#confirmClaudeOnboarding")
action.click()
expect(page.locator("#claudeOnboardingDialogMessage")).to_contain_text(
"Could not access"
)
expect(action).to_be_enabled()
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
page.unroute(endpoint, reject)
action.click()
expect(button).to_have_text("Completed")
def test_failed_connect_updates_independent_onboarding_card(
page, admin_base_url, tmp_path, monkeypatch
):
settings = tmp_path / "vscode" / "settings.json"
write = claude_integration.atomic_write_text
def fail_settings(path, content):
if path == settings:
raise PermissionError("denied")
write(path, content)
monkeypatch.setattr(claude_integration, "atomic_write_text", fail_settings)
page.goto(f"{admin_base_url}/admin/integrations")
expect(page.locator("#openClaudeOnboarding")).to_have_text("Complete onboarding")
page.locator("#openClaudeIntegration").click()
page.locator("#confirmClaudeIntegration").click()
expect(page.locator("#claudeIntegrationDialogMessage")).to_contain_text(
"Could not access"
)
expect(page.locator("#openClaudeOnboarding")).to_have_text("Completed")
expect(page.locator("#openClaudeIntegration")).to_have_text("Connect")
assert not settings.exists()
assert (
json.loads((tmp_path / ".claude.json").read_text())["hasCompletedOnboarding"]
is True
)
def test_late_onboarding_status_cannot_undo_connect_result(
page, admin_base_url, tmp_path
):
pending = []
checks = 0
def hold_first(route):
nonlocal checks
checks += 1
if checks == 1:
pending.append(route)
else:
route.continue_()
endpoint = "**/admin/api/integrations/claude-onboarding"
page.route(endpoint, hold_first)
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator("#openClaudeOnboarding")
expect(button).to_have_text("Loading…")
page.locator("#openClaudeIntegration").click()
page.locator("#confirmClaudeIntegration").click()
expect(button).to_have_text("Completed")
assert checks == 2
with page.expect_response(
lambda response: response.url.endswith("/claude-onboarding")
):
pending.pop().fulfill(
json={
"completed": False,
"paths": {"claude_state": str(tmp_path / ".claude.json")},
}
)
page.evaluate(
"() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))"
)
expect(button).to_have_text("Completed")
expect(button).to_be_disabled()
@pytest.mark.parametrize("save_failed", [False, True])
def test_connect_reconciles_after_pending_onboarding_save(
page, admin_base_url, tmp_path, save_failed
):
pending = []
def hold(route):
pending.append(route)
endpoint = "**/admin/api/integrations/claude-onboarding/complete"
page.route(endpoint, hold)
page.goto(f"{admin_base_url}/admin/integrations")
button = page.locator("#openClaudeOnboarding")
expect(button).to_have_text("Complete onboarding")
button.click()
page.locator("#confirmClaudeOnboarding").click()
expect(button).to_have_text("Saving…")
page.keyboard.press("Escape")
expect(page.locator("#claudeOnboardingDialog")).not_to_be_visible()
page.locator("#openClaudeIntegration").click()
page.locator("#confirmClaudeIntegration").click()
expect(page.locator("#openClaudeIntegration")).to_have_text("Disconnect")
assert (
json.loads((tmp_path / ".claude.json").read_text())["hasCompletedOnboarding"]
is True
)
assert len(pending) == 1
with page.expect_response(
lambda response: response.url.endswith("/claude-onboarding")
):
pending.pop().fulfill(
status=503 if save_failed else 200,
json=(
{"detail": "Temporary completion error"}
if save_failed
else {"completed": True, "changed": False}
),
)
expect(button).to_have_text("Completed")
expect(button).to_be_disabled()
expect(page.locator("#claudeOnboardingMessage")).to_be_hidden()