@peers-app/peers-ui 0.23.14 → 0.25.0

package/src/screens/contacts/user-connect.test.tsx

@@ -1,382 +0,0 @@
-import type { UserConnectStatus } from "@peers-app/peers-sdk";
-import { TrustLevel } from "@peers-app/peers-sdk";
-import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { mainContentPath } from "../../globals";
-import { UserConnect } from "./user-connect";
-import {
-  buildUserConnectInviteUrl,
-  readUserConnectPendingIntent,
-  writeUserConnectPendingIntent,
-} from "./user-connect-invite";
-
-interface MockObservable<T> {
-  (): T;
-  (next: T): T;
-  subscribe: (listener: () => void) => { dispose: () => void };
-  loadingPromise: Promise<void>;
-  reset: (next: T) => void;
-}
-
-jest.mock("../../globals", () => ({
-  mainContentPath: jest.fn(),
-}));
-
-jest.mock("../../ui-router/ui-loader", () => ({
-  registerInternalPeersUI: jest.fn(),
-}));
-
-jest.mock("../../hooks", () => {
-  const React = jest.requireActual<typeof import("react")>("react");
-  return {
-    useObservable: <T,>(observable: MockObservable<T>) => {
-      const [value, setValue] = React.useState(observable());
-      React.useEffect(() => {
-        const subscription = observable.subscribe(() => setValue(observable()));
-        return () => subscription.dispose();
-      }, [observable]);
-      return [value, observable] as const;
-    },
-  };
-});
-
-jest.mock("@peers-app/peers-sdk", () => {
-  const actual = jest.requireActual<typeof import("@peers-app/peers-sdk")>("@peers-app/peers-sdk");
-
-  const createObservable = <T,>(initial: T): MockObservable<T> => {
-    let value = initial;
-    const listeners = new Set<() => void>();
-    const observable = jest.fn((next?: T) => {
-      if (next !== undefined) {
-        value = next as T;
-        for (const listener of listeners) listener();
-      }
-      return value;
-    }) as unknown as MockObservable<T>;
-    observable.subscribe = (listener) => {
-      listeners.add(listener);
-      return { dispose: () => listeners.delete(listener) };
-    };
-    observable.loadingPromise = Promise.resolve();
-    observable.reset = (next) => {
-      value = next;
-      for (const listener of listeners) listener();
-    };
-    return observable;
-  };
-
-  const idle: UserConnectStatus = { kind: "idle" };
-  const status = createObservable<UserConnectStatus>(idle);
-  const offer = createObservable("");
-  const answer = createObservable("");
-  const remoteUser = {
-    userId: "remote-user",
-    name: "Ada",
-    publicKey: "remote-public-key",
-    publicBoxKey: "remote-public-box-key",
-  };
-
-  return {
-    ...actual,
-    copyToClipboard: jest.fn(async () => true),
-    Devices: jest.fn(() => ({
-      get: jest.fn(async () => ({ deviceId: "remote-device", userId: remoteUser.userId })),
-    })),
-    generateConnectionCode: jest.fn(() => ({
-      code: "ABCD1234EFGH",
-      alias: "ABCD",
-      secret: "1234EFGH",
-    })),
-    getMe: jest.fn(async () => ({
-      userId: "local-user",
-      name: "Grace",
-      publicKey: "local-public-key",
-      publicBoxKey: "local-public-box-key",
-    })),
-    getUserContext: jest.fn(async () => ({
-      userDataContext: {},
-      deviceId: () => "local-device",
-    })),
-    rpcServerCalls: {
-      ...actual.rpcServerCalls,
-      listConnectedDevices: jest.fn(async () => [
-        {
-          deviceId: "route-device",
-          userId: "route-user",
-          connectionId: "route-connection",
-          trustLevel: 0,
-          verified: true,
-        },
-      ]),
-    },
-    setUserTrustLevel: jest.fn(async () => undefined),
-    Users: jest.fn(() => ({
-      get: jest.fn(async () => remoteUser),
-    })),
-    userConnectCodeAnswer: answer,
-    userConnectCodeOffer: offer,
-    userConnectStatus: status,
-  };
-});
-
-const sdk = jest.requireMock("@peers-app/peers-sdk") as {
-  copyToClipboard: jest.Mock;
-  Devices: jest.Mock;
-  setUserTrustLevel: jest.Mock;
-  userConnectCodeAnswer: MockObservable<string> & jest.Mock;
-  userConnectCodeOffer: MockObservable<string> & jest.Mock;
-  userConnectStatus: MockObservable<UserConnectStatus> & jest.Mock;
-};
-
-const validCode = "ABCD1234EFGH";
-
-function resetMocks(): void {
-  sessionStorage.clear();
-  window.history.replaceState(null, "", "/");
-  sdk.userConnectStatus.reset({ kind: "idle" });
-  sdk.userConnectCodeOffer.reset("");
-  sdk.userConnectCodeAnswer.reset("");
-  jest.clearAllMocks();
-}
-
-describe("UserConnect", () => {
-  beforeEach(() => {
-    resetMocks();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-    Reflect.deleteProperty(navigator, "share");
-  });
-
-  it("starts with a QR invite and readable fallback code", async () => {
-    render(<UserConnect />);
-
-    expect(
-      await screen.findByText("Ask the other person to scan this with their camera"),
-    ).toBeVisible();
-    expect(screen.getByLabelText("Connection QR code")).toBeVisible();
-    expect(screen.getByLabelText("Connection code")).toHaveValue("ABCD-1234-EFGH");
-    expect(sdk.userConnectCodeOffer).toHaveBeenCalledWith(validCode);
-  });
-
-  it("opens a captured inbound invite in review without auto-submitting", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-
-    render(<UserConnect />);
-
-    expect(await screen.findByText("You opened a connection invite")).toBeVisible();
-    expect(screen.getByText("ABCD-1234-EFGH")).toBeVisible();
-    expect(sdk.userConnectCodeAnswer).not.toHaveBeenCalledWith(validCode);
-  });
-
-  it("keeps an unconfirmed invite available across a screen remount", async () => {
-    window.history.replaceState(null, "", "/#contacts/connect");
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    const firstRender = render(<UserConnect />);
-    expect(await screen.findByText("You opened a connection invite")).toBeVisible();
-
-    firstRender.unmount();
-    render(<UserConnect />);
-
-    expect(await screen.findByText("You opened a connection invite")).toBeVisible();
-    expect(screen.getByText("ABCD-1234-EFGH")).toBeVisible();
-  });
-
-  it("clears an unconfirmed invite when navigating away", async () => {
-    window.history.replaceState(null, "", "/#contacts/connect");
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    const rendered = render(<UserConnect />);
-    expect(await screen.findByText("You opened a connection invite")).toBeVisible();
-
-    window.history.replaceState(null, "", "/#contacts");
-    rendered.unmount();
-
-    expect(readUserConnectPendingIntent()).toEqual({ ok: false, reason: "none" });
-  });
-
-  it("captures an invite opened while the screen is already mounted", async () => {
-    render(<UserConnect />);
-    await screen.findByText("Ask the other person to scan this with their camera");
-
-    window.history.replaceState(
-      null,
-      "",
-      `/?app#contacts/connect?code=${encodeURIComponent("ABCD-1234-EFGH")}`,
-    );
-    fireEvent(window, new HashChangeEvent("hashchange"));
-
-    expect(await screen.findByText("You opened a connection invite")).toBeVisible();
-    expect(screen.getByText("ABCD-1234-EFGH")).toBeVisible();
-    expect(window.location.hash).toBe("#contacts/connect");
-    expect(sdk.userConnectCodeOffer).toHaveBeenCalledWith("");
-    expect(sdk.userConnectCodeAnswer).not.toHaveBeenCalledWith(validCode);
-  });
-
-  it("copies the complete invite link", async () => {
-    render(<UserConnect />);
-    fireEvent.click(await screen.findByRole("button", { name: "Copy link" }));
-
-    await waitFor(() => {
-      expect(sdk.copyToClipboard).toHaveBeenCalledWith(buildUserConnectInviteUrl(validCode));
-    });
-    expect((await screen.findAllByText("Link copied")).length).toBeGreaterThan(0);
-  });
-
-  it("shares the complete invite through the Web Share API", async () => {
-    const share = jest.fn(async () => undefined);
-    Object.defineProperty(navigator, "share", {
-      configurable: true,
-      value: share,
-    });
-    render(<UserConnect />);
-
-    fireEvent.click(await screen.findByRole("button", { name: "Share link" }));
-
-    await waitFor(() => {
-      expect(share).toHaveBeenCalledWith(
-        expect.objectContaining({
-          title: "Connect on Peers",
-          url: buildUserConnectInviteUrl(validCode),
-          text: expect.stringContaining("expires in 10 minutes"),
-        }),
-      );
-    });
-  });
-
-  it("stops waiting when the invite expires", async () => {
-    jest.useFakeTimers();
-    jest.setSystemTime(new Date("2026-07-16T12:00:00Z"));
-    render(<UserConnect />);
-
-    await act(async () => {
-      jest.advanceTimersByTime(600_000);
-    });
-
-    expect(screen.getByText("Invite expired")).toBeVisible();
-    expect(sdk.userConnectCodeOffer).toHaveBeenCalledWith("");
-  });
-
-  it("submits an inbound invite only once on a double click", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    const connect = await screen.findByRole("button", { name: "Connect" });
-
-    fireEvent.click(connect);
-    fireEvent.click(connect);
-
-    expect(
-      sdk.userConnectCodeAnswer.mock.calls.filter(([code]) => code === validCode),
-    ).toHaveLength(1);
-    expect(readUserConnectPendingIntent()).toEqual({ ok: false, reason: "none" });
-  });
-
-  it("rechecks invite expiry before confirming review", async () => {
-    jest.useFakeTimers();
-    jest.setSystemTime(new Date("2026-07-16T12:00:00Z"));
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    const connect = await screen.findByRole("button", { name: "Connect" });
-
-    jest.setSystemTime(new Date("2026-07-16T12:10:00Z"));
-    fireEvent.click(connect);
-
-    expect(screen.getByText("Invite expired")).toBeVisible();
-    expect(sdk.userConnectCodeAnswer).not.toHaveBeenCalledWith(validCode);
-  });
-
-  it("does not treat the initial idle status as a canceled connection", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-
-    fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
-
-    expect(screen.getByText("Connecting…")).toBeVisible();
-    expect(screen.queryByText("Connection canceled")).not.toBeInTheDocument();
-  });
-
-  it("leaves connecting when the answer expires back to idle", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
-
-    act(() => {
-      sdk.userConnectCodeAnswer("");
-      sdk.userConnectStatus({ kind: "idle" });
-    });
-
-    expect(await screen.findByText("Invite expired")).toBeVisible();
-  });
-
-  it("reports cancellation when an active protocol resets to idle", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
-
-    act(() => {
-      sdk.userConnectStatus({ kind: "connecting", attempt: 1 });
-    });
-    act(() => {
-      sdk.userConnectStatus({ kind: "idle" });
-    });
-
-    expect(await screen.findByText("Connection canceled")).toBeVisible();
-  });
-
-  it("renders actionable structured errors", async () => {
-    render(<UserConnect />);
-
-    act(() => {
-      sdk.userConnectStatus({ kind: "error", code: "no-route" });
-    });
-
-    expect(await screen.findByText("This device isn’t connected yet")).toBeVisible();
-    expect(
-      screen.getByText(
-        "Connect this device to the internet or another Peers device, then try again.",
-      ),
-    ).toBeVisible();
-  });
-
-  it("trusts only when the primary success action is selected", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
-
-    act(() => {
-      sdk.userConnectStatus({
-        kind: "connected",
-        remoteUserId: "remote-user",
-        remoteDeviceId: "remote-device",
-      });
-    });
-    fireEvent.click(await screen.findByRole("button", { name: "Trust and view contact" }));
-
-    await waitFor(() => {
-      expect(sdk.Devices.mock.results.at(-1)?.value.get).toHaveBeenCalledWith("remote-device");
-      expect(sdk.setUserTrustLevel).toHaveBeenCalledWith(
-        "remote-user",
-        TrustLevel.Trusted,
-        expect.anything(),
-      );
-      expect(mainContentPath).toHaveBeenCalledWith("contacts/remote-user");
-    });
-  });
-
-  it("can view a connected contact without changing trust", async () => {
-    writeUserConnectPendingIntent({ code: validCode, capturedAt: Date.now() });
-    render(<UserConnect />);
-    fireEvent.click(await screen.findByRole("button", { name: "Connect" }));
-
-    act(() => {
-      sdk.userConnectStatus({
-        kind: "connected",
-        remoteUserId: "remote-user",
-        remoteDeviceId: "remote-device",
-      });
-    });
-    fireEvent.click(await screen.findByRole("button", { name: "View without trusting" }));
-
-    expect(sdk.setUserTrustLevel).not.toHaveBeenCalled();
-    expect(mainContentPath).toHaveBeenCalledWith("contacts/remote-user");
-  });
-});