@terreno/ui 0.9.3 → 0.11.0

package/src/table/tableContext.test.tsx

@@ -0,0 +1,96 @@
+import {describe, expect, it, mock} from "bun:test";
+import {render} from "@testing-library/react-native";
+import {useEffect} from "react";
+import {Text} from "react-native";
+
+import type {TableContextType} from "../Common";
+import {renderWithTheme} from "../test-utils";
+import {TableContextProvider, useTableContext} from "./tableContext";
+
+const captureContext = (): {
+  getContext: () => TableContextType;
+  Consumer: () => React.ReactElement;
+} => {
+  let captured: TableContextType | undefined;
+  const Consumer = () => {
+    captured = useTableContext();
+    return <Text>ok</Text>;
+  };
+  const getContext = (): TableContextType => {
+    if (!captured) {
+      throw new Error("Context was not captured");
+    }
+    return captured;
+  };
+  return {Consumer, getContext};
+};
+
+describe("tableContext", () => {
+  it("exposes default values from useTableContext when no provider is present", () => {
+    const {getContext, Consumer} = captureContext();
+    renderWithTheme(<Consumer />);
+    const ctx = getContext();
+    expect(ctx.columns).toEqual([]);
+    expect(ctx.stickyHeader).toBe(true);
+    expect(ctx.alternateRowBackground).toBe(true);
+    expect(ctx.borderStyle).toBe("sm");
+    expect(ctx.hasDrawerContents).toBe(false);
+    expect(typeof ctx.setSortColumn).toBe("function");
+    // Invoke default setSortColumn to cover the no-op default
+    expect(() => ctx.setSortColumn({column: 0, direction: "asc"})).not.toThrow();
+  });
+
+  it("passes provided values through the provider", () => {
+    const setSortColumn = mock(() => {});
+    const {getContext, Consumer} = captureContext();
+    render(
+      <TableContextProvider
+        alternateRowBackground={false}
+        borderStyle="lg"
+        columns={[100, 200]}
+        hasDrawerContents
+        page={3}
+        setSortColumn={setSortColumn}
+        sortColumn={{column: 1, direction: "desc"}}
+        stickyHeader={false}
+      >
+        <Consumer />
+      </TableContextProvider>
+    );
+    const ctx = getContext();
+    expect(ctx.columns).toEqual([100, 200]);
+    expect(ctx.hasDrawerContents).toBe(true);
+    expect(ctx.stickyHeader).toBe(false);
+    expect(ctx.alternateRowBackground).toBe(false);
+    expect(ctx.borderStyle).toBe("lg");
+    expect(ctx.sortColumn).toEqual({column: 1, direction: "desc"});
+    ctx.setSortColumn({column: 0, direction: "asc"});
+    expect(setSortColumn).toHaveBeenCalled();
+  });
+
+  it("useEffect-based consumer can call setSortColumn without errors", () => {
+    const setSortColumn = mock(() => {});
+    const Consumer = () => {
+      const {setSortColumn: setter} = useTableContext();
+      useEffect(() => {
+        setter({column: 2, direction: "desc"});
+      }, [setter]);
+      return <Text>ok</Text>;
+    };
+    render(
+      <TableContextProvider
+        alternateRowBackground
+        borderStyle="sm"
+        columns={[100]}
+        hasDrawerContents={false}
+        page={1}
+        setSortColumn={setSortColumn}
+        sortColumn={undefined}
+        stickyHeader
+      >
+        <Consumer />
+      </TableContextProvider>
+    );
+    expect(setSortColumn).toHaveBeenCalledWith({column: 2, direction: "desc"});
+  });
+});

package/src/test-utils.tsx

@@ -5,7 +5,7 @@ import type React from "react";
 import {ThemeProvider} from "./Theme";
 
 export const renderWithTheme = (ui: React.ReactElement) => {
-  return render(<ThemeProvider>{ui}</ThemeProvider>);
+  return render(ui, {wrapper: ThemeProvider});
 };
 
 export const createCommonMocks = () => ({

package/src/useConsentForms.test.ts

@@ -0,0 +1,130 @@
+import {describe, expect, it, mock} from "bun:test";
+import {renderHook} from "@testing-library/react-native";
+
+import {detectLocale, useConsentForms} from "./useConsentForms";
+
+mock.module("expo-localization", () => ({
+  getLocales: () => [{languageTag: "es-ES"}],
+}));
+
+describe("detectLocale", () => {
+  it("returns locale from expo-localization in native test env", () => {
+    const originalNavigator = (globalThis as any).navigator;
+    (globalThis as any).navigator = undefined;
+    const locale = detectLocale();
+    (globalThis as any).navigator = originalNavigator;
+    expect(typeof locale).toBe("string");
+    expect(locale.length).toBeGreaterThan(0);
+  });
+
+  it("falls back to en when expo-localization throws and no navigator", () => {
+    const originalNavigator = (globalThis as any).navigator;
+    (globalThis as any).navigator = undefined;
+    mock.module("expo-localization", () => ({
+      getLocales: () => {
+        throw new Error("not available");
+      },
+    }));
+    const locale = detectLocale();
+    (globalThis as any).navigator = originalNavigator;
+    // Reset mock
+    mock.module("expo-localization", () => ({
+      getLocales: () => [{languageTag: "es-ES"}],
+    }));
+    expect(locale).toBe("en");
+  });
+
+  it("returns navigator.language when available", () => {
+    const originalNavigator = (globalThis as any).navigator;
+    (globalThis as any).navigator = {language: "fr-FR"};
+    const locale = detectLocale();
+    (globalThis as any).navigator = originalNavigator;
+    expect(locale).toBe("fr-FR");
+  });
+});
+
+describe("useConsentForms", () => {
+  const buildApi = (queryResult: {data?: unknown; error?: unknown; isLoading?: boolean}) => {
+    const refetch = mock(() => {});
+    const useGetPendingConsentsQuery = mock(() => ({
+      data: queryResult.data,
+      error: queryResult.error,
+      isLoading: queryResult.isLoading ?? false,
+      refetch,
+    }));
+    const api = {
+      enhanceEndpoints: mock(() => ({
+        injectEndpoints: mock((opts: any) => {
+          // Call endpoint builder to exercise provides/onQueryStarted
+          const build = {
+            query: mock((def: any) => {
+              // Call onQueryStarted with a successful result
+              if (def.onQueryStarted) {
+                void def.onQueryStarted(undefined, {
+                  queryFulfilled: Promise.resolve({data: [{id: "1"}]}),
+                });
+              }
+              // Also exercise the URL builder
+              def.query();
+              return "pending-query";
+            }),
+          };
+          opts.endpoints(build);
+          return {useGetPendingConsentsQuery};
+        }),
+      })),
+    };
+    return {api, refetch};
+  };
+
+  it("returns an array of forms when response is an array", () => {
+    const {api} = buildApi({data: [{id: "1", title: "Form 1"} as any]});
+    const {result} = renderHook(() => useConsentForms(api as any));
+    expect(result.current.forms).toBeDefined();
+    expect(Array.isArray(result.current.forms)).toBe(true);
+  });
+
+  it("unwraps .data property when response is object shape", () => {
+    const {api} = buildApi({data: {data: [{id: "2"} as any]}});
+    const {result} = renderHook(() => useConsentForms(api as any, "/api"));
+    expect(Array.isArray(result.current.forms)).toBe(true);
+  });
+
+  it("returns empty array when no data is present", () => {
+    const {api} = buildApi({data: undefined, isLoading: true});
+    const {result} = renderHook(() => useConsentForms(api as any));
+    expect(result.current.forms).toEqual([]);
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it("calls onQueryStarted with failing query", () => {
+    const refetch = mock(() => {});
+    const api = {
+      enhanceEndpoints: mock(() => ({
+        injectEndpoints: mock((opts: any) => {
+          const build = {
+            query: mock((def: any) => {
+              if (def.onQueryStarted) {
+                void def.onQueryStarted(undefined, {
+                  queryFulfilled: Promise.reject(new Error("failed")),
+                });
+              }
+              return "q";
+            }),
+          };
+          opts.endpoints(build);
+          return {
+            useGetPendingConsentsQuery: () => ({
+              data: undefined,
+              error: "error",
+              isLoading: false,
+              refetch,
+            }),
+          };
+        }),
+      })),
+    };
+    const {result} = renderHook(() => useConsentForms(api as any));
+    expect(result.current.error).toBe("error");
+  });
+});

package/src/useSubmitConsent.test.ts

@@ -0,0 +1,64 @@
+import {describe, expect, it, mock} from "bun:test";
+import {renderHook} from "@testing-library/react-native";
+
+import {useSubmitConsent} from "./useSubmitConsent";
+
+describe("useSubmitConsent", () => {
+  const buildApi = () => {
+    const unwrap = mock(async () => ({success: true}));
+    const submitMutation = mock(() => ({unwrap}));
+    const useSubmitConsentResponseMutation = mock(() => [
+      submitMutation,
+      {error: undefined, isLoading: false},
+    ]);
+    const api = {
+      enhanceEndpoints: mock(() => ({
+        injectEndpoints: mock((opts: any) => {
+          const build = {
+            mutation: mock((def: any) => {
+              // Exercise the query builder
+              const result = def.query({
+                agreed: true,
+                consentFormId: "f1",
+                locale: "en",
+              });
+              expect(result.method).toBe("POST");
+              expect(result.url).toContain("/consents/respond");
+              return "submit-mutation";
+            }),
+          };
+          opts.endpoints(build);
+          return {useSubmitConsentResponseMutation};
+        }),
+      })),
+    };
+    return {api, submitMutation, unwrap};
+  };
+
+  it("returns submit function and state", () => {
+    const {api} = buildApi();
+    const {result} = renderHook(() => useSubmitConsent(api as any));
+    expect(typeof result.current.submit).toBe("function");
+    expect(result.current.isSubmitting).toBe(false);
+    expect(result.current.error).toBeUndefined();
+  });
+
+  it("calls submit mutation when submit is invoked", async () => {
+    const {api, submitMutation, unwrap} = buildApi();
+    const {result} = renderHook(() => useSubmitConsent(api as any, "/api"));
+    const response = await result.current.submit({
+      agreed: true,
+      consentFormId: "f1",
+      locale: "en",
+    });
+    expect(submitMutation).toHaveBeenCalled();
+    expect(unwrap).toHaveBeenCalled();
+    expect(response).toEqual({success: true});
+  });
+
+  it("uses empty baseUrl when none provided", () => {
+    const {api} = buildApi();
+    const {result} = renderHook(() => useSubmitConsent(api as any));
+    expect(result.current.submit).toBeDefined();
+  });
+});