@terreno/rtk 0.23.1 → 0.25.0

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();
+  });
+});

package/src/useServerStatus.test.ts

@@ -235,6 +235,74 @@ describe("useServerStatus", () => {
     unmount();
   });
 
+  it("polls again after the online interval elapses", async () => {
+    const fetchFn = mock(async () => new Response("ok", {status: 200}));
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {unmount} = renderHook(
+      () =>
+        useServerStatus({
+          healthUrl: "http://localhost:4000/health",
+          pollIntervalMs: 20,
+        }),
+      {wrapper: createWrapper(store)}
+    );
+
+    // Wait long enough for several interval ticks to fire the setInterval callback.
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    });
+
+    expect(fetchFn.mock.calls.length).toBeGreaterThan(1);
+    unmount();
+  });
+
+  it("aborts the in-flight health check once the request timeout fires", async () => {
+    const originalSetTimeout = globalThis.setTimeout;
+    // Fire the 4000ms abort timer synchronously so controller.abort() runs.
+    globalThis.setTimeout = ((handler: TimerHandler, timeout?: number, ...args: unknown[]) => {
+      if (timeout === 4_000 && typeof handler === "function") {
+        (handler as () => void)();
+        return 0;
+      }
+      return originalSetTimeout(handler, timeout as number, ...(args as []));
+    }) as unknown as typeof globalThis.setTimeout;
+
+    const fetchFn = mock(
+      (_url: string, init?: {signal?: AbortSignal}) =>
+        new Promise<Response>((_resolve, reject) => {
+          const signal = init?.signal;
+          if (signal?.aborted) {
+            reject(new Error("aborted"));
+            return;
+          }
+          signal?.addEventListener("abort", () => reject(new Error("aborted")));
+        })
+    );
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    try {
+      const {unmount} = renderHook(
+        () =>
+          useServerStatus({
+            healthUrl: "http://localhost:4000/health",
+            pollIntervalMs: 60_000,
+          }),
+        {wrapper: createWrapper(store)}
+      );
+
+      await act(async () => {
+        await new Promise((resolve) => originalSetTimeout(resolve, 50));
+      });
+
+      expect(fetchFn).toHaveBeenCalled();
+      expect(store.getState().offline.isOnline).toBe(false);
+      unmount();
+    } finally {
+      globalThis.setTimeout = originalSetTimeout;
+    }
+  });
+
   it("triggers health check when browser fires online event", async () => {
     store.dispatch(setOnlineStatus(false));
     const fetchFn = mock(async () => new Response("ok", {status: 200}));

package/src/useTerrenoFeatureFlags.test.ts

@@ -196,6 +196,21 @@ describe("useTerrenoFeatureFlags ref-count cleanup", () => {
     await OpenFeature.setProviderAndWait(refcountTestDomain, NOOP_PROVIDER);
   });
 
+  it("awaits pending provider switch during cleanup when unmount overlaps setProviderAndWait", async () => {
+    const {api} = buildApi({data: {alpha: boolDef("on")}});
+    // Render and immediately unmount before the provider switch resolves.
+    // This exercises the `await pending` path (line 119) in the cleanup.
+    const {unmount} = renderHook(() =>
+      useTerrenoFeatureFlags(api as never, {domain: refcountTestDomain, userId: "u-fast"})
+    );
+    // Unmount immediately — cleanup fires while the provider switch is still in-flight
+    unmount();
+    // Allow microtasks (the pending await + NOOP install) to settle
+    await new Promise((r) => setTimeout(r, 200));
+    // After cleanup the domain should have fallen back to NOOP
+    expect(OpenFeature.getClient(refcountTestDomain).getBooleanValue("alpha", false)).toBe(false);
+  });
+
   it("installs NOOP provider after the last hook instance unmounts", async () => {
     const {api} = buildApi({data: {alpha: boolDef("on")}});
     const {unmount} = renderHook(() =>
@@ -219,4 +234,29 @@ describe("useTerrenoFeatureFlags ref-count cleanup", () => {
       {timeout: 5000}
     );
   });
+
+  it("keeps the provider installed while another hook instance is still mounted", async () => {
+    const {api} = buildApi({data: {alpha: boolDef("on")}});
+    // Two instances share the domain, so the ref count reaches 2.
+    const first = renderHook(() =>
+      useTerrenoFeatureFlags(api as never, {domain: refcountTestDomain, userId: "u1"})
+    );
+    const second = renderHook(() =>
+      useTerrenoFeatureFlags(api as never, {domain: refcountTestDomain, userId: "u1"})
+    );
+    await waitFor(
+      () => {
+        expect(OpenFeature.getClient(refcountTestDomain).getBooleanValue("alpha", false)).toBe(
+          true
+        );
+      },
+      {timeout: 5000}
+    );
+    // Unmounting one instance decrements the ref count to 1 (the else branch),
+    // so the provider must remain installed rather than falling back to NOOP.
+    first.unmount();
+    await new Promise((r) => setTimeout(r, 200));
+    expect(OpenFeature.getClient(refcountTestDomain).getBooleanValue("alpha", false)).toBe(true);
+    second.unmount();
+  });
 });

package/src/useUpgradeCheck.test.ts

@@ -0,0 +1,226 @@
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {configureStore} from "@reduxjs/toolkit";
+import {act, renderHook} from "@testing-library/react-native";
+import Constants from "expo-constants";
+import React from "react";
+import {Provider} from "react-redux";
+
+// Capture the AppState "change" handler so tests can simulate foreground transitions.
+let appStateChangeHandler: ((state: string) => void) | undefined;
+const appStateMock = {
+  addEventListener: (_event: string, handler: (state: string) => void) => {
+    appStateChangeHandler = handler;
+    return {remove: () => {}};
+  },
+  currentState: "active",
+};
+
+// Keep this react-native mock a superset of the preload's mock so other test
+// files still resolve AppState / Linking / Platform after this file runs.
+mock.module("react-native", () => ({
+  AppState: appStateMock,
+  Linking: {openURL: async () => true},
+  Platform: {OS: "web"},
+  StyleSheet: {create: (s: unknown) => s},
+}));
+
+// Force IsWeb=true regardless of load order with the native test files.
+mock.module("./platform", () => ({IsWeb: true}));
+
+const {emptySplitApi} = await import("./emptyApi");
+const {useUpgradeCheck} = await import("./useUpgradeCheck");
+
+interface VersionCheckPayload {
+  message?: string;
+  pollingIntervalMs?: number;
+  status: "ok" | "warning" | "required";
+  updateUrl?: string;
+}
+
+const constantsWithExtra = Constants as unknown as {
+  expoConfig: {extra: Record<string, unknown>};
+};
+
+const createTestStore = () =>
+  configureStore({
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(emptySplitApi.middleware),
+    reducer: {[emptySplitApi.reducerPath]: emptySplitApi.reducer},
+  });
+
+const createWrapper = (store: ReturnType<typeof createTestStore>) => {
+  const Wrapper: React.FC<{children: React.ReactNode}> = ({children}) =>
+    React.createElement(Provider, {children, store});
+  return Wrapper;
+};
+
+const mockFetchWith = (payload: VersionCheckPayload): ReturnType<typeof mock> => {
+  const fetchFn = mock(
+    async () =>
+      new Response(JSON.stringify(payload), {
+        headers: {"content-type": "application/json"},
+        status: 200,
+      })
+  );
+  globalThis.fetch = fetchFn as unknown as typeof fetch;
+  return fetchFn;
+};
+
+const flush = async (ms = 60): Promise<void> => {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  });
+};
+
+describe("useUpgradeCheck (web)", () => {
+  let originalFetch: typeof globalThis.fetch;
+  let originalWindow: unknown;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    originalWindow = (globalThis as {window?: unknown}).window;
+    appStateChangeHandler = undefined;
+    appStateMock.currentState = "active";
+    constantsWithExtra.expoConfig.extra.buildNumber = 100;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    (globalThis as {window?: unknown}).window = originalWindow;
+    delete constantsWithExtra.expoConfig.extra.buildNumber;
+    emptySplitApi.util.resetApiState();
+  });
+
+  it("does not call the backend when the build number is unavailable", async () => {
+    delete constantsWithExtra.expoConfig.extra.buildNumber;
+    const fetchFn = mockFetchWith({status: "ok"});
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    expect(fetchFn).not.toHaveBeenCalled();
+    expect(result.current.isRequired).toBe(false);
+    expect(result.current.isWarning).toBe(false);
+    unmount();
+  });
+
+  it("flags a required upgrade and adopts the server polling interval", async () => {
+    const fetchFn = mockFetchWith({
+      message: "Please update",
+      pollingIntervalMs: 999_999,
+      status: "required",
+      updateUrl: "https://example.com/update",
+    });
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    expect(result.current.isRequired).toBe(true);
+    expect(result.current.requiredMessage).toBe("Please update");
+    expect(result.current.isWarning).toBe(false);
+    // On web the app can always self-update via reload.
+    expect(result.current.canUpdate).toBe(true);
+    unmount();
+  });
+
+  it("flags a warning upgrade and increments the warning check count", async () => {
+    const fetchFn = mockFetchWith({message: "Update soon", status: "warning"});
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    expect(fetchFn).toHaveBeenCalled();
+    expect(result.current.isWarning).toBe(true);
+    expect(result.current.warningMessage).toBe("Update soon");
+    expect(result.current.warningCheckCount).toBe(1);
+    expect(result.current.isRequired).toBe(false);
+    unmount();
+  });
+
+  it("clears upgrade state for an ok status", async () => {
+    mockFetchWith({status: "ok"});
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    expect(result.current.isRequired).toBe(false);
+    expect(result.current.isWarning).toBe(false);
+    unmount();
+  });
+
+  it("swallows version-check failures and stays in the default state", async () => {
+    const fetchFn = mock(async () => {
+      throw new Error("network down");
+    });
+    globalThis.fetch = fetchFn as unknown as typeof fetch;
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    // Wait long enough for RTK Query's retry backoff to exhaust and reject.
+    await flush(7000);
+
+    expect(result.current.isRequired).toBe(false);
+    expect(result.current.isWarning).toBe(false);
+    unmount();
+  }, 20_000);
+
+  it("reloads the page on web when onUpdate is invoked", async () => {
+    mockFetchWith({status: "required", updateUrl: "https://example.com/update"});
+    const reload = mock(() => {});
+    (globalThis as {window?: unknown}).window = {location: {reload}};
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    act(() => {
+      result.current.onUpdate();
+    });
+
+    expect(reload).toHaveBeenCalledTimes(1);
+    unmount();
+  });
+
+  it("polls repeatedly using the fallback interval", async () => {
+    const fetchFn = mockFetchWith({status: "ok"});
+
+    const {unmount} = renderHook(() => useUpgradeCheck({pollingIntervalMs: 20}), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush(120);
+
+    expect(fetchFn.mock.calls.length).toBeGreaterThan(1);
+    unmount();
+  });
+
+  it("re-checks when the app returns to the foreground", async () => {
+    const fetchFn = mockFetchWith({status: "ok"});
+
+    const {unmount} = renderHook(() => useUpgradeCheck({recheckOnForeground: true}), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    const initialCalls = fetchFn.mock.calls.length;
+    expect(appStateChangeHandler).toBeDefined();
+
+    await act(async () => {
+      appStateChangeHandler?.("background");
+      appStateChangeHandler?.("active");
+      await new Promise((resolve) => setTimeout(resolve, 30));
+    });
+
+    expect(fetchFn.mock.calls.length).toBeGreaterThan(initialCalls);
+    unmount();
+  });
+});

package/src/useUpgradeCheckNative.test.ts

@@ -0,0 +1,124 @@
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {configureStore} from "@reduxjs/toolkit";
+import {act, renderHook} from "@testing-library/react-native";
+import Constants from "expo-constants";
+import React from "react";
+import {Provider} from "react-redux";
+
+const openedUrls: string[] = [];
+
+// Keep this react-native mock a superset of the preload's mock so other test
+// files still resolve AppState / Linking / Platform after this file runs.
+mock.module("react-native", () => ({
+  AppState: {
+    addEventListener: () => ({remove: () => {}}),
+    currentState: "active",
+  },
+  Linking: {
+    openURL: async (url: string) => {
+      openedUrls.push(url);
+      return true;
+    },
+  },
+  Platform: {OS: "ios"},
+  StyleSheet: {create: (s: unknown) => s},
+}));
+
+// Force IsWeb=false so the mobile update path is exercised.
+mock.module("./platform", () => ({IsWeb: false}));
+
+const {emptySplitApi} = await import("./emptyApi");
+const {useUpgradeCheck} = await import("./useUpgradeCheck");
+
+interface VersionCheckPayload {
+  message?: string;
+  status: "ok" | "warning" | "required";
+  updateUrl?: string;
+}
+
+const constantsWithExtra = Constants as unknown as {
+  expoConfig: {extra: Record<string, unknown>};
+};
+
+const createTestStore = () =>
+  configureStore({
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(emptySplitApi.middleware),
+    reducer: {[emptySplitApi.reducerPath]: emptySplitApi.reducer},
+  });
+
+const createWrapper = (store: ReturnType<typeof createTestStore>) => {
+  const Wrapper: React.FC<{children: React.ReactNode}> = ({children}) =>
+    React.createElement(Provider, {children, store});
+  return Wrapper;
+};
+
+const mockFetchWith = (payload: VersionCheckPayload): void => {
+  globalThis.fetch = mock(
+    async () =>
+      new Response(JSON.stringify(payload), {
+        headers: {"content-type": "application/json"},
+        status: 200,
+      })
+  ) as unknown as typeof fetch;
+};
+
+const flush = async (ms = 60): Promise<void> => {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  });
+};
+
+describe("useUpgradeCheck (native)", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    openedUrls.length = 0;
+    constantsWithExtra.expoConfig.extra.buildNumber = 100;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    delete constantsWithExtra.expoConfig.extra.buildNumber;
+    emptySplitApi.util.resetApiState();
+  });
+
+  it("opens the update URL on native when onUpdate is invoked", async () => {
+    mockFetchWith({status: "required", updateUrl: "https://example.com/app-update"});
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    // canUpdate on native depends on having a resolved update URL.
+    expect(result.current.canUpdate).toBe(true);
+
+    await act(async () => {
+      result.current.onUpdate();
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    expect(openedUrls).toEqual(["https://example.com/app-update"]);
+    unmount();
+  });
+
+  it("does not open a URL on native when no update URL is available", async () => {
+    mockFetchWith({status: "required"});
+
+    const {result, unmount} = renderHook(() => useUpgradeCheck(), {
+      wrapper: createWrapper(createTestStore()),
+    });
+    await flush();
+
+    expect(result.current.canUpdate).toBe(false);
+
+    await act(async () => {
+      result.current.onUpdate();
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    });
+
+    expect(openedUrls).toEqual([]);
+    unmount();
+  });
+});

package/dist/isolated/constants.isolated.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=constants.isolated.d.ts.map

package/dist/isolated/constants.isolated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.isolated.d.ts","sourceRoot":"","sources":["../../src/isolated/constants.isolated.ts"],"names":[],"mappings":""}

package/dist/isolated/constants.isolated.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.isolated.js","sourceRoot":"","sources":["../../src/isolated/constants.isolated.ts"],"names":[],"mappings":"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"}