Merge pull request #29 from objectstack-ai/copilot/complete-development-testing

Author: hotlong

__tests__/hooks/useAnalyticsTracking.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for useAnalyticsTracking – validates page view and action
+ * tracking hooks wrapping the analytics tracker.
+ */
+import { renderHook } from "@testing-library/react-native";
+import { createAnalyticsTracker } from "~/lib/analytics";
+import { usePageView, useTrackAction } from "~/hooks/useAnalyticsTracking";
+
+describe("usePageView", () => {
+  it("tracks a page view on mount", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "trackPageView");
+
+    renderHook(() => usePageView("HomeScreen", undefined, tracker));
+
+    expect(spy).toHaveBeenCalledWith("HomeScreen", undefined);
+  });
+
+  it("tracks with additional properties", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "trackPageView");
+
+    renderHook(() =>
+      usePageView("DetailScreen", { recordId: "123" }, tracker),
+    );
+
+    expect(spy).toHaveBeenCalledWith("DetailScreen", { recordId: "123" });
+  });
+
+  it("re-tracks when screen name changes", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "trackPageView");
+
+    const { rerender } = renderHook(
+      ({ screen }: { screen: string }) =>
+        usePageView(screen, undefined, tracker),
+      { initialProps: { screen: "ScreenA" } },
+    );
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    rerender({ screen: "ScreenB" });
+
+    expect(spy).toHaveBeenCalledTimes(2);
+    expect(spy).toHaveBeenLastCalledWith("ScreenB", undefined);
+  });
+
+  it("does not re-track when other props change", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "trackPageView");
+
+    const { rerender } = renderHook(
+      ({ screen }: { screen: string }) =>
+        usePageView(screen, undefined, tracker),
+      { initialProps: { screen: "ScreenA" } },
+    );
+
+    rerender({ screen: "ScreenA" }); // Same screen name
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useTrackAction", () => {
+  it("returns trackAction and track functions", () => {
+    const tracker = createAnalyticsTracker();
+    const { result } = renderHook(() => useTrackAction(tracker));
+
+    expect(typeof result.current.trackAction).toBe("function");
+    expect(typeof result.current.track).toBe("function");
+  });
+
+  it("trackAction calls tracker.trackAction()", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "trackAction");
+    const { result } = renderHook(() => useTrackAction(tracker));
+
+    result.current.trackAction("button_click", { buttonId: "save" });
+
+    expect(spy).toHaveBeenCalledWith("button_click", { buttonId: "save" });
+  });
+
+  it("track calls tracker.track()", () => {
+    const tracker = createAnalyticsTracker();
+    const spy = jest.spyOn(tracker, "track");
+    const { result } = renderHook(() => useTrackAction(tracker));
+
+    result.current.track("custom_event", { key: "value" });
+
+    expect(spy).toHaveBeenCalledWith("custom_event", { key: "value" });
+  });
+});

__tests__/hooks/useBatchMutation.test.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for useBatchMutation – validates the SDK-compatible alias
+ * for useBatchOperations.
+ */
+import { useBatchMutation } from "~/hooks/useBatchMutation";
+import { useBatchOperations } from "~/hooks/useBatchOperations";
+
+describe("useBatchMutation (alias)", () => {
+  it("is re-exported as useBatchOperations", () => {
+    expect(useBatchMutation).toBe(useBatchOperations);
+  });
+});

__tests__/hooks/useFeatureFlag.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Tests for useFeatureFlag – validates reactive feature flag hooks
+ * that subscribe to flag changes via FeatureFlagManager.
+ */
+import { renderHook, act } from "@testing-library/react-native";
+import { createFeatureFlagManager } from "~/lib/feature-flags";
+import {
+  useFeatureFlag,
+  useFeatureFlagPayload,
+  useFeatureFlags,
+} from "~/hooks/useFeatureFlag";
+
+describe("useFeatureFlag", () => {
+  it("returns false for unknown flags", () => {
+    const mgr = createFeatureFlagManager();
+    const { result } = renderHook(() => useFeatureFlag("nonexistent", mgr));
+    expect(result.current).toBe(false);
+  });
+
+  it("returns true for enabled flags", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "dark_mode", enabled: true }],
+    });
+    const { result } = renderHook(() => useFeatureFlag("dark_mode", mgr));
+    expect(result.current).toBe(true);
+  });
+
+  it("returns false for disabled flags", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "beta", enabled: false }],
+    });
+    const { result } = renderHook(() => useFeatureFlag("beta", mgr));
+    expect(result.current).toBe(false);
+  });
+
+  it("re-renders when flags are overridden", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "feature_x", enabled: false }],
+    });
+    const { result } = renderHook(() => useFeatureFlag("feature_x", mgr));
+    expect(result.current).toBe(false);
+
+    act(() => {
+      mgr.overrideFlags([{ key: "feature_x", enabled: true }]);
+    });
+
+    expect(result.current).toBe(true);
+  });
+
+  it("cleans up subscription on unmount", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "test", enabled: true }],
+    });
+    const { unmount } = renderHook(() => useFeatureFlag("test", mgr));
+
+    // Should not throw after unmount
+    unmount();
+    act(() => {
+      mgr.overrideFlags([{ key: "test", enabled: false }]);
+    });
+  });
+});
+
+describe("useFeatureFlagPayload", () => {
+  it("returns undefined for flags without payload", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "basic", enabled: true }],
+    });
+    const { result } = renderHook(() => useFeatureFlagPayload("basic", mgr));
+    expect(result.current).toBeUndefined();
+  });
+
+  it("returns the payload for a flag", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [
+        {
+          key: "experiment",
+          enabled: true,
+          payload: { variant: "B", color: "blue" },
+        },
+      ],
+    });
+    const { result } = renderHook(() =>
+      useFeatureFlagPayload("experiment", mgr),
+    );
+    expect(result.current).toEqual({ variant: "B", color: "blue" });
+  });
+
+  it("updates when payload changes", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [
+        { key: "exp", enabled: true, payload: { version: 1 } },
+      ],
+    });
+    const { result } = renderHook(() => useFeatureFlagPayload("exp", mgr));
+    expect(result.current).toEqual({ version: 1 });
+
+    act(() => {
+      mgr.overrideFlags([
+        { key: "exp", enabled: true, payload: { version: 2 } },
+      ]);
+    });
+
+    expect(result.current).toEqual({ version: 2 });
+  });
+});
+
+describe("useFeatureFlags", () => {
+  it("returns all flags", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [
+        { key: "a", enabled: true },
+        { key: "b", enabled: false },
+      ],
+    });
+    const { result } = renderHook(() => useFeatureFlags(mgr));
+
+    expect(result.current.flags).toEqual([
+      { key: "a", enabled: true },
+      { key: "b", enabled: false },
+    ]);
+    expect(typeof result.current.refresh).toBe("function");
+  });
+
+  it("updates when flags change", () => {
+    const mgr = createFeatureFlagManager({
+      defaults: [{ key: "x", enabled: false }],
+    });
+    const { result } = renderHook(() => useFeatureFlags(mgr));
+    expect(result.current.flags).toHaveLength(1);
+
+    act(() => {
+      mgr.overrideFlags([
+        { key: "x", enabled: true },
+        { key: "y", enabled: true },
+      ]);
+    });
+
+    expect(result.current.flags).toHaveLength(2);
+    expect(result.current.flags[0].enabled).toBe(true);
+  });
+});