@applicaster/quick-brick-core 16.0.0-rc.104 → 16.0.0-rc.106

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

@@ -0,0 +1,189 @@
+import React from "react";
+import { renderHook, act } from "@testing-library/react-native";
+import { AppState, Platform } from "react-native";
+
+import { useResumeVerifiedNetInfo } from "../useResumeVerifiedNetInfo";
+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 mockAppState = AppState as any;
+
+const changeAppState = (state: string) =>
+  act(() => {
+    mockAppState.currentState = state;
+    mockAppState.emitter.emit("change", state);
+  });
+
+const advance = (ms: number) =>
+  act(() => {
+    jest.advanceTimersByTime(ms);
+  });
+
+const setup = (initial = ONLINE, options = {}) => {
+  const hook = renderHook(({ info }) => useResumeVerifiedNetInfo(info), {
+    initialProps: { info: initial },
+    ...options,
+  });
+
+  const setLive = (info) => hook.rerender({ info });
+  const publishedOnline = () => isOnline(hook.result.current.netInfo) === true;
+
+  return { ...hook, setLive, publishedOnline };
+};
+
+const infoMessages = () =>
+  mockLogger.info.mock.calls.map(([event]) => event.message);
+
+describe("useResumeVerifiedNetInfo", () => {
+  const originalOS = Platform.OS;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    Platform.OS = "ios";
+    mockAppState.currentState = "active";
+    mockAppState.emitter.removeAllListeners();
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    Platform.OS = originalOS;
+  });
+
+  it("publishes live changes immediately while active", () => {
+    const { setLive, result } = setup(ONLINE);
+
+    setLive(OFFLINE);
+
+    expect(result.current.netInfo).toBe(OFFLINE);
+    expect(result.current.stillOfflineAfterResumeCount).toBe(0);
+  });
+
+  it("holds the state in background and publishes the verified state 5s after resume", () => {
+    const { setLive, publishedOnline } = setup(ONLINE);
+
+    changeAppState("background");
+    setLive(OFFLINE);
+    changeAppState("active");
+
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+  });
+
+  it("logs the resume verification at info level (delegates to the controller)", () => {
+    setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(infoMessages()).toEqual(
+      expect.arrayContaining([
+        "NetworkStatus: resume verification started",
+        "NetworkStatus: resume verification finished",
+      ])
+    );
+
+    expect(mockLogger.warning).not.toHaveBeenCalled();
+  });
+
+  it("exposes stillOfflineAfterResumeCount after an offline resume", () => {
+    const { result } = setup(OFFLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(result.current.stillOfflineAfterResumeCount).toBe(1);
+  });
+
+  it("stops the controller on unmount (no AppState listener, pending window never finishes)", () => {
+    const { setLive, unmount } = setup(ONLINE);
+
+    changeAppState("background");
+    changeAppState("active");
+    setLive(OFFLINE);
+
+    unmount();
+    advance(RESUME_VERIFICATION_DELAY_MS);
+
+    expect(mockAppState.emitter.listenerCount("change")).toBe(0);
+
+    expect(infoMessages()).not.toContain(
+      "NetworkStatus: resume verification finished"
+    );
+  });
+
+  it("works under React.StrictMode (double-invoked effects)", () => {
+    const { setLive, publishedOnline } = setup(ONLINE, {
+      wrapper: React.StrictMode,
+    });
+
+    expect(mockAppState.emitter.listenerCount("change")).toBe(1);
+
+    changeAppState("background");
+    changeAppState("active");
+    setLive(OFFLINE);
+
+    advance(RESUME_VERIFICATION_DELAY_MS - 1);
+    expect(publishedOnline()).toBe(true);
+
+    advance(1);
+    expect(publishedOnline()).toBe(false);
+  });
+});

package/App/NetworkStatusProvider/resumeVerification.ts

@@ -0,0 +1,54 @@
+import { Platform } from "react-native";
+import { NetInfoState } from "@react-native-community/netinfo";
+import { isConnectionInfoReady, isOnline } from "./utils";
+
+type ConnectionInfo = NetInfoState & { deviceStatus?: NetStatus };
+
+export type ResumeDecision =
+  | "still_online"
+  | "went_offline"
+  | "back_online"
+  | "still_offline";
+
+/**
+ * Time to wait after the app returns to foreground before trusting NetInfo.
+ * On iOS the JS reachability check (NetInfo internetReachability) is suspended
+ * with the app and reports a stale failure right after resume/unlock.
+ */
+export const RESUME_VERIFICATION_DELAY_MS = 5000;
+
+// Only "background" suspends JS (and NetInfo's reachability check). "inactive"
+// (Control Center, Notification Center, system alerts) keeps JS running, and is
+// where users toggle airplane mode / Wi-Fi, so changes there must pass through.
+export const isBackgroundAppState = (state?: string | null): boolean =>
+  state === "background";
+
+// Mobile only: tvOS / Android TV report Platform.OS "ios" / "android" too
+export const isResumeVerificationEnabled = (): boolean =>
+  (Platform.OS === "ios" || Platform.OS === "android") && !Platform.isTV;
+
+export const getResumeDecision = (
+  wasOnline: boolean,
+  isOnlineNow: boolean
+): ResumeDecision => {
+  if (wasOnline) {
+    return isOnlineNow ? "still_online" : "went_offline";
+  }
+
+  return isOnlineNow ? "back_online" : "still_offline";
+};
+
+// Log-safe summary: details holds ipAddress/subnet/carrier, never log it as is
+export const describeNetInfo = (info: ConnectionInfo | null) => {
+  const safeInfo = (info ?? {}) as ConnectionInfo;
+
+  return {
+    online: isOnline(safeInfo) === true,
+    isReady: !!isConnectionInfoReady(safeInfo),
+    type: safeInfo.type,
+    isConnected: safeInfo.isConnected,
+    isInternetReachable: safeInfo.isInternetReachable,
+    deviceOnline: safeInfo.deviceStatus?.online,
+    at: new Date().toISOString(),
+  };
+};

package/App/NetworkStatusProvider/useResumeVerifiedNetInfo.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+
+import {
+  ConnectionInfo,
+  ResumeVerificationController,
+  ResumeVerifiedState,
+} from "./ResumeVerificationController";
+
+/**
+ * Network status verified after the app returns from background,
+ * see ResumeVerificationController.
+ * liveNetInfo must keep its reference until it really changes (memoize it),
+ * every new reference is treated as a network update.
+ */
+export function useResumeVerifiedNetInfo<T extends ConnectionInfo>(
+  liveNetInfo: T
+): ResumeVerifiedState<T> {
+  const [controller] = React.useState(
+    () => new ResumeVerificationController(liveNetInfo)
+  );
+
+  React.useLayoutEffect(() => {
+    controller.start();
+
+    return () => controller.stop();
+  }, [controller]);
+
+  React.useLayoutEffect(() => {
+    controller.setNetInfo(liveNetInfo);
+  }, [controller, liveNetInfo]);
+
+  return React.useSyncExternalStore(controller.subscribe, controller.getState);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "16.0.0-rc.104",
+  "version": "16.0.0-rc.106",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,13 +28,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-rc.104",
-    "@applicaster/quick-brick-core-plugins": "16.0.0-rc.104",
-    "@applicaster/zapp-pipes-v2-client": "16.0.0-rc.104",
-    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.104",
-    "@applicaster/zapp-react-native-redux": "16.0.0-rc.104",
-    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.104",
-    "@applicaster/zapp-react-native-utils": "16.0.0-rc.104",
+    "@applicaster/applicaster-types": "16.0.0-rc.106",
+    "@applicaster/quick-brick-core-plugins": "16.0.0-rc.106",
+    "@applicaster/zapp-pipes-v2-client": "16.0.0-rc.106",
+    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.106",
+    "@applicaster/zapp-react-native-redux": "16.0.0-rc.106",
+    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.106",
+    "@applicaster/zapp-react-native-utils": "16.0.0-rc.106",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",