源码快照 @ 2026-09-02 (source-only, 剔除非源码素材)

apps/app/tests/den-auth-provider.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+
+import { DenApiError } from "../src/app/lib/den";
+import {
+  DEN_AUTH_SIGNAL_RETRY_COOLDOWN_MS,
+  hasRetainedDenSession,
+  isDenSessionRestoring,
+  resolveDenActiveOrganizationWithRetry,
+  resolveDenAuthFailureStatus,
+  shouldRetryDenAuthOnSignal,
+} from "../src/react-app/domains/cloud/den-auth-provider";
+
+const resolvedOrganization = {
+  id: "org_invited",
+  name: "Invited organization",
+  slug: "invited-organization",
+  role: "member",
+};
+
+describe("resolveDenAuthFailureStatus", () => {
+  test("only treats a confirmed unauthorized response as signed out", () => {
+    expect(resolveDenAuthFailureStatus(new DenApiError(401, "unauthorized", "Unauthorized"))).toBe(
+      "signed_out",
+    );
+    expect(resolveDenAuthFailureStatus(new DenApiError(403, "forbidden", "Forbidden"))).toBe(
+      "unavailable",
+    );
+  });
+
+  test("keeps the session for server, timeout, and network failures", () => {
+    expect(resolveDenAuthFailureStatus(new DenApiError(503, "unavailable", "Unavailable"))).toBe(
+      "unavailable",
+    );
+    expect(resolveDenAuthFailureStatus(new Error("Request timed out."))).toBe("unavailable");
+    expect(resolveDenAuthFailureStatus(new TypeError("Failed to fetch"))).toBe("unavailable");
+  });
+});
+
+describe("retained Den sessions", () => {
+  test("keeps signed-in behavior while Cloud availability is unknown", () => {
+    expect(hasRetainedDenSession("signed_in")).toBe(true);
+    expect(hasRetainedDenSession("unavailable")).toBe(true);
+    expect(hasRetainedDenSession("checking")).toBe(false);
+    expect(hasRetainedDenSession("signed_out")).toBe(false);
+  });
+});
+
+describe("isDenSessionRestoring", () => {
+  test("a retained account without a confirmed user is restoring, never signed out", () => {
+    // Initial check in flight.
+    expect(isDenSessionRestoring({ status: "checking", hasUser: false })).toBe(true);
+    // First check failed transiently (local restart, control-plane blip)
+    // before any user was confirmed: the account UI must keep showing the
+    // restoring state instead of flashing "Sign in".
+    expect(isDenSessionRestoring({ status: "unavailable", hasUser: false })).toBe(true);
+  });
+
+  test("settled sessions are not restoring", () => {
+    expect(isDenSessionRestoring({ status: "signed_in", hasUser: true })).toBe(false);
+    // A previously confirmed user stays rendered as the account during an
+    // availability blip.
+    expect(isDenSessionRestoring({ status: "unavailable", hasUser: true })).toBe(false);
+    expect(isDenSessionRestoring({ status: "signed_out", hasUser: false })).toBe(false);
+  });
+});
+
+describe("shouldRetryDenAuthOnSignal", () => {
+  test("retries an unavailable session when connectivity returns", () => {
+    expect(
+      shouldRetryDenAuthOnSignal({
+        status: "unavailable",
+        online: true,
+        now: 1_000,
+        lastAttemptAt: null,
+      }),
+    ).toBe(true);
+  });
+
+  test("does not retry offline, healthy, or inside the signal cooldown", () => {
+    expect(
+      shouldRetryDenAuthOnSignal({
+        status: "unavailable",
+        online: false,
+        now: 1_000,
+        lastAttemptAt: null,
+      }),
+    ).toBe(false);
+    expect(
+      shouldRetryDenAuthOnSignal({
+        status: "signed_in",
+        online: true,
+        now: 1_000,
+        lastAttemptAt: null,
+      }),
+    ).toBe(false);
+    expect(
+      shouldRetryDenAuthOnSignal({
+        status: "unavailable",
+        online: true,
+        now: 1_000 + DEN_AUTH_SIGNAL_RETRY_COOLDOWN_MS - 1,
+        lastAttemptAt: 1_000,
+      }),
+    ).toBe(false);
+    expect(
+      shouldRetryDenAuthOnSignal({
+        status: "unavailable",
+        online: true,
+        now: 1_000 + DEN_AUTH_SIGNAL_RETRY_COOLDOWN_MS,
+        lastAttemptAt: 1_000,
+      }),
+    ).toBe(true);
+  });
+});
+
+describe("resolveDenActiveOrganizationWithRetry", () => {
+  test("recovers when an invited organization is temporarily unavailable", async () => {
+    let attempts = 0;
+    const waits: number[] = [];
+
+    const result = await resolveDenActiveOrganizationWithRetry(
+      async () => {
+        attempts += 1;
+        if (attempts === 1) throw new TypeError("Failed to fetch");
+        if (attempts === 2) return null;
+        return resolvedOrganization;
+      },
+      async (delayMs) => {
+        waits.push(delayMs);
+      },
+    );
+
+    expect(result).toEqual(resolvedOrganization);
+    expect(attempts).toBe(3);
+    expect(waits).toEqual([200, 600]);
+  });
+});