@terreno/rtk 0.24.0 → 0.26.0

package/src/isolated/constants.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Isolated tests for constants.ts paths that require mock.module.
+ *
+ * The module is loaded in a subprocess so mock.module does not replace
+ * expo-constants for the rest of the package test process.
+ */
+import {describe, it} from "bun:test";
+import {assert} from "chai";
+
+interface ConstantsModuleResult {
+  authDebug: boolean;
+  debugCalls: unknown[][];
+  errorCalls: unknown[][];
+  infoCalls: unknown[][];
+}
+
+const runConstantsModule = async (
+  expoConstants: Record<string, unknown>
+): Promise<ConstantsModuleResult> => {
+  const constantsUrl = new URL("../constants.ts", import.meta.url).href;
+  const script = `
+    import {mock} from "bun:test";
+    const output = console.log.bind(console);
+    const debugCalls = [];
+    const errorCalls = [];
+    const infoCalls = [];
+    console.debug = (...args) => debugCalls.push(args);
+    console.error = (...args) => errorCalls.push(args);
+    console.info = (...args) => infoCalls.push(args);
+    mock.module("expo-constants", () => ({default: ${JSON.stringify(expoConstants)}}));
+    const loaded = await import(${JSON.stringify(constantsUrl)});
+    loaded.logAuth("hello");
+    loaded.logSocket(undefined, "ws on");
+    output(JSON.stringify({
+      authDebug: loaded.AUTH_DEBUG,
+      debugCalls,
+      errorCalls,
+      infoCalls,
+    }));
+  `;
+  const child = Bun.spawn([process.execPath, "-e", script], {
+    cwd: import.meta.dir,
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+
+  assert.equal(exitCode, 0, stderr);
+  return JSON.parse(stdout.trim()) as ConstantsModuleResult;
+};
+
+describe("expo tunnel warning", () => {
+  it("warns when expoGoConfig.debuggerHost contains exp.direct", async () => {
+    const result = await runConstantsModule({
+      expoConfig: {extra: {}},
+      expoGoConfig: {debuggerHost: "abc.exp.direct"},
+    });
+
+    assert.isTrue(
+      result.errorCalls.some((args) =>
+        args.some((value) => String(value).includes("Expo Tunnel is not currently"))
+      )
+    );
+  });
+});
+
+describe("AUTH_DEBUG enabled path", () => {
+  it("logs auth and websocket debug messages when enabled", async () => {
+    const result = await runConstantsModule({
+      expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}},
+    });
+
+    assert.isTrue(result.authDebug);
+    assert.isTrue(
+      result.debugCalls.some((args) =>
+        args.some((value) => String(value).includes("AUTH_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      result.debugCalls.some((args) =>
+        args.some((value) => String(value).includes("WEBSOCKETS_DEBUG is enabled"))
+      )
+    );
+    assert.isTrue(
+      result.debugCalls.some((args) => args.some((value) => String(value).includes("hello")))
+    );
+    assert.isTrue(
+      result.infoCalls.some((args) => args[0] === "[websocket]" && args[1] === "ws on")
+    );
+  });
+});

package/src/mongooseSlice.test.ts

@@ -1,4 +1,3 @@
-// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {describe, expect, it} from "bun:test";
 
 import {type ListResponse, populateId} from "./mongooseSlice";
@@ -39,7 +38,7 @@ describe("populateId", () => {
 
   it("handles sparse arrays without throwing", () => {
     const sparse: ListResponse<{_id: string}> = {
-      data: [undefined as any, {_id: "found"}],
+      data: [undefined as unknown as {_id: string}, {_id: "found"}],
     };
     expect(populateId("found", sparse)).toEqual({_id: "found"});
   });

package/src/sync.test.ts

@@ -0,0 +1,391 @@
+import {describe, expect, it, mock} from "bun:test";
+import {configureStore} from "@reduxjs/toolkit";
+import {act, renderHook} from "@testing-library/react-native";
+import React from "react";
+import {Provider} from "react-redux";
+import type {Socket} from "socket.io-client";
+
+import type {RealtimeEvent} from "./realtime";
+import {useSyncConnection} from "./sync";
+
+const REDUCER_PATH = "testApi";
+
+type SocketHandler = (arg?: unknown) => void;
+
+interface FakeSocket {
+  connected: boolean;
+  emit: ReturnType<typeof mock>;
+  on: ReturnType<typeof mock>;
+  off: ReturnType<typeof mock>;
+  trigger: (event: string, arg?: unknown) => void;
+}
+
+const createFakeSocket = (connected: boolean): FakeSocket => {
+  const handlers: Record<string, SocketHandler[]> = {};
+  return {
+    connected,
+    emit: mock(() => {}),
+    off: mock((event: string, cb: SocketHandler) => {
+      handlers[event] = (handlers[event] ?? []).filter((h) => h !== cb);
+    }),
+    on: mock((event: string, cb: SocketHandler) => {
+      handlers[event] = handlers[event] ?? [];
+      handlers[event].push(cb);
+    }),
+    trigger: (event: string, arg?: unknown) => {
+      for (const cb of handlers[event] ?? []) {
+        cb(arg);
+      }
+    },
+  };
+};
+
+interface QueryEntry {
+  status: string;
+  endpointName: string;
+  originalArgs: unknown;
+  data?: Record<string, unknown>;
+}
+
+const createApi = (queries: Record<string, QueryEntry> | null) => {
+  const dataByEndpoint: Record<string, Record<string, unknown>> = {};
+  if (queries) {
+    for (const key of Object.keys(queries)) {
+      const entry = queries[key];
+      if (entry.data) {
+        dataByEndpoint[entry.endpointName] = entry.data;
+      }
+    }
+  }
+
+  const invalidateTags = mock((tags: string[]) => ({payload: tags, type: "api/invalidateTags"}));
+  const updateQueryData = mock(
+    (endpointName: string, _args: unknown, recipe: (draft: Record<string, unknown>) => void) => {
+      const draft = dataByEndpoint[endpointName];
+      if (draft) {
+        recipe(draft);
+      }
+      return {type: "api/updateQueryData"};
+    }
+  );
+
+  const api = {
+    reducerPath: REDUCER_PATH,
+    util: {invalidateTags, updateQueryData},
+  };
+
+  const store = configureStore({
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware({immutableCheck: false, serializableCheck: false}),
+    reducer: {
+      [REDUCER_PATH]: (state = {queries: queries ?? undefined}) => state,
+    },
+  });
+
+  return {api, invalidateTags, store, updateQueryData};
+};
+
+const renderSync = (
+  socket: FakeSocket | null,
+  // biome-ignore lint/suspicious/noExplicitAny: test-only structural RTK Query api stub
+  api: any,
+  store: ReturnType<typeof configureStore>,
+  options: {tagTypes?: string[]; debug?: boolean} = {}
+) => {
+  const Wrapper: React.FC<{children: React.ReactNode}> = ({children}) =>
+    React.createElement(Provider, {children, store});
+  return renderHook(
+    () =>
+      useSyncConnection({
+        api,
+        debug: options.debug ?? true,
+        socket: socket as unknown as Socket,
+        tagTypes: options.tagTypes ?? ["todos"],
+      }),
+    {wrapper: Wrapper}
+  );
+};
+
+const syncEvent = (overrides: Partial<RealtimeEvent>): RealtimeEvent =>
+  ({
+    collection: "todos",
+    id: "1",
+    method: "update",
+    ...overrides,
+  }) as RealtimeEvent;
+
+describe("useSyncConnection", () => {
+  it("does nothing when there is no socket", () => {
+    const {store, api} = createApi(null);
+    const {result} = renderSync(null, api, store);
+    expect(result.current).toBeUndefined();
+  });
+
+  it("subscribes to model rooms when the socket is already connected", () => {
+    const socket = createFakeSocket(true);
+    const {store, api} = createApi({});
+    const {unmount} = renderSync(socket, api, store, {tagTypes: ["todos", "users"]});
+
+    expect(socket.emit).toHaveBeenCalledWith("subscribe:model", "todos");
+    expect(socket.emit).toHaveBeenCalledWith("subscribe:model", "users");
+    expect(socket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+    expect(socket.on).toHaveBeenCalledWith("sync", expect.any(Function));
+
+    unmount();
+    expect(socket.emit).toHaveBeenCalledWith("unsubscribe:model", "todos");
+    expect(socket.off).toHaveBeenCalledWith("sync", expect.any(Function));
+  });
+
+  it("subscribes on the connect event when not initially connected", () => {
+    const socket = createFakeSocket(false);
+    const {store, api} = createApi({});
+    const {unmount} = renderSync(socket, api, store);
+
+    expect(socket.emit).not.toHaveBeenCalledWith("subscribe:model", "todos");
+
+    act(() => {
+      socket.trigger("connect");
+    });
+    expect(socket.emit).toHaveBeenCalledWith("subscribe:model", "todos");
+
+    // Not connected on cleanup, so no unsubscribe emit.
+    socket.emit.mockClear();
+    unmount();
+    expect(socket.emit).not.toHaveBeenCalledWith("unsubscribe:model", "todos");
+  });
+
+  it("ignores events for collections that are not tracked", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi({});
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({collection: "other", method: "create"}));
+    });
+    expect(invalidateTags).not.toHaveBeenCalled();
+  });
+
+  it("invalidates tags for create events", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi({});
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({method: "create"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("invalidates tags for update events without data", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi({});
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({data: undefined, method: "update"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("invalidates tags for update events when there are no cached queries", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi(null);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({data: {name: "new"}, method: "update"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("patches a matching entity inside a cached list query on update", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getTodos()": {
+        data: {data: [{_id: "1", name: "old", updated: "2026-01-01T00:00:00.000Z"}], total: 1},
+        endpointName: "getTodos",
+        originalArgs: undefined,
+        status: "fulfilled",
+      },
+    };
+    const {store, api, updateQueryData, invalidateTags} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger(
+        "sync",
+        syncEvent({data: {name: "new", updated: "2026-02-01T00:00:00.000Z"}, method: "update"})
+      );
+    });
+
+    expect(updateQueryData).toHaveBeenCalled();
+    expect(queries["getTodos()"].data.data[0].name).toBe("new");
+    expect(invalidateTags).not.toHaveBeenCalled();
+  });
+
+  it("skips stale updates in a cached list query", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getTodos()": {
+        data: {data: [{_id: "1", name: "current", updated: "2026-03-01T00:00:00.000Z"}], total: 1},
+        endpointName: "getTodos",
+        originalArgs: undefined,
+        status: "fulfilled",
+      },
+    };
+    const {store, api} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger(
+        "sync",
+        syncEvent({data: {name: "stale", updated: "2026-01-01T00:00:00.000Z"}, method: "update"})
+      );
+    });
+
+    expect(queries["getTodos()"].data.data[0].name).toBe("current");
+  });
+
+  it("patches a matching single-entity cached query on update", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getTodoById(1)": {
+        data: {_id: "1", name: "old", updated: "2026-01-01T00:00:00.000Z"},
+        endpointName: "getTodoById",
+        originalArgs: {id: "1"},
+        status: "fulfilled",
+      },
+    };
+    const {store, api, updateQueryData} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger(
+        "sync",
+        syncEvent({data: {name: "new", updated: "2026-02-01T00:00:00.000Z"}, method: "update"})
+      );
+    });
+
+    expect(updateQueryData).toHaveBeenCalled();
+    expect(queries["getTodoById(1)"].data.name).toBe("new");
+  });
+
+  it("skips stale updates for a single-entity cached query", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getTodoById(1)": {
+        data: {_id: "1", name: "current", updated: "2026-03-01T00:00:00.000Z"},
+        endpointName: "getTodoById",
+        originalArgs: {id: "1"},
+        status: "fulfilled",
+      },
+    };
+    const {store, api, invalidateTags} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger(
+        "sync",
+        syncEvent({data: {name: "stale", updated: "2026-01-01T00:00:00.000Z"}, method: "update"})
+      );
+    });
+
+    expect(queries["getTodoById(1)"].data.name).toBe("current");
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("invalidates tags on update when no cached query matches", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getOthers()": {
+        data: {data: [{_id: "999", name: "unrelated"}]},
+        endpointName: "getOthers",
+        originalArgs: undefined,
+        status: "fulfilled",
+      },
+      "pending()": {
+        data: {data: [{_id: "1"}]},
+        endpointName: "pending",
+        originalArgs: undefined,
+        status: "pending",
+      },
+    };
+    const {store, api, invalidateTags} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({data: {name: "new"}, method: "update"}));
+    });
+
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("removes a deleted entity from cached list queries and decrements total", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getTodos()": {
+        data: {
+          data: [
+            {_id: "1", name: "a"},
+            {_id: "2", name: "b"},
+          ],
+          total: 2,
+        },
+        endpointName: "getTodos",
+        originalArgs: undefined,
+        status: "fulfilled",
+      },
+    };
+    const {store, api, updateQueryData} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({method: "delete"}));
+    });
+
+    expect(updateQueryData).toHaveBeenCalled();
+    expect(queries["getTodos()"].data.data).toHaveLength(1);
+    expect(queries["getTodos()"].data.total).toBe(1);
+  });
+
+  it("invalidates tags on delete when there are no cached queries", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi(null);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({method: "delete"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("invalidates tags on delete when no cached query matches", () => {
+    const socket = createFakeSocket(true);
+    const queries = {
+      "getOthers()": {
+        data: {data: [{_id: "999"}]},
+        endpointName: "getOthers",
+        originalArgs: undefined,
+        status: "fulfilled",
+      },
+    };
+    const {store, api, invalidateTags} = createApi(queries);
+    renderSync(socket, api, store);
+
+    act(() => {
+      socket.trigger("sync", syncEvent({method: "delete"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+
+  it("does not log sync details when debug is disabled", () => {
+    const socket = createFakeSocket(true);
+    const {store, api, invalidateTags} = createApi({});
+    renderSync(socket, api, store, {debug: false});
+
+    act(() => {
+      socket.trigger("sync", syncEvent({method: "create"}));
+    });
+    expect(invalidateTags).toHaveBeenCalledWith(["todos"]);
+  });
+});

package/src/useFeatureFlags.ts

@@ -1,4 +1,5 @@
 import type {Api} from "@reduxjs/toolkit/query/react";
+import {DateTime} from "luxon";
 import {useCallback, useEffect, useMemo, useRef} from "react";
 import {useTerrenoFeatureFlags} from "./useTerrenoFeatureFlags";
 
@@ -104,7 +105,7 @@ export const useFeatureFlags = (
       return;
     }
 
-    fetchStartedAtRef.current = Date.now();
+    fetchStartedAtRef.current = DateTime.now().toMillis();
     console.debug("[feature-flags] flagConfiguration request started", {
       basePath,
     });
@@ -115,7 +116,7 @@ export const useFeatureFlags = (
       return;
     }
 
-    const durationMs = Date.now() - fetchStartedAtRef.current;
+    const durationMs = DateTime.now().toMillis() - fetchStartedAtRef.current;
     fetchStartedAtRef.current = null;
     console.debug("[feature-flags] flagConfiguration request failed", {
       basePath,
@@ -142,7 +143,7 @@ export const useFeatureFlags = (
       return;
     }
 
-    const durationMs = Date.now() - fetchStartedAtRef.current;
+    const durationMs = DateTime.now().toMillis() - fetchStartedAtRef.current;
     fetchStartedAtRef.current = null;
     console.debug("[feature-flags] flagConfiguration request completed", {
       basePath,

package/src/useRealtimeDebug.test.ts

@@ -0,0 +1,173 @@
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {configureStore} from "@reduxjs/toolkit";
+import {act, renderHook} from "@testing-library/react-native";
+import React from "react";
+import {Provider} from "react-redux";
+
+import {isWebsocketsDebugEnabled, setRealtimeDebug} from "./constants";
+import {offlineReducer, setOnlineStatus} from "./offlineSlice";
+import {useRealtimeDebug} from "./useRealtimeDebug";
+
+const createTestStore = (): ReturnType<typeof configureStore> =>
+  configureStore({
+    reducer: {offline: offlineReducer},
+  });
+
+const createWrapper = (
+  store: ReturnType<typeof createTestStore>
+): React.FC<{children: React.ReactNode}> => {
+  const Wrapper: React.FC<{children: React.ReactNode}> = ({children}) =>
+    React.createElement(Provider, {children, store});
+  return Wrapper;
+};
+
+const flush = async (ms = 50): Promise<void> => {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  });
+};
+
+describe("useRealtimeDebug", () => {
+  let store: ReturnType<typeof createTestStore>;
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    store = createTestStore();
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    // Reset the module-level runtime debug flag so tests do not leak into each other.
+    setRealtimeDebug(false);
+  });
+
+  it("does not fetch when offline and returns the env-based debug value", async () => {
+    store.dispatch(setOnlineStatus(false));
+    const fetchFn = mock(async () => new Response("{}", {status: 200}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    await flush();
+
+    expect(fetchFn).not.toHaveBeenCalled();
+    expect(result.current).toBe(false);
+    unmount();
+  });
+
+  it("enables debug when the health endpoint reports debug true", async () => {
+    const fetchFn = mock(async () => new Response(JSON.stringify({debug: true}), {status: 200}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    const callUrl = (fetchFn.mock.calls[0] as unknown[])[0] as string;
+    expect(callUrl).toBe("http://localhost:4000/realtime/health");
+    expect(isWebsocketsDebugEnabled()).toBe(true);
+    expect(result.current).toBe(true);
+    unmount();
+  });
+
+  it("keeps debug disabled when the health endpoint reports debug false", async () => {
+    const fetchFn = mock(async () => new Response(JSON.stringify({debug: false}), {status: 200}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    expect(isWebsocketsDebugEnabled()).toBe(false);
+    expect(result.current).toBe(false);
+    unmount();
+  });
+
+  it("ignores a non-ok health response", async () => {
+    const fetchFn = mock(async () => new Response("error", {status: 500}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    expect(result.current).toBe(false);
+    unmount();
+  });
+
+  it("swallows fetch errors and keeps env-based debug", async () => {
+    const fetchFn = mock(async () => {
+      throw new Error("Network error");
+    });
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    expect(result.current).toBe(false);
+    unmount();
+  });
+
+  it("does not apply the debug flag when the hook unmounts before the response resolves", async () => {
+    let resolveJson: (value: {debug: boolean}) => void = () => {};
+    const jsonPromise = new Promise<{debug: boolean}>((resolve) => {
+      resolveJson = resolve;
+    });
+    const fetchFn = mock(async () => ({json: () => jsonPromise, ok: true}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {unmount} = renderHook(() => useRealtimeDebug("http://localhost:4000"), {
+      wrapper: createWrapper(store),
+    });
+
+    // Unmount while the response body is still pending, then resolve it.
+    unmount();
+    await act(async () => {
+      resolveJson({debug: true});
+      await jsonPromise;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    // The cancelled guard should prevent setRealtimeDebug from running.
+    expect(isWebsocketsDebugEnabled()).toBe(false);
+  });
+
+  it("re-runs the health check when the refresh key changes", async () => {
+    const fetchFn = mock(async () => new Response(JSON.stringify({debug: false}), {status: 200}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {rerender, unmount} = renderHook(
+      ({key}: {key: number}) => useRealtimeDebug("http://localhost:4000", key),
+      {
+        initialProps: {key: 1},
+        wrapper: createWrapper(store),
+      }
+    );
+
+    await flush();
+    const firstCallCount = fetchFn.mock.calls.length;
+    expect(firstCallCount).toBeGreaterThan(0);
+
+    rerender({key: 2});
+    await flush();
+
+    expect(fetchFn.mock.calls.length).toBeGreaterThan(firstCallCount);
+    unmount();
+  });
+});