@applicaster/quick-brick-core 16.0.0-rc.99 → 17.0.0-alpha.2451166845

package/App/NetworkStatusProvider/__tests__/NetworkStatusProvider.test.tsx

@@ -5,6 +5,69 @@ import { NetworkStatusContext } from "@applicaster/zapp-react-native-ui-componen
 import { NetworkStatusProvider } from "../NetworkStatusProvider";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import NetInfo from "@react-native-community/netinfo";
+import { AppState } from "react-native";
+import { RESUME_VERIFICATION_DELAY_MS } from "../resumeVerification";
+
+const mockLogger = {
+  warning: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  log: jest.fn(),
+  error: jest.fn(),
+};
+
+// subsystemLogger runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => {
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/logger"
+  );
+
+  return {
+    ...actual,
+    // Only the logger of this subsystem is replaced; every other module keeps its real one.
+    subsystemLogger: (subsystem: string) => {
+      if (subsystem !== "network/reachability") {
+        return actual.subsystemLogger(subsystem);
+      }
+
+      const logger = {
+        warning: (event) => mockLogger.warning(event),
+        debug: (event) => mockLogger.debug(event),
+        info: (event) => mockLogger.info(event),
+        log: (event) => mockLogger.log(event),
+        error: (event) => mockLogger.error(event),
+        addSubsystem: () => logger,
+      };
+
+      return logger;
+    },
+  };
+});
+
+jest.mock("react-native/Libraries/AppState/AppState", () => {
+  const { EventEmitter } = require("events");
+  const emitter = new EventEmitter();
+
+  return {
+    emitter,
+    currentState: "active",
+    addEventListener: (type, handler) => {
+      emitter.addListener(type, handler);
+
+      return { remove: () => emitter.removeListener(type, handler) };
+    },
+  };
+});
+
+const mockAppState = AppState as any;
+
+const changeAppState = (state: string) =>
+  act(() => {
+    mockAppState.currentState = state;
+    mockAppState.emitter.emit("change", state);
+  });
+
+const OFFLINE_PATCH = { isConnected: false, isInternetReachable: false };
 
 const NetInfoMock = {
   type: "cellular",
@@ -49,7 +112,10 @@ describe("NetworkStatusProvider", function () {
       getWrapper(store)
     );
 
-    expect(result.current).toStrictEqual(NetInfoMock);
+    expect(result.current).toStrictEqual({
+      ...NetInfoMock,
+      stillOfflineAfterResumeCount: 0,
+    });
   });
 
   it("should call onConnectionLost callback when connection type changes to none", async function () {
@@ -135,3 +201,103 @@ describe("NetworkStatusProvider", function () {
     expect(onConnectionTypeChanged).toBeCalledWith("wifi");
   });
 });
+
+describe("NetworkStatusProvider – app resume", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockAppState.currentState = "active";
+    mockAppState.emitter.removeAllListeners();
+    // @ts-ignore
+    jest.spyOn(NetInfo, "useNetInfo").mockImplementation(useNetInfoMock);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("does not call onConnectionLost/Restored for a reachability blip right after resume", () => {
+    const onConnectionLost = jest.fn();
+    const onConnectionRestored = jest.fn();
+
+    const store = {
+      plugins: [
+        {
+          module: { networkHooks: { onConnectionLost, onConnectionRestored } },
+        },
+      ],
+    };
+
+    renderHook(() => React.useContext(NetworkStatusContext), getWrapper(store));
+
+    changeAppState("background");
+    changeAppState("active");
+
+    act(() => setNetInfoState(R.mergeRight(NetInfoMock, OFFLINE_PATCH)));
+    act(() => jest.advanceTimersByTime(2000));
+    act(() => setNetInfoState(NetInfoMock));
+    act(() => jest.advanceTimersByTime(RESUME_VERIFICATION_DELAY_MS));
+
+    expect(onConnectionLost).not.toHaveBeenCalled();
+    expect(onConnectionRestored).not.toHaveBeenCalled();
+  });
+
+  it("calls onConnectionLost 5s after resume when the device is really offline", () => {
+    const onConnectionLost = jest.fn();
+
+    const store = {
+      plugins: [{ module: { networkHooks: { onConnectionLost } } }],
+    };
+
+    renderHook(() => React.useContext(NetworkStatusContext), getWrapper(store));
+
+    changeAppState("background");
+    changeAppState("active");
+    act(() => setNetInfoState(R.mergeRight(NetInfoMock, OFFLINE_PATCH)));
+
+    act(() => jest.advanceTimersByTime(RESUME_VERIFICATION_DELAY_MS - 1));
+    expect(onConnectionLost).not.toHaveBeenCalled();
+
+    act(() => jest.advanceTimersByTime(1));
+    expect(onConnectionLost).toHaveBeenCalledTimes(1);
+  });
+
+  it("exposes stillOfflineAfterResumeCount when the device is still offline after resume", () => {
+    const store = { plugins: [{}] };
+
+    const { result } = renderHook(
+      () => React.useContext(NetworkStatusContext) as any,
+      getWrapper(store)
+    );
+
+    act(() => setNetInfoState(R.mergeRight(NetInfoMock, OFFLINE_PATCH)));
+    expect(result.current.stillOfflineAfterResumeCount).toBe(0);
+
+    changeAppState("background");
+    changeAppState("active");
+    act(() => jest.advanceTimersByTime(RESUME_VERIFICATION_DELAY_MS));
+
+    expect(result.current.stillOfflineAfterResumeCount).toBe(1);
+    expect(result.current.isInternetReachable).toBe(false);
+  });
+
+  it("logs online status changes at info level", () => {
+    mockLogger.info.mockClear();
+    mockLogger.warning.mockClear();
+
+    renderHook(
+      () => React.useContext(NetworkStatusContext),
+      getWrapper({ plugins: [{}] })
+    );
+
+    act(() => setNetInfoState(R.mergeRight(NetInfoMock, OFFLINE_PATCH)));
+
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "NetworkStatus: online status changed",
+        data: expect.objectContaining({ online: false, previousOnline: true }),
+      })
+    );
+
+    expect(mockLogger.warning).not.toHaveBeenCalled();
+  });
+});

package/App/NetworkStatusProvider/__tests__/ResumeVerificationController.test.ts

@@ -0,0 +1,486 @@
+import { AppState, Platform } from "react-native";
+
+import { ResumeVerificationController } from "../ResumeVerificationController";
+import { RESUME_VERIFICATION_DELAY_MS } from "../resumeVerification";
+import { isOnline } from "../utils";
+
+const mockLogger = {
+  warning: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  log: jest.fn(),
+  error: jest.fn(),
+};
+
+// subsystemLogger runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => {
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/logger"
+  );
+
+  return {
+    ...actual,
+    // Only the logger of this subsystem is replaced; every other module keeps its real one.
+    subsystemLogger: (subsystem: string) => {
+      if (subsystem !== "network/reachability") {
+        return actual.subsystemLogger(subsystem);
+      }
+
+      const logger = {
+        warning: (event) => mockLogger.warning(event),
+        debug: (event) => mockLogger.debug(event),
+        info: (event) => mockLogger.info(event),
+        log: (event) => mockLogger.log(event),
+        error: (event) => mockLogger.error(event),
+        addSubsystem: () => logger,
+      };
+
+      return logger;
+    },
+  };
+});
+
+jest.mock("react-native/Libraries/AppState/AppState", () => {
+  const { EventEmitter } = require("events");
+  const emitter = new EventEmitter();
+
+  return {
+    emitter,
+    currentState: "active",
+    addEventListener: (type, handler) => {
+      emitter.addListener(type, handler);
+
+      return { remove: () => emitter.removeListener(type, handler) };
+    },
+  };
+});
+
+const ONLINE = {
+  type: "wifi",
+  details: { isConnectionExpensive: false },
+  isConnected: true,
+  isInternetReachable: true,
+  deviceStatus: null,
+} as any;
+
+const OFFLINE = {
+  type: "wifi",
+  details: { isConnectionExpensive: false },
+  isConnected: false,
+  isInternetReachable: false,
+  deviceStatus: null,
+} as any;
+
+const NOT_READY = {
+  type: "unknown",
+  details: null,
+  isConnected: null,
+  isInternetReachable: null,
+  deviceStatus: null,
+} as any;
+
+const mockAppState = AppState as any;
+
+const changeAppState = (state: string) => {
+  mockAppState.currentState = state;
+  mockAppState.emitter.emit("change", state);
+};
+
+const advance = (ms: number) => jest.advanceTimersByTime(ms);
+
+let controller: ResumeVerificationController<any> | undefined;
+
+const setup = (initial = ONLINE) => {
+  controller = new ResumeVerificationController(initial);
+  controller.start();
+
+  return controller;
+};
+
+const publishedOnline = () => isOnline(controller.getState().netInfo) === true;
+
+const infoMessages = () =>
+  mockLogger.info.mock.calls.map(([event]) => event.message);
+
+describe("ResumeVerificationController", () => {
+  const originalOS = Platform.OS;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    Platform.OS = "ios";
+    mockAppState.currentState = "active";
+    mockAppState.emitter.removeAllListeners();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    controller?.stop();
+    controller = undefined;
+    jest.useRealTimers();
+    Platform.OS = originalOS;
+  });
+
+  it("passes live changes through immediately while active", () => {
+    setup(ONLINE);
+
+    controller.setNetInfo(OFFLINE);
+    expect(controller.getState().netInfo).toBe(OFFLINE);
+
+    controller.setNetInfo(ONLINE);
+    expect(controller.getState().netInfo).toBe(ONLINE);
+    expect(controller.getState().stillOfflineAfterResumeCount).toBe(0);
+  });
+
+  it("ignores network changes while in background", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    controller.setNetInfo(OFFLINE);
+
+    expect(publishedOnline()).toBe(true);
+
+    expect(infoMessages()).toContain(
+      "NetworkStatus: network change ignored until verified"
+    );
+  });
+
+  it("'inactive' (Control Center, Notification Center) passes network changes through immediately", () => {
+    setup(ONLINE);
+
+    changeAppState("inactive");
+    controller.setNetInfo(OFFLINE);
+    expect(publishedOnline()).toBe(false);
+
+    changeAppState("active");
+    controller.setNetInfo(ONLINE);
+    expect(publishedOnline()).toBe(true);
+  });
+
+  it("lock screen (active -> inactive -> background -> active) still verifies for 5s", () => {
+    setup(ONLINE);
+
+    changeAppState("inactive");
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("'inactive' during the verification window keeps the window running", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+    advance(2000);
+
+    changeAppState("inactive");
+    expect(publishedOnline()).toBe(true);
+
+    advance(RESUME_VERIFICATION_DELAY_MS - 2000);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("online -> resume with late offline blip -> stays online", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+
+    controller.setNetInfo(OFFLINE); // stale reachability failure lands after 'active'
+    expect(publishedOnline()).toBe(true);
+
+    advance(2000);
+    controller.setNetInfo(ONLINE); // retry succeeds
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(publishedOnline()).toBe(true);
+    expect(controller.getState().stillOfflineAfterResumeCount).toBe(0);
+
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "NetworkStatus: resume verification finished",
+        data: expect.objectContaining({ decision: "still_online" }),
+      })
+    );
+  });
+
+  it("blip arriving before 'active' (while background) is also ignored", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    controller.setNetInfo(OFFLINE);
+    changeAppState("active");
+    advance(1000);
+    controller.setNetInfo(ONLINE);
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(publishedOnline()).toBe(true);
+  });
+
+  it("online -> resume -> still offline after 5s -> publishes offline exactly at 5s", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ decision: "went_offline" }),
+      })
+    );
+  });
+
+  it("offline -> resume -> online after 5s -> publishes online only at 5s", () => {
+    setup(OFFLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(ONLINE);
+    expect(publishedOnline()).toBe(false);
+
+    advance(RESUME_VERIFICATION_DELAY_MS);
+    expect(publishedOnline()).toBe(true);
+
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ decision: "back_online" }),
+      })
+    );
+  });
+
+  it("offline -> resume -> still offline -> increments stillOfflineAfterResumeCount", () => {
+    setup(OFFLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(publishedOnline()).toBe(false);
+    expect(controller.getState().stillOfflineAfterResumeCount).toBe(1);
+
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(controller.getState().stillOfflineAfterResumeCount).toBe(2);
+  });
+
+  it("going back to background mid-window cancels and restarts the 5s window", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+    advance(3000);
+
+    changeAppState("background");
+
+    expect(infoMessages()).toContain(
+      "NetworkStatus: resume verification cancelled"
+    );
+
+    advance(RESUME_VERIFICATION_DELAY_MS); // old timer must not fire
+    expect(publishedOnline()).toBe(true);
+
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("after verification ends, live changes pass through immediately again", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    controller.setNetInfo(OFFLINE);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("constructed while app is in background starts frozen and verifies on first active", () => {
+    mockAppState.currentState = "background";
+    setup(ONLINE);
+
+    controller.setNetInfo(OFFLINE);
+    expect(publishedOnline()).toBe(true);
+
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("a not-ready snapshot counts as online; offline at 5s is announced", () => {
+    setup(NOT_READY);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("active -> active (no background) does not open a window", () => {
+    setup(ONLINE);
+
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("logs app state changes at info level with app state and network summaries", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+
+    expect(mockLogger.info).toHaveBeenCalledWith({
+      message: "NetworkStatus: app state changed",
+      data: expect.objectContaining({
+        appState: "background",
+        previousAppState: "active",
+        phase: "live",
+        nextPhase: "frozen",
+        published: expect.objectContaining({ online: true }),
+        live: expect.objectContaining({ online: true }),
+      }),
+    });
+  });
+
+  it("non-native platforms pass through untouched and never subscribe", () => {
+    Platform.OS = "web" as any;
+    setup(ONLINE);
+
+    expect(mockAppState.emitter.listenerCount("change")).toBe(0);
+
+    changeAppState("background");
+    controller.setNetInfo(OFFLINE);
+
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("catches up when 'active' happened between construction and start()", () => {
+    mockAppState.currentState = "background";
+    controller = new ResumeVerificationController(ONLINE);
+
+    mockAppState.currentState = "active"; // emitted before start() subscribed
+    controller.start();
+
+    controller.setNetInfo(OFFLINE);
+    expect(publishedOnline()).toBe(true);
+
+    advance(RESUME_VERIFICATION_DELAY_MS);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("getState keeps the same reference until something is published", () => {
+    setup(ONLINE);
+
+    const listener = jest.fn();
+    controller.subscribe(listener);
+    const before = controller.getState();
+
+    controller.setNetInfo(ONLINE); // same reference
+    expect(controller.getState()).toBe(before);
+
+    changeAppState("background");
+    controller.setNetInfo(OFFLINE);
+    expect(controller.getState()).toBe(before);
+    expect(listener).not.toHaveBeenCalled();
+
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(controller.getState()).not.toBe(before);
+  });
+
+  it("unsubscribe stops notifications", () => {
+    setup(ONLINE);
+
+    const listener = jest.fn();
+    const unsubscribe = controller.subscribe(listener);
+
+    unsubscribe();
+    controller.setNetInfo(OFFLINE);
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("stop() removes the AppState listener and pending timer; start() while active opens a fresh window", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    controller.setNetInfo(OFFLINE);
+    advance(3000);
+
+    controller.stop();
+    expect(mockAppState.emitter.listenerCount("change")).toBe(0);
+    expect(jest.getTimerCount()).toBe(0);
+
+    controller.start();
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("start() is idempotent (no duplicate AppState listener)", () => {
+    setup(ONLINE);
+    controller.start();
+
+    expect(mockAppState.emitter.listenerCount("change")).toBe(1);
+  });
+
+  it("does not log 'ignored' when nothing changed (constructed in background)", () => {
+    mockAppState.currentState = "background";
+    setup(ONLINE);
+
+    expect(infoMessages()).not.toContain(
+      "NetworkStatus: network change ignored until verified"
+    );
+  });
+
+  it("logs only at info level", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    controller.setNetInfo(OFFLINE);
+    changeAppState("active");
+    advance(1000);
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(infoMessages()).toEqual(
+      expect.arrayContaining([
+        "NetworkStatus: app state changed",
+        "NetworkStatus: network change ignored until verified",
+        "NetworkStatus: resume verification started",
+        "NetworkStatus: resume verification cancelled",
+        "NetworkStatus: resume verification finished",
+      ])
+    );
+
+    expect(mockLogger.warning).not.toHaveBeenCalled();
+  });
+});