Add test files for Phase 12 (Security) and Phase 13 (Advanced) hooks

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

__tests__/hooks/useAuditLog.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for useAuditLog – validates audit log fetching
+ * with optional pagination options.
+ */
+import { renderHook, act } from "@testing-library/react-native";
+
+/* ---- Mock useClient from SDK ---- */
+const mockList = jest.fn();
+
+const mockClient = {
+  system: {
+    audit: { list: mockList },
+  },
+};
+
+jest.mock("@objectstack/client-react", () => ({
+  useClient: () => mockClient,
+}));
+
+import { useAuditLog } from "~/hooks/useAuditLog";
+
+beforeEach(() => {
+  mockList.mockReset();
+});
+
+describe("useAuditLog", () => {
+  it("getAuditLog fetches and stores entries", async () => {
+    const entries = [
+      {
+        id: "audit-1",
+        action: "create",
+        object: "tasks",
+        recordId: "task-1",
+        userId: "user-1",
+        timestamp: "2026-01-01T00:00:00Z",
+        changes: [{ field: "status", oldValue: null, newValue: "open" }],
+      },
+      {
+        id: "audit-2",
+        action: "update",
+        object: "tasks",
+        recordId: "task-1",
+        userId: "user-1",
+        timestamp: "2026-01-02T00:00:00Z",
+        changes: [{ field: "status", oldValue: "open", newValue: "closed" }],
+      },
+    ];
+    mockList.mockResolvedValue(entries);
+
+    const { result } = renderHook(() => useAuditLog());
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.getAuditLog("tasks", "task-1");
+    });
+
+    expect(mockList).toHaveBeenCalledWith({ object: "tasks", recordId: "task-1" });
+    expect(returned).toEqual(entries);
+    expect(result.current.entries).toEqual(entries);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("getAuditLog with options (limit, offset)", async () => {
+    const entries = [
+      {
+        id: "audit-3",
+        action: "delete",
+        object: "tasks",
+        recordId: "task-2",
+        userId: "user-2",
+        timestamp: "2026-01-03T00:00:00Z",
+      },
+    ];
+    mockList.mockResolvedValue(entries);
+
+    const { result } = renderHook(() => useAuditLog());
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.getAuditLog("tasks", "task-2", {
+        limit: 10,
+        offset: 5,
+      });
+    });
+
+    expect(mockList).toHaveBeenCalledWith({
+      object: "tasks",
+      recordId: "task-2",
+      limit: 10,
+      offset: 5,
+    });
+    expect(returned).toEqual(entries);
+    expect(result.current.entries).toEqual(entries);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("handles getAuditLog error", async () => {
+    mockList.mockRejectedValue(new Error("Access denied"));
+
+    const { result } = renderHook(() => useAuditLog());
+
+    await act(async () => {
+      await expect(result.current.getAuditLog("tasks", "task-1")).rejects.toThrow("Access denied");
+    });
+
+    expect(result.current.entries).toEqual([]);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error?.message).toBe("Access denied");
+  });
+});

__tests__/hooks/useCollaboration.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Tests for useCollaboration – validates joining, leaving,
+ * and cursor updates in a collaboration session.
+ */
+import { renderHook, act } from "@testing-library/react-native";
+
+/* ---- Mock useClient from SDK ---- */
+const mockJoin = jest.fn();
+const mockLeave = jest.fn();
+const mockGetParticipants = jest.fn();
+const mockUpdateCursor = jest.fn();
+
+const mockClient = {
+  realtime: {
+    collaboration: {
+      join: mockJoin,
+      leave: mockLeave,
+      getParticipants: mockGetParticipants,
+      updateCursor: mockUpdateCursor,
+    },
+  },
+};
+
+jest.mock("@objectstack/client-react", () => ({
+  useClient: () => mockClient,
+}));
+
+import { useCollaboration } from "~/hooks/useCollaboration";
+
+beforeEach(() => {
+  mockJoin.mockReset();
+  mockLeave.mockReset();
+  mockGetParticipants.mockReset();
+  mockUpdateCursor.mockReset();
+});
+
+describe("useCollaboration", () => {
+  it("join connects and fetches participants", async () => {
+    const participants = [
+      { userId: "user-1", status: "active", color: "#ff0000", lastSeen: "2026-01-01T00:00:00Z" },
+      { userId: "user-2", status: "idle", color: "#00ff00", lastSeen: "2026-01-01T00:00:00Z" },
+    ];
+    mockJoin.mockResolvedValue(undefined);
+    mockGetParticipants.mockResolvedValue(participants);
+
+    const { result } = renderHook(() => useCollaboration());
+
+    await act(async () => {
+      await result.current.join("tasks", "task-123");
+    });
+
+    expect(mockJoin).toHaveBeenCalledWith("tasks", "task-123");
+    expect(mockGetParticipants).toHaveBeenCalled();
+    expect(result.current.participants).toEqual(participants);
+    expect(result.current.isConnected).toBe(true);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("leave disconnects and clears participants", async () => {
+    mockJoin.mockResolvedValue(undefined);
+    mockGetParticipants.mockResolvedValue([
+      { userId: "user-1", status: "active", color: "#ff0000", lastSeen: "2026-01-01T00:00:00Z" },
+    ]);
+    mockLeave.mockResolvedValue(undefined);
+
+    const { result } = renderHook(() => useCollaboration());
+
+    // First join
+    await act(async () => {
+      await result.current.join("tasks", "task-123");
+    });
+    expect(result.current.isConnected).toBe(true);
+
+    // Then leave
+    await act(async () => {
+      await result.current.leave();
+    });
+
+    expect(mockLeave).toHaveBeenCalled();
+    expect(result.current.participants).toEqual([]);
+    expect(result.current.isConnected).toBe(false);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("updateCursor sends cursor data", async () => {
+    mockUpdateCursor.mockResolvedValue(undefined);
+
+    const { result } = renderHook(() => useCollaboration());
+
+    const cursor = { x: 100, y: 200, field: "name" };
+    await act(async () => {
+      await result.current.updateCursor(cursor);
+    });
+
+    expect(mockUpdateCursor).toHaveBeenCalledWith(cursor);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("handles join error", async () => {
+    mockJoin.mockRejectedValue(new Error("Connection refused"));
+
+    const { result } = renderHook(() => useCollaboration());
+
+    await act(async () => {
+      await expect(result.current.join("tasks", "task-123")).rejects.toThrow("Connection refused");
+    });
+
+    expect(result.current.isConnected).toBe(false);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error?.message).toBe("Connection refused");
+  });
+
+  it("handles leave error", async () => {
+    mockLeave.mockRejectedValue(new Error("Disconnect failed"));
+
+    const { result } = renderHook(() => useCollaboration());
+
+    await act(async () => {
+      await expect(result.current.leave()).rejects.toThrow("Disconnect failed");
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error?.message).toBe("Disconnect failed");
+  });
+});

__tests__/hooks/useRLS.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Tests for useRLS – validates RLS policy fetching
+ * and access evaluation.
+ */
+import { renderHook, act } from "@testing-library/react-native";
+
+/* ---- Mock useClient from SDK ---- */
+const mockList = jest.fn();
+const mockEvaluate = jest.fn();
+
+const mockClient = {
+  security: {
+    rls: { list: mockList, evaluate: mockEvaluate },
+  },
+};
+
+jest.mock("@objectstack/client-react", () => ({
+  useClient: () => mockClient,
+}));
+
+import { useRLS } from "~/hooks/useRLS";
+
+beforeEach(() => {
+  mockList.mockReset();
+  mockEvaluate.mockReset();
+});
+
+describe("useRLS", () => {
+  it("getPolicies fetches and stores policies", async () => {
+    const policies = [
+      {
+        id: "pol-1",
+        object: "Account",
+        name: "Account Select",
+        operation: "select",
+        condition: "owner_id = current_user()",
+        enabled: true,
+      },
+      {
+        id: "pol-2",
+        object: "Account",
+        name: "Account Update",
+        operation: "update",
+        condition: "owner_id = current_user()",
+        enabled: false,
+      },
+    ];
+    mockList.mockResolvedValue(policies);
+
+    const { result } = renderHook(() => useRLS());
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.getPolicies("Account");
+    });
+
+    expect(mockList).toHaveBeenCalledWith({ object: "Account" });
+    expect(returned).toEqual(policies);
+    expect(result.current.policies).toEqual(policies);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("evaluate checks access for record", async () => {
+    const evaluation = {
+      allowed: true,
+      appliedPolicies: ["pol-1"],
+    };
+    mockEvaluate.mockResolvedValue(evaluation);
+
+    const { result } = renderHook(() => useRLS());
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.evaluate("Account", "001", "select");
+    });
+
+    expect(mockEvaluate).toHaveBeenCalledWith({
+      object: "Account",
+      recordId: "001",
+      operation: "select",
+    });
+    expect(returned).toEqual(evaluation);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("handles getPolicies error", async () => {
+    mockList.mockRejectedValue(new Error("Forbidden"));
+
+    const { result } = renderHook(() => useRLS());
+
+    await act(async () => {
+      await expect(result.current.getPolicies("Account")).rejects.toThrow("Forbidden");
+    });
+
+    expect(result.current.policies).toEqual([]);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error?.message).toBe("Forbidden");
+  });
+
+  it("handles evaluate error", async () => {
+    mockEvaluate.mockRejectedValue(new Error("Evaluation failed"));
+
+    const { result } = renderHook(() => useRLS());
+
+    await act(async () => {
+      await expect(result.current.evaluate("Account", "001")).rejects.toThrow("Evaluation failed");
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.error?.message).toBe("Evaluation failed");
+  });
+});