Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

25.4 KB
Raw Blame
import { draftPersistence } from "./draft-persistence";
import {
  describe,
  test,
  expect,
  vi,
  beforeEach,
  afterEach,
  type MockInstance,
} from "vitest";
import type { Backoff } from "@webstudio-is/sync-client";

//  Module mocks

const {
  mockBuildPatch,
  mockCreateNativeClient,
  mockCreateBackoff,
  mockLoadBuilderData,
} = vi.hoisted(() => ({
  mockBuildPatch: vi.fn(),
  mockCreateNativeClient: vi.fn(),
  mockCreateBackoff: vi.fn(),
  mockLoadBuilderData: vi.fn(),
}));

vi.mock("~/shared/trpc/trpc-client", () => ({
  createNativeClient: mockCreateNativeClient,
  nativeClient: { build: { patch: { mutate: mockBuildPatch } } },
}));

vi.mock("~/env/env.static", () => ({
  publicStaticEnv: { VERSION: "test-version" },
}));

vi.mock("@webstudio-is/sync-client", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@webstudio-is/sync-client")>()),
  createBackoff: mockCreateBackoff,
}));

vi.mock("~/shared/builder-data", () => ({
  loadBuilderData: mockLoadBuilderData,
}));

//  Imports (after mocks)

import type { BuilderPatchChange } from "@webstudio-is/project-build/contracts";
import {
  $hasUnsavedSyncChanges,
  $syncStatus,
  type Transaction,
} from "@webstudio-is/sync-client";
import { toast } from "@webstudio-is/design-system";
import type { ServerSyncState } from "./sync-stores";
import {
  $lastTransactionId,
  commandQueue,
  isSyncIdle,
  onTransactionComplete,
  onNextTransactionComplete,
  enqueueProjectDetails,
  stopPolling,
  ServerSyncStorage,
  __testing__,
} from "./project-queue";

const { retry, pollCommands, transactionCallbacks } = __testing__;
let mockToastError: MockInstance<typeof toast.error>;

//  Constants (duplicated to avoid exporting them just for tests)

const NEW_ENTRIES_INTERVAL = 1000;
const INTERVAL_RECOVERY = 2000;
const MAX_RETRY_RECOVERY = 5;
const MAX_ALLOWED_API_ERRORS = 5;

//  Helpers

const flush = () => vi.advanceTimersByTimeAsync(0);

const makeTx = (id: string): Transaction<BuilderPatchChange[]> => ({
  id,
  object: "server" as const,
  payload: [{ namespace: "pages", patches: [] }],
});

const initialState: ServerSyncState = new Map();

const createMockBackoff = (overrides: Partial<Backoff> = {}): Backoff => {
  let failures = 0;
  return {
    next:
      overrides.next ??
      vi.fn(() => {
        failures += 1;
        return 10_000;
      }),
    reset:
      overrides.reset ??
      vi.fn(() => {
        failures = 0;
      }),
    attempts: overrides.attempts ?? vi.fn(() => failures),
  };
};

//  Tests

describe("project-queue", () => {
  beforeEach(() => {
    vi.useFakeTimers();
    $syncStatus.set({ status: "idle" });
    $lastTransactionId.set(undefined);
    commandQueue.dequeueAll();
    transactionCallbacks.clear();
    stopPolling();

    // Default mocks
    mockCreateBackoff.mockReturnValue(createMockBackoff());
    mockCreateNativeClient.mockReturnValue({
      build: { patch: { mutate: mockBuildPatch } },
    });
    mockBuildPatch.mockResolvedValue({ status: "ok" });
    mockToastError = vi.spyOn(toast, "error").mockImplementation(() => "");
    mockLoadBuilderData.mockResolvedValue({});
  });

  afterEach(() => {
    stopPolling();
    vi.useRealTimers();
    vi.restoreAllMocks();
  });

  //  unload protection

  describe("$hasUnsavedSyncChanges", () => {
    test("is false when sync is idle", () => {
      $syncStatus.set({ status: "idle" });

      expect($hasUnsavedSyncChanges.get()).toBe(false);
    });

    test("is true while changes are not saved yet", () => {
      $syncStatus.set({ status: "syncing" });

      expect($hasUnsavedSyncChanges.get()).toBe(true);
    });
  });

  //  isSyncIdle

  describe("isSyncIdle", () => {
    test("resolves immediately when status is idle", async () => {
      $syncStatus.set({ status: "idle" });
      const result = await isSyncIdle();
      expect(result).toEqual({ status: "idle" });
    });

    test("rejects immediately when status is fatal", async () => {
      $syncStatus.set({ status: "fatal", error: "broken" });
      await expect(isSyncIdle()).rejects.toThrow(
        "Synchronization is in fatal state"
      );
    });

    test("waits and resolves when status transitions to idle", async () => {
      $syncStatus.set({ status: "syncing" });

      let resolved = false;
      isSyncIdle().then(() => {
        resolved = true;
      });
      await flush();
      expect(resolved).toBe(false);

      $syncStatus.set({ status: "idle" });
      await flush();
      expect(resolved).toBe(true);
    });

    test("waits and rejects when status transitions to fatal", async () => {
      $syncStatus.set({ status: "syncing" });

      let error: Error | undefined;
      isSyncIdle().catch((err: Error) => {
        error = err;
      });
      await flush();
      expect(error).toBeUndefined();

      $syncStatus.set({ status: "fatal", error: "crashed" });
      await flush();
      expect(error?.message).toMatch("Synchronization is in fatal state");
    });

    test("ignores intermediate non-idle/non-fatal statuses", async () => {
      $syncStatus.set({ status: "syncing" });

      let resolved = false;
      isSyncIdle().then(() => {
        resolved = true;
      });
      await flush();

      $syncStatus.set({ status: "recovering" });
      await flush();
      expect(resolved).toBe(false);

      $syncStatus.set({ status: "failed" });
      await flush();
      expect(resolved).toBe(false);

      $syncStatus.set({ status: "idle" });
      await flush();
      expect(resolved).toBe(true);
    });
  });

  //  onTransactionComplete

  describe("onTransactionComplete", () => {
    test("cleans up callbacks after 60s timeout", async () => {
      const cb = vi.fn();
      onTransactionComplete("tx-1", cb);

      expect(transactionCallbacks.has("tx-1")).toBe(true);

      await vi.advanceTimersByTimeAsync(60_000);

      expect(transactionCallbacks.has("tx-1")).toBe(false);
    });
  });

  //  onNextTransactionComplete

  describe("onNextTransactionComplete", () => {
    test("fires when $lastTransactionId changes and transaction succeeds", async () => {
      const cb = vi.fn();
      onNextTransactionComplete(cb);

      $lastTransactionId.set("tx-next");

      const callbacks = transactionCallbacks.get("tx-next");
      expect(callbacks).toBeDefined();
      callbacks?.[0](true);

      expect(cb).toHaveBeenCalledOnce();
    });

    test("does not fire when transaction fails", async () => {
      const cb = vi.fn();
      onNextTransactionComplete(cb);

      $lastTransactionId.set("tx-fail");

      const callbacks = transactionCallbacks.get("tx-fail");
      callbacks?.[0](false);

      expect(cb).not.toHaveBeenCalled();
    });
  });

  //  retry generator

  describe("retry generator (backoff integration)", () => {
    test("uses 'recovering' status for the first MAX_RETRY_RECOVERY attempts", async () => {
      let failureCount = 0;
      mockCreateBackoff.mockReturnValue(
        createMockBackoff({
          next: vi.fn(() => {
            failureCount += 1;
            return 10_000;
          }),
          attempts: vi.fn(() => failureCount),
        })
      );

      const gen = retry();
      await gen.next();

      for (let i = 0; i < MAX_RETRY_RECOVERY; i++) {
        const p = gen.next();
        await vi.advanceTimersByTimeAsync(INTERVAL_RECOVERY);
        await p;

        expect($syncStatus.get()).toEqual({ status: "recovering" });
      }
    });

    test("transitions to 'failed' status after MAX_RETRY_RECOVERY attempts", async () => {
      let failureCount = 0;
      const mockNext = vi.fn(() => {
        failureCount += 1;
        return 15_000;
      });
      mockCreateBackoff.mockReturnValue(
        createMockBackoff({
          next: mockNext,
          attempts: vi.fn(() => failureCount),
        })
      );

      const gen = retry();
      await gen.next();

      for (let i = 0; i < MAX_RETRY_RECOVERY; i++) {
        const p = gen.next();
        await vi.advanceTimersByTimeAsync(INTERVAL_RECOVERY);
        await p;
      }

      const failedPromise = gen.next();
      await vi.advanceTimersByTimeAsync(15_000);
      await failedPromise;

      expect($syncStatus.get()).toEqual({ status: "failed" });
    });

    test("uses backoff.next() delay and shows toast in failed state", async () => {
      let failureCount = 0;
      const mockNext = vi.fn(() => {
        failureCount += 1;
        return 25_000;
      });
      mockCreateBackoff.mockReturnValue(
        createMockBackoff({
          next: mockNext,
          attempts: vi.fn(() => failureCount),
        })
      );

      const gen = retry();
      await gen.next();

      for (let i = 0; i < MAX_RETRY_RECOVERY; i++) {
        const p = gen.next();
        await vi.advanceTimersByTimeAsync(INTERVAL_RECOVERY);
        await p;
      }

      const failedPromise = gen.next();
      await vi.advanceTimersByTimeAsync(25_000);
      await failedPromise;

      expect(mockToastError).toHaveBeenCalledWith(
        expect.stringContaining("Retry in 25 seconds")
      );
    });

    test("calls backoff.next() in recovery to track attempts", async () => {
      let failureCount = 0;
      const mockNext = vi.fn(() => {
        failureCount += 1;
        return 5_000;
      });
      mockCreateBackoff.mockReturnValue(
        createMockBackoff({
          next: mockNext,
          attempts: vi.fn(() => failureCount),
        })
      );

      const gen = retry();
      await gen.next();

      const p = gen.next();
      await vi.advanceTimersByTimeAsync(INTERVAL_RECOVERY);
      await p;

      expect(mockNext).toHaveBeenCalledTimes(1);
    });
  });

  //  pollCommands generator

  describe("pollCommands generator", () => {
    test("yields commands from the queue", async () => {
      commandQueue.enqueue({
        type: "setDetails",
        projectId: "p1",
        version: 1,
        buildId: "b1",
        authToken: undefined,
      });

      const gen = pollCommands();
      const result = await gen.next();

      expect(result.value).toEqual(
        expect.objectContaining({ type: "setDetails", projectId: "p1" })
      );
    });

    test("sets status to syncing when commands are available", async () => {
      commandQueue.enqueue({
        type: "setDetails",
        projectId: "p1",
        version: 1,
        buildId: "b1",
        authToken: undefined,
      });

      const gen = pollCommands();
      await gen.next();

      expect($syncStatus.get()).toEqual({ status: "syncing" });
    });

    test("sets status to idle and waits when queue is empty", async () => {
      const gen = pollCommands();

      const p = gen.next();
      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL);

      commandQueue.enqueue({
        type: "setDetails",
        projectId: "p1",
        version: 1,
        buildId: "b1",
        authToken: undefined,
      });
      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL);
      const result = await p;

      expect(result.value).toEqual(
        expect.objectContaining({ type: "setDetails" })
      );
    });
  });

  test.each([true, false])(
    "Preview waits for singleplayer PATCH persistence: %s",
    async (success) => {
      vi.spyOn(globalThis, "confirm").mockReturnValue(false);
      draftPersistence.reset("project");
      let save: ((value: { status: string }) => void) | undefined;
      mockBuildPatch.mockImplementation(
        () =>
          new Promise((resolve) => {
            save = resolve;
          })
      );
      enqueueProjectDetails({
        projectId: "project",
        buildId: "build",
        version: 1,
        authPermit: "build",
        authToken: undefined,
      });
      const storage = new ServerSyncStorage("project", initialState);
      storage.sendTransaction(makeTx("pending"));
      const done = vi.fn();
      const saved = draftPersistence.wait("project", {
        signal: new AbortController().signal,
      });
      const waiting = success
        ? saved.then(done)
        : expect(saved).rejects.toMatchObject({
            name: "DraftPersistenceError",
            reason: "save-failed",
          });
      await vi.advanceTimersByTimeAsync(2000);
      expect(mockBuildPatch).toHaveBeenCalled();
      expect(done).not.toHaveBeenCalled();
      save?.({ status: success ? "ok" : "authorization_error" });
      await flush();
      await waiting;
      if (success) {
        expect(done).toHaveBeenCalledOnce();
      } else {
        await expect(
          draftPersistence.wait("project", {
            signal: new AbortController().signal,
          })
        ).rejects.toMatchObject({
          name: "DraftPersistenceError",
          reason: "save-failed",
        });
      }
      draftPersistence.reset();
    }
  );

  //  enqueueProjectDetails

  describe("enqueueProjectDetails", () => {
    test("skips enqueue for 'view' permit", () => {
      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "view",
        authToken: undefined,
      });

      const commands = commandQueue.dequeueAll();
      expect(commands).toHaveLength(0);
    });

    test.each([
      { authPermit: "edit", authToken: "tok" },
      { authPermit: "own", authToken: undefined },
    ] as const)(
      "enqueues project details for '$authPermit' permit",
      async ({ authPermit, authToken }) => {
        enqueueProjectDetails({
          projectId: "p1",
          buildId: "b1",
          version: 1,
          authPermit,
          authToken,
        });
        commandQueue.enqueue({
          type: "transactions",
          projectId: "p1",
          transactions: [makeTx(`tx-${authPermit}`)],
        });

        await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
        await flush();

        expect(mockBuildPatch).toHaveBeenCalledWith(
          expect.objectContaining({
            projectId: "p1",
            buildId: "b1",
            version: 1,
            authToken,
          })
        );
      }
    );
  });

  //  ServerSyncStorage

  describe("ServerSyncStorage", () => {
    test("subscribe seeds initial data without loading builder data again", () => {
      const serverState: ServerSyncState = new Map([["pages", undefined]]);
      const storage = new ServerSyncStorage("p1", serverState);
      const setState = vi.fn();
      mockLoadBuilderData.mockClear();

      storage.subscribe(setState, new AbortController().signal);

      expect(mockLoadBuilderData).not.toHaveBeenCalled();
      expect(setState).toHaveBeenCalledWith(new Map([["server", serverState]]));
    });

    test("subscribe does nothing when aborted", () => {
      const storage = new ServerSyncStorage("p1", initialState);
      const controller = new AbortController();
      const setState = vi.fn();
      controller.abort();

      storage.subscribe(setState, controller.signal);

      expect(setState).not.toHaveBeenCalled();
    });

    test("sendTransaction enqueues only for 'server' object", () => {
      const storage = new ServerSyncStorage("p1", initialState);

      storage.sendTransaction({
        id: "tx-1",
        object: "server",
        payload: [{ namespace: "pages", patches: [] }],
      });

      const commands = commandQueue.dequeueAll();
      expect(commands).toHaveLength(1);
      if (commands[0].type === "transactions") {
        expect(commands[0].transactions[0].id).toBe("tx-1");
      }
    });

    test("sendTransaction ignores non-server objects", () => {
      const storage = new ServerSyncStorage("p1", initialState);

      storage.sendTransaction({
        id: "tx-1",
        object: "client",
        payload: [],
      });

      const commands = commandQueue.dequeueAll();
      expect(commands).toHaveLength(0);
    });

    test("sendTransaction sets $lastTransactionId", () => {
      const storage = new ServerSyncStorage("p1", initialState);

      storage.sendTransaction({
        id: "tx-42",
        object: "server",
        payload: [{ namespace: "pages", patches: [] }],
      });

      expect($lastTransactionId.get()).toBe("tx-42");
    });
  });

  //  pollQueue integration

  describe("pollQueue integration", () => {
    test("successful transaction increments version and fires callbacks", async () => {
      mockBuildPatch.mockResolvedValue({ status: "ok" });

      const txCallback = vi.fn();
      onTransactionComplete("tx-success", txCallback);

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });

      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-success")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
      await flush();

      expect(txCallback).toHaveBeenCalledWith(true);
    });

    test("sends auth token in RPC input and header", async () => {
      mockBuildPatch.mockResolvedValue({ status: "ok" });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-auth")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
      await flush();

      expect(mockBuildPatch).toHaveBeenCalledWith(
        expect.objectContaining({
          authToken: "tok",
          source: "browser",
        })
      );
      expect(mockCreateNativeClient).toHaveBeenCalledWith({
        "x-auth-token": "tok",
      });
    });

    test("version_mismatched response sets fatal status", async () => {
      vi.stubGlobal(
        "confirm",
        vi.fn(() => false)
      );

      mockBuildPatch.mockResolvedValue({
        status: "version_mismatched",
        errors: "Version mismatch",
      });
      const completion = vi.fn();
      onTransactionComplete("tx-1", completion);

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-1")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
      await flush();

      expect($syncStatus.get().status).toBe("fatal");
      expect(completion).toHaveBeenCalledWith(false);

      vi.unstubAllGlobals();
    });

    test("authorization_error response sets fatal status", async () => {
      vi.stubGlobal(
        "confirm",
        vi.fn(() => false)
      );

      mockBuildPatch.mockResolvedValue({
        status: "authorization_error",
        errors: "Not authorized",
      });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-1")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
      await flush();

      expect($syncStatus.get().status).toBe("fatal");

      vi.unstubAllGlobals();
    });

    test("partial response sets fatal status", async () => {
      vi.stubGlobal(
        "confirm",
        vi.fn(() => false)
      );

      const acceptedCompletion = vi.fn();
      const failedCompletion = vi.fn();
      onTransactionComplete("tx-accepted", acceptedCompletion);
      onTransactionComplete("tx-failed", failedCompletion);
      mockBuildPatch.mockResolvedValue({
        status: "partial",
        version: 1,
        entries: [
          {
            seq: 0,
            transactionId: "tx-accepted",
            status: "accepted",
          },
          {
            seq: 1,
            transactionId: "tx-failed",
            status: "failed",
            errors: "Patch failed",
          },
        ],
      });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-accepted"), makeTx("tx-failed")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 3);
      await flush();

      expect($syncStatus.get()).toEqual({
        status: "fatal",
        error: "Patch failed",
      });
      expect(acceptedCompletion).toHaveBeenCalledWith(true);
      expect(failedCompletion).toHaveBeenCalledWith(false);

      vi.unstubAllGlobals();
    });

    test("fatal after MAX_ALLOWED_API_ERRORS unknown API errors", async () => {
      mockBuildPatch.mockResolvedValue({
        status: "unknown_error",
        errors: "Something bad",
      });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-1")],
      });

      for (
        let i = 0;
        i < MAX_ALLOWED_API_ERRORS + MAX_RETRY_RECOVERY + 2;
        i++
      ) {
        await vi.advanceTimersByTimeAsync(
          NEW_ENTRIES_INTERVAL + INTERVAL_RECOVERY + 30_000
        );
        await flush();
      }

      expect($syncStatus.get().status).toBe("fatal");
    });

    test("rpc errors retry without crashing", async () => {
      let callCount = 0;
      mockBuildPatch.mockImplementation(async () => {
        callCount += 1;
        if (callCount <= 2) {
          throw new Error("Server Error");
        }
        return { status: "ok" };
      });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-retry")],
      });

      for (let i = 0; i < 10; i++) {
        await vi.advanceTimersByTimeAsync(
          NEW_ENTRIES_INTERVAL + INTERVAL_RECOVERY + 15_000
        );
        await flush();
      }

      expect(callCount).toBeGreaterThanOrEqual(3);
    });

    test("network error retries without crashing", async () => {
      let callCount = 0;
      mockBuildPatch.mockImplementation(async () => {
        callCount += 1;
        if (callCount <= 1) {
          throw new Error("ERR_CONNECTION_REFUSED");
        }
        return { status: "ok" };
      });

      Object.defineProperty(navigator, "onLine", {
        value: true,
        writable: true,
        configurable: true,
      });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-net")],
      });

      for (let i = 0; i < 10; i++) {
        await vi.advanceTimersByTimeAsync(
          NEW_ENTRIES_INTERVAL + INTERVAL_RECOVERY + 15_000
        );
        await flush();
      }

      expect(callCount).toBeGreaterThanOrEqual(2);
    });

    test("missing project details causes fatal status", async () => {
      commandQueue.enqueue({
        type: "transactions",
        projectId: "p-unknown",
        transactions: [makeTx("tx-orphan")],
      });

      enqueueProjectDetails({
        projectId: "p-other",
        buildId: "b-other",
        version: 1,
        authPermit: "edit",
        authToken: undefined,
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 5);
      await flush();

      expect($syncStatus.get().status).toBe("fatal");
      expect(mockToastError).toHaveBeenCalledWith(
        expect.stringContaining("Project details not found"),
        expect.anything()
      );
    });

    test("outdated version on setDetails sets fatal status", async () => {
      vi.stubGlobal(
        "confirm",
        vi.fn(() => false)
      );

      mockBuildPatch.mockResolvedValue({ status: "ok" });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 5,
        authPermit: "edit",
        authToken: "tok",
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL);
      await flush();

      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-v")],
      });
      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 2);
      await flush();

      commandQueue.enqueue({
        type: "setDetails",
        projectId: "p1",
        version: 3,
        buildId: "b1",
        authToken: "tok",
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 2);
      await flush();

      expect($syncStatus.get().status).toBe("fatal");

      vi.unstubAllGlobals();
    });
  });

  //  stopPolling

  describe("stopPolling", () => {
    test("can be called safely when not polling", () => {
      expect(() => stopPolling()).not.toThrow();
    });

    test("stops the polling loop", async () => {
      mockBuildPatch.mockResolvedValue({ status: "ok" });

      enqueueProjectDetails({
        projectId: "p1",
        buildId: "b1",
        version: 1,
        authPermit: "edit",
        authToken: "tok",
      });

      stopPolling();
      mockBuildPatch.mockClear();

      commandQueue.enqueue({
        type: "transactions",
        projectId: "p1",
        transactions: [makeTx("tx-after-stop")],
      });

      await vi.advanceTimersByTimeAsync(NEW_ENTRIES_INTERVAL * 5);
      await flush();

      // No fetch calls should have happened after stopping
      expect(mockBuildPatch).not.toHaveBeenCalled();
    });
  });
});