Spaces:
Running
Running
Download e2e/test_admin_integrations.py from dherain24/claude-proxy: direct link, hf CLI and curl.
- Browser
- Download file 27.6 kB
-
https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/e2e/test_admin_integrations.py
- Command line
-
hf download hf://spaces/dherain24/claude-proxy/e2e/test_admin_integrations.py
-
curl -L -o test_admin_integrations.py https://huggingface.co/spaces/dherain24/claude-proxy/resolve/main/e2e/test_admin_integrations.py
27.6 kB
| 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 | |
| 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") | |
| 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() | |
| 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() | |
| 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." | |
| ) | |
| 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 | |
| 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}' | |
| 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() | |
| 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() | |