@applicaster/quick-brick-core 16.0.0-rc.11 → 16.0.0-rc.110

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

@@ -0,0 +1,471 @@
+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(),
+};
+
+// addSubsystem runs at module load, before mockLogger is initialised: delegate lazily
+jest.mock("../../logger", () => ({
+  coreAppLogger: {
+    addSubsystem: () => ({
+      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),
+    }),
+  },
+}));
+
+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();
+  });
+});

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

@@ -0,0 +1,126 @@
+import { Platform } from "react-native";
+import {
+  RESUME_VERIFICATION_DELAY_MS,
+  describeNetInfo,
+  getResumeDecision,
+  isBackgroundAppState,
+  isResumeVerificationEnabled,
+} from "../resumeVerification";
+
+describe("resumeVerification", () => {
+  it("uses a 5s verification delay", () => {
+    expect(RESUME_VERIFICATION_DELAY_MS).toBe(5000);
+  });
+
+  describe("isBackgroundAppState", () => {
+    it.each([
+      ["inactive", false],
+      ["background", true],
+      ["active", false],
+      ["unknown", false],
+      ["extension", false],
+      [null, false],
+      [undefined, false],
+    ])("%s -> %s", (state, expected) => {
+      expect(isBackgroundAppState(state)).toBe(expected);
+    });
+  });
+
+  describe("getResumeDecision", () => {
+    it.each([
+      [true, true, "still_online"],
+      [true, false, "went_offline"],
+      [false, true, "back_online"],
+      [false, false, "still_offline"],
+    ])("wasOnline=%s isOnlineNow=%s -> %s", (was, now, expected) => {
+      expect(getResumeDecision(was, now)).toBe(expected);
+    });
+  });
+
+  describe("isResumeVerificationEnabled", () => {
+    const originalOS = Platform.OS;
+
+    afterEach(() => {
+      Platform.OS = originalOS;
+    });
+
+    it.each([
+      ["ios", true],
+      ["android", true],
+      ["web", false],
+      ["samsung_tv", false],
+      ["lg_tv", false],
+    ])("%s -> %s", (os, expected) => {
+      Platform.OS = os as any;
+      expect(isResumeVerificationEnabled()).toBe(expected);
+    });
+
+    it.each(["ios", "android"])(
+      "is disabled on TV platforms (%s isTV)",
+      (os) => {
+        const isTVDescriptor = Object.getOwnPropertyDescriptor(
+          Platform,
+          "isTV"
+        );
+
+        Platform.OS = os as any;
+
+        Object.defineProperty(Platform, "isTV", {
+          value: true,
+          configurable: true,
+        });
+
+        try {
+          expect(isResumeVerificationEnabled()).toBe(false);
+        } finally {
+          if (isTVDescriptor) {
+            Object.defineProperty(Platform, "isTV", isTVDescriptor);
+          } else {
+            delete (Platform as any).isTV;
+          }
+        }
+      }
+    );
+  });
+
+  describe("describeNetInfo", () => {
+    it("summarises the status without leaking details (ip, subnet, carrier)", () => {
+      const summary = describeNetInfo({
+        type: "wifi",
+        isConnected: false,
+        isInternetReachable: false,
+        details: { ipAddress: "10.0.0.2", subnet: "255.255.255.0" },
+        deviceStatus: null,
+      } as any);
+
+      expect(summary).toEqual({
+        online: false,
+        isReady: true,
+        type: "wifi",
+        isConnected: false,
+        isInternetReachable: false,
+        deviceOnline: undefined,
+        at: expect.any(String),
+      });
+
+      expect(JSON.stringify(summary)).not.toContain("10.0.0.2");
+    });
+
+    it("reports not-ready info as online (mirrors isOnline)", () => {
+      expect(
+        describeNetInfo({
+          type: "unknown",
+          isConnected: null,
+          isInternetReachable: null,
+          details: null,
+        } as any)
+      ).toEqual(expect.objectContaining({ online: true, isReady: false }));
+    });
+
+    it("handles null input", () => {
+      expect(describeNetInfo(null)).toEqual(
+        expect.objectContaining({ online: true, isReady: false })
+      );
+    });
+  });
+});