@multiplatform.one/frappe 7.8.0 → 7.10.0

package/src/sync/refreshSubscriptions.lifecycle.spec.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it, vi } from "vitest";
+import { NormalizedCache } from "./normalizedCache";
+import { SubscriptionManager } from "./subscriptionManager";
+import type { SyncOptions } from "./types";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+const row = (name: string, title = name) => ({
+  name,
+  title,
+  doctype: "Item",
+  modified: "2026-09-09T01:00:00Z",
+});
+const query = { doctype: "Item" };
+async function setup(options: SyncOptions = {}) {
+  const db = { getDocList: vi.fn().mockResolvedValue([row("a")]) };
+  const cache = new NormalizedCache();
+  const manager = new SubscriptionManager(db as never, cache, options);
+  const { subscriptionId: id } = await manager.subscribe(query);
+  return { db, cache, manager, id };
+}
+function pending(db: Awaited<ReturnType<typeof setup>>["db"]) {
+  const response = deferred<ReturnType<typeof row>[]>();
+  const started = deferred<void>();
+  db.getDocList.mockImplementationOnce(() => {
+    started.resolve();
+    return response.promise;
+  });
+  return { ...response, started: started.promise };
+}
+
+describe("snapshot refresh lifecycle", () => {
+  it.each(["resolve", "reject"] as const)(
+    "invalidates pre-detach refresh that later %ss after re-adoption",
+    async (outcome) => {
+      const { manager, db, cache, id } = await setup({ persistKey: "lifecycle" });
+      const old = pending(db);
+      const oldResult = manager.refreshSubscriptions();
+      await old.started;
+      manager.unsubscribe(id);
+      const fresh = pending(db);
+      const adopted = await manager.subscribe(query);
+      expect(adopted.subscriptionId).toBe(id);
+      expect(adopted.rows).toEqual([row("a")]);
+      await fresh.started;
+      fresh.resolve([row("a", "new-adoption")]);
+      expect(await adopted.refresh).toMatchObject({ ok: true });
+      if (outcome === "resolve") old.resolve([row("a", "obsolete-before-detach"), row("obsolete")]);
+      else old.reject(new Error("old failure"));
+      expect((await oldResult)[0].ok).toBe(false);
+      expect(manager.getDocsForSubscription(id)).toEqual([row("a", "new-adoption")]);
+      expect(cache.get({ doctype: "Item", name: "obsolete" })).toBeUndefined();
+      expect(manager.getSubscription(id)?.stale).toBe(false);
+    },
+  );
+
+  it("does not let an old finally erase the new adoption operation", async () => {
+    const { manager, db, cache, id } = await setup({ persistKey: "lifecycle" });
+    const old = pending(db);
+    const oldResult = manager.refreshSubscriptions();
+    await old.started;
+    manager.unsubscribe(id);
+    const adoption = pending(db);
+    const adopted = await manager.subscribe(query);
+    await adoption.started;
+    old.resolve([row("obsolete")]);
+    expect((await oldResult)[0].ok).toBe(false);
+    const trailing = pending(db);
+    const explicit = manager.refreshSubscriptions();
+    expect(db.getDocList).toHaveBeenCalledTimes(3);
+    adoption.resolve([row("discarded-adoption")]);
+    await trailing.started;
+    expect(cache.get({ doctype: "Item", name: "discarded-adoption" })).toBeUndefined();
+    expect(manager.getDocsForSubscription(id)).toEqual([row("a")]);
+    trailing.resolve([row("final")]);
+    expect(await adopted.refresh).toEqual((await explicit)[0]);
+    expect(manager.getDocsForSubscription(id)).toEqual([row("final")]);
+    expect(db.getDocList).toHaveBeenCalledTimes(4);
+  });
+
+  it.each([false, true])(
+    "coalesces requests and retains the committed snapshot when trailing fails=%s",
+    async (fails) => {
+      const { manager, db, cache, id } = await setup();
+      const before = structuredClone(manager.getSubscription(id));
+      const first = pending(db);
+      const one = manager.refreshSubscriptions();
+      await first.started;
+      const last = pending(db);
+      const two = manager.refreshSubscriptions();
+      const three = manager.refreshSubscriptions();
+      first.resolve([row("a", "discarded"), row("obsolete")]);
+      await last.started;
+      expect(cache.get({ doctype: "Item", name: "obsolete" })).toBeUndefined();
+      expect(manager.getDocsForSubscription(id)).toEqual([row("a")]);
+      const error = new Error("trailing failed");
+      if (fails) last.reject(error);
+      else last.resolve([row("final")]);
+      const results = await Promise.all([one, two, three]);
+      expect(results).toEqual(
+        Array(3).fill([{ subscriptionId: id, ok: !fails, ...(fails ? { error } : {}) }]),
+      );
+      if (fails) for (const result of results) expect(result[0].error).toBe(error);
+      expect(db.getDocList).toHaveBeenCalledTimes(3);
+      if (fails) expect(manager.getSubscription(id)).toEqual({ ...before, stale: true });
+      else expect(manager.getDocsForSubscription(id)).toEqual([row("final")]);
+      await manager.refreshSubscriptions();
+      expect(db.getDocList).toHaveBeenCalledTimes(4);
+    },
+  );
+
+  it("trails a failed attempt only when another caller requested it", async () => {
+    const { manager, db, id } = await setup();
+    const first = pending(db);
+    const one = manager.refreshSubscriptions();
+    await first.started;
+    const last = pending(db);
+    const two = manager.refreshSubscriptions();
+    first.reject(new Error("superseded failure"));
+    await last.started;
+    last.resolve([row("final")]);
+    expect(await one).toEqual(await two);
+    expect(manager.getDocsForSubscription(id)).toEqual([row("final")]);
+    expect(db.getDocList).toHaveBeenCalledTimes(3);
+  });
+
+  it("joins an adoption already fetching and discards its superseded rows", async () => {
+    const { manager, db, cache, id } = await setup({ persistKey: "lifecycle" });
+    manager.unsubscribe(id);
+    const adoption = pending(db);
+    const adopted = await manager.subscribe(query);
+    await adoption.started;
+    const last = pending(db);
+    const explicit = manager.refreshSubscriptions();
+    adoption.resolve([row("obsolete")]);
+    await last.started;
+    expect(cache.get({ doctype: "Item", name: "obsolete" })).toBeUndefined();
+    last.resolve([row("final")]);
+    expect(await adopted.refresh).toEqual((await explicit)[0]);
+    expect(manager.getDocsForSubscription(id)).toEqual([row("final")]);
+  });
+
+  it("invalidates the last release without corrupting cached documents", async () => {
+    const { manager, db, cache, id } = await setup();
+    const read = pending(db);
+    const result = manager.refreshSubscriptions();
+    await read.started;
+    manager.unsubscribe(id);
+    read.resolve([row("a", "obsolete"), row("new")]);
+    expect((await result)[0].ok).toBe(false);
+    expect(manager.getSubscription(id)).toBeUndefined();
+    expect(cache.get({ doctype: "Item", name: "a" })).toEqual(row("a"));
+    expect(cache.get({ doctype: "Item", name: "new" })).toBeUndefined();
+  });
+
+  it("keeps shared refreshes active until the last consumer releases", async () => {
+    const { manager, db, id } = await setup();
+    expect((await manager.subscribe(query)).subscriptionId).toBe(id);
+    const first = pending(db);
+    const one = manager.refreshSubscriptions();
+    await first.started;
+    manager.unsubscribe(id);
+    first.resolve([row("updated")]);
+    expect(await one).toEqual([{ subscriptionId: id, ok: true }]);
+    const last = pending(db);
+    const two = manager.refreshSubscriptions();
+    await last.started;
+    manager.unsubscribe(id);
+    last.resolve([row("obsolete")]);
+    expect((await two)[0].ok).toBe(false);
+    expect(manager.getSubscription(id)).toBeUndefined();
+  });
+
+  it("invalidates clear and allows a subsequent activation", async () => {
+    const { manager, db, cache, id } = await setup();
+    const old = pending(db);
+    const result = manager.refreshSubscriptions();
+    await old.started;
+    manager.clear();
+    cache.clear();
+    const fresh = await manager.subscribe(query);
+    old.resolve([row("a", "obsolete"), row("obsolete")]);
+    expect((await result)[0].ok).toBe(false);
+    expect(manager.getSubscription(id)).toBeUndefined();
+    expect(manager.getDocsForSubscription(fresh.subscriptionId)).toEqual([row("a")]);
+    expect(cache.get({ doctype: "Item", name: "obsolete" })).toBeUndefined();
+  });
+
+  it("does not seed in the microtask between HTTP completion and acceptance", async () => {
+    const { manager, db, cache, id } = await setup();
+    const first = pending(db);
+    const one = manager.refreshSubscriptions();
+    await first.started;
+    const last = pending(db);
+    first.resolve([row("obsolete")]);
+    const two = Promise.resolve().then(() => manager.refreshSubscriptions());
+    await last.started;
+    expect(cache.get({ doctype: "Item", name: "obsolete" })).toBeUndefined();
+    expect(manager.getDocsForSubscription(id)).toEqual([row("a")]);
+    last.resolve([row("final")]);
+    expect(await one).toEqual(await two);
+  });
+
+  it("allows different subscriptions to finish independently", async () => {
+    const { manager, db, id } = await setup();
+    const second = await manager.subscribe({ doctype: "Other" });
+    const slow = pending(db);
+    const fast = pending(db);
+    const result = manager.refreshSubscriptions();
+    await Promise.all([slow.started, fast.started]);
+    fast.resolve([row("fast")]);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(manager.getSubscription(second.subscriptionId)?.docIds).toEqual(["fast"]);
+    expect(manager.getSubscription(id)?.docIds).toEqual(["a"]);
+    slow.resolve([row("slow")]);
+    expect((await result).every((entry) => entry.ok)).toBe(true);
+  });
+});
+
+it("excludes dormant restored subscriptions and selects each shared id once", async () => {
+  const { manager, db, id } = await setup();
+  await manager.subscribe(query);
+  manager.restoreSubscription({ id: "dormant", query: { doctype: "Dormant" }, docIds: ["cached"] });
+  expect(await manager.refreshSubscriptions({ doctypes: ["Dormant"] })).toEqual([]);
+  expect(await manager.refreshSubscriptions({ doctypes: [] })).toEqual([]);
+  expect(db.getDocList).toHaveBeenCalledTimes(1);
+  expect(await manager.refreshSubscriptions()).toEqual([{ subscriptionId: id, ok: true }]);
+  expect(db.getDocList).toHaveBeenCalledTimes(2);
+  manager.unsubscribe(id);
+  manager.unsubscribe(id);
+  expect(manager.getSubscription(id)).toBeUndefined();
+});
+
+it("retains cached projections and documents outside the refreshed membership", async () => {
+  const { manager, db, cache, id } = await setup();
+  cache.upsert({ ...row("a"), detail: "other view" });
+  db.getDocList.mockResolvedValueOnce([row("b")]);
+  const other = await manager.subscribe({ doctype: "Item", filters: { enabled: 1 } });
+  db.getDocList
+    .mockResolvedValueOnce([{ name: "a", title: "projected" }])
+    .mockResolvedValueOnce([]);
+  await manager.refreshSubscriptions();
+  expect(manager.getDocsForSubscription(id)).toEqual([
+    { ...row("a", "projected"), detail: "other view" },
+  ]);
+  expect(manager.getDocsForSubscription(other.subscriptionId)).toEqual([]);
+  expect(cache.get({ doctype: "Item", name: "b" })).toEqual(row("b"));
+});
+
+it("shares the first read when callers arrive before it starts", async () => {
+  const { manager, db, id } = await setup();
+  const first = pending(db);
+  const one = manager.refreshSubscriptions();
+  const two = manager.refreshSubscriptions();
+  await first.started;
+  first.resolve([row("final")]);
+  expect(await one).toEqual(await two);
+  expect(manager.getDocsForSubscription(id)).toEqual([row("final")]);
+  expect(db.getDocList).toHaveBeenCalledTimes(2);
+});

package/src/sync/refreshSubscriptions.spec.ts

@@ -0,0 +1,295 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { createFrappeCollection } from "../collection";
+import { SyncModule as PublicSyncModule } from "../index";
+import { SyncModule } from "./index";
+import { Order, defaultPageLength } from "./types";
+import type { SubscriptionQuery } from "./types";
+
+vi.mock("@multiplatform.one/platform", () => ({
+  isNative: false,
+  isServer: true,
+  isWindowDefined: false,
+  onAppFocus: () => () => {},
+  onOnline: () => () => {},
+  onVisibilityChange: () => () => {},
+}));
+const instances: SyncModule[] = [];
+const cleanups: (() => unknown)[] = [];
+afterEach(async () => {
+  try {
+    for (const cleanup of cleanups.splice(0)) await cleanup();
+  } finally {
+    for (const sync of instances.splice(0)) await sync.dispose();
+  }
+});
+const row = (name: string, title = name) => ({
+  name,
+  title,
+  doctype: "Item",
+  modified: "2026-09-09T01:00:00Z",
+});
+function setup() {
+  const db = { getDocList: vi.fn().mockResolvedValue([row("a"), row("b")]) };
+  const sync = new SyncModule(db as never, undefined);
+  instances.push(sync);
+  return { db, sync };
+}
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+it("replaces mounted collection membership and clears authoritative empty snapshots", async () => {
+  const { db, sync } = setup();
+  const subscribe = vi.spyOn(sync, "subscribe");
+  const collection = createFrappeCollection<ReturnType<typeof row>>("Item", { sync });
+  cleanups.push(() => collection.cleanup());
+  await collection.preload();
+  const originalCollection = collection;
+  const id = (await subscribe.mock.results[0].value).subscriptionId;
+  const observed: string[][] = [];
+  cleanups.push(
+    sync.subscribeStore(() => {
+      observed.push(sync.getDocsForSubscription(id!).map((doc) => doc.name));
+    }),
+  );
+  db.getDocList.mockResolvedValue({
+    data: [row("b", "updated"), row("c")],
+    cursor: "replacement-cursor",
+  });
+  const [result] = await sync.refreshSubscriptions();
+  expect(result.ok).toBe(true);
+  expect(result.subscriptionId).toBe(id);
+  expect(collection).toBe(originalCollection);
+  expect(
+    [...collection.state.values()]
+      .map(({ name, title }) => ({ name, title }))
+      .sort((a, b) => a.name.localeCompare(b.name)),
+  ).toEqual([
+    { name: "b", title: "updated" },
+    { name: "c", title: "c" },
+  ]);
+  expect(observed).toEqual([["b", "c"]]);
+  expect(sync.getSubscription(id)?.cursor).toBe("replacement-cursor");
+  expect(sync.getDocFromCache("Item", "a")).toEqual(row("a"));
+  db.getDocList.mockResolvedValue([]);
+  expect(await sync.refreshSubscriptions()).toEqual([result]);
+  expect([...collection.state.values()]).toEqual([]);
+  expect(sync.getSubscription(result.subscriptionId)?.boundaries).toBeUndefined();
+  expect(collection).toBe(originalCollection);
+  expect(observed).toEqual([["b", "c"], []]);
+  expect(subscribe).toHaveBeenCalledTimes(1);
+  expect(sync.getSubscription(id)).toMatchObject({
+    id,
+    docIds: [],
+    metadata: { itemsBeforePage: 0, itemsAfterPage: 0 },
+  });
+  expect(sync.getSubscription(id)?.cursor).toBeUndefined();
+  expect(sync.getSubscription(id)?.checkpoint).toBeUndefined();
+});
+it("retains data and checkpoint on failure and preserves the query", async () => {
+  const { db, sync } = setup();
+  db.getDocList.mockResolvedValue({ data: [row("a"), row("b")], cursor: "committed-cursor" });
+  const query = {
+    doctype: "Item",
+    fields: ["title"],
+    filters: { enabled: 1 },
+    orderBy: [{ field: "title", order: Order.Desc }],
+    limit: 3,
+    limitStart: 6,
+  };
+  const { subscriptionId } = await sync.subscribe(query);
+  const before = structuredClone(sync.getSubscription(subscriptionId));
+  const error = new Error("offline");
+  db.getDocList.mockRejectedValue(error);
+  const results = await sync.refreshSubscriptions();
+  expect(results).toEqual([{ subscriptionId, ok: false, error }]);
+  expect(results[0].error).toBe(error);
+  expect(sync.getSubscription(subscriptionId)).toEqual({ ...before, stale: true });
+  expect(db.getDocList.mock.calls).toEqual(
+    Array(2).fill([
+      "Item",
+      {
+        fields: ["title", "modified", "name"],
+        filters: { enabled: 1 },
+        orderBy: [{ field: "title", order: Order.Desc }],
+        limit: 3,
+        limitStart: 6,
+      },
+    ]),
+  );
+  expect(sync.getDocsForSubscription(subscriptionId)).toEqual([row("a"), row("b")]);
+});
+it("coalesces overlapping requests into a trailing authoritative fetch", async () => {
+  const { db, sync } = setup();
+  const { subscriptionId } = await sync.subscribe({ doctype: "Item" });
+  const first = deferred<ReturnType<typeof row>[]>();
+  const last = deferred<ReturnType<typeof row>[]>();
+  db.getDocList.mockReturnValueOnce(first.promise).mockReturnValueOnce(last.promise);
+  const one = sync.refreshSubscriptions();
+  await vi.waitFor(() => expect(db.getDocList).toHaveBeenCalledTimes(2));
+  const two = sync.refreshSubscriptions();
+  await Promise.resolve();
+  first.resolve([row("old")]);
+  await vi.waitFor(() => expect(db.getDocList).toHaveBeenCalledTimes(3));
+  expect(sync.getDocsForSubscription(subscriptionId)).toEqual([row("a"), row("b")]);
+  last.resolve([row("new")]);
+  expect(await one).toEqual(await two);
+  expect(sync.getDocsForSubscription(subscriptionId)).toEqual([row("new")]);
+});
+it("does not resurrect an unsubscribed request or modify its cached rows", async () => {
+  const { db, sync } = setup();
+  const { subscriptionId } = await sync.subscribe({ doctype: "Item" });
+  const pending = deferred<ReturnType<typeof row>[]>();
+  db.getDocList.mockReturnValueOnce(pending.promise);
+  const refresh = sync.refreshSubscriptions();
+  await vi.waitFor(() => expect(db.getDocList).toHaveBeenCalledTimes(2));
+  sync.unsubscribe(subscriptionId);
+  pending.resolve([row("a", "obsolete")]);
+  expect((await refresh)[0].ok).toBe(false);
+  expect(sync.getSubscription(subscriptionId)).toBeUndefined();
+  expect(sync.getDocFromCache("Item", "a")).toEqual(row("a"));
+});
+it("filters active doctypes and explicitly declines progressive refresh", async () => {
+  const { db, sync } = setup();
+  await sync.subscribe({ doctype: "Item" });
+  const progressive = await sync.subscribe({ doctype: "Paged", progressive: true });
+  const before = structuredClone(sync.getSubscription(progressive.subscriptionId));
+  const pageBefore = structuredClone(sync.getPageInfo(progressive.subscriptionId));
+  expect(db.getDocList).toHaveBeenCalledTimes(2);
+  db.getDocList.mockClear();
+  expect(await sync.refreshSubscriptions({ doctypes: [] })).toEqual([]);
+  expect(await sync.refreshSubscriptions({ doctypes: ["Unknown"] })).toEqual([]);
+  expect(db.getDocList).not.toHaveBeenCalled();
+  expect((await sync.refreshSubscriptions({ doctypes: ["Item"] }))[0].ok).toBe(true);
+  expect(db.getDocList).toHaveBeenCalledTimes(1);
+  const result = await sync.refreshSubscriptions({ doctypes: ["Paged"] });
+  expect(sync.getSubscription(progressive.subscriptionId)).toEqual(before);
+  expect(sync.getPageInfo(progressive.subscriptionId)).toEqual(pageBefore);
+  expect(result).toEqual([
+    {
+      subscriptionId: progressive.subscriptionId,
+      ok: false,
+      error: new Error("Snapshot refresh does not support progressive subscriptions"),
+    },
+  ]);
+  expect(db.getDocList).toHaveBeenCalledTimes(1);
+});
+
+it("exports the public runtime constructor", () => {
+  expect(PublicSyncModule).toBe(SyncModule);
+  expect(PublicSyncModule.prototype.refreshSubscriptions).toBeTypeOf("function");
+});
+
+it.each([
+  [undefined, undefined, defaultPageLength],
+  [undefined, 8, defaultPageLength],
+  [null, 4, defaultPageLength],
+  [0, 0, 0],
+  [7, 2, 7],
+])("preserves query window limit=%s offset=%s", async (limit, limitStart, expectedLimit) => {
+  const { sync, db } = setup();
+  const query = {
+    doctype: "Item",
+    fields: ["title", "name", "title"],
+    filters: { enabled: 1 },
+    orderBy: [{ field: "title", order: Order.Desc }],
+    ...(limit === undefined ? {} : { limit }),
+    ...(limitStart === undefined ? {} : { limitStart }),
+  } as SubscriptionQuery;
+  const { subscriptionId } = await sync.subscribe(query);
+  expect(sync.getSubscription(subscriptionId)?.boundaries?.pageSize).toBe(expectedLimit);
+  db.getDocList.mockResolvedValue({
+    data: [row("z"), { ...row("b"), modified: "2026-09-09T02:00:00Z" }],
+    cursor: "new-cursor",
+  });
+  await sync.refreshSubscriptions();
+  expect(db.getDocList.mock.calls).toEqual(
+    Array(2).fill([
+      "Item",
+      {
+        fields: ["title", "name", "modified"],
+        filters: query.filters,
+        orderBy: query.orderBy,
+        limit: expectedLimit,
+        ...(limitStart === undefined ? {} : { limitStart }),
+      },
+    ]),
+  );
+  expect(sync.getSubscription(subscriptionId)).toMatchObject({
+    docIds: ["z", "b"],
+    cursor: "new-cursor",
+    checkpoint: "2026-09-09T02:00:00Z",
+    boundaries: { pageSize: expectedLimit, offset: limitStart ?? 0 },
+  });
+});
+
+it.each([404, 403])("handles single-name getDoc status %s", async (status) => {
+  const db = { getDoc: vi.fn().mockResolvedValue(row("a")), getDocList: vi.fn() };
+  const sync = new SyncModule(db as never, undefined);
+  instances.push(sync);
+  const { subscriptionId } = await sync.subscribe({ doctype: "Item", filters: { name: "a" } });
+  const before = structuredClone(sync.getSubscription(subscriptionId));
+  const error = Object.assign(new Error("getDoc failed"), { status });
+  db.getDoc.mockRejectedValue(error);
+  expect(await sync.refreshSubscriptions()).toEqual([
+    { subscriptionId, ok: status === 404, ...(status === 404 ? {} : { error }) },
+  ]);
+  expect(db.getDoc.mock.calls).toEqual([
+    ["Item", "a"],
+    ["Item", "a"],
+  ]);
+  expect(db.getDocList).not.toHaveBeenCalled();
+  if (status === 404) {
+    expect(sync.getDocsForSubscription(subscriptionId)).toEqual([]);
+    expect(sync.getSubscription(subscriptionId)?.boundaries).toBeUndefined();
+  } else expect(sync.getSubscription(subscriptionId)).toEqual({ ...before, stale: true });
+  expect(sync.getDocFromCache("Item", "a")).toEqual(row("a"));
+});
+
+it("returns independent success, failure and progressive refusal", async () => {
+  const { sync, db } = setup();
+  const item = await sync.subscribe({ doctype: "Item" });
+  const other = await sync.subscribe({ doctype: "Other" });
+  const progressive = await sync.subscribe({ doctype: "Paged", progressive: true });
+  const before = structuredClone(sync.getSubscription(progressive.subscriptionId));
+  const pageBefore = structuredClone(sync.getPageInfo(progressive.subscriptionId));
+  const error = new Error("offline");
+  db.getDocList.mockRejectedValueOnce(error).mockResolvedValueOnce([row("success")]);
+  expect(await sync.refreshSubscriptions()).toEqual([
+    { subscriptionId: item.subscriptionId, ok: false, error },
+    { subscriptionId: other.subscriptionId, ok: true },
+    {
+      subscriptionId: progressive.subscriptionId,
+      ok: false,
+      error: new Error("Snapshot refresh does not support progressive subscriptions"),
+    },
+  ]);
+  expect(sync.getSubscription(progressive.subscriptionId)).toEqual(before);
+  expect(sync.getPageInfo(progressive.subscriptionId)).toEqual(pageBefore);
+  expect(db.getDocList).toHaveBeenCalledTimes(5);
+});
+
+it.each(["resetCache", "dispose"] as const)(
+  "invalidates a pending refresh on %s",
+  async (action) => {
+    const { sync, db } = setup();
+    const { subscriptionId } = await sync.subscribe({ doctype: "Item" });
+    const pending = deferred<ReturnType<typeof row>[]>();
+    const started = deferred<void>();
+    db.getDocList.mockImplementationOnce(() => {
+      started.resolve();
+      return pending.promise;
+    });
+    const result = sync.refreshSubscriptions();
+    await started.promise;
+    await sync[action]();
+    pending.resolve([row("a", "obsolete"), row("obsolete")]);
+    expect((await result)[0].ok).toBe(false);
+    expect(sync.getSubscription(subscriptionId)).toBeUndefined();
+    expect(sync.getDocFromCache("Item", "a")).toBeUndefined();
+    expect(sync.getDocFromCache("Item", "obsolete")).toBeUndefined();
+  },
+);