import type { DesktopBridge } from "@t3tools/contracts";import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; function jsonResponse(body: unknown, init?: ResponseInit) { return new Response(JSON.stringify(body), { headers: { "content-type": "application/json", }, status: 200, ...init, });} type TestWindow = { location: URL; history: { replaceState: (_data: unknown, _unused: string, url: string) => void; }; desktopBridge?: DesktopBridge;}; function installTestBrowser(url: string) { const testWindow: TestWindow = { location: new URL(url), history: { replaceState: (_data, _unused, nextUrl) => { testWindow.location = new URL(nextUrl, testWindow.location.href); }, }, }; vi.stubGlobal("window", testWindow); vi.stubGlobal("document", { title: "T3 Code" }); return testWindow;} function sessionResponse(body: unknown, init?: ResponseInit) { return jsonResponse(body, init);} describe("resolveInitialServerAuthGateState", () => { beforeEach(() => { vi.restoreAllMocks(); vi.useRealTimers(); installTestBrowser("http://localhost/"); }); afterEach(async () => { const { __resetServerAuthBootstrapForTests } = await import("./environments/primary"); __resetServerAuthBootstrapForTests(); vi.unstubAllEnvs(); vi.useRealTimers(); vi.restoreAllMocks(); }); it("reuses an in-flight silent bootstrap attempt", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const testWindow = installTestBrowser("http://localhost/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://localhost:3773", wsBaseUrl: "ws://localhost:3773", bootstrapToken: "desktop-bootstrap-token", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await Promise.all([resolveInitialServerAuthGateState(), resolveInitialServerAuthGateState()]); expect(fetchMock).toHaveBeenCalledTimes(3); expect(fetchMock.mock.calls[0]?.[0]).toBe("http://localhost:3773/api/auth/session"); expect(fetchMock.mock.calls[1]?.[0]).toBe("http://localhost:3773/api/auth/bootstrap"); expect(fetchMock.mock.calls[2]?.[0]).toBe("http://localhost:3773/api/auth/session"); }); it("uses https fetch urls when the primary environment uses wss", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); vi.stubEnv("VITE_HTTP_URL", "https://remote.example.com"); vi.stubEnv("VITE_WS_URL", "wss://remote.example.com"); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("https://remote.example.com/api/auth/session", { credentials: "include", }); }); it("uses the current origin as an auth proxy base for local dev environments", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); installTestBrowser("http://localhost:5735/"); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("http://localhost:5735/api/auth/session", { credentials: "include", }); }); it("uses the vite proxy for desktop-managed loopback auth requests during local dev", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); vi.stubEnv("VITE_DEV_SERVER_URL", "http://127.0.0.1:5733"); const testWindow = installTestBrowser("http://127.0.0.1:5733/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://127.0.0.1:3773", wsBaseUrl: "ws://127.0.0.1:3773", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("http://127.0.0.1:5733/api/auth/session", { credentials: "include", }); }); it("returns a requires-auth state instead of throwing when no bootstrap credential exists", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); }); it("retries transient auth session bootstrap failures after restart", async () => { vi.useFakeTimers(); const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); const gateStatePromise = resolveInitialServerAuthGateState(); await vi.advanceTimersByTimeAsync(2_000); await expect(gateStatePromise).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledTimes(4); }); it("takes a pairing token from the location hash and strips it immediately", async () => { const testWindow = installTestBrowser("http://localhost/#token=pairing-token"); const { takePairingTokenFromUrl } = await import("./environments/primary"); expect(takePairingTokenFromUrl()).toBe("pairing-token"); expect(testWindow.location.hash).toBe(""); expect(testWindow.location.searchParams.get("token")).toBeNull(); }); it("accepts query-string pairing tokens as a backward-compatible fallback", async () => { const testWindow = installTestBrowser("http://localhost/?token=pairing-token"); const { takePairingTokenFromUrl } = await import("./environments/primary"); expect(takePairingTokenFromUrl()).toBe("pairing-token"); expect(testWindow.location.searchParams.get("token")).toBeNull(); }); it("allows manual token submission after the initial auth check requires pairing", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); installTestBrowser("http://localhost/"); const { resolveInitialServerAuthGateState, submitServerAuthCredential } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); await expect(submitServerAuthCredential("retry-token")).resolves.toBeUndefined(); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "authenticated", }); expect(fetchMock).toHaveBeenCalledTimes(3); }); it("waits for the authenticated session to become observable after silent desktop bootstrap", async () => { vi.useFakeTimers(); const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const testWindow = installTestBrowser("http://localhost/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://localhost:3773", wsBaseUrl: "ws://localhost:3773", bootstrapToken: "desktop-bootstrap-token", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); const gateStatePromise = resolveInitialServerAuthGateState(); await vi.advanceTimersByTimeAsync(100); await expect(gateStatePromise).resolves.toEqual({ status: "authenticated", }); expect(fetchMock).toHaveBeenCalledTimes(4); expect(fetchMock.mock.calls[2]?.[0]).toBe("http://localhost:3773/api/auth/session"); expect(fetchMock.mock.calls[3]?.[0]).toBe("http://localhost:3773/api/auth/session"); }); it("revalidates the server session state after a previous authenticated result", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "authenticated", }); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledTimes(2); }); it("creates a pairing credential from the authenticated auth endpoint", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( jsonResponse({ id: "pairing-link-1", credential: "pairing-token", label: "Julius iPhone", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const { createServerPairingCredential } = await import("./environments/primary"); await expect(createServerPairingCredential("Julius iPhone")).resolves.toEqual({ id: "pairing-link-1", credential: "pairing-token", label: "Julius iPhone", expiresAt: "2026-04-05T00:00:00.000Z", }); expect(fetchMock).toHaveBeenCalledWith("http://localhost/api/auth/pairing-token", { body: JSON.stringify({ label: "Julius iPhone" }), credentials: "include", headers: { "content-type": "application/json", }, method: "POST", }); });Lines 1–500 of 501. Load more
import type { DesktopBridge } from "@t3tools/contracts"; import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; function jsonResponse(body: unknown, init?: ResponseInit) { return new Response(JSON.stringify(body), { headers: { "content-type": "application/json", }, status: 200, ...init, }); } type TestWindow = { location: URL; history: { replaceState: (_data: unknown, _unused: string, url: string) => void; }; desktopBridge?: DesktopBridge; }; function installTestBrowser(url: string) { const testWindow: TestWindow = { location: new URL(url), history: { replaceState: (_data, _unused, nextUrl) => { testWindow.location = new URL(nextUrl, testWindow.location.href); }, }, }; vi.stubGlobal("window", testWindow); vi.stubGlobal("document", { title: "T3 Code" }); return testWindow; } function sessionResponse(body: unknown, init?: ResponseInit) { return jsonResponse(body, init); } describe("resolveInitialServerAuthGateState", () => { beforeEach(() => { vi.restoreAllMocks(); vi.useRealTimers(); installTestBrowser("http://localhost/"); }); afterEach(async () => { const { __resetServerAuthBootstrapForTests } = await import("./environments/primary"); __resetServerAuthBootstrapForTests(); vi.unstubAllEnvs(); vi.useRealTimers(); vi.restoreAllMocks(); }); it("reuses an in-flight silent bootstrap attempt", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const testWindow = installTestBrowser("http://localhost/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://localhost:3773", wsBaseUrl: "ws://localhost:3773", bootstrapToken: "desktop-bootstrap-token", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await Promise.all([resolveInitialServerAuthGateState(), resolveInitialServerAuthGateState()]); expect(fetchMock).toHaveBeenCalledTimes(3); expect(fetchMock.mock.calls[0]?.[0]).toBe("http://localhost:3773/api/auth/session"); expect(fetchMock.mock.calls[1]?.[0]).toBe("http://localhost:3773/api/auth/bootstrap"); expect(fetchMock.mock.calls[2]?.[0]).toBe("http://localhost:3773/api/auth/session"); }); it("uses https fetch urls when the primary environment uses wss", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); vi.stubEnv("VITE_HTTP_URL", "https://remote.example.com"); vi.stubEnv("VITE_WS_URL", "wss://remote.example.com"); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("https://remote.example.com/api/auth/session", { credentials: "include", }); }); it("uses the current origin as an auth proxy base for local dev environments", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); installTestBrowser("http://localhost:5735/"); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("http://localhost:5735/api/auth/session", { credentials: "include", }); }); it("uses the vite proxy for desktop-managed loopback auth requests during local dev", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); vi.stubEnv("VITE_DEV_SERVER_URL", "http://127.0.0.1:5733"); const testWindow = installTestBrowser("http://127.0.0.1:5733/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://127.0.0.1:3773", wsBaseUrl: "ws://127.0.0.1:3773", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledWith("http://127.0.0.1:5733/api/auth/session", { credentials: "include", }); }); it("returns a requires-auth state instead of throwing when no bootstrap credential exists", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); }); it("retries transient auth session bootstrap failures after restart", async () => { vi.useFakeTimers(); const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce(new Response("Bad Gateway", { status: 502 })) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); const gateStatePromise = resolveInitialServerAuthGateState(); await vi.advanceTimersByTimeAsync(2_000); await expect(gateStatePromise).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledTimes(4); }); it("takes a pairing token from the location hash and strips it immediately", async () => { const testWindow = installTestBrowser("http://localhost/#token=pairing-token"); const { takePairingTokenFromUrl } = await import("./environments/primary"); expect(takePairingTokenFromUrl()).toBe("pairing-token"); expect(testWindow.location.hash).toBe(""); expect(testWindow.location.searchParams.get("token")).toBeNull(); }); it("accepts query-string pairing tokens as a backward-compatible fallback", async () => { const testWindow = installTestBrowser("http://localhost/?token=pairing-token"); const { takePairingTokenFromUrl } = await import("./environments/primary"); expect(takePairingTokenFromUrl()).toBe("pairing-token"); expect(testWindow.location.searchParams.get("token")).toBeNull(); }); it("allows manual token submission after the initial auth check requires pairing", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); installTestBrowser("http://localhost/"); const { resolveInitialServerAuthGateState, submitServerAuthCredential } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); await expect(submitServerAuthCredential("retry-token")).resolves.toBeUndefined(); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "authenticated", }); expect(fetchMock).toHaveBeenCalledTimes(3); }); it("waits for the authenticated session to become observable after silent desktop bootstrap", async () => { vi.useFakeTimers(); const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( jsonResponse({ authenticated: true, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "desktop-managed-local", bootstrapMethods: ["desktop-bootstrap"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const testWindow = installTestBrowser("http://localhost/"); testWindow.desktopBridge = { getLocalEnvironmentBootstrap: () => ({ label: "Local environment", httpBaseUrl: "http://localhost:3773", wsBaseUrl: "ws://localhost:3773", bootstrapToken: "desktop-bootstrap-token", }), } as DesktopBridge; const { resolveInitialServerAuthGateState } = await import("./environments/primary"); const gateStatePromise = resolveInitialServerAuthGateState(); await vi.advanceTimersByTimeAsync(100); await expect(gateStatePromise).resolves.toEqual({ status: "authenticated", }); expect(fetchMock).toHaveBeenCalledTimes(4); expect(fetchMock.mock.calls[2]?.[0]).toBe("http://localhost:3773/api/auth/session"); expect(fetchMock.mock.calls[3]?.[0]).toBe("http://localhost:3773/api/auth/session"); }); it("revalidates the server session state after a previous authenticated result", async () => { const fetchMock = vi .fn<typeof fetch>() .mockResolvedValueOnce( sessionResponse({ authenticated: true, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, sessionMethod: "browser-session-cookie", expiresAt: "2026-04-05T00:00:00.000Z", }), ) .mockResolvedValueOnce( sessionResponse({ authenticated: false, auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }), ); vi.stubGlobal("fetch", fetchMock); const { resolveInitialServerAuthGateState } = await import("./environments/primary"); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "authenticated", }); await expect(resolveInitialServerAuthGateState()).resolves.toEqual({ status: "requires-auth", auth: { policy: "loopback-browser", bootstrapMethods: ["one-time-token"], sessionMethods: ["browser-session-cookie"], sessionCookieName: "t3_session", }, }); expect(fetchMock).toHaveBeenCalledTimes(2); }); it("creates a pairing credential from the authenticated auth endpoint", async () => { const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce( jsonResponse({ id: "pairing-link-1", credential: "pairing-token", label: "Julius iPhone", expiresAt: "2026-04-05T00:00:00.000Z", }), ); vi.stubGlobal("fetch", fetchMock); const { createServerPairingCredential } = await import("./environments/primary"); await expect(createServerPairingCredential("Julius iPhone")).resolves.toEqual({ id: "pairing-link-1", credential: "pairing-token", label: "Julius iPhone", expiresAt: "2026-04-05T00:00:00.000Z", }); expect(fetchMock).toHaveBeenCalledWith("http://localhost/api/auth/pairing-token", { body: JSON.stringify({ label: "Julius iPhone" }), credentials: "include", headers: { "content-type": "application/json", }, method: "POST", }); });