sailfork / t3code-github / apps/ mobile/ src/ lib/ protectedData.test.ts

import * as Effect from "effect/Effect";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

const mocks = vi.hoisted(() => ({
  appState: "background" as string | null,
  nativeCheckSupported: true,
  platform: "ios",
  subscribed: Promise.withResolvers<void>(),
  listeners: new Set<(state: string) => void>(),
  isProtectedDataAvailable: vi.fn<() => Promise<boolean>>(),
  readStorage: vi.fn<() => Promise<void>>(),
}));

vi.mock("expo", () => ({
  requireOptionalNativeModule: () => ({
    ...(mocks.nativeCheckSupported && {
      isProtectedDataAvailable: mocks.isProtectedDataAvailable,
    }),
  }),
}));
vi.mock("react-native", () => ({
  Platform: {
    get OS() {
      return mocks.platform;
    },
  },
  AppState: {
    get currentState() {
      return mocks.appState;
    },
    addEventListener: (_event: string, listener: (state: string) => void) => {
      mocks.listeners.add(listener);
      mocks.subscribed.resolve();
      return { remove: () => mocks.listeners.delete(listener) };
    },
  },
}));

vi.mock("../persistence/layer", async () => {
  const Effect = await import("effect/Effect");
  const Layer = await import("effect/Layer");
  return { layer: Layer.effectDiscard(Effect.promise(mocks.readStorage)) };
});
vi.mock("../features/cloud/dpop", async () => ({
  layer: (await import("effect/Layer")).empty,
}));
vi.mock("../features/cloud/managedRelayLayer", async () => {
  const Layer = await import("effect/Layer");
  return { layer: () => Layer.empty };
});
vi.mock("../features/cloud/publicConfig", () => ({
  resolveCloudPublicConfig: () => ({ relay: { url: null } }),
}));
vi.mock("../features/observability/tracing", async () => ({
  layer: (await import("effect/Layer")).empty,
}));
vi.mock("@t3tools/client-runtime/rpc", async () => {
  const Layer = await import("effect/Layer");
  return { layerRemoteHttpClient: () => Layer.empty };
});

let runtime: typeof import("./runtime").runtime | undefined;

beforeEach(() => {
  vi.resetModules();
  mocks.appState = "background";
  mocks.nativeCheckSupported = true;
  mocks.platform = "ios";
  mocks.subscribed = Promise.withResolvers<void>();
  mocks.listeners.clear();
  mocks.isProtectedDataAvailable.mockReset();
  mocks.readStorage.mockReset().mockResolvedValue(undefined);
});

afterEach(async () => {
  await runtime?.dispose();
  runtime = undefined;
});

describe("protected storage startup", () => {
  it.each([
    { launch: "background", state: "background", checkRejects: false },
    { launch: "background with a failed native check", state: "background", checkRejects: true },
    { launch: "unset without a native check", state: null, nativeCheckSupported: false },
  ])(
    "keeps a locked $launch launch usable after activation without rebuilding its runtime",
    async (scenario) => {
      mocks.appState = scenario.state;
      mocks.nativeCheckSupported = scenario.nativeCheckSupported ?? true;
      mocks.isProtectedDataAvailable.mockImplementation(async () => {
        if (scenario.checkRejects) throw new Error("Protected data check unavailable.");
        return false;
      });
      mocks.readStorage.mockImplementation(async () => {
        if (mocks.appState !== "active") throw new Error("User interaction is not allowed.");
      });
      ({ runtime } = await import("./runtime"));
      const startup = runtime.runPromiseExit(Effect.succeed("ready"));

      // A missing gate finishes startup with a cached storage failure instead.
      await Promise.race([mocks.subscribed.promise, startup]);
      expect(mocks.readStorage).not.toHaveBeenCalled();
      mocks.appState = "inactive";
      for (const listener of mocks.listeners) listener("inactive");
      await Promise.resolve();
      expect(mocks.readStorage).not.toHaveBeenCalled();

      mocks.appState = "active";
      for (const listener of mocks.listeners) listener("active");
      expect(await startup).toMatchObject({ _tag: "Success", value: "ready" });
      expect(await runtime.runPromise(Effect.succeed("still ready"))).toBe("still ready");
      expect(mocks.readStorage).toHaveBeenCalledOnce();
      expect(mocks.listeners.size).toBe(0);
      mocks.appState = "background";
      await (await import("./protectedData")).whenProtectedDataAvailable();
      expect(mocks.isProtectedDataAvailable).toHaveBeenCalledTimes(
        mocks.nativeCheckSupported ? 1 : 0,
      );
    },
  );
});