330 lines
23 KiB
TypeScript
330 lines
23 KiB
TypeScript
import React, { act } from "react";
|
|
(globalThis as Record<string, unknown>).React = React;
|
|
import assert from "node:assert/strict";
|
|
import { afterEach, test } from "node:test";
|
|
import { createRoot, type Root } from "react-dom/client";
|
|
import { renderToStaticMarkup } from "react-dom/server";
|
|
import { parseHTML } from "linkedom";
|
|
import { ChatGPTBackgroundAccess, ChatGPTConnection, ChatGPTUIProvider, CHATGPT_NOTICE } from "../components/settings/chatgpt-connection.tsx";
|
|
import { SettingsDialogBody } from "../components/settings/settings-dialog.tsx";
|
|
import { ModelControl } from "../components/model-picker.tsx";
|
|
import type { ChatGPTStatus, ChatGPTControlBridge } from "../src/core/index.ts";
|
|
|
|
const dom = parseHTML("<html><body></body></html>");
|
|
Object.assign(globalThis, { window: dom.window, document: dom.document, Element: dom.window.Element, HTMLElement: dom.window.HTMLElement, CustomEvent: dom.window.CustomEvent, IS_REACT_ACT_ENVIRONMENT: true, localStorage: { getItem: () => null, setItem() {} } });
|
|
const originalFetch = globalThis.fetch;
|
|
let root: Root | undefined, host: HTMLDivElement | undefined;
|
|
const account = (id = "private-registration-id", email = "learner@example.invalid", connected = true, background = false) => ({ id, email, registration: "private-issued-client", connected, background, planEnabled: true });
|
|
const disconnected = (): ChatGPTStatus => ({ available: true, pending: false, activeId: null, accounts: [account("signed-out-record", "signed-out@example.invalid", false)], error: null });
|
|
const connected = (background = false): ChatGPTStatus => ({ ...disconnected(), activeId: "private-registration-id", accounts: [account(undefined, undefined, true, background), ...disconnected().accounts] });
|
|
function deferred<T>() { let resolve!: (v: T) => void; const promise = new Promise<T>((done) => { resolve = done; }); return { promise, resolve }; }
|
|
function fixture(initial = disconnected(), overrides: Partial<ChatGPTControlBridge> = {}) {
|
|
let status = initial;
|
|
const calls = { login: 0, cancel: 0, consent: [] as boolean[], consentIds: [] as string[], logout: 0 };
|
|
const listeners = new Set<() => void>();
|
|
const bridge: ChatGPTControlBridge = {
|
|
status: async () => status,
|
|
login: async () => { calls.login++; return status = connected(); },
|
|
cancel: async () => { calls.cancel++; return status = disconnected(); },
|
|
select: async (id) => { status = { ...status, activeId: id }; return status; },
|
|
logout: async () => { calls.logout++; return status = disconnected(); },
|
|
consent: async (id, enabled) => { calls.consentIds.push(id); calls.consent.push(enabled); status = { ...status, accounts: status.accounts.map((a) => a.id === id ? { ...a, background: enabled } : a) }; return status; },
|
|
onChange: (cb) => { listeners.add(cb); return () => listeners.delete(cb); },
|
|
...overrides,
|
|
};
|
|
window.lh = { expandWindow() {}, chatgpt: bridge };
|
|
return { calls, bridge, push(next: ChatGPTStatus) { status = next; for (const cb of listeners) cb(); } };
|
|
}
|
|
async function mount(children: React.ReactNode = <ChatGPTConnection />) {
|
|
host = document.createElement("div"); document.body.append(host); root = createRoot(host);
|
|
await act(async () => root!.render(<ChatGPTUIProvider>{children}</ChatGPTUIProvider>));
|
|
}
|
|
const byTest = (id: string) => document.querySelector<HTMLElement>(`[data-testid="${id}"]`)!;
|
|
async function click(element: HTMLElement) { assert(element); await act(async () => element.click()); }
|
|
function button(text: string, scope: ParentNode = document) { return [...scope.querySelectorAll<HTMLButtonElement>("button")].find((el) => el.textContent === text)!; }
|
|
afterEach(async () => { await act(async () => root?.unmount()); host?.remove(); root = undefined; host = undefined; delete window.lh; globalThis.fetch = originalFetch; });
|
|
|
|
test("settings put Model providers first and select it by default", () => {
|
|
const html = renderToStaticMarkup(<SettingsDialogBody onClose={() => {}} />);
|
|
assert.match(html, /settings-nav-keys[^>]*aria-current="true"/);
|
|
assert(html.indexOf("settings-nav-keys") < html.indexOf("settings-nav-general"));
|
|
assert.match(html, />Model providers<\/button>/);
|
|
assert.doesNotMatch(html, />Connections<\/button>/);
|
|
});
|
|
|
|
test("setup and disconnected rows are secondary buttons, not disclosure walls; cancel never logs in or changes consent", async () => {
|
|
const f = fixture(); await mount(<ChatGPTConnection setup />);
|
|
assert(!document.body.textContent?.includes(CHATGPT_NOTICE));
|
|
assert(!document.body.textContent?.includes("Manage usage"));
|
|
assert(!document.body.textContent?.includes("signed-out@example.invalid"));
|
|
assert.equal(f.calls.login, 0);
|
|
const trigger = byTest("chatgpt-login");
|
|
assert.match(trigger.className, /cursor-pointer/);
|
|
assert.match(trigger.className, /hover:bg-accent/);
|
|
assert.match(trigger.className, /focus-visible:ring/);
|
|
await click(trigger);
|
|
assert.equal(f.calls.login, 0, "opening disclosure is not OAuth");
|
|
assert(document.body.textContent?.includes(CHATGPT_NOTICE));
|
|
const toggle = document.querySelector<HTMLElement>('[role="switch"][aria-label="Allow background use"]')!;
|
|
assert.equal(toggle.getAttribute("aria-checked"), "false");
|
|
await click(toggle); assert.equal(toggle.getAttribute("aria-checked"), "true");
|
|
await click(button("Cancel", byTest("chatgpt-account-dialog")));
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
assert.equal(f.calls.login, 0); assert.deepEqual(f.calls.consent, []); assert.equal(f.calls.cancel, 0);
|
|
await click(byTest("chatgpt-login"));
|
|
assert.equal(document.querySelector('[role="switch"]')?.getAttribute("aria-checked"), "false", "each initial connection choice starts OFF");
|
|
});
|
|
|
|
test("only explicit proceed invokes OAuth; initial background opt-in waits for verified connection", async () => {
|
|
const f = fixture(); await mount(); await click(byTest("chatgpt-login"));
|
|
await click(document.querySelector<HTMLElement>('[role="switch"]')!);
|
|
assert.deepEqual(f.calls.consent, []);
|
|
await click(byTest("chatgpt-proceed"));
|
|
assert.equal(f.calls.login, 1); assert.deepEqual(f.calls.consent, [true]);
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
assert(button("Manage…"));
|
|
});
|
|
|
|
test("closing pending OAuth cancels and a late login result cannot apply draft consent", async () => {
|
|
const login = deferred<ChatGPTStatus>();
|
|
const f = fixture(disconnected(), { login: () => { f.calls.login++; return login.promise; } });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!);
|
|
await click(byTest("chatgpt-proceed"));
|
|
await click(button("Cancel", byTest("chatgpt-account-dialog")));
|
|
assert.equal(f.calls.cancel, 1);
|
|
await act(async () => login.resolve(connected()));
|
|
assert.deepEqual(f.calls.consent, []);
|
|
assert(!button("Manage…"));
|
|
});
|
|
|
|
test("connected account selector displays email only, excludes signed-out registrations, and retains safe fallback", async () => {
|
|
const status = connected(); status.accounts.push(account("second-id", "second@example.invalid"), account("missing-email", ""));
|
|
fixture(status); await mount();
|
|
const select = document.querySelector<HTMLSelectElement>('select[aria-label="ChatGPT account"]')!;
|
|
assert.deepEqual([...select.querySelectorAll("option")].map((o) => o.textContent), ["learner@example.invalid", "second@example.invalid", "ChatGPT account"]);
|
|
assert.doesNotMatch(document.body.textContent!, /private-registration-id|private-issued-client|second-id|signed-out@example| · active|registration /);
|
|
assert(!document.body.textContent?.includes(CHATGPT_NOTICE));
|
|
await click(button("Manage…"));
|
|
assert(document.body.textContent?.includes(CHATGPT_NOTICE));
|
|
assert(byTest("chatgpt-disconnect"));
|
|
});
|
|
|
|
test("successful local disconnect removes action, resets dialog, and prevents repeated pending clicks without deleting registration UI state", async () => {
|
|
const logout = deferred<ChatGPTStatus>();
|
|
const f = fixture(connected(), { logout: () => { f.calls.logout++; return logout.promise; } });
|
|
await mount(); await click(button("Manage…"));
|
|
const disconnect = byTest("chatgpt-disconnect") as HTMLButtonElement;
|
|
await act(async () => { disconnect.click(); disconnect.click(); });
|
|
assert.equal(f.calls.logout, 1); assert.equal(disconnect.disabled, true);
|
|
await act(async () => logout.resolve(disconnected()));
|
|
assert(!document.querySelector('[data-testid="chatgpt-disconnect"]'));
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
assert(byTest("chatgpt-login"));
|
|
assert(!document.body.textContent?.includes("Signed out locally"));
|
|
assert(!document.querySelector('[role="alert"]'));
|
|
await click(byTest("chatgpt-login"));
|
|
assert(document.body.textContent?.includes("signed-out@example.invalid"), "retained registration can still be explicitly reauthorized inside sign-in dialog");
|
|
});
|
|
|
|
test("real unconfirmed revoke is a distinct contextual dismissible warning, not permanent global red error", async () => {
|
|
const warning = "Signed out locally. Remote revocation was not confirmed; disconnect LearnHarness in ChatGPT Settings.";
|
|
fixture(connected(), { logout: async () => ({ ...disconnected(), error: warning }) });
|
|
await mount(); await click(button("Manage…")); await click(byTest("chatgpt-disconnect"));
|
|
assert(byTest("chatgpt-login")); assert(!document.querySelector('[data-testid="chatgpt-disconnect"]'));
|
|
const alert = byTest("chatgpt-revocation-warning");
|
|
assert.equal(alert.textContent, warning); assert.doesNotMatch(alert.className, /text-red/);
|
|
await click(button("Dismiss", byTest("chatgpt-account-dialog")));
|
|
assert(!document.querySelector('[data-testid="chatgpt-revocation-warning"]'));
|
|
assert(!document.querySelector('[role="alert"]'));
|
|
});
|
|
|
|
test("background model choice has contextual Enable action only while connected, selected, and consent OFF", async () => {
|
|
const f = fixture(connected());
|
|
await mount(<><ChatGPTBackgroundAccess provider="chatgpt" /><ChatGPTBackgroundAccess provider="openai" /><ChatGPTConnection /></>);
|
|
assert.equal([...document.querySelectorAll("button")].filter((b) => b.textContent === "Enable background use").length, 1);
|
|
await click(button("Enable background use"));
|
|
assert.deepEqual(f.calls.consent, []);
|
|
await click(document.querySelector<HTMLElement>('[role="switch"]')!);
|
|
assert.deepEqual(f.calls.consent, [true]);
|
|
assert(!button("Enable background use"));
|
|
await act(async () => f.push(disconnected()));
|
|
assert(!button("Enable background use"));
|
|
});
|
|
|
|
test("browser-only sign-in is disabled without invoking OAuth", async () => {
|
|
await mount();
|
|
const trigger = byTest("chatgpt-login") as HTMLButtonElement;
|
|
assert(trigger.disabled); assert.match(trigger.className, /disabled:opacity/);
|
|
await click(trigger); assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
});
|
|
|
|
test("foreground model/dictation toolbar has no plan badge or background-consent action", async () => {
|
|
globalThis.fetch = async (input) => {
|
|
if (input === "/api/models") return Response.json({ models: [], providers: [], slots: {}, defaults: {} });
|
|
if (input === "/api/settings") return Response.json({ settings: { models: { strong: { model: { provider: "chatgpt", id: "gpt-5" } } } } });
|
|
throw new Error(`unexpected fixture request ${input}`);
|
|
};
|
|
fixture(connected()); await mount(<ModelControl />);
|
|
assert.match(byTest("stats-model").textContent!, /gpt/i);
|
|
assert(!document.body.textContent?.includes("Using ChatGPT plan"));
|
|
assert(!document.body.textContent?.includes("Enable background use"));
|
|
assert(!document.querySelector('a[href="https://chatgpt.com/settings/usage"]'));
|
|
});
|
|
|
|
const storageError = "ChatGPT credentials could not be saved securely. Reconnect before making requests.";
|
|
const errorReply = () => ({ error: storageError } as ChatGPTStatus); // Actual IPC catch envelope, deliberately not a snapshot.
|
|
function pendingFixture(initial = disconnected(), overrides: Partial<ChatGPTControlBridge> = {}) {
|
|
const f = fixture(initial, { login: async () => { f.calls.login++; const pending = { ...initial, pending: true }; f.push(pending); return pending; }, ...overrides });
|
|
return f;
|
|
}
|
|
|
|
test("production lifecycle: Cancel after the immediate pending reply cancels OAuth; later events cannot apply the old choice or close a new dialog", async () => {
|
|
const f = pendingFixture(); await mount(); await click(byTest("chatgpt-login"));
|
|
await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
assert(document.body.textContent?.includes("Waiting for browser sign-in"));
|
|
await click(button("Cancel", byTest("chatgpt-account-dialog"))); assert.equal(f.calls.cancel, 1);
|
|
await click(byTest("chatgpt-login")); const nextDialog = byTest("chatgpt-account-dialog");
|
|
await act(async () => f.push(connected(false)));
|
|
assert.deepEqual(f.calls.consent, []); assert.equal(f.calls.login, 1); assert.equal(byTest("chatgpt-account-dialog"), nextDialog);
|
|
});
|
|
|
|
test("production lifecycle: verified onChange applies explicit ON once to the completed account and closes only its disclosure", async () => {
|
|
const f = pendingFixture(); await mount(); await click(byTest("chatgpt-login"));
|
|
await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
assert.equal(f.calls.login, 1); assert.deepEqual(f.calls.consent, []);
|
|
assert((byTest("chatgpt-proceed") as HTMLButtonElement).disabled);
|
|
await act(async () => f.push(connected(false)));
|
|
assert.deepEqual(f.calls.consent, [true]); assert.deepEqual(f.calls.consentIds, ["private-registration-id"]);
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
await act(async () => f.push(connected(true))); assert.deepEqual(f.calls.consent, [true]);
|
|
});
|
|
|
|
test("production lifecycle: initial OFF revokes retained ON only after verified returning-account completion", async () => {
|
|
const initial = connected(true); initial.activeId = null; initial.accounts[0]!.connected = false;
|
|
const f = pendingFixture(initial); await mount(); await click(byTest("chatgpt-login"));
|
|
assert.equal(document.querySelector('[role="switch"]')?.getAttribute("aria-checked"), "false");
|
|
await click(byTest("chatgpt-proceed")); assert.deepEqual(f.calls.consent, []);
|
|
await act(async () => f.push(connected(true)));
|
|
assert.deepEqual(f.calls.consent, [false]); assert.deepEqual(f.calls.consentIds, ["private-registration-id"]);
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
});
|
|
|
|
test("error-only logout reply preserves valid status, shows recoverable error, never claims disconnect, and permits explicit retry", async () => {
|
|
const f = fixture(connected(), { logout: async () => { f.calls.logout++; return errorReply(); } });
|
|
await mount(); await click(button("Manage…"));
|
|
await assert.doesNotReject(() => click(byTest("chatgpt-disconnect")));
|
|
assert.equal(document.querySelector('[role="alert"]')?.textContent, storageError);
|
|
assert.equal((byTest("chatgpt-disconnect") as HTMLButtonElement).disabled, false);
|
|
assert.equal(document.querySelector('select[aria-label="ChatGPT account"] option')?.textContent, "learner@example.invalid");
|
|
assert(!document.querySelector('[data-testid="chatgpt-login"]')); assert(!document.body.textContent?.includes("Signed out locally"));
|
|
f.bridge.logout = async () => { f.calls.logout++; return disconnected(); };
|
|
await click(byTest("chatgpt-disconnect")); assert.equal(f.calls.logout, 2);
|
|
assert(byTest("chatgpt-login")); assert(!document.querySelector('[data-testid="chatgpt-disconnect"]'));
|
|
});
|
|
|
|
test("error-only consent reply leaves the saved toggle unchanged with a contextual error", async () => {
|
|
fixture(connected(), { consent: async () => errorReply() }); await mount(); await click(button("Manage…"));
|
|
await assert.doesNotReject(() => click(document.querySelector<HTMLElement>('[role="switch"]')!));
|
|
assert.equal(document.querySelector('[role="switch"]')?.getAttribute("aria-checked"), "false");
|
|
assert.equal(document.querySelector('[role="alert"]')?.textContent, storageError); assert(byTest("chatgpt-disconnect"));
|
|
});
|
|
|
|
test("error-only initial login reply is recoverable without corrupting status or automatically retrying", async () => {
|
|
const f = fixture(disconnected(), { login: async () => { f.calls.login++; return errorReply(); } });
|
|
await mount(); await click(byTest("chatgpt-login")); await assert.doesNotReject(() => click(byTest("chatgpt-proceed")));
|
|
assert.equal(document.querySelector('[role="alert"]')?.textContent, storageError);
|
|
assert.equal((byTest("chatgpt-proceed") as HTMLButtonElement).disabled, false); assert.equal(f.calls.login, 1);
|
|
assert.deepEqual(f.calls.consent, []);
|
|
});
|
|
|
|
test("error-only consent after verified login keeps disclosure/error open and cannot be retried by a duplicate completion push", async () => {
|
|
let consentCalls = 0;
|
|
const f = pendingFixture(disconnected(), { consent: async () => { consentCalls++; return errorReply(); } });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push(connected(false)));
|
|
assert.equal(document.querySelector('[role="alert"]')?.textContent, storageError); assert(byTest("chatgpt-account-dialog"));
|
|
await act(async () => f.push(connected(false))); assert.equal(consentCalls, 1); assert.equal(f.calls.login, 1);
|
|
});
|
|
|
|
test("failed pending attempt never applies draft consent, starts another login, or closes disclosure on a later clean status", async () => {
|
|
const f = pendingFixture(); await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push({ ...connected(false), error: "ChatGPT sign-in could not be verified." }));
|
|
assert.equal(document.querySelector('[role="alert"]')?.textContent, "ChatGPT sign-in could not be verified.");
|
|
await act(async () => f.push(connected(false)));
|
|
assert.deepEqual(f.calls.consent, []); assert.equal(f.calls.login, 1); assert(byTest("chatgpt-account-dialog"));
|
|
});
|
|
|
|
test("saved-registration attempt cannot apply its choice to a different active account", async () => {
|
|
const f = pendingFixture(); await mount(); await click(byTest("chatgpt-login"));
|
|
const select = document.querySelector<HTMLSelectElement>('select[aria-label="Saved ChatGPT account"]')!;
|
|
await act(async () => { select.querySelector<HTMLOptionElement>('option[value="signed-out-record"]')!.selected = true; select.dispatchEvent(new window.Event("change", { bubbles: true })); });
|
|
await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push(connected(false)));
|
|
assert.deepEqual(f.calls.consent, []); assert(byTest("chatgpt-account-dialog")); assert(document.querySelector('[role="alert"]'));
|
|
});
|
|
|
|
test("account invalidation while initial consent is awaiting IPC fences its stale reply and preserves an unrelated later Manage dialog", async () => {
|
|
const consent = deferred<ChatGPTStatus>();
|
|
const f = pendingFixture(disconnected(), { consent: () => consent.promise });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push(connected(false)));
|
|
const other = { ...connected(), activeId: "other", accounts: [account("other", "other@example.invalid")] };
|
|
await act(async () => f.push(other));
|
|
await click(button("Cancel", byTest("chatgpt-account-dialog"))); await click(button("Manage…")); const manage = byTest("chatgpt-account-dialog");
|
|
await act(async () => consent.resolve(connected(true)));
|
|
assert.equal(byTest("chatgpt-account-dialog"), manage); assert(manage.textContent?.includes("other@example.invalid"));
|
|
assert.equal(document.querySelector('select[aria-label="ChatGPT account"] option')?.textContent, "other@example.invalid");
|
|
});
|
|
|
|
test("verified event before the initial IPC acknowledgement is handled once; the late pending reply cannot reopen or overwrite it", async () => {
|
|
const ack = deferred<ChatGPTStatus>();
|
|
const f = fixture(disconnected(), { login: () => { f.calls.login++; return ack.promise; } });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push({ ...disconnected(), pending: true }));
|
|
await act(async () => f.push(connected(false)));
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
await act(async () => ack.resolve({ ...disconnected(), pending: true }));
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]')); assert(button("Manage…")); assert.equal(f.calls.login, 1);
|
|
});
|
|
|
|
test("error-only pending cancellation reply remains visible and recoverable without replacing status", async () => {
|
|
const f = pendingFixture(disconnected(), { cancel: async () => { f.calls.cancel++; return errorReply(); } });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(byTest("chatgpt-proceed"));
|
|
await assert.doesNotReject(() => click(button("Cancel", byTest("chatgpt-account-dialog"))));
|
|
assert.equal(f.calls.cancel, 1); assert.equal(document.querySelector('[role="alert"]')?.textContent, storageError);
|
|
assert(document.querySelector('[data-testid="chatgpt-connection"]')); assert.deepEqual(f.calls.consent, []);
|
|
assert(byTest("chatgpt-account-dialog"));
|
|
f.bridge.cancel = async () => { f.calls.cancel++; return disconnected(); };
|
|
await click(button("Cancel", byTest("chatgpt-account-dialog")));
|
|
assert.equal(f.calls.cancel, 2); assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
});
|
|
|
|
test("coalesced completion before the pending acknowledgement is reconciled from fresh post-ack status", async () => {
|
|
const ack = deferred<ChatGPTStatus>();
|
|
const f = fixture(disconnected(), { login: () => { f.calls.login++; return ack.promise; } });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
// A status reader can miss pending entirely when two notifications coalesce.
|
|
await act(async () => f.push(connected(false))); assert.deepEqual(f.calls.consent, []);
|
|
await act(async () => ack.resolve({ ...disconnected(), pending: true }));
|
|
assert.deepEqual(f.calls.consent, [true]); assert.deepEqual(f.calls.consentIds, ["private-registration-id"]);
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]'));
|
|
});
|
|
|
|
test("a canceled attempt's late IPC reply cannot release a newer pending attempt or apply its old ON choice", async () => {
|
|
const oldAck = deferred<ChatGPTStatus>();
|
|
const f = fixture(disconnected(), { login: async () => {
|
|
f.calls.login++;
|
|
if (f.calls.login === 1) return oldAck.promise;
|
|
const pending = { ...disconnected(), pending: true }; f.push(pending); return pending;
|
|
} });
|
|
await mount(); await click(byTest("chatgpt-login")); await click(document.querySelector<HTMLElement>('[role="switch"]')!); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => f.push({ ...disconnected(), pending: true })); await click(button("Cancel", byTest("chatgpt-account-dialog")));
|
|
await click(byTest("chatgpt-login")); await click(byTest("chatgpt-proceed"));
|
|
await act(async () => oldAck.resolve(connected(false)));
|
|
assert((byTest("chatgpt-proceed") as HTMLButtonElement).disabled); assert.deepEqual(f.calls.consent, []);
|
|
const next = { ...connected(), activeId: "new-attempt-account", accounts: [account("new-attempt-account", "new@example.invalid", true, true)] };
|
|
await act(async () => f.push(next));
|
|
assert.deepEqual(f.calls.consent, [false]); assert.deepEqual(f.calls.consentIds, ["new-attempt-account"]);
|
|
assert(!document.querySelector('[data-testid="chatgpt-account-dialog"]')); assert.equal(f.calls.login, 2);
|
|
});
|