) {
+ return Promise.resolve(obj);
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ mockGetInstance.mockResolvedValue({
+ resolveContactIdFromPage: mockResolveContactIdFromPage,
+ });
+});
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe("AddEditFamilyPage", () => {
+ it("renders with initialContactId null when there is no recordID", async () => {
+ mockParseToolParams.mockResolvedValue({ recordID: undefined });
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({}) });
+ render(jsx);
+ expect(screen.getByTestId("initial-contact-id").textContent).toBe("null");
+ expect(mockGetInstance).not.toHaveBeenCalled();
+ });
+
+ it("does not resolve when recordID is not positive", async () => {
+ mockParseToolParams.mockResolvedValue({
+ recordID: -1,
+ pageData: {
+ Table_Name: "Contacts",
+ Primary_Key: "Contact_ID",
+ Contact_ID_Field: "Contact_ID",
+ },
+ });
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({ recordID: "-1" }) });
+ render(jsx);
+ expect(screen.getByTestId("initial-contact-id").textContent).toBe("null");
+ expect(mockGetInstance).not.toHaveBeenCalled();
+ });
+
+ it("does not resolve when pageData is missing required fields", async () => {
+ mockParseToolParams.mockResolvedValue({
+ recordID: 42,
+ pageData: { Table_Name: "Contacts" }, // missing Primary_Key/Contact_ID_Field
+ });
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({ recordID: "42" }) });
+ render(jsx);
+ expect(screen.getByTestId("initial-contact-id").textContent).toBe("null");
+ expect(mockGetInstance).not.toHaveBeenCalled();
+ });
+
+ it("resolves the Contact_ID from the page record when all params are present", async () => {
+ mockParseToolParams.mockResolvedValue({
+ recordID: 42,
+ pageData: {
+ Table_Name: "Households",
+ Primary_Key: "Household_ID",
+ Contact_ID_Field: "Contact_ID",
+ },
+ });
+ mockResolveContactIdFromPage.mockResolvedValue(999);
+
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({ recordID: "42" }) });
+ render(jsx);
+
+ expect(mockResolveContactIdFromPage).toHaveBeenCalledWith(
+ "Households",
+ "Household_ID",
+ 42,
+ "Contact_ID",
+ );
+ expect(screen.getByTestId("initial-contact-id").textContent).toBe("999");
+ });
+
+ it("swallows a resolution failure and renders with initialContactId null", async () => {
+ mockParseToolParams.mockResolvedValue({
+ recordID: 42,
+ pageData: {
+ Table_Name: "Households",
+ Primary_Key: "Household_ID",
+ Contact_ID_Field: "Contact_ID",
+ },
+ });
+ mockResolveContactIdFromPage.mockRejectedValue(new Error("no security role"));
+ const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({ recordID: "42" }) });
+ render(jsx);
+
+ expect(screen.getByTestId("initial-contact-id").textContent).toBe("null");
+ expect(warnSpy).toHaveBeenCalledWith(
+ "Failed to resolve Contact_ID from page record:",
+ expect.any(Error),
+ );
+ });
+
+ it("passes params through to AddEditFamily", async () => {
+ mockParseToolParams.mockResolvedValue({ recordID: undefined, pageID: 292 });
+ const jsx = await AddEditFamilyPage({ searchParams: searchParamsOf({ pageID: "292" }) });
+ render(jsx);
+ expect(screen.getByTestId("params").textContent).toContain("292");
+ });
+
+ it("generateMetadata returns the tool title", async () => {
+ await expect(generateMetadata()).resolves.toEqual({ title: "Add/Edit Family" });
+ });
+});
diff --git a/src/app/(web)/tools/addresslabels/address-labels.test.tsx b/src/app/(web)/tools/addresslabels/address-labels.test.tsx
new file mode 100644
index 0000000..e0a9299
--- /dev/null
+++ b/src/app/(web)/tools/addresslabels/address-labels.test.tsx
@@ -0,0 +1,357 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, cleanup, screen, fireEvent, waitFor } from '@testing-library/react';
+import type { LabelConfig, LabelData, SkipRecord } from '@/lib/dto';
+import type { ToolParams } from '@/lib/tool-params';
+
+const {
+ mockFetchAddressLabels,
+ mockGenerateLabelPdf,
+ mockGenerateLabelDocx,
+ mockRouterBack,
+} = vi.hoisted(() => ({
+ mockFetchAddressLabels: vi.fn(),
+ mockGenerateLabelPdf: vi.fn(),
+ mockGenerateLabelDocx: vi.fn(),
+ mockRouterBack: vi.fn(),
+}));
+
+vi.mock('next/navigation', () => ({
+ useRouter: () => ({
+ back: mockRouterBack,
+ push: vi.fn(),
+ replace: vi.fn(),
+ refresh: vi.fn(),
+ prefetch: vi.fn(),
+ forward: vi.fn(),
+ }),
+}));
+
+vi.mock('@/components/dev-panel', () => ({
+ DevPanel: () => null,
+}));
+
+vi.mock('@/components/address-labels/actions', () => ({
+ fetchAddressLabels: mockFetchAddressLabels,
+ generateLabelPdf: mockGenerateLabelPdf,
+ generateLabelDocx: mockGenerateLabelDocx,
+}));
+
+vi.mock('@/components/address-labels', () => ({
+ AddressLabelsForm: ({
+ config,
+ onChange,
+ maxStartPosition,
+ }: {
+ config: LabelConfig;
+ onChange: (c: LabelConfig) => void;
+ maxStartPosition: number;
+ }) => (
+
+ {JSON.stringify(config)}
+ {maxStartPosition}
+ onChange({ ...config, stockId: '5161' })}>change-stock
+ onChange({ ...config, barcodeFormat: 'imb', mailerId: '123' })}>
+ set-invalid-imb
+
+ onChange({ ...config, barcodeFormat: 'imb', mailerId: '123456789' })}>
+ set-valid-imb
+
+
+ ),
+ AddressLabelsSummary: ({
+ printableCount,
+ skipped,
+ }: {
+ printableCount: number;
+ skipped: SkipRecord[];
+ }) => (
+
+ {printableCount} printable / {skipped.length} skipped
+
+ ),
+}));
+
+vi.mock('@/components/address-labels/mail-merge-tab', () => ({
+ MailMergeTab: ({ printable }: { printable: LabelData[] }) => (
+ merge-tab:{printable.length}
+ ),
+}));
+
+import { AddressLabels } from './address-labels';
+
+const params: ToolParams = { recordID: 1 };
+
+const printableLabel: LabelData = {
+ name: 'Jane Doe',
+ addressLine1: '123 Main St',
+ city: 'Chicago',
+ state: 'IL',
+ postalCode: '60601',
+};
+
+function arrayBufferToBase64(text: string): string {
+ return Buffer.from(text).toString('base64');
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ localStorage.clear();
+ mockFetchAddressLabels.mockResolvedValue({ printable: [printableLabel], skipped: [] });
+ URL.createObjectURL = vi.fn(() => 'blob:mock-url');
+ URL.revokeObjectURL = vi.fn();
+ window.open = vi.fn();
+ HTMLAnchorElement.prototype.click = vi.fn();
+});
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('AddressLabels', () => {
+ it('shows a loading indicator while address data is being fetched', async () => {
+ let resolveFetch!: (v: { printable: LabelData[]; skipped: SkipRecord[] }) => void;
+ mockFetchAddressLabels.mockReturnValue(
+ new Promise((resolve) => {
+ resolveFetch = resolve;
+ })
+ );
+
+ render({JSON.stringify(params)}
+ ),
+}));
+
+import AddressLabelsPage from './page';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('AddressLabelsPage', () => {
+ it('parses search params and renders AddressLabels with the result', async () => {
+ const parsed: ToolParams = { recordID: 42 };
+ mockParseToolParams.mockResolvedValue(parsed);
+
+ const searchParams = Promise.resolve({ recordID: '42' });
+ const ui = await AddressLabelsPage({ searchParams });
+ render(ui);
+
+ expect(mockParseToolParams).toHaveBeenCalledWith({ recordID: '42' });
+ expect(screen.getByTestId('address-labels').textContent).toBe(JSON.stringify(parsed));
+ });
+});
diff --git a/src/app/(web)/tools/fieldmanagement/field-management.test.tsx b/src/app/(web)/tools/fieldmanagement/field-management.test.tsx
new file mode 100644
index 0000000..d038be0
--- /dev/null
+++ b/src/app/(web)/tools/fieldmanagement/field-management.test.tsx
@@ -0,0 +1,314 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, act, fireEvent, waitFor } from '@testing-library/react';
+import { forwardRef, useImperativeHandle } from 'react';
+import type { ToolParams } from '@/lib/tool-params';
+import type { FieldOrderEditorHandle, PageListItem } from '@/components/field-management';
+
+const {
+ mockRouterBack,
+ mockFetchPageFieldData,
+ mockSavePageFieldOrder,
+ mockToastSuccess,
+ mockToastError,
+ mockGetSavePayload,
+ mockMoveHiddenToOther,
+ mockHideAllSeparators,
+ mockOnSelectHolder,
+} = vi.hoisted(() => ({
+ mockRouterBack: vi.fn(),
+ mockFetchPageFieldData: vi.fn(),
+ mockSavePageFieldOrder: vi.fn(),
+ mockToastSuccess: vi.fn(),
+ mockToastError: vi.fn(),
+ mockGetSavePayload: vi.fn(),
+ mockMoveHiddenToOther: vi.fn(),
+ mockHideAllSeparators: vi.fn(),
+ mockOnSelectHolder: { current: undefined as ((page: PageListItem) => void) | undefined },
+}));
+
+vi.mock('next/navigation', () => ({
+ useRouter: () => ({ back: mockRouterBack }),
+}));
+
+vi.mock('@/components/field-management/actions', () => ({
+ fetchPageFieldData: mockFetchPageFieldData,
+ savePageFieldOrder: mockSavePageFieldOrder,
+}));
+
+vi.mock('sonner', () => ({
+ toast: { success: mockToastSuccess, error: mockToastError },
+}));
+
+vi.mock('@/components/tool', () => ({
+ ToolContainer: (props: Record) => (
+
+
{props.footerExtra as React.ReactNode}
+ {!props.hideFooter && (
+
void}>
+ {props.saveLabel as string}
+
+ )}
+
void}>
+ Close
+
+ {props.children as React.ReactNode}
+
;
+ },
+}));
+
+vi.mock('@/components/field-management/field-order-editor', () => ({
+ FieldOrderEditor: forwardRef void }>(
+ function MockFieldOrderEditor({ onDirtyChange }, ref) {
+ useImperativeHandle(ref, () => ({
+ getSavePayload: mockGetSavePayload,
+ moveHiddenToOther: mockMoveHiddenToOther,
+ hideAllSeparators: mockHideAllSeparators,
+ }));
+ return (
+
+ onDirtyChange(true)}>
+ mark dirty
+
+
+ );
+ }
+ ),
+}));
+
+import { FieldManagement } from './field-management';
+
+const params: ToolParams = { pageID: 292 };
+const page: PageListItem = { Page_ID: 292, Display_Name: 'Contacts', Table_Name: 'Contacts' };
+
+async function selectPage() {
+ render(;
groupDisplayMap: Map;
+ onContactSelect: (id: number, name: string) => void;
+ onGroupSelect: (field: string, id: number | null, name: string) => void;
}) => (
{contactDisplayMap.size}
@@ -103,6 +107,20 @@ vi.mock('@/components/group-wizard', async () => {
{name}
))}
+ onContactSelect(99, 'Selected Contact')}
+ >
+ Select Contact
+
+ onGroupSelect('Parent_Group', 55, 'Selected Group')}
+ >
+ Select Group
+
),
StepMeeting: () =>
,
@@ -442,4 +460,209 @@ describe('GroupWizard shell', () => {
// Back button is hidden on step 0
expect(screen.queryByRole('button', { name: /back/i })).not.toBeInTheDocument();
});
+
+ it('shows the thrown-Error message when fetchGroupWizardLookups rejects', async () => {
+ mockFetchGroupWizardLookups.mockRejectedValueOnce(new Error('Lookup service down'));
+ const params: ToolParams = { recordID: -1 };
+ render(
+ {JSON.stringify(params)}
+ {mpTimezone}
+
+ ),
+}));
+
+import GroupWizardPage from './page';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('GroupWizardPage', () => {
+ it('parses search params and MP timezone, forwarding both to GroupWizard', async () => {
+ const parsedParams: ToolParams = { recordID: 5 };
+ mockParseToolParams.mockResolvedValueOnce(parsedParams);
+ mockGetMpTimezone.mockResolvedValueOnce('America/Chicago');
+
+ const jsx = await GroupWizardPage({
+ searchParams: Promise.resolve({ recordID: '5' }),
+ });
+ render(jsx);
+
+ expect(screen.getByTestId('group-wizard-stub')).toBeInTheDocument();
+ expect(screen.getByTestId('params').textContent).toBe(JSON.stringify(parsedParams));
+ expect(screen.getByTestId('mp-timezone').textContent).toBe('America/Chicago');
+ expect(mockParseToolParams).toHaveBeenCalledWith({ recordID: '5' });
+ expect(mockGetMpTimezone).toHaveBeenCalledTimes(1);
+ });
+
+ it('awaits the searchParams promise before parsing', async () => {
+ mockParseToolParams.mockResolvedValueOnce({ recordID: -1 });
+ mockGetMpTimezone.mockResolvedValueOnce('Etc/UTC');
+
+ const rawParams = { pageID: '292' };
+ await GroupWizardPage({ searchParams: Promise.resolve(rawParams) });
+
+ expect(mockParseToolParams).toHaveBeenCalledWith(rawParams);
+ });
+});
diff --git a/src/app/(web)/tools/layout.test.tsx b/src/app/(web)/tools/layout.test.tsx
new file mode 100644
index 0000000..f606db1
--- /dev/null
+++ b/src/app/(web)/tools/layout.test.tsx
@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { isValidElement } from 'react';
+
+/**
+ * ToolsLayout Tests
+ *
+ * This layout is the page-level authorization gate for every route under
+ * /tools. React renders a layout before its children, so a redirect() here
+ * means no tool page component ever runs.
+ *
+ * It is the UX layer, not the security control — enforcement lives in the
+ * server actions and service methods. These tests pin both halves of that
+ * contract: that a permitted user gets their children rendered, and that a
+ * non-permitted user is redirected to /no-access before children are touched.
+ */
+
+const { mockHasSecurityRole, mockRedirect } = vi.hoisted(() => ({
+ mockHasSecurityRole: vi.fn(),
+ mockRedirect: vi.fn((url: string) => {
+ // redirect() throws in real Next.js to abort rendering; mirror that so
+ // code after it doesn't execute in tests.
+ throw new Error(`NEXT_REDIRECT:${url}`);
+ }),
+}));
+
+vi.mock('next/navigation', () => ({
+ redirect: mockRedirect,
+}));
+
+vi.mock('@/services/authorizationService', () => ({
+ AuthorizationService: {
+ getInstance: vi.fn(() => ({
+ hasSecurityRole: mockHasSecurityRole,
+ })),
+ },
+}));
+
+import ToolsLayout from './layout';
+
+describe('ToolsLayout authorization gate', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('renders children when the user holds a security role', async () => {
+ mockHasSecurityRole.mockResolvedValueOnce(true);
+
+ const result = await ToolsLayout({ children: 'tool-content' });
+
+ expect(mockRedirect).not.toHaveBeenCalled();
+ expect(isValidElement(result)).toBe(true);
+ expect(result.props.children).toBe('tool-content');
+ });
+
+ it('redirects to /no-access when the user holds no security role', async () => {
+ mockHasSecurityRole.mockResolvedValueOnce(false);
+
+ await expect(
+ ToolsLayout({ children: 'tool-content' }),
+ ).rejects.toThrow('NEXT_REDIRECT:/no-access');
+
+ expect(mockRedirect).toHaveBeenCalledExactlyOnceWith('/no-access');
+ });
+
+ it('consults the authorization service exactly once per render', async () => {
+ mockHasSecurityRole.mockResolvedValueOnce(true);
+
+ await ToolsLayout({ children: 'tool-content' });
+
+ expect(mockHasSecurityRole).toHaveBeenCalledTimes(1);
+ });
+
+ it('propagates an infrastructure failure rather than rendering the tool', async () => {
+ // hasSecurityRole() is documented to fail closed and return false, but if
+ // it ever throws, the gate must not fall through to rendering children.
+ mockHasSecurityRole.mockRejectedValueOnce(new Error('MP unreachable'));
+
+ await expect(
+ ToolsLayout({ children: 'tool-content' }),
+ ).rejects.toThrow('MP unreachable');
+
+ expect(mockRedirect).not.toHaveBeenCalled();
+ });
+
+ it('does not evaluate children before the gate decides', async () => {
+ // Children arrive as an already-constructed element tree, so the gate
+ // cannot "skip" work — but it must not pass them through on denial.
+ mockHasSecurityRole.mockResolvedValueOnce(false);
+
+ await expect(
+ ToolsLayout({ children: 'tool-content' }),
+ ).rejects.toThrow(/NEXT_REDIRECT/);
+ });
+});
diff --git a/src/app/(web)/tools/template/page.test.tsx b/src/app/(web)/tools/template/page.test.tsx
new file mode 100644
index 0000000..4645172
--- /dev/null
+++ b/src/app/(web)/tools/template/page.test.tsx
@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockParseToolParams } = vi.hoisted(() => ({
+ mockParseToolParams: vi.fn(),
+}));
+
+vi.mock('@/lib/tool-params.server', () => ({
+ parseToolParams: mockParseToolParams,
+}));
+
+vi.mock('./template-tool', () => ({
+ TemplateTool: () => null,
+}));
+
+import TemplateToolPage from './page';
+
+describe('TemplateToolPage', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('awaits searchParams before parsing them', async () => {
+ const raw = { pageID: '312', recordID: '7' };
+ mockParseToolParams.mockResolvedValueOnce({ pageID: 312, recordID: 7 });
+
+ await TemplateToolPage({ searchParams: Promise.resolve(raw) });
+
+ expect(mockParseToolParams).toHaveBeenCalledExactlyOnceWith(raw);
+ });
+
+ it('passes the parsed params through to TemplateTool', async () => {
+ const parsed = { pageID: 312, recordID: 7 };
+ mockParseToolParams.mockResolvedValueOnce(parsed);
+
+ const element = await TemplateToolPage({ searchParams: Promise.resolve({}) });
+
+ expect(element.props.params).toBe(parsed);
+ });
+
+ it('propagates a parse failure rather than rendering with bad params', async () => {
+ mockParseToolParams.mockRejectedValueOnce(new Error('bad params'));
+
+ await expect(
+ TemplateToolPage({ searchParams: Promise.resolve({}) }),
+ ).rejects.toThrow('bad params');
+ });
+});
diff --git a/src/app/(web)/tools/template/template-tool.test.tsx b/src/app/(web)/tools/template/template-tool.test.tsx
new file mode 100644
index 0000000..6f6e637
--- /dev/null
+++ b/src/app/(web)/tools/template/template-tool.test.tsx
@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, act, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+const { mockBack, mockToolContainer } = vi.hoisted(() => ({
+ mockBack: vi.fn(),
+ mockToolContainer: vi.fn(),
+}));
+
+vi.mock('next/navigation', () => ({
+ useRouter: () => ({ back: mockBack }),
+}));
+
+vi.mock('@/components/tool', () => ({
+ ToolContainer: (props: Record) => {
+ mockToolContainer(props);
+ return (
+
+
{props.infoContent as React.ReactNode}
+
void}>save
+
void}>close
+
{String(props.isSaving)}
+ {props.children as React.ReactNode}
+
+
{title}
+
{infoContent}
+ {children}
+
+ form
+
+ ),
+}));
+
+import { TemplateEditor } from './template-editor';
+
+describe('TemplateEditor', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('renders the ToolContainer with the Template Editor title and form', () => {
+ const params: ToolParams = {};
+ render( = {}) {
+ const error = new Error('boom') as Error & { digest?: string };
+ return Object.assign(error, overrides);
+}
+
+describe('GlobalError', () => {
+ it('renders the failure message and a retry control', () => {
+ render({children}
+ ),
+}));
+
+vi.mock('sonner', () => ({
+ Toaster: (props: Record) => {
+ mockToaster(props);
+ return
;
+ },
+}));
+
+import { Providers } from './providers';
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+
+describe('Providers', () => {
+ it('wraps children in the UserProvider', () => {
+ render(
+
+ app-content
+ ,
+ );
+
+ const provider = screen.getByTestId('user-provider');
+ expect(provider).toBeInTheDocument();
+ expect(provider).toHaveTextContent('app-content');
+ });
+
+ it('mounts the Toaster inside the provider so toasts can read user context', () => {
+ render(
+
+ app-content
+ ,
+ );
+
+ expect(screen.getByTestId('user-provider')).toContainElement(screen.getByTestId('toaster'));
+ });
+
+ it('configures the Toaster bottom-right with rich colors', () => {
+ render(
+
+ app-content
+ ,
+ );
+
+ expect(mockToaster).toHaveBeenCalledWith(
+ expect.objectContaining({ position: 'bottom-right', richColors: true }),
+ );
+ });
+});
diff --git a/src/app/session-error/page.test.tsx b/src/app/session-error/page.test.tsx
new file mode 100644
index 0000000..66c2739
--- /dev/null
+++ b/src/app/session-error/page.test.tsx
@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+
+/**
+ * SessionErrorPage is the only escape hatch for an authenticated-but-unusable
+ * session (one with no userGuid). AuthWrapper redirects here, and because the
+ * page sits outside the (web) group it is not itself wrapped — so it cannot
+ * loop. The sign-out form must always render.
+ */
+
+const { mockHandleSignOut } = vi.hoisted(() => ({
+ mockHandleSignOut: vi.fn(),
+}));
+
+vi.mock('@/components/user-menu/actions', () => ({
+ handleSignOut: mockHandleSignOut,
+}));
+
+import SessionErrorPage, { dynamic } from './page';
+
+afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+});
+
+describe('SessionErrorPage', () => {
+ it('is force-dynamic so the per-request CSP nonce is available', () => {
+ // A prerendered page has no request, therefore no nonce, therefore a
+ // blocked bootstrap script — which would leave this page's only
+ // sign-out control non-functional.
+ expect(dynamic).toBe('force-dynamic');
+ });
+
+ it('explains that the MP user link was missing', () => {
+ render() {
mockUseSearchParams.mockReturnValue(sp);
}
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('SignIn page', () => {
let originalLocation: Location;
let locationHref: string;
@@ -280,3 +292,140 @@ describe('SignIn route rendering mode', () => {
expect(source).toMatch(/^["']use client["']/m);
});
});
+
+/**
+ * Error-code classification.
+ *
+ * `describeOAuthError` is not exported, so it is exercised through the rendered
+ * error card. Each branch maps a provider error code to the guidance the user
+ * actually reads — getting this wrong tells people to retry something that
+ * will never succeed, or to contact support for a cancelled sign-in.
+ */
+describe('SignIn OAuth error classification', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockGetSession.mockResolvedValue(null);
+ });
+
+ it.each([
+ 'invalid_request',
+ 'invalid_client',
+ 'invalid_grant',
+ 'unauthorized_client',
+ 'unsupported_response_type',
+ 'invalid_scope',
+ ])('describes %s as a request rejected by the provider', async (code) => {
+ setSearchParams({ error: code });
+
+ render(;
+
+ expect(result.sub).toBe(GUID);
+ expect(result.mpEmail).toBe('person@church.org');
+ });
+
+ it('nulls mpEmail when the profile email is blank', async () => {
+ vi.stubGlobal(
+ 'fetch',
+ vi.fn().mockResolvedValue({
+ ok: true,
+ status: 200,
+ json: vi.fn().mockResolvedValue({ sub: GUID, email: ' ' }),
+ }),
+ );
+
+ const result = (await callGetUserInfo()) as Record;
+
+ expect(result.mpEmail).toBeNull();
+ });
+});
+
+/**
+ * `mapProfileToUser` must refuse to build a user record it cannot tie back to
+ * an MP `dp_Users` row. `getUserInfo` has already validated `sub`, so reaching
+ * the throw means the provider contract changed underneath us — failing loudly
+ * is correct there, unlike in `getUserInfo`.
+ */
+describe('Auth - mapProfileToUser', () => {
+ const GUID = 'ab12cd34-ef56-7890-abcd-ef1234567890';
+
+ function callMapProfileToUser(profile: Record) {
+ const fn = ministryPlatformProviderConfig.mapProfileToUser;
+ if (!fn) throw new Error('mapProfileToUser must be declared');
+ return fn(profile as never) as Record;
+ }
+
+ it('throws when the profile has no usable sub', () => {
+ expect(() => callMapProfileToUser({ email: 'x@y.z' })).toThrow(/no usable sub/i);
+ });
+
+ it('maps sub to userGuid and derives the synthetic email', () => {
+ const mapped = callMapProfileToUser({ sub: GUID });
+
+ expect(mapped.userGuid).toBe(GUID);
+ expect(mapped.email).toBe(syntheticEmailForSub(GUID));
+ });
+
+ it('passes an mpEmail through and defaults it to null', () => {
+ expect(callMapProfileToUser({ sub: GUID, mpEmail: 'real@church.org' }).mpEmail).toBe(
+ 'real@church.org',
+ );
+ expect(callMapProfileToUser({ sub: GUID }).mpEmail).toBeNull();
+ });
+});
diff --git a/src/components/address-labels/actions.test.ts b/src/components/address-labels/actions.test.ts
index c88ea10..7192bac 100644
--- a/src/components/address-labels/actions.test.ts
+++ b/src/components/address-labels/actions.test.ts
@@ -7,6 +7,7 @@ const mockGetAddressForContact = vi.hoisted(() => vi.fn());
const mockToBlob = vi.hoisted(() => vi.fn());
const mockDocxtemplaterRender = vi.hoisted(() => vi.fn());
const mockDocxtemplaterGetZip = vi.hoisted(() => vi.fn());
+const mockImageModuleCtor = vi.hoisted(() => vi.fn());
vi.mock('@/lib/auth', () => ({
auth: {
@@ -91,7 +92,11 @@ vi.mock('pizzip', () => ({
}));
vi.mock('docxtemplater-image', () => ({
- default: class {},
+ default: class {
+ constructor(...args: unknown[]) {
+ mockImageModuleCtor(...args);
+ }
+ },
}));
vi.mock('@/lib/barcode-helpers', () => ({
@@ -109,6 +114,18 @@ import { fetchAddressLabels, generateLabelPdf, mergeTemplate } from './actions';
import type { LabelConfig, LabelData } from '@/lib/dto';
import type { ToolParams } from '@/lib/tool-params';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('fetchAddressLabels', () => {
const defaultConfig: LabelConfig = {
stockId: '5160',
@@ -292,6 +309,51 @@ describe('fetchAddressLabels', () => {
expect(result.skipped).toHaveLength(1);
expect(result.skipped[0].reason).toBe('no_barcode');
});
+
+ it('returns empty results when neither selection nor recordID params are provided', async () => {
+ const params: ToolParams = {};
+ const result = await fetchAddressLabels(params, defaultConfig);
+ expect(result).toEqual({ printable: [], skipped: [] });
+ });
+
+ it('returns empty results in selection mode when the selection has no records', async () => {
+ mockGetSelectionRecordIds.mockResolvedValue([]);
+ const params: ToolParams = { pageID: 292, s: 1, sc: 0 };
+ const result = await fetchAddressLabels(params, defaultConfig);
+ expect(result).toEqual({ printable: [], skipped: [] });
+ expect(mockGetAddressesForContacts).not.toHaveBeenCalled();
+ });
+
+ it('returns empty results in recordID mode when the contact address lookup finds nothing', async () => {
+ mockGetAddressForContact.mockResolvedValue(undefined);
+ const params: ToolParams = { recordID: 7 };
+ const result = await fetchAddressLabels(params, defaultConfig);
+ expect(result).toEqual({ printable: [], skipped: [] });
+ });
+
+ it('sorts multiple printable results by postal code', async () => {
+ mockGetSelectionRecordIds.mockResolvedValue([1, 2]);
+ mockGetAddressesForContacts.mockResolvedValue([
+ {
+ Contact_ID: 1, Display_Name: 'Zeta Person', Household_ID: null,
+ Household_Name: null, Bulk_Mail_Opt_Out: false,
+ Address_Line_1: '1 Z St', City: 'Zeta', 'State/Region': 'TX',
+ Postal_Code: '99999', Bar_Code: '01234567094987654321',
+ },
+ {
+ Contact_ID: 2, Display_Name: 'Alpha Person', Household_ID: null,
+ Household_Name: null, Bulk_Mail_Opt_Out: false,
+ Address_Line_1: '1 A St', City: 'Alpha', 'State/Region': 'TX',
+ Postal_Code: '10000', Bar_Code: '01234567094987654321',
+ },
+ ]);
+
+ const params: ToolParams = { pageID: 292, s: 1, sc: 2 };
+ const config: LabelConfig = { ...defaultConfig, addressMode: 'individual' };
+ const result = await fetchAddressLabels(params, config);
+
+ expect(result.printable.map((p) => p.postalCode)).toEqual(['10000', '99999']);
+ });
});
describe('generateLabelPdf', () => {
@@ -348,6 +410,14 @@ describe('generateLabelPdf', () => {
expect(result.error).toContain('No labels to print');
}
});
+
+ it('returns a validation error and skips PDF rendering for an invalid IMb mailerId', async () => {
+ const labels: LabelData[] = [{ name: 'Test', addressLine1: '123 Main', city: 'Test', state: 'TX', postalCode: '75001' }];
+ const result = await generateLabelPdf(labels, { ...pdfConfig, barcodeFormat: 'imb', mailerId: '123' });
+ expect(result.success).toBe(false);
+ if (!result.success) expect(result.error).toContain('Mailer ID must be exactly 6 or 9 digits');
+ expect(mockToBlob).not.toHaveBeenCalled();
+ });
});
describe('mergeTemplate', () => {
@@ -455,6 +525,47 @@ describe('mergeTemplate', () => {
const result = await mergeTemplate(Buffer.from('x').toString('base64'), labels, mergeConfig);
expect(result.success).toBe(true);
});
+
+ it('returns a validation error and never renders when the IMb mailerId is invalid', async () => {
+ const labels: LabelData[] = [{ name: 'T', addressLine1: 'A', city: 'C', state: 'S', postalCode: '12345' }];
+ const invalidImbConfig: LabelConfig = { ...mergeConfig, barcodeFormat: 'imb', mailerId: '123' };
+
+ const result = await mergeTemplate(Buffer.from('x').toString('base64'), labels, invalidImbConfig);
+
+ expect(result.success).toBe(false);
+ if (!result.success) expect(result.error).toContain('Mailer ID must be exactly 6 or 9 digits');
+ expect(mockDocxtemplaterRender).not.toHaveBeenCalled();
+ });
+
+ it('accepts a valid 9-digit IMb mailerId and proceeds to render', async () => {
+ const labels: LabelData[] = [{ name: 'T', addressLine1: 'A', city: 'C', state: 'S', postalCode: '12345' }];
+ const validImbConfig: LabelConfig = { ...mergeConfig, barcodeFormat: 'imb', mailerId: '123456789' };
+
+ const result = await mergeTemplate(Buffer.from('x').toString('base64'), labels, validImbConfig);
+
+ expect(result.success).toBe(true);
+ expect(mockDocxtemplaterRender).toHaveBeenCalled();
+ });
+
+ it('resolves the getImage/getSize callbacks passed to the image module', async () => {
+ mockImageModuleCtor.mockClear();
+ const labels: LabelData[] = [{ name: 'NoKey', addressLine1: '1 A', city: 'C', state: 'S', postalCode: '12345' }];
+ const result = await mergeTemplate(Buffer.from('x').toString('base64'), labels, mergeConfig);
+ expect(result.success).toBe(true);
+
+ expect(mockImageModuleCtor).toHaveBeenCalled();
+ const [options] = mockImageModuleCtor.mock.calls[0] as [{
+ getImage: (tagValue: unknown) => Buffer;
+ getSize: (img: Buffer | string, tagValue: unknown, tagName: string) => [number, number];
+ }];
+
+ // getImage falls back to an empty buffer for a key with no matching barcode
+ expect(options.getImage('not-a-real-key')).toEqual(Buffer.alloc(0));
+ // getSize returns the Barcode-specific size for the Barcode tag...
+ expect(options.getSize(Buffer.alloc(0), 'barcode_0', 'Barcode')).toEqual([200, 25]);
+ // ...and a generic fallback size for any other tag
+ expect(options.getSize(Buffer.alloc(0), 'x', 'SomeOtherTag')).toEqual([100, 100]);
+ });
});
describe('generateLabelDocx', () => {
@@ -500,6 +611,29 @@ describe('generateLabelDocx', () => {
expect(result.success).toBe(false);
if (!result.success) expect(result.error).toContain('No labels to export');
});
+
+ it('returns a validation error and skips docx rendering for an invalid IMb mailerId', async () => {
+ const { generateLabelDocx } = await import('./actions');
+ const labels: LabelData[] = [{ name: 'Docx', addressLine1: '1 Docx Rd', city: 'Town', state: 'TX', postalCode: '75001' }];
+ const result = await generateLabelDocx(labels, { ...docxConfig, barcodeFormat: 'imb', mailerId: '1234' });
+ expect(result.success).toBe(false);
+ if (!result.success) expect(result.error).toContain('Mailer ID must be exactly 6 or 9 digits');
+ });
+
+ it('returns a generic error when building the docx throws', async () => {
+ const { generateLabelDocx } = await import('./actions');
+ const labels: LabelData[] = [{ name: 'Docx', addressLine1: '1 Docx Rd', city: 'Town', state: 'TX', postalCode: '75001' }];
+ const { preEncodeBarcodes } = await import('@/lib/barcode-helpers');
+ (preEncodeBarcodes as unknown as { mockImplementationOnce: (fn: unknown) => void }).mockImplementationOnce(
+ () => {
+ throw new Error('encode failure');
+ }
+ );
+
+ const result = await generateLabelDocx(labels, docxConfig);
+ expect(result.success).toBe(false);
+ if (!result.success) expect(result.error).toBe('encode failure');
+ });
});
describe('generateLabelPdf error branches', () => {
diff --git a/src/components/address-labels/address-label.test.tsx b/src/components/address-labels/address-label.test.tsx
new file mode 100644
index 0000000..e97b1ed
--- /dev/null
+++ b/src/components/address-labels/address-label.test.tsx
@@ -0,0 +1,109 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, cleanup, screen } from '@testing-library/react';
+
+// react-pdf's View/Text accept array `style` props (merged internally by the
+// PDF renderer); real DOM elements don't support that, so the mock flattens
+// array styles into a single object the way react-pdf effectively does.
+function flattenStyle(style: unknown): Record | undefined {
+ if (Array.isArray(style)) return Object.assign({}, ...style);
+ return style as Record | undefined;
+}
+
+vi.mock('@react-pdf/renderer', () => ({
+ View: ({ style, children, ...props }: { style?: unknown; children?: React.ReactNode }) => (
+ {children}
+ ),
+ Text: ({ style, children, ...props }: { style?: unknown; children?: React.ReactNode }) => (
+ {children}
+ ),
+ StyleSheet: { create: (s: Record) => s },
+}));
+
+vi.mock('./imb-barcode', () => ({
+ ImbBarcode: ({ barStates }: { barStates: string }) => (
+ {barStates}
+ ),
+}));
+
+vi.mock('./postnet-barcode', () => ({
+ PostnetBarcode: ({ barStates }: { barStates: string }) => (
+ {barStates}
+ ),
+}));
+
+import { AddressLabel } from './address-label';
+import type { LabelData } from '@/lib/dto';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+const baseLabel: LabelData = {
+ name: 'Jane Doe',
+ addressLine1: '123 Main St',
+ city: 'Chicago',
+ state: 'IL',
+ postalCode: '60601',
+};
+
+describe('AddressLabel', () => {
+ it('renders name, address line 1, and city/state/zip', () => {
+ render( is unrecognized in this browser".
+ */
+vi.mock('@react-pdf/renderer', () => ({
+ View: 'rpdf-view',
+}));
+
+import { ImbBarcode } from './imb-barcode';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+const VALID_BAR_STATES = 'T'.repeat(65);
+
+describe('ImbBarcode', () => {
+ it('renders null when barStates is empty', () => {
+ const { container } = render({children}
,
+ Page: ({ children }: { children?: React.ReactNode }) => {children}
,
+ View: ({ children, style }: { children?: React.ReactNode; style?: unknown }) => (
+ {children}
+ ),
+ StyleSheet: { create: (s: Record) => s },
+}));
+
+vi.mock('./address-label', () => ({
+ AddressLabel: ({ data }: { data: { name: string } }) => (
+ {data.name}
+ ),
+}));
+
+import { LabelDocument } from './label-document';
+import type { LabelStockConfig } from '@/lib/label-stock';
+import type { LabelData } from '@/lib/dto';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+const stock: LabelStockConfig = {
+ id: '5160',
+ name: 'Avery 5160',
+ pageWidth: 612,
+ pageHeight: 792,
+ labelWidth: 189,
+ labelHeight: 72,
+ columns: 3,
+ rows: 10,
+ marginTop: 36,
+ marginLeft: 13.5,
+ columnGap: 9,
+ rowGap: 0,
+};
+
+function makeLabels(count: number): LabelData[] {
+ return Array.from({ length: count }, (_, i) => ({
+ name: `Label ${i}`,
+ addressLine1: '123 Main St',
+ city: 'Chicago',
+ state: 'IL',
+ postalCode: '60601',
+ }));
+}
+
+describe('LabelDocument', () => {
+ it('renders a single page for labels that fit within one page', () => {
+ const { getAllByTestId } = render(
+ is unrecognized in this browser".
+ */
+vi.mock('@react-pdf/renderer', () => ({
+ View: 'rpdf-view',
+}));
+
+import { PostnetBarcode } from './postnet-barcode';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('PostnetBarcode', () => {
+ it('renders null for invalid JSON', () => {
+ const { container } = render(
,
}));
vi.mock("./panels/user-tools-panel", () => ({
- UserToolsPanel: () =>
,
+ UserToolsPanel: ({ refreshKey }: { refreshKey?: number }) => (
+ {refreshKey}
+ ),
}));
vi.mock("./panels/deploy-tool-panel", () => ({
- DeployToolPanel: () =>
,
+ DeployToolPanel: ({ onDeployed }: { onDeployed?: () => void }) => (
+
+
+ simulate deploy
+
+
+ ),
}));
import { DevPanel } from "./dev-panel";
@@ -97,4 +106,42 @@ describe("DevPanel", () => {
expect(screen.getByTestId("dev-panel")).toBeInTheDocument();
expect(screen.queryByTestId("dev-panel-body")).not.toBeInTheDocument();
});
+
+ it("swallows localStorage write errors when toggled", async () => {
+ const user = userEvent.setup();
+ vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => {
+ throw new Error("quota exceeded");
+ });
+ render({children}
,
+}));
+
+vi.mock('./sortable-field-item', () => ({
+ SortableFieldItem: ({ field }: { field: PageField }) => (
+ {field.Field_Name}
+ ),
+}));
+
+vi.mock('./sortable-group', () => ({
+ SortableGroup: ({ groupName, isPinned, fieldIds }: { groupName: string; isPinned: boolean; fieldIds: number[] }) => (
+
+ {groupName} ({fieldIds.length})
+
+ ),
+}));
+
+vi.mock('./new-group-dialog', () => ({
+ NewGroupDialog: ({
+ open,
+ onCreateGroup,
+ existingGroupNames,
+ }: {
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ onCreateGroup: (name: string) => void;
+ existingGroupNames: string[];
+ }) =>
+ open ? (
+
+ {existingGroupNames.join(',')}
+ onCreateGroup('New Group')}>confirm-create
+
+ ) : null,
+}));
+
+import { FieldOrderEditor } from './field-order-editor';
+
+function makeField(overrides: Partial = {}): PageField {
+ return {
+ Page_Field_ID: 1,
+ Page_ID: 1,
+ Field_Name: 'First_Name',
+ Group_Name: null,
+ View_Order: 1,
+ Required: false,
+ Hidden: false,
+ Default_Value: null,
+ Filter_Clause: null,
+ Depends_On_Field: null,
+ Field_Label: null,
+ Writing_Assistant_Enabled: false,
+ isSeparator: false,
+ ...overrides,
+ };
+}
+
+function defaultState(overrides: Record = {}) {
+ return {
+ groupedFields: { __flat__: [1] },
+ groupOrder: ['__flat__'],
+ fieldLookup: new Map([[1, makeField()]]),
+ isFlat: true,
+ isDirty: false,
+ handleDragStart: mockHandleDragStart,
+ handleDragOver: mockHandleDragOver,
+ handleDragEnd: mockHandleDragEnd,
+ addGroup: mockAddGroup,
+ removeGroup: mockRemoveGroup,
+ moveHiddenToOther: mockMoveHiddenToOther,
+ hideAllSeparators: mockHideAllSeparators,
+ updateField: mockUpdateField,
+ buildSavePayload: mockBuildSavePayload,
+ ...overrides,
+ };
+}
+
+describe('FieldOrderEditor', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockUseFieldOrderState.mockReturnValue(defaultState());
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('renders a flat list of fields with a field/fields count and no group count', () => {
+ render(();
+ mockBuildSavePayload.mockReturnValue([{ Field_Name: 'A' }]);
+
+ render( = {}): PageField {
+ return {
+ Page_Field_ID: 1,
+ Page_ID: 1,
+ Field_Name: 'First_Name',
+ Group_Name: '1 - General',
+ View_Order: 1,
+ Required: false,
+ Hidden: false,
+ Default_Value: null,
+ Filter_Clause: null,
+ Depends_On_Field: null,
+ Field_Label: null,
+ Writing_Assistant_Enabled: false,
+ isSeparator: false,
+ ...overrides,
+ };
+}
+
+describe('SortableFieldItem', () => {
+ beforeEach(() => {
+ mockUseSortable.mockReturnValue({ ref: vi.fn(), isDragging: false });
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('calls useSortable with id/index/group/type derived from props', () => {
+ const field = makeField();
+ render(
+ = {}): PageField {
+ return {
+ Page_Field_ID: 1,
+ Page_ID: 1,
+ Field_Name: 'First_Name',
+ Group_Name: '1 - General',
+ View_Order: 1,
+ Required: false,
+ Hidden: false,
+ Default_Value: null,
+ Filter_Clause: null,
+ Depends_On_Field: null,
+ Field_Label: null,
+ Writing_Assistant_Enabled: false,
+ isSeparator: false,
+ ...overrides,
+ };
+}
+
+describe('SortableGroup', () => {
+ beforeEach(() => {
+ mockUseSortable.mockReturnValue({ ref: vi.fn(), isDragging: false });
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('calls useSortable with id/index/type/accept/collisionPriority/disabled derived from props', () => {
+ render(
+ & { Page_Field_ID: number; Field_Name: string }): PageField {
return {
Page_Field_ID: overrides.Page_Field_ID,
Page_ID: 1,
Field_Name: overrides.Field_Name,
- Group_Name: overrides.Group_Name ?? '1 - General',
+ Group_Name: 'Group_Name' in overrides ? overrides.Group_Name! : '1 - General',
View_Order: overrides.View_Order ?? 1,
Required: overrides.Required ?? false,
Hidden: overrides.Hidden ?? false,
@@ -23,6 +53,10 @@ function makeField(overrides: Partial & { Page_Field_ID: number; Fiel
};
}
+beforeEach(() => {
+ vi.clearAllMocks();
+});
+
describe('useFieldOrderState > hideAllSeparators', () => {
it('flips Hidden to true and moves separators to "99 - Other Fields"', () => {
const fields: PageField[] = [
@@ -109,3 +143,457 @@ describe('useFieldOrderState > hideAllSeparators', () => {
expect(sep?.Group_Name).toBe(OTHER);
});
});
+
+describe('useFieldOrderState > initialization', () => {
+ it('groups flat fields (no Group_Name) under the internal flat bucket, sorted by View_Order', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 2, Field_Name: 'Second', Group_Name: null, View_Order: 2 }),
+ makeField({ Page_Field_ID: 1, Field_Name: 'First', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ expect(result.current.isFlat).toBe(true);
+ expect(result.current.groupOrder).toEqual([FLAT]);
+ expect(result.current.groupedFields[FLAT]).toEqual([1, 2]);
+ });
+
+ it('groups fields by Group_Name, sorting groups numerically with "Other" pinned last', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '10 - Later', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '2 - Earlier', View_Order: 1 }),
+ makeField({ Page_Field_ID: 3, Field_Name: 'C', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ expect(result.current.isFlat).toBe(false);
+ expect(result.current.groupOrder).toEqual(['2 - Earlier', '10 - Later', OTHER]);
+ expect(result.current.groupedFields[OTHER]).toEqual([3]);
+ });
+});
+
+describe('useFieldOrderState > handleDragOver', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - General', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '1 - General', View_Order: 2 }),
+ ];
+
+ it('skips calling move() when the drag source is a group', () => {
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.groupedFields;
+
+ act(() => {
+ result.current.handleDragOver(fakeDragEvent({ operation: { source: { type: 'group' } } }));
+ });
+
+ expect(mockMove).not.toHaveBeenCalled();
+ expect(result.current.groupedFields).toBe(before);
+ });
+
+ it('delegates to move() and applies its result when the source is a field', () => {
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const moved = { '1 - General': [2, 1] };
+ mockMove.mockReturnValue(moved);
+
+ const event = { operation: { source: { type: 'field', id: 1 }, target: { id: 2 } } };
+ act(() => {
+ result.current.handleDragOver(fakeDragEvent(event));
+ });
+
+ expect(mockMove).toHaveBeenCalledWith({ '1 - General': [1, 2] }, event);
+ expect(result.current.groupedFields).toEqual(moved);
+ });
+});
+
+describe('useFieldOrderState > handleDragEnd', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - General', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '2 - Second', View_Order: 1 }),
+ ];
+
+ it('restores the pre-drag snapshot when the drag is canceled', () => {
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.handleDragStart();
+ });
+ // Mutate state after the snapshot was taken, simulating an in-flight drag.
+ mockMove.mockReturnValue({ '1 - General': [], '2 - Second': [1, 2] });
+ act(() => {
+ result.current.handleDragOver(fakeDragEvent({ operation: { source: { type: 'field', id: 1 }, target: { id: 2 } } }));
+ });
+ expect(result.current.groupedFields).toEqual({ '1 - General': [], '2 - Second': [1, 2] });
+
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({ canceled: true, operation: { source: { type: 'field' } } }));
+ });
+
+ expect(result.current.groupedFields).toEqual({ '1 - General': [1], '2 - Second': [2] });
+ expect(result.current.groupOrder).toEqual(['1 - General', '2 - Second']);
+ expect(result.current.isDirty).toBe(false);
+ });
+
+ it('reorders groupOrder and re-pins "Other Fields" last when a group handle is dropped', () => {
+ const groupedFields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '2 - Second', View_Order: 1 }),
+ makeField({ Page_Field_ID: 3, Field_Name: 'C', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(groupedFields));
+ expect(result.current.groupOrder).toEqual(['1 - First', '2 - Second', OTHER]);
+
+ mockIsSortable.mockReturnValue(true);
+ mockMove.mockReturnValue([OTHER, '1 - First', '2 - Second']);
+
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({
+ canceled: false,
+ operation: { source: { type: 'group', id: OTHER }, target: { id: '1 - First' } },
+ }));
+ });
+
+ // "Other Fields" must be pulled back to the end even though move() put it first.
+ expect(result.current.groupOrder).toEqual(['1 - First', '2 - Second', OTHER]);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('leaves groupOrder untouched when isSortable() is false, even if source.type is "group"', () => {
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.groupOrder;
+ mockIsSortable.mockReturnValue(false);
+
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({
+ canceled: false,
+ operation: { source: { type: 'group' }, target: { id: '2 - Second' } },
+ }));
+ });
+
+ expect(mockMove).not.toHaveBeenCalled();
+ expect(result.current.groupOrder).toBe(before);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('only marks dirty (no groupOrder change) when the source is a plain field, not a group', () => {
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.groupOrder;
+ mockIsSortable.mockReturnValue(true);
+
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({
+ canceled: false,
+ operation: { source: { type: 'field' }, target: { id: 2 } },
+ }));
+ });
+
+ expect(mockMove).not.toHaveBeenCalled();
+ expect(result.current.groupOrder).toBe(before);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('does not re-splice when "Other Fields" is already last after the group move', () => {
+ const groupedFields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(groupedFields));
+
+ mockIsSortable.mockReturnValue(true);
+ mockMove.mockReturnValue(['1 - First', OTHER]);
+
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({
+ canceled: false,
+ operation: { source: { type: 'group' }, target: { id: '1 - First' } },
+ }));
+ });
+
+ expect(result.current.groupOrder).toEqual(['1 - First', OTHER]);
+ });
+});
+
+describe('useFieldOrderState > addGroup', () => {
+ it('transitions flat fields into a new group, moving all flat fields into "Other Fields"', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: null, View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: null, View_Order: 2 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ expect(result.current.isFlat).toBe(true);
+
+ act(() => {
+ result.current.addGroup('1 - New Group');
+ });
+
+ expect(result.current.isFlat).toBe(false);
+ expect(result.current.groupedFields).toEqual({
+ '1 - New Group': [],
+ [OTHER]: [1, 2],
+ });
+ expect(result.current.groupOrder).toEqual(['1 - New Group', OTHER]);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('inserts a new group before "Other Fields" when already grouped', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.addGroup('2 - New');
+ });
+
+ expect(result.current.groupOrder).toEqual(['1 - First', '2 - New', OTHER]);
+ expect(result.current.groupedFields['2 - New']).toEqual([]);
+ });
+
+ it('appends the new group at the end when there is no "Other Fields" group yet', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.addGroup('2 - New');
+ });
+
+ expect(result.current.groupOrder).toEqual(['1 - First', '2 - New']);
+ });
+});
+
+describe('useFieldOrderState > removeGroup', () => {
+ it('removes an empty group from both groupedFields and groupOrder', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.addGroup('2 - Empty');
+ });
+ expect(result.current.groupedFields['2 - Empty']).toEqual([]);
+
+ act(() => {
+ result.current.removeGroup('2 - Empty');
+ });
+
+ expect(result.current.groupedFields['2 - Empty']).toBeUndefined();
+ expect(result.current.groupOrder).not.toContain('2 - Empty');
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('is a no-op on groupedFields when the group still has fields, but still removes it from groupOrder', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.removeGroup('1 - First');
+ });
+
+ // Documented actual behavior: groupedFields keeps the non-empty group (guard
+ // in removeGroup refuses to drop its fields), but groupOrder unconditionally
+ // filters the name out regardless of that guard — see filed TODO
+ // 2026-09-13-removegroup-order-guard-mismatch.md.
+ expect(result.current.groupedFields['1 - First']).toEqual([1]);
+ expect(result.current.groupOrder).not.toContain('1 - First');
+
+ // Consequence: buildSavePayload iterates groupOrder, so field 1 is silently
+ // dropped from the save payload even though it still exists in groupedFields.
+ const payload = result.current.buildSavePayload();
+ expect(payload.find((p) => p.Field_Name === 'A')).toBeUndefined();
+ });
+
+ it('is a no-op when the group name does not exist in groupedFields at all', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.groupedFields;
+
+ act(() => {
+ result.current.removeGroup('Never Existed');
+ });
+
+ expect(result.current.groupedFields).toEqual(before);
+ expect(result.current.isDirty).toBe(true);
+ });
+});
+
+describe('useFieldOrderState > moveHiddenToOther', () => {
+ it('moves hidden fields from every group into "Other Fields", appending after existing Other fields', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1, Hidden: false }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '1 - First', View_Order: 2, Hidden: true }),
+ makeField({ Page_Field_ID: 3, Field_Name: 'C', Group_Name: OTHER, View_Order: 3, Hidden: false }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.moveHiddenToOther();
+ });
+
+ expect(result.current.groupedFields['1 - First']).toEqual([1]);
+ expect(result.current.groupedFields[OTHER]).toEqual([3, 2]);
+ expect(result.current.groupOrder).toContain(OTHER);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('is a no-op when nothing is hidden', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1, Hidden: false }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.groupedFields;
+
+ act(() => {
+ result.current.moveHiddenToOther();
+ });
+
+ expect(result.current.groupedFields).toBe(before);
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('adds "Other Fields" to groupOrder if it was not already present', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: null, View_Order: 1, Hidden: true }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ // Flat mode: groupOrder is [FLAT] and does not include OTHER yet.
+ expect(result.current.groupOrder).not.toContain(OTHER);
+
+ act(() => {
+ result.current.moveHiddenToOther();
+ });
+
+ expect(result.current.groupOrder).toContain(OTHER);
+ });
+});
+
+describe('useFieldOrderState > updateField', () => {
+ it('merges updates into the existing field and marks dirty', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1, Required: false }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.updateField(1, { Required: true });
+ });
+
+ expect(result.current.fieldLookup.get(1)?.Required).toBe(true);
+ expect(result.current.fieldLookup.get(1)?.Field_Name).toBe('A');
+ expect(result.current.isDirty).toBe(true);
+ });
+
+ it('no-ops when the field id is unknown, but still marks dirty', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+ const before = result.current.fieldLookup;
+
+ act(() => {
+ result.current.updateField(999, { Required: true });
+ });
+
+ expect(result.current.fieldLookup).toBe(before);
+ expect(result.current.isDirty).toBe(true);
+ });
+});
+
+describe('useFieldOrderState > buildSavePayload', () => {
+ it('resolves group names to null for flat mode', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: null, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ const payload = result.current.buildSavePayload();
+ expect(payload).toEqual([
+ expect.objectContaining({ Field_Name: 'A', Group_Name: null, View_Order: 1 }),
+ ]);
+ });
+
+ it('renumbers named groups sequentially and keeps "Other Fields" as-is, skipping unknown field ids', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '5 - First', View_Order: 1 }),
+ makeField({ Page_Field_ID: 2, Field_Name: 'B', Group_Name: '10 - Second', View_Order: 1 }),
+ makeField({ Page_Field_ID: 3, Field_Name: 'C', Group_Name: OTHER, View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ const payload = result.current.buildSavePayload();
+ const byName = Object.fromEntries(payload.map((p) => [p.Field_Name, p]));
+
+ expect(byName['A'].Group_Name).toBe('1 - First');
+ expect(byName['B'].Group_Name).toBe('2 - Second');
+ expect(byName['C'].Group_Name).toBe(OTHER);
+ // View_Order increments continuously across groups regardless of renumbering.
+ expect(payload.map((p) => p.View_Order)).toEqual([1, 2, 3]);
+ });
+
+ it('falls back to an empty field list for a group present in groupOrder but absent from groupedFields', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ // Drive groupOrder to include a name with no corresponding groupedFields entry
+ // via the mocked move() used by the group-reorder path in handleDragEnd.
+ mockIsSortable.mockReturnValue(true);
+ mockMove.mockReturnValue(['1 - First', 'Ghost Group']);
+ act(() => {
+ result.current.handleDragEnd(fakeDragEvent({
+ canceled: false,
+ operation: { source: { type: 'group' }, target: { id: '1 - First' } },
+ }));
+ });
+ expect(result.current.groupOrder).toContain('Ghost Group');
+ expect(result.current.groupedFields['Ghost Group']).toBeUndefined();
+
+ const payload = result.current.buildSavePayload();
+ expect(payload).toHaveLength(1);
+ expect(payload[0].Field_Name).toBe('A');
+ });
+
+ it('skips a field id present in a group array but missing from fieldLookup', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'A', Group_Name: '1 - First', View_Order: 1 }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ // Inject a dangling field id (999) into the group via the mocked move() used
+ // by the field-reorder path in handleDragOver.
+ mockMove.mockReturnValue({ '1 - First': [1, 999] });
+ act(() => {
+ result.current.handleDragOver(fakeDragEvent({ operation: { source: { type: 'field', id: 1 }, target: { id: 1 } } }));
+ });
+ expect(result.current.groupedFields['1 - First']).toEqual([1, 999]);
+
+ const payload = result.current.buildSavePayload();
+ expect(payload).toHaveLength(1);
+ expect(payload[0].Field_Name).toBe('A');
+ });
+});
+
+describe('useFieldOrderState > hideAllSeparators idempotency', () => {
+ it('leaves an already-hidden separator untouched on a second call', () => {
+ const fields: PageField[] = [
+ makeField({ Page_Field_ID: 1, Field_Name: 'Sep_A', Group_Name: '1 - General', View_Order: 1, isSeparator: true }),
+ ];
+ const { result } = renderHook(() => useFieldOrderState(fields));
+
+ act(() => {
+ result.current.hideAllSeparators();
+ });
+ expect(result.current.fieldLookup.get(1)?.Hidden).toBe(true);
+
+ act(() => {
+ result.current.hideAllSeparators();
+ });
+ expect(result.current.fieldLookup.get(1)?.Hidden).toBe(true);
+ });
+});
diff --git a/src/components/group-wizard/contact-search.test.tsx b/src/components/group-wizard/contact-search.test.tsx
new file mode 100644
index 0000000..bf8dbbd
--- /dev/null
+++ b/src/components/group-wizard/contact-search.test.tsx
@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent, act } from '@testing-library/react';
+
+const { mockSearchContacts } = vi.hoisted(() => ({
+ mockSearchContacts: vi.fn(),
+}));
+
+vi.mock('./actions', () => ({
+ searchContacts: mockSearchContacts,
+}));
+
+import { ContactSearch } from './contact-search';
+
+async function flush() {
+ await act(async () => {
+ await Promise.resolve();
+ });
+}
+
+async function advanceDebounce(ms = 300) {
+ await act(async () => {
+ vi.advanceTimersByTime(ms);
+ await Promise.resolve();
+ });
+}
+
+describe('ContactSearch', () => {
+ beforeEach(() => {
+ // jsdom does not implement scrollIntoView; cmdk calls it on selection change.
+ Element.prototype.scrollIntoView = vi.fn();
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+ mockSearchContacts.mockReset();
+ mockSearchContacts.mockResolvedValue([]);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.useRealTimers();
+ vi.restoreAllMocks();
+ });
+
+ it('shows the fixed placeholder when closed with no value', () => {
+ render( }) {
+ const form = useForm({
+ resolver: zodResolver(groupWizardSchema),
+ defaultValues: { ...GROUP_WIZARD_DEFAULTS, ...overrides } as GroupWizardFormData,
+ mode: 'onTouched',
+ });
+ return (
+
+ {
+ void form.trigger(['Target_Size']);
+ }}
+ >
+ validate
+
+
+ );
+}
+
+function renderStep(overrides?: Partial) {
+ return render(, comboboxIndex: number, optionName: string) {
+ const comboboxes = screen.getAllByRole('combobox');
+ await user.click(comboboxes[comboboxIndex]);
+ const option = await screen.findByRole('option', { name: optionName });
+ await user.click(option);
+}
+
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
+describe('StepAttributes', () => {
+ it('renders all attribute fields', () => {
+ renderStep();
+ expect(screen.getByText('Group Attributes')).toBeInTheDocument();
+ expect(screen.getByLabelText(/Target Size/)).toBeInTheDocument();
+ expect(screen.getByText('Life Stage')).toBeInTheDocument();
+ expect(screen.getByText('Group Focus')).toBeInTheDocument();
+ expect(screen.getByText('Required Book')).toBeInTheDocument();
+ expect(screen.getByText('SMS Number')).toBeInTheDocument();
+ expect(screen.getByText('Group Is Full')).toBeInTheDocument();
+ });
+
+ it('enters a target size and converts it to a number', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ const input = screen.getByLabelText(/Target Size/);
+ await user.type(input, '12');
+ expect(input).toHaveValue(12);
+ });
+
+ it('clears the target size back to null', async () => {
+ const user = userEvent.setup();
+ renderStep({ Target_Size: 12 });
+ const input = screen.getByLabelText(/Target Size/);
+ await user.clear(input);
+ expect(input).toHaveValue(null);
+ });
+
+ it('rejects a non-positive Target_Size on validation', async () => {
+ const user = userEvent.setup();
+ renderStep({ Target_Size: 0 });
+ await user.click(screen.getByTestId('trigger-validate'));
+ expect(await screen.findByText('Must be a positive number')).toBeInTheDocument();
+ });
+
+ it('selects a life stage', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 0, 'Youth');
+ expect(screen.getAllByRole('combobox')[0]).toHaveTextContent('Youth');
+ });
+
+ it('selects a group focus', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 1, 'Support');
+ expect(screen.getAllByRole('combobox')[1]).toHaveTextContent('Support');
+ });
+
+ it('selects a required book', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 2, 'Book B');
+ expect(screen.getAllByRole('combobox')[2]).toHaveTextContent('Book B');
+ });
+
+ it('selects an SMS number', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 3, '555-0200');
+ expect(screen.getAllByRole('combobox')[3]).toHaveTextContent('555-0200');
+ });
+
+ it('toggles Group Is Full switch', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ const toggle = screen.getByRole('switch');
+ expect(toggle).toHaveAttribute('data-state', 'unchecked');
+ await user.click(toggle);
+ expect(toggle).toHaveAttribute('data-state', 'checked');
+ });
+
+ it('renders with Group_Is_Full already true', () => {
+ renderStep({ Group_Is_Full: true });
+ expect(screen.getByRole('switch')).toHaveAttribute('data-state', 'checked');
+ });
+
+ it('renders with pre-selected lookup values', () => {
+ renderStep({ Life_Stage_ID: 1, Group_Focus_ID: 2, Required_Book: 1, SMS_Number: 2 });
+ const comboboxes = screen.getAllByRole('combobox');
+ expect(comboboxes[0]).toHaveTextContent('Adult');
+ expect(comboboxes[1]).toHaveTextContent('Support');
+ expect(comboboxes[2]).toHaveTextContent('Book A');
+ expect(comboboxes[3]).toHaveTextContent('555-0200');
+ });
+});
diff --git a/src/components/group-wizard/step-attributes.tsx b/src/components/group-wizard/step-attributes.tsx
index 97132b0..f8dc1b1 100644
--- a/src/components/group-wizard/step-attributes.tsx
+++ b/src/components/group-wizard/step-attributes.tsx
@@ -67,7 +67,7 @@ export function StepAttributes({ lookups }: StepAttributesProps) {
Life Stage
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -95,7 +95,7 @@ export function StepAttributes({ lookups }: StepAttributesProps) {
Group Focus
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -123,7 +123,7 @@ export function StepAttributes({ lookups }: StepAttributesProps) {
Required Book
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -151,7 +151,7 @@ export function StepAttributes({ lookups }: StepAttributesProps) {
SMS Number
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
diff --git a/src/components/group-wizard/step-identity.test.tsx b/src/components/group-wizard/step-identity.test.tsx
new file mode 100644
index 0000000..52812b7
--- /dev/null
+++ b/src/components/group-wizard/step-identity.test.tsx
@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useForm, FormProvider } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { StepIdentity } from './step-identity';
+import { groupWizardSchema, GROUP_WIZARD_DEFAULTS, type GroupWizardFormData } from './schema';
+import type { GroupWizardLookups } from './types';
+
+// Radix Select relies on pointer-capture / scrollIntoView APIs jsdom does not
+// implement — stub them so the popover content actually opens in tests.
+beforeEach(() => {
+ Element.prototype.hasPointerCapture = Element.prototype.hasPointerCapture || (() => false);
+ Element.prototype.setPointerCapture = Element.prototype.setPointerCapture || (() => {});
+ Element.prototype.releasePointerCapture = Element.prototype.releasePointerCapture || (() => {});
+ Element.prototype.scrollIntoView = Element.prototype.scrollIntoView || (() => {});
+});
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+const LOOKUPS: GroupWizardLookups = {
+ groupTypes: [
+ { id: 1, name: 'Small Group' },
+ { id: 2, name: 'Class' },
+ ],
+ ministries: [],
+ congregations: [],
+ meetingDays: [],
+ meetingFrequencies: [],
+ meetingDurations: [],
+ lifeStages: [],
+ groupFocuses: [],
+ priorities: [],
+ rooms: [],
+ books: [],
+ smsNumbers: [],
+ groupEndedReasons: [
+ { id: 1, name: 'Moved' },
+ { id: 2, name: 'Disbanded' },
+ ],
+};
+
+function Harness({ overrides }: { overrides?: Partial }) {
+ const form = useForm({
+ resolver: zodResolver(groupWizardSchema),
+ defaultValues: { ...GROUP_WIZARD_DEFAULTS, ...overrides } as GroupWizardFormData,
+ mode: 'onTouched',
+ });
+ return (
+
+ {
+ void form.trigger(['Group_Name', 'Group_Type_ID', 'Start_Date']);
+ }}
+ >
+ validate
+
+
+ );
+}
+
+function renderStep(overrides?: Partial) {
+ return render(Group Type *
field.onChange(Number(val))}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -125,7 +125,7 @@ export function StepIdentity({ lookups }: StepIdentityProps) {
Reason Ended
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
diff --git a/src/components/group-wizard/step-meeting.test.tsx b/src/components/group-wizard/step-meeting.test.tsx
new file mode 100644
index 0000000..2e1627f
--- /dev/null
+++ b/src/components/group-wizard/step-meeting.test.tsx
@@ -0,0 +1,157 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useForm, FormProvider } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { StepMeeting } from './step-meeting';
+import { groupWizardSchema, GROUP_WIZARD_DEFAULTS, type GroupWizardFormData } from './schema';
+import type { GroupWizardLookups } from './types';
+
+beforeEach(() => {
+ Element.prototype.hasPointerCapture = Element.prototype.hasPointerCapture || (() => false);
+ Element.prototype.setPointerCapture = Element.prototype.setPointerCapture || (() => {});
+ Element.prototype.releasePointerCapture = Element.prototype.releasePointerCapture || (() => {});
+ Element.prototype.scrollIntoView = Element.prototype.scrollIntoView || (() => {});
+});
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+const LOOKUPS: GroupWizardLookups = {
+ groupTypes: [],
+ ministries: [],
+ congregations: [],
+ meetingDays: [
+ { id: 1, name: 'Sunday' },
+ { id: 2, name: 'Monday' },
+ ],
+ meetingFrequencies: [
+ { id: 1, name: 'Weekly' },
+ { id: 2, name: 'Biweekly' },
+ ],
+ meetingDurations: [
+ { id: 1, name: '1 hour' },
+ { id: 2, name: '2 hours' },
+ ],
+ lifeStages: [],
+ groupFocuses: [],
+ priorities: [],
+ rooms: [
+ { id: 1, name: 'Room A' },
+ { id: 2, name: 'Room B' },
+ ],
+ books: [],
+ smsNumbers: [],
+ groupEndedReasons: [],
+};
+
+function Harness({ overrides }: { overrides?: Partial }) {
+ const form = useForm({
+ resolver: zodResolver(groupWizardSchema),
+ defaultValues: { ...GROUP_WIZARD_DEFAULTS, ...overrides } as GroupWizardFormData,
+ mode: 'onTouched',
+ });
+ return (
+
+
+ );
+}
+
+function renderStep(overrides?: Partial) {
+ return render(, comboboxIndex: number, optionName: string) {
+ const comboboxes = screen.getAllByRole('combobox');
+ await user.click(comboboxes[comboboxIndex]);
+ const option = await screen.findByRole('option', { name: optionName });
+ await user.click(option);
+}
+
+describe('StepMeeting', () => {
+ it('renders all meeting fields', () => {
+ renderStep();
+ expect(screen.getByText('Meeting Schedule')).toBeInTheDocument();
+ expect(screen.getByText('Meeting Day')).toBeInTheDocument();
+ expect(screen.getByLabelText(/Meeting Time/)).toBeInTheDocument();
+ expect(screen.getByText('Meeting Frequency')).toBeInTheDocument();
+ expect(screen.getByText('Meeting Duration')).toBeInTheDocument();
+ expect(screen.getByLabelText(/Default Meeting Room/)).toBeInTheDocument();
+ expect(screen.getByLabelText(/Offsite Meeting Address/)).toBeInTheDocument();
+ expect(screen.getByText('Meets Online')).toBeInTheDocument();
+ });
+
+ it('selects a meeting day', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 0, 'Monday');
+ expect(screen.getAllByRole('combobox')[0]).toHaveTextContent('Monday');
+ });
+
+ it('selects a meeting frequency', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 1, 'Biweekly');
+ expect(screen.getAllByRole('combobox')[1]).toHaveTextContent('Biweekly');
+ });
+
+ it('selects a meeting duration', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 2, '2 hours');
+ expect(screen.getAllByRole('combobox')[2]).toHaveTextContent('2 hours');
+ });
+
+ it('selects a default meeting room', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 3, 'Room B');
+ expect(screen.getAllByRole('combobox')[3]).toHaveTextContent('Room B');
+ });
+
+ it('sets a meeting time', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ const time = screen.getByLabelText(/Meeting Time/);
+ await user.type(time, '09:30');
+ expect(time).toHaveValue('09:30');
+ });
+
+ it('enters a numeric offsite address and converts to a number', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ const addr = screen.getByLabelText(/Offsite Meeting Address/);
+ await user.type(addr, '55');
+ expect(addr).toHaveValue(55);
+ });
+
+ it('clears the offsite address back to empty/null', async () => {
+ const user = userEvent.setup();
+ renderStep({ Offsite_Meeting_Address: 55 });
+ const addr = screen.getByLabelText(/Offsite Meeting Address/);
+ await user.clear(addr);
+ expect(addr).toHaveValue(null);
+ });
+
+ it('toggles Meets Online switch on', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ const toggle = screen.getByRole('switch');
+ expect(toggle).toHaveAttribute('data-state', 'unchecked');
+ await user.click(toggle);
+ expect(toggle).toHaveAttribute('data-state', 'checked');
+ });
+
+ it('renders with a pre-set meeting time value', () => {
+ renderStep({ Meeting_Time: '14:00' });
+ expect(screen.getByLabelText(/Meeting Time/)).toHaveValue('14:00');
+ });
+
+ it('renders with Meets_Online already true', () => {
+ renderStep({ Meets_Online: true });
+ expect(screen.getByRole('switch')).toHaveAttribute('data-state', 'checked');
+ });
+});
diff --git a/src/components/group-wizard/step-meeting.tsx b/src/components/group-wizard/step-meeting.tsx
index 0cb7159..1902102 100644
--- a/src/components/group-wizard/step-meeting.tsx
+++ b/src/components/group-wizard/step-meeting.tsx
@@ -46,7 +46,7 @@ export function StepMeeting({ lookups }: StepMeetingProps) {
Meeting Day
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -92,7 +92,7 @@ export function StepMeeting({ lookups }: StepMeetingProps) {
Meeting Frequency
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -120,7 +120,7 @@ export function StepMeeting({ lookups }: StepMeetingProps) {
Meeting Duration
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -148,7 +148,7 @@ export function StepMeeting({ lookups }: StepMeetingProps) {
Default Meeting Room
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
diff --git a/src/components/group-wizard/step-organization.test.tsx b/src/components/group-wizard/step-organization.test.tsx
new file mode 100644
index 0000000..be607e9
--- /dev/null
+++ b/src/components/group-wizard/step-organization.test.tsx
@@ -0,0 +1,212 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useForm, FormProvider } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { groupWizardSchema, GROUP_WIZARD_DEFAULTS, type GroupWizardFormData } from './schema';
+import type { GroupWizardLookups } from './types';
+
+beforeEach(() => {
+ Element.prototype.hasPointerCapture = Element.prototype.hasPointerCapture || (() => false);
+ Element.prototype.setPointerCapture = Element.prototype.setPointerCapture || (() => {});
+ Element.prototype.releasePointerCapture = Element.prototype.releasePointerCapture || (() => {});
+ Element.prototype.scrollIntoView = Element.prototype.scrollIntoView || (() => {});
+});
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+// StepOrganization's own search UX (debounce, no-results, error states) is
+// covered by contact-search.test.tsx / group-search.test.tsx directly. Here we
+// only need stubs that let us drive the onSelect callbacks this step wires up.
+vi.mock('./contact-search', () => ({
+ ContactSearch: ({
+ onSelect,
+ displayName,
+ }: {
+ onSelect: (id: number, name: string) => void;
+ displayName?: string;
+ }) => (
+
+ {displayName ?? ''}
+ onSelect(42, 'Jane Doe')}>
+ pick-contact
+
+
+ ),
+}));
+
+vi.mock('./group-search', () => ({
+ GroupSearch: ({
+ onSelect,
+ displayName,
+ placeholder,
+ }: {
+ onSelect: (id: number | null, name: string) => void;
+ displayName?: string;
+ placeholder?: string;
+ }) => (
+
+ {displayName ?? ''}
+ onSelect(77, 'Parent Group Name')}>
+ pick-group
+
+ onSelect(null, '')}>
+ clear-group
+
+
+ ),
+}));
+
+import { StepOrganization } from './step-organization';
+
+const LOOKUPS: GroupWizardLookups = {
+ groupTypes: [],
+ ministries: [
+ { id: 1, name: 'Youth Ministry' },
+ { id: 2, name: 'Adult Ministry' },
+ ],
+ congregations: [
+ { id: 1, name: 'Main Campus' },
+ { id: 2, name: 'East Campus' },
+ ],
+ meetingDays: [],
+ meetingFrequencies: [],
+ meetingDurations: [],
+ lifeStages: [],
+ groupFocuses: [],
+ priorities: [
+ { id: 1, name: 'High' },
+ { id: 2, name: 'Low' },
+ ],
+ rooms: [],
+ books: [],
+ smsNumbers: [],
+ groupEndedReasons: [],
+};
+
+function Harness({
+ overrides,
+ onContactSelect = vi.fn(),
+ onGroupSelect = vi.fn(),
+ contactDisplayMap = new Map(),
+ groupDisplayMap = new Map(),
+}: {
+ overrides?: Partial;
+ onContactSelect?: (id: number, name: string) => void;
+ onGroupSelect?: (field: string, id: number | null, name: string) => void;
+ contactDisplayMap?: Map;
+ groupDisplayMap?: Map;
+}) {
+ const form = useForm({
+ resolver: zodResolver(groupWizardSchema),
+ defaultValues: { ...GROUP_WIZARD_DEFAULTS, ...overrides } as GroupWizardFormData,
+ mode: 'onTouched',
+ });
+ return (
+
+ {
+ void form.trigger(['Congregation_ID', 'Ministry_ID', 'Primary_Contact']);
+ }}
+ >
+ validate
+
+
+ );
+}
+
+function renderStep(props: Parameters[0] = {}) {
+ return render(, comboboxIndex: number, optionName: string) {
+ const comboboxes = screen.getAllByRole('combobox');
+ await user.click(comboboxes[comboboxIndex]);
+ const option = await screen.findByRole('option', { name: optionName });
+ await user.click(option);
+}
+
+describe('StepOrganization', () => {
+ it('renders all organization fields', () => {
+ renderStep();
+ expect(screen.getByText('Organization & People')).toBeInTheDocument();
+ expect(screen.getByText(/Congregation/)).toBeInTheDocument();
+ expect(screen.getByText(/Ministry/)).toBeInTheDocument();
+ expect(screen.getByText(/Primary Contact/)).toBeInTheDocument();
+ expect(screen.getByText('Parent Group')).toBeInTheDocument();
+ expect(screen.getByText('Priority')).toBeInTheDocument();
+ });
+
+ it('selects a congregation', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 0, 'East Campus');
+ expect(screen.getAllByRole('combobox')[0]).toHaveTextContent('East Campus');
+ });
+
+ it('selects a ministry', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 1, 'Adult Ministry');
+ expect(screen.getAllByRole('combobox')[1]).toHaveTextContent('Adult Ministry');
+ });
+
+ it('selects a priority', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await selectOption(user, 2, 'High');
+ expect(screen.getAllByRole('combobox')[2]).toHaveTextContent('High');
+ });
+
+ it('picks a primary contact via ContactSearch and notifies the parent', async () => {
+ const user = userEvent.setup();
+ const onContactSelect = vi.fn();
+ renderStep({ onContactSelect });
+ await user.click(screen.getByText('pick-contact'));
+ expect(onContactSelect).toHaveBeenCalledWith(42, 'Jane Doe');
+ });
+
+ it('picks a parent group via GroupSearch and notifies the parent with the field name', async () => {
+ const user = userEvent.setup();
+ const onGroupSelect = vi.fn();
+ renderStep({ onGroupSelect });
+ const stub = screen.getByTestId('group-search-stub-Search parent group...');
+ await user.click(within(stub).getByText('pick-group'));
+ expect(onGroupSelect).toHaveBeenCalledWith('Parent_Group', 77, 'Parent Group Name');
+ });
+
+ it('clears the parent group selection', async () => {
+ const user = userEvent.setup();
+ const onGroupSelect = vi.fn();
+ renderStep({ onGroupSelect, overrides: { Parent_Group: 77 } });
+ const stub = screen.getByTestId('group-search-stub-Search parent group...');
+ await user.click(within(stub).getByText('clear-group'));
+ expect(onGroupSelect).toHaveBeenCalledWith('Parent_Group', null, '');
+ });
+
+ it('renders the contact display name from the map', () => {
+ renderStep({ contactDisplayMap: new Map([[42, 'Jane Doe']]), overrides: { Primary_Contact: 42 } });
+ expect(screen.getByTestId('contact-display-name')).toHaveTextContent('Jane Doe');
+ });
+
+ it('shows required-field validation errors when validated empty', async () => {
+ const user = userEvent.setup();
+ renderStep();
+ await user.click(screen.getByTestId('trigger-validate'));
+ expect(await screen.findByText('Congregation is required')).toBeInTheDocument();
+ expect(await screen.findByText('Ministry is required')).toBeInTheDocument();
+ expect(await screen.findByText('Primary contact is required')).toBeInTheDocument();
+ });
+});
diff --git a/src/components/group-wizard/step-organization.tsx b/src/components/group-wizard/step-organization.tsx
index 191b35d..a180d34 100644
--- a/src/components/group-wizard/step-organization.tsx
+++ b/src/components/group-wizard/step-organization.tsx
@@ -56,7 +56,7 @@ export function StepOrganization({
Congregation *
field.onChange(Number(val))}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -84,7 +84,7 @@ export function StepOrganization({
Ministry *
field.onChange(Number(val))}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
@@ -159,7 +159,7 @@ export function StepOrganization({
Priority
field.onChange(val ? Number(val) : null)}
- value={field.value ? String(field.value) : undefined}
+ value={field.value ? String(field.value) : ""}
>
diff --git a/src/components/group-wizard/step-review.test.tsx b/src/components/group-wizard/step-review.test.tsx
new file mode 100644
index 0000000..25183ca
--- /dev/null
+++ b/src/components/group-wizard/step-review.test.tsx
@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+import { useForm, FormProvider } from 'react-hook-form';
+import { GROUP_WIZARD_DEFAULTS, type GroupWizardFormData } from './schema';
+import type { GroupWizardLookups } from './types';
+import { StepReview } from './step-review';
+
+const LOOKUPS: GroupWizardLookups = {
+ groupTypes: [{ id: 1, name: 'Small Group' }],
+ ministries: [{ id: 1, name: 'Youth' }],
+ congregations: [{ id: 1, name: 'Main' }],
+ meetingDays: [{ id: 1, name: 'Monday' }],
+ meetingFrequencies: [{ id: 1, name: 'Weekly' }],
+ meetingDurations: [{ id: 1, name: '1 hour' }],
+ lifeStages: [{ id: 1, name: 'Adult' }],
+ groupFocuses: [{ id: 1, name: 'Bible Study' }],
+ priorities: [{ id: 1, name: 'High' }],
+ rooms: [{ id: 1, name: 'Room A' }],
+ books: [{ id: 1, name: 'Genesis' }],
+ smsNumbers: [{ id: 1, name: '555-1234' }],
+ groupEndedReasons: [{ id: 1, name: 'Completed' }],
+};
+
+const BASE_FORM: GroupWizardFormData = {
+ ...GROUP_WIZARD_DEFAULTS,
+ Group_Name: 'My Group',
+ Group_Type_ID: 1,
+ Start_Date: '2026-01-01',
+ Congregation_ID: 1,
+ Ministry_ID: 1,
+ Primary_Contact: 42,
+};
+
+function Harness({
+ defaultValues,
+ onEditStep = vi.fn(),
+ submitResult = null,
+ isEditMode = false,
+ onCreateAnother = vi.fn(),
+ onClose = vi.fn(),
+ contactDisplayMap = new Map([[42, 'Jane Doe']]),
+ groupDisplayMap = new Map(),
+}: {
+ defaultValues?: Partial;
+ onEditStep?: (step: number) => void;
+ submitResult?: { groupId: number; groupName: string } | null;
+ isEditMode?: boolean;
+ onCreateAnother?: () => void;
+ onClose?: () => void;
+ contactDisplayMap?: Map;
+ groupDisplayMap?: Map;
+}) {
+ const form = useForm({
+ defaultValues: { ...BASE_FORM, ...defaultValues },
+ });
+ return (
+
+
+ );
+}
+
+describe('StepReview', () => {
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ describe('submitResult (success) branch', () => {
+ it('renders "Group Created!" in create mode with Create Another button', () => {
+ const onCreateAnother = vi.fn();
+ const onClose = vi.fn();
+ render(
+ " when a lookup id is not found in the lookups array', () => {
+ render(" for primary contact / parent / promote group not in display map', () => {
+ render(
+
+ {value ?? 'none'}
+ {displayName ?? 'none'}
+ onSelect(999, 'Selected Group')}>
+ select-{placeholder}
+
+ onSelect(null, '')}>
+ clear-{placeholder}
+
+
+ ),
+}));
+
+import { StepSettings } from './step-settings';
+
+const LOOKUPS: GroupWizardLookups = {
+ groupTypes: [],
+ ministries: [],
+ congregations: [],
+ meetingDays: [],
+ meetingFrequencies: [],
+ meetingDurations: [],
+ lifeStages: [],
+ groupFocuses: [],
+ priorities: [],
+ rooms: [],
+ books: [],
+ smsNumbers: [],
+ groupEndedReasons: [],
+};
+
+function Harness({
+ groupDisplayMap = new Map(),
+ onGroupSelect = mockOnSelect,
+ defaultValues,
+}: {
+ groupDisplayMap?: Map;
+ onGroupSelect?: (field: string, id: number | null, name: string) => void;
+ defaultValues?: Partial;
+}) {
+ const form = useForm({
+ resolver: zodResolver(groupWizardSchema),
+ defaultValues: { ...GROUP_WIZARD_DEFAULTS, ...defaultValues },
+ });
+ return (
+
+
+ );
+}
+
+const SWITCH_LABELS = [
+ 'Available Online',
+ 'Available On App',
+ 'Enable Discussion',
+ 'Send Attendance Notification',
+ 'Send Service Notification',
+ 'Create Next Meeting',
+ 'Secure Check-in',
+ 'Suppress Nametag',
+ 'Suppress Care Note',
+ 'On Classroom Manager',
+ 'Promote Weekly',
+ 'Promote Participants Only',
+];
+
+describe('StepSettings', () => {
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('renders all switch rows unchecked by default', () => {
+ render(> = {}) {
+ return {
+ currentStep: 0,
+ totalSteps: 6,
+ onBack: vi.fn(),
+ onNext: vi.fn(),
+ onCancel: vi.fn(),
+ onSubmit: vi.fn(),
+ isSubmitting: false,
+ isEditMode: false,
+ ...overrides,
+ };
+}
+
+describe('WizardNavigation', () => {
+ it('hides Back button on the first step', () => {
+ render(Hi
+ close
+
+ ),
+}));
+
+vi.mock('grapesjs', () => ({
+ default: {},
+}));
+
+vi.mock('grapesjs-mjml', () => ({
+ default: {},
+}));
+
+// jsdom/vitest route real .css imports through the project's PostCSS/Tailwind
+// config, which isn't valid outside a Next.js build — stub both stylesheet
+// imports so only the component logic is under test.
+vi.mock('grapesjs/dist/css/grapes.min.css', () => ({}));
+vi.mock('@/styles/grapesjs-overrides.css', () => ({}));
+
+const { mockRegisterMergeFieldBlocks } = vi.hoisted(() => ({
+ mockRegisterMergeFieldBlocks: vi.fn(),
+}));
+
+vi.mock('./merge-fields', () => ({
+ registerMergeFieldBlocks: mockRegisterMergeFieldBlocks,
+}));
+
+const { _mockBlocksAdd, mockBlocksRemove, mockSetComponents, buildFakeEditor } = vi.hoisted(() => {
+ const _mockBlocksAdd = vi.fn();
+ const mockBlocksRemove = vi.fn();
+ const mockSetComponents = vi.fn();
+ const buildFakeEditor = () => ({
+ Blocks: { add: _mockBlocksAdd, remove: mockBlocksRemove },
+ setComponents: mockSetComponents,
+ });
+ return { _mockBlocksAdd, mockBlocksRemove, mockSetComponents, buildFakeEditor };
+});
+
+vi.mock('@grapesjs/react', () => ({
+ __esModule: true,
+ // Named `GjsEditorMock` rather than declared inline on `default:` so the
+ // react-hooks lint rule recognises it as a component and allows useEffect.
+ default: function GjsEditorMock({
+ onReady,
+ children,
+ className,
+ }: {
+ onReady?: (editor: Editor) => void;
+ children?: React.ReactNode;
+ className?: string;
+ }) {
+ const React = require('react');
+ React.useEffect(() => {
+ onReady?.(buildFakeEditor() as unknown as Editor);
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, []);
+ return React.createElement('div', { className, 'data-testid': 'gjs-editor' }, children);
+ },
+ Canvas: ({ className }: { className?: string }) => (
+ // Real GrapesJS mounts its canvas iframe under a `.gjs-cv-canvas` node
+ // regardless of the className prop — replicate that class here so the
+ // component's `document.querySelector('.gjs-cv-canvas')` sizing logic
+ // has something to find, the same as it would in a real DOM.
+
+ ),
+ WithEditor: ({ children }: { children?: React.ReactNode }) => <>{children},
+}));
+
+import { EditorCanvas } from './editor-canvas';
+import { STORAGE_KEY, DEFAULT_MJML_TEMPLATE } from './grapes-config';
+
+describe('EditorCanvas', () => {
+ const onClose = vi.fn();
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ localStorage.clear();
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('renders the canvas and the (stubbed) toolbar', () => {
+ render(edited edited ;
+ let revokeObjectURL: ReturnType;
+ let clickSpy: ReturnType;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockGetHtml.mockReturnValue('
: null,
+}));
+vi.mock('./editor-import-dialog', () => ({
+ EditorImportDialog: ({ open }: { open: boolean }) =>
+ open ?
: null,
+}));
+vi.mock('./editor-export-dialog', () => ({
+ EditorExportDialog: ({ open }: { open: boolean }) =>
+ open ?
: null,
+}));
+vi.mock('./merge-field-picker', () => ({
+ MergeFieldPicker: () =>
,
+}));
+
+const {
+ mockHasUndo,
+ mockHasRedo,
+ mockUndo,
+ mockRedo,
+ mockOn,
+ mockOff,
+ mockSetDevice,
+ mockDomComponentsClear,
+ mockCssComposerClear,
+ mockUndoManagerClear,
+ mockCommandsHas,
+ mockRunCommand,
+ mockStopCommand,
+ mockEditor,
+} = vi.hoisted(() => {
+ const mockHasUndo = vi.fn(() => false);
+ const mockHasRedo = vi.fn(() => false);
+ const mockUndo = vi.fn();
+ const mockRedo = vi.fn();
+ const mockOn = vi.fn();
+ const mockOff = vi.fn();
+ const mockSetDevice = vi.fn();
+ const mockDomComponentsClear = vi.fn();
+ const mockCssComposerClear = vi.fn();
+ const mockUndoManagerClear = vi.fn();
+ const mockCommandsHas = vi.fn(() => false);
+ const mockRunCommand = vi.fn();
+ const mockStopCommand = vi.fn();
+
+ // Stable object identity — EditorToolbar's effects depend on `editor` by
+ // reference, so recreating the object per useEditor() call would retrigger
+ // effects every render and infinite-loop the test.
+ const mockEditor = {
+ UndoManager: {
+ hasUndo: mockHasUndo,
+ hasRedo: mockHasRedo,
+ undo: mockUndo,
+ redo: mockRedo,
+ clear: mockUndoManagerClear,
+ },
+ on: mockOn,
+ off: mockOff,
+ setDevice: mockSetDevice,
+ DomComponents: { clear: mockDomComponentsClear },
+ CssComposer: { clear: mockCssComposerClear },
+ Commands: { has: mockCommandsHas },
+ runCommand: mockRunCommand,
+ stopCommand: mockStopCommand,
+ };
+
+ return {
+ mockHasUndo,
+ mockHasRedo,
+ mockUndo,
+ mockRedo,
+ mockOn,
+ mockOff,
+ mockSetDevice,
+ mockDomComponentsClear,
+ mockCssComposerClear,
+ mockUndoManagerClear,
+ mockCommandsHas,
+ mockRunCommand,
+ mockStopCommand,
+ mockEditor,
+ };
+});
+
+vi.mock('@grapesjs/react', () => ({
+ useEditor: () => mockEditor,
+}));
+
+import { EditorToolbar } from './editor-toolbar';
+
+/**
+ * `ToolbarButton` renders icon-only buttons: the tooltip text is not wired as
+ * an accessible name (Radix Tooltip only links `aria-describedby` while the
+ * tooltip is actually open), so `getByRole('button', { name })` cannot find
+ * them. Locate them instead by the lucide icon's stable CSS class
+ * (`lucide-`), which each toolbar button renders
+ * exactly one of.
+ */
+function getIconButton(iconClass: string): HTMLElement {
+ const button = screen
+ .getAllByRole('button')
+ .find((b) => b.querySelector(`svg.lucide-${iconClass}`));
+ if (!button) {
+ throw new Error(`No button found containing an svg.lucide-${iconClass}`);
+ }
+ return button;
+}
+
+describe('EditorToolbar', () => {
+ const onClose = vi.fn();
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockHasUndo.mockReturnValue(false);
+ mockHasRedo.mockReturnValue(false);
+ mockCommandsHas.mockReturnValue(false);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('subscribes to change:changesCount on mount and unsubscribes on unmount', () => {
+ const { unmount } = render(');
+ expect(DEFAULT_MJML_TEMPLATE).toContain('');
+ });
+
+ it('createEditorConfig returns a config wired to the shared storage key', () => {
+ const config = createEditorConfig();
+
+ expect(config.fromElement).toBe(false);
+ expect(config.height).toBe('100%');
+ expect(config.storageManager).toMatchObject({
+ type: 'local',
+ autosave: true,
+ autoload: true,
+ stepsBeforeSave: 1,
+ options: {
+ local: {
+ key: STORAGE_KEY,
+ },
+ },
+ });
+ });
+
+ it('createEditorConfig includes Desktop and Mobile devices', () => {
+ const config = createEditorConfig();
+ const devices = config.deviceManager?.devices ?? [];
+ const names = devices.map((d) => d.name);
+ expect(names).toEqual(['Desktop', 'Mobile']);
+ });
+
+ it('createEditorConfig disables default panels (custom React toolbar is used instead)', () => {
+ const config = createEditorConfig();
+ expect(config.panels).toEqual({ defaults: [] });
+ });
+
+ it('createEditorConfig returns a fresh object on each call', () => {
+ const first = createEditorConfig();
+ const second = createEditorConfig();
+ expect(first).not.toBe(second);
+ expect(first).toEqual(second);
+ });
+});
diff --git a/src/components/template-editor/merge-field-picker.test.tsx b/src/components/template-editor/merge-field-picker.test.tsx
new file mode 100644
index 0000000..8542008
--- /dev/null
+++ b/src/components/template-editor/merge-field-picker.test.tsx
@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/react';
+
+const { mockGetSelected, mockGetWrapper } = vi.hoisted(() => ({
+ mockGetSelected: vi.fn(),
+ mockGetWrapper: vi.fn(),
+}));
+
+vi.mock('@grapesjs/react', () => ({
+ useEditor: () => ({
+ getSelected: mockGetSelected,
+ getWrapper: mockGetWrapper,
+ }),
+}));
+
+import { MergeFieldPicker } from './merge-field-picker';
+
+describe('MergeFieldPicker', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockGetSelected.mockReturnValue(null);
+ mockGetWrapper.mockReturnValue(null);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ async function openPicker() {
+ render(Hi
' : undefined),
+ set,
+ };
+ mockGetSelected.mockReturnValue(selected);
+
+ await openPicker();
+ fireEvent.click(await screen.findByText('First Name'));
+
+ expect(set).toHaveBeenCalledWith('content', 'Hi
{{First_Name}}');
+ expect(mockGetWrapper).not.toHaveBeenCalled();
+ });
+
+ it('treats an empty existing content as empty string, not the literal "undefined"', async () => {
+ const set = vi.fn();
+ const selected = {
+ get: (key: string) => (key === 'type' ? 'mj-text' : key === 'content' ? undefined : undefined),
+ set,
+ };
+ mockGetSelected.mockReturnValue(selected);
+
+ await openPicker();
+ fireEvent.click(await screen.findByText('First Name'));
+
+ expect(set).toHaveBeenCalledWith('content', '{{First_Name}}');
+ });
+
+ it('inserts a new mj-section under the mj-body when nothing is selected', async () => {
+ const append = vi.fn();
+ const body = { append };
+ const wrapper = {
+ find: (selector: string) => (selector === 'mj-body' ? [body] : []),
+ };
+ mockGetSelected.mockReturnValue(null);
+ mockGetWrapper.mockReturnValue(wrapper);
+
+ await openPicker();
+ fireEvent.click(await screen.findByText('Unsubscribe Link'));
+
+ expect(append).toHaveBeenCalledWith({
+ type: 'mj-section',
+ components: [
+ {
+ type: 'mj-column',
+ components: [
+ {
+ type: 'mj-text',
+ content: '{{Unsubscribe_URL}}
',
+ },
+ ],
+ },
+ ],
+ });
+ });
+
+ it('falls back to appending directly on the wrapper when no mj-body is found', async () => {
+ const append = vi.fn();
+ const wrapper = {
+ find: () => [],
+ append,
+ };
+ mockGetSelected.mockReturnValue(null);
+ mockGetWrapper.mockReturnValue(wrapper);
+
+ await openPicker();
+ fireEvent.click(await screen.findByText('First Name'));
+
+ expect(append).toHaveBeenCalledTimes(1);
+ });
+
+ it('does nothing (no throw) when selected is not mj-text and no wrapper exists', async () => {
+ mockGetSelected.mockReturnValue(null);
+ mockGetWrapper.mockReturnValue(null);
+
+ await openPicker();
+ const field = await screen.findByText('First Name');
+ expect(() => fireEvent.click(field)).not.toThrow();
+ });
+
+ it('closes the popover after inserting a field', async () => {
+ await openPicker();
+ expect(await screen.findByText('Merge Fields')).toBeInTheDocument();
+ fireEvent.click(screen.getByText('First Name'));
+
+ expect(screen.queryByText('Merge Fields')).not.toBeInTheDocument();
+ });
+});
diff --git a/src/components/template-editor/merge-fields.test.ts b/src/components/template-editor/merge-fields.test.ts
new file mode 100644
index 0000000..feaad17
--- /dev/null
+++ b/src/components/template-editor/merge-fields.test.ts
@@ -0,0 +1,60 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+ MERGE_FIELDS,
+ MERGE_FIELD_CATEGORIES,
+ getFieldsByCategory,
+ registerMergeFieldBlocks,
+} from './merge-fields';
+import type { Editor } from 'grapesjs';
+
+describe('MERGE_FIELD_CATEGORIES', () => {
+ it('dedupes categories preserving first-seen order', () => {
+ expect(MERGE_FIELD_CATEGORIES).toEqual(['Contact', 'Household', 'Church', 'System']);
+ });
+
+ it('matches the set of categories present in MERGE_FIELDS', () => {
+ const categoriesInFields = new Set(MERGE_FIELDS.map((f) => f.category));
+ expect(new Set(MERGE_FIELD_CATEGORIES)).toEqual(categoriesInFields);
+ });
+});
+
+describe('getFieldsByCategory', () => {
+ it('returns only fields matching the given category', () => {
+ const contactFields = getFieldsByCategory('Contact');
+ expect(contactFields.length).toBeGreaterThan(0);
+ expect(contactFields.every((f) => f.category === 'Contact')).toBe(true);
+ expect(contactFields.map((f) => f.value)).toContain('{{First_Name}}');
+ });
+
+ it('returns an empty array for an unknown category', () => {
+ expect(getFieldsByCategory('Nonexistent')).toEqual([]);
+ });
+});
+
+describe('registerMergeFieldBlocks', () => {
+ it('calls editor.Blocks.add twice with the expected block ids and categories', () => {
+ const add = vi.fn();
+ const editor = { Blocks: { add } } as unknown as Editor;
+
+ registerMergeFieldBlocks(editor);
+
+ expect(add).toHaveBeenCalledTimes(2);
+ expect(add).toHaveBeenNthCalledWith(
+ 1,
+ 'merge-field-contact',
+ expect.objectContaining({
+ label: 'Contact Fields',
+ category: 'Merge Fields',
+ content: expect.objectContaining({ type: 'mj-text' }),
+ }),
+ );
+ expect(add).toHaveBeenNthCalledWith(
+ 2,
+ 'merge-field-unsubscribe',
+ expect.objectContaining({
+ label: 'Unsubscribe Link',
+ category: 'Merge Fields',
+ }),
+ );
+ });
+});
diff --git a/src/components/template-editor/template-editor-form.test.tsx b/src/components/template-editor/template-editor-form.test.tsx
new file mode 100644
index 0000000..c29d3d0
--- /dev/null
+++ b/src/components/template-editor/template-editor-form.test.tsx
@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+
+/**
+ * `next/dynamic` is mocked directly so both the resolved component and the
+ * `loading` fallback (`EditorSkeleton`) are independently testable and
+ * covered, without depending on the real dynamic-import/suspense timing.
+ */
+const { mockDynamic } = vi.hoisted(() => ({
+ mockDynamic: vi.fn(),
+}));
+
+vi.mock('next/dynamic', () => ({
+ default: mockDynamic,
+}));
+
+vi.mock('./editor-canvas', () => ({
+ EditorCanvas: ({ onClose }: { onClose: () => void }) => (
+
+ ),
+}));
+
+describe('TemplateEditorForm', () => {
+ beforeEach(() => {
+ vi.resetModules();
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+ });
+
+ it('calls next/dynamic with a loader resolving to EditorCanvas and ssr disabled', async () => {
+ let capturedOptions: { ssr?: boolean; loading?: () => React.ReactNode } | undefined;
+ mockDynamic.mockImplementation((loader, options) => {
+ capturedOptions = options;
+ return function DynamicResult() {
+ return
;
+ };
+ });
+
+ const { TemplateEditorForm } = await import('./template-editor-form');
+ render(
;
+ };
+ });
+
+ await import('./template-editor-form');
+ const loadingNode = capturedOptions?.loading?.();
+
+ // EditorSkeleton renders Skeleton placeholders inside a flex row plus a
+ // header skeleton — assert the structural shape rather than text, since
+ // Skeleton has no visible copy.
+ const { container } = render(<>{loadingNode});
+ expect(container.querySelectorAll('[class*="animate-pulse"]').length).toBeGreaterThan(0);
+ });
+
+ it('renders the resolved dynamic component (EditorCanvas) with onClose wired through', async () => {
+ const { EditorCanvas } = await import('./editor-canvas');
+ mockDynamic.mockImplementation(() => EditorCanvas);
+
+ const { TemplateEditorForm } = await import('./template-editor-form');
+ const onClose = vi.fn();
+ render(dev-panel:{params.pageID}
+ ),
+}));
+
+import { ToolContainer } from './tool-container';
+import { ToolHeader } from './tool-header';
+import { ToolFooter } from './tool-footer';
+
+afterEach(() => {
+ cleanup();
+ vi.restoreAllMocks();
+});
+
+describe('ToolFooter', () => {
+ it('renders default Close and Save labels', () => {
+ render(extra-node} />);
+ expect(screen.getByText('extra-node')).toBeInTheDocument();
+ unmount();
+
+ render(help text} />);
+
+ expect(screen.getByRole('button', { name: 'Information' })).toBeInTheDocument();
+ });
+});
+
+describe('ToolContainer', () => {
+ const params = { pageID: 42 } as never;
+
+ it('renders children, header and footer by default', () => {
+ render(
+
+ body-content
+ ,
+ );
+
+ expect(screen.getByRole('heading', { level: 1, name: 'Container Tool' })).toBeInTheDocument();
+ expect(screen.getByText('body-content')).toBeInTheDocument();
+ expect(screen.getByRole('button', { name: 'Save' })).toBeInTheDocument();
+ });
+
+ it('omits the footer when hideFooter is set', () => {
+ render(
+
+ body-content
+ ,
+ );
+
+ expect(screen.queryByRole('button', { name: 'Save' })).not.toBeInTheDocument();
+ });
+
+ it('renders the DevPanel only when params are supplied', () => {
+ const { unmount } = render(
+
+ body
+ ,
+ );
+ expect(screen.queryByTestId('dev-panel')).not.toBeInTheDocument();
+ unmount();
+
+ render(
+
+ body
+ ,
+ );
+ expect(screen.getByTestId('dev-panel')).toHaveTextContent('dev-panel:42');
+ });
+
+ it('forwards footer props through to ToolFooter', async () => {
+ const onSave = vi.fn();
+ render(
+ footer-extra}
+ >
+ body
+ ,
+ );
+
+ expect(screen.getByText('footer-extra')).toBeInTheDocument();
+ await userEvent.click(screen.getByRole('button', { name: 'Persist' }));
+ expect(onSave).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/src/contexts/user-context.test.tsx b/src/contexts/user-context.test.tsx
index e799b11..ec171b1 100644
--- a/src/contexts/user-context.test.tsx
+++ b/src/contexts/user-context.test.tsx
@@ -143,3 +143,93 @@ describe('UserContext', () => {
});
});
});
+
+/**
+ * Branches the mount effect alone cannot reach.
+ *
+ * The effect only calls `loadUserProfile()` when a `userGuid` exists, so the
+ * guard clause inside that callback is reachable only through an explicit
+ * `refreshUserProfile()` — which is exactly what happens if a component
+ * refreshes while the session is still resolving or has gone stale.
+ */
+describe('UserProvider edge branches', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('clears the profile without calling the server when refreshed with no userGuid', async () => {
+ mockUseSession.mockReturnValue({
+ data: { user: { id: 'internal-id' } },
+ isPending: false,
+ });
+
+ const { result } = renderHook(() => useUser(), { wrapper: createWrapper() });
+
+ await act(async () => {
+ await result.current.refreshUserProfile();
+ });
+
+ expect(mockGetCurrentUserProfile).not.toHaveBeenCalled();
+ expect(result.current.userProfile).toBeNull();
+ expect(result.current.isLoading).toBe(false);
+ });
+
+ it('stays in the loading state while the session is pending', () => {
+ mockUseSession.mockReturnValue({ data: undefined, isPending: true });
+
+ const { result } = renderHook(() => useUser(), { wrapper: createWrapper() });
+
+ expect(result.current.isLoading).toBe(true);
+ expect(mockGetCurrentUserProfile).not.toHaveBeenCalled();
+ });
+
+ it('wraps a non-Error rejection in a real Error', async () => {
+ mockUseSession.mockReturnValue({
+ data: { user: { id: 'internal-id', userGuid: 'guid-123' } },
+ isPending: false,
+ });
+ mockGetCurrentUserProfile.mockRejectedValueOnce('a bare string');
+
+ const { result } = renderHook(() => useUser(), { wrapper: createWrapper() });
+
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ expect(result.current.error).toBeInstanceOf(Error);
+ expect(result.current.error?.message).toBe('Failed to load user profile');
+ expect(result.current.userProfile).toBeNull();
+ });
+
+ it('treats an undefined profile result as no profile', async () => {
+ mockUseSession.mockReturnValue({
+ data: { user: { id: 'internal-id', userGuid: 'guid-123' } },
+ isPending: false,
+ });
+ mockGetCurrentUserProfile.mockResolvedValueOnce(undefined);
+
+ const { result } = renderHook(() => useUser(), { wrapper: createWrapper() });
+
+ await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+ expect(result.current.userProfile).toBeNull();
+ expect(result.current.error).toBeNull();
+ });
+
+ it('clears a previous error on a successful refresh', async () => {
+ mockUseSession.mockReturnValue({
+ data: { user: { id: 'internal-id', userGuid: 'guid-123' } },
+ isPending: false,
+ });
+ mockGetCurrentUserProfile.mockRejectedValueOnce(new Error('transient'));
+
+ const { result } = renderHook(() => useUser(), { wrapper: createWrapper() });
+ await waitFor(() => expect(result.current.error).not.toBeNull());
+
+ mockGetCurrentUserProfile.mockResolvedValueOnce({ Contact_ID: 7 });
+ await act(async () => {
+ await result.current.refreshUserProfile();
+ });
+
+ expect(result.current.error).toBeNull();
+ expect(result.current.userProfile).toEqual({ Contact_ID: 7 });
+ });
+});
diff --git a/src/lib/auth-client.test.ts b/src/lib/auth-client.test.ts
new file mode 100644
index 0000000..c9f230c
--- /dev/null
+++ b/src/lib/auth-client.test.ts
@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+
+import { authClient } from './auth-client';
+
+/**
+ * Smoke coverage for the Better Auth browser client.
+ *
+ * Better Auth 1.7 removed `genericOAuthClient()`; the MP generic OAuth provider
+ * is now registered as a first-class social provider, so sign-in must go
+ * through `signIn.social({ provider: "ministryplatform" })` rather than the
+ * removed `signIn.oauth2`. These assertions pin the surface the app calls.
+ *
+ * The client is NOT mocked here: `better-auth/react` is a subpath export that
+ * Vitest's module registry does not intercept in this setup, and the real
+ * client constructs fine under jsdom. Constructing it for real is also the
+ * stronger test — it proves the plugin list in the source actually builds.
+ */
+
+describe('authClient', () => {
+ it('constructs without throwing at import time', () => {
+ expect(authClient).toBeDefined();
+ });
+
+ it('exposes signIn.social, the endpoint the MP provider uses', () => {
+ expect(authClient.signIn.social).toBeTypeOf('function');
+ });
+
+ it('exposes the customSession-backed useSession hook', () => {
+ expect(authClient.useSession).toBeDefined();
+ });
+
+ it('exposes signOut', () => {
+ expect(authClient.signOut).toBeTypeOf('function');
+ });
+});
diff --git a/src/lib/dto/address-label.dto.test.ts b/src/lib/dto/address-label.dto.test.ts
new file mode 100644
index 0000000..ba11d85
--- /dev/null
+++ b/src/lib/dto/address-label.dto.test.ts
@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+
+import { SERVICE_TYPES } from './address-label.dto';
+
+/**
+ * SERVICE_TYPES feeds the USPS Service Type Identifier (STID) field of an
+ * Intelligent Mail barcode. A malformed id here produces a barcode the Postal
+ * Service rejects, so the shape is pinned rather than left to review.
+ */
+
+describe('SERVICE_TYPES', () => {
+ it('offers the five supported mail classes', () => {
+ expect(SERVICE_TYPES).toHaveLength(5);
+ });
+
+ it('uses exactly three digits for every service type id, as the IMb STID requires', () => {
+ for (const type of SERVICE_TYPES) {
+ expect(type.id).toMatch(/^\d{3}$/);
+ }
+ });
+
+ it('gives every entry a non-empty display name', () => {
+ for (const type of SERVICE_TYPES) {
+ expect(type.name.trim()).not.toBe('');
+ }
+ });
+
+ it('has no duplicate ids', () => {
+ const ids = SERVICE_TYPES.map((t) => t.id);
+
+ expect(new Set(ids).size).toBe(ids.length);
+ });
+
+ it('includes First-Class Mail as service type 040', () => {
+ expect(SERVICE_TYPES).toContainEqual({ id: '040', name: 'First-Class Mail' });
+ });
+});
diff --git a/src/lib/dto/family.test.ts b/src/lib/dto/family.test.ts
new file mode 100644
index 0000000..489d77b
--- /dev/null
+++ b/src/lib/dto/family.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect } from "vitest";
+import {
+ FamilyAddressSchema,
+ FamilyMemberParticipantSchema,
+ FamilyMemberSchema,
+ HouseholdSchema,
+ emptyAddress,
+ emptyMember,
+ emptyHousehold,
+ type FamilyDefaults,
+} from "./family";
+
+const defaults: FamilyDefaults = {
+ congregationId: 1,
+ sourceId: 18,
+ countryCode: "US",
+ state: "CA",
+ householdPositionId: 2,
+ participantTypeId: 4,
+ showEnvelopeNumbers: true,
+};
+
+describe("emptyAddress", () => {
+ it("returns a blank address shape", () => {
+ expect(emptyAddress()).toEqual({
+ addressId: 0,
+ addressLine1: null,
+ addressLine2: null,
+ city: null,
+ state: null,
+ region: null,
+ postalCode: "",
+ countryCode: null,
+ });
+ });
+
+ it("validates against FamilyAddressSchema", () => {
+ expect(() => FamilyAddressSchema.parse(emptyAddress())).not.toThrow();
+ });
+});
+
+describe("emptyMember", () => {
+ it("builds a member with the given contactId and lastName", () => {
+ const member = emptyMember(-1, "Smith", defaults);
+ expect(member.contactId).toBe(-1);
+ expect(member.lastName).toBe("Smith");
+ expect(member.firstName).toBe("");
+ expect(member.householdPositionId).toBe(defaults.householdPositionId);
+ expect(member.participant).toEqual({
+ participantId: 0,
+ participantTypeId: defaults.participantTypeId,
+ notes: null,
+ });
+ expect(member.isDonor).toBe(false);
+ expect(member.donorId).toBeNull();
+ expect(member.contactStatusId).toBe(1);
+ });
+
+ it("validates against FamilyMemberSchema", () => {
+ const member = emptyMember(-2, "Jones", defaults);
+ expect(() => FamilyMemberSchema.parse(member)).not.toThrow();
+ });
+});
+
+describe("emptyHousehold", () => {
+ it("builds a household with two blank members by default lastName", () => {
+ const household = emptyHousehold(defaults);
+ expect(household.householdId).toBe(0);
+ expect(household.householdName).toBe("");
+ expect(household.members).toHaveLength(2);
+ expect(household.members[0].contactId).toBe(-1);
+ expect(household.members[1].contactId).toBe(-2);
+ expect(household.address.countryCode).toBe(defaults.countryCode);
+ expect(household.address.state).toBe(defaults.state);
+ expect(household.alternateMailingAddress.countryCode).toBe(defaults.countryCode);
+ });
+
+ it("uses the provided lastName for householdName and members", () => {
+ const household = emptyHousehold(defaults, "Rivera");
+ expect(household.householdName).toBe("Rivera");
+ expect(household.members[0].lastName).toBe("Rivera");
+ expect(household.members[1].lastName).toBe("Rivera");
+ });
+
+ it("validates against HouseholdSchema", () => {
+ const household = emptyHousehold(defaults, "Rivera");
+ expect(() => HouseholdSchema.parse(household)).not.toThrow();
+ });
+});
+
+describe("FamilyMemberParticipantSchema", () => {
+ it("accepts a participant with optional notes omitted", () => {
+ const result = FamilyMemberParticipantSchema.safeParse({
+ participantId: 1,
+ participantTypeId: 2,
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it("rejects a non-integer participantId", () => {
+ const result = FamilyMemberParticipantSchema.safeParse({
+ participantId: 1.5,
+ participantTypeId: 2,
+ });
+ expect(result.success).toBe(false);
+ });
+});
diff --git a/src/lib/providers/google-places/provider.test.ts b/src/lib/providers/google-places/provider.test.ts
new file mode 100644
index 0000000..0c86725
--- /dev/null
+++ b/src/lib/providers/google-places/provider.test.ts
@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { GooglePlacesProvider } from "./provider";
+
+const mockFetch = vi.fn();
+
+describe("GooglePlacesProvider", () => {
+ beforeEach(() => {
+ vi.stubGlobal("fetch", mockFetch);
+ mockFetch.mockReset();
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ describe("constructor", () => {
+ it("throws when apiKey is empty", () => {
+ expect(() => new GooglePlacesProvider("")).toThrow(
+ "GooglePlacesProvider requires a non-empty API key",
+ );
+ });
+
+ it("constructs with a non-empty key", () => {
+ expect(() => new GooglePlacesProvider("key-123")).not.toThrow();
+ });
+ });
+
+ describe("autocomplete", () => {
+ it("returns [] when trimmed input is shorter than 3 chars", async () => {
+ const provider = new GooglePlacesProvider("key-123");
+ const result = await provider.autocomplete(" a ", "token-1");
+ expect(result).toEqual([]);
+ expect(mockFetch).not.toHaveBeenCalled();
+ });
+
+ it("calls the autocomplete endpoint and maps suggestions", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ suggestions: [
+ {
+ placePrediction: {
+ placeId: "place-1",
+ text: { text: "123 Main St, Springfield" },
+ structuredFormat: {
+ mainText: { text: "123 Main St" },
+ secondaryText: { text: "Springfield" },
+ },
+ },
+ },
+ {
+ placePrediction: {
+ placeId: "place-2",
+ text: { text: "456 Oak Ave" },
+ // no structuredFormat
+ },
+ },
+ // missing placeId entirely -> filtered out
+ { placePrediction: { placeId: "" } },
+ {},
+ ],
+ }),
+ });
+
+ const provider = new GooglePlacesProvider("key-123");
+ const result = await provider.autocomplete("123 Main", "token-1");
+
+ expect(mockFetch).toHaveBeenCalledWith(
+ "https://places.googleapis.com/v1/places:autocomplete",
+ expect.objectContaining({
+ method: "POST",
+ headers: expect.objectContaining({
+ "X-Goog-Api-Key": "key-123",
+ }),
+ }),
+ );
+ const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+ expect(body).toEqual({
+ input: "123 Main",
+ sessionToken: "token-1",
+ includedPrimaryTypes: ["street_address", "premise", "subpremise"],
+ });
+
+ expect(result).toEqual([
+ {
+ placeId: "place-1",
+ primary: "123 Main St",
+ secondary: "Springfield",
+ full: "123 Main St, Springfield",
+ },
+ {
+ placeId: "place-2",
+ primary: "456 Oak Ave",
+ secondary: "",
+ full: "456 Oak Ave",
+ },
+ ]);
+ });
+
+ it("returns [] when suggestions is missing entirely", async () => {
+ mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({}) });
+ const provider = new GooglePlacesProvider("key-123");
+ const result = await provider.autocomplete("123 Main", "token-1");
+ expect(result).toEqual([]);
+ });
+
+ it("throws with status and body text when the response is not ok", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: false,
+ status: 429,
+ text: async () => "Rate limited",
+ });
+ const provider = new GooglePlacesProvider("key-123");
+ await expect(provider.autocomplete("123 Main", "token-1")).rejects.toThrow(
+ "Google Places autocomplete failed: 429 Rate limited",
+ );
+ });
+ });
+
+ describe("getPlaceDetails", () => {
+ it("requests details and maps address components", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ id: "place-1",
+ formattedAddress: "123 Main St, Springfield, IL 62701, US",
+ addressComponents: [
+ { longText: "123", shortText: "123", types: ["street_number"] },
+ { longText: "Main St", shortText: "Main St", types: ["route"] },
+ { longText: "Springfield", shortText: "Springfield", types: ["locality"] },
+ { longText: "Illinois", shortText: "IL", types: ["administrative_area_level_1"] },
+ { longText: "62701", shortText: "62701", types: ["postal_code"] },
+ { longText: "United States", shortText: "US", types: ["country"] },
+ ],
+ }),
+ });
+
+ const provider = new GooglePlacesProvider("key-123");
+ const details = await provider.getPlaceDetails("place-1", "token-1");
+
+ expect(mockFetch).toHaveBeenCalledWith(
+ "https://places.googleapis.com/v1/places/place-1?sessionToken=token-1",
+ expect.objectContaining({
+ method: "GET",
+ headers: expect.objectContaining({ "X-Goog-Api-Key": "key-123" }),
+ }),
+ );
+
+ expect(details).toEqual({
+ placeId: "place-1",
+ formattedAddress: "123 Main St, Springfield, IL 62701, US",
+ addressLine1: "123 Main St",
+ city: "Springfield",
+ state: "IL",
+ postalCode: "62701",
+ countryCode: "US",
+ });
+ });
+
+ it("falls back through city component types", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ id: "place-2",
+ addressComponents: [
+ { longText: "Some Town", shortText: "Some Town", types: ["postal_town"] },
+ ],
+ }),
+ });
+ const provider = new GooglePlacesProvider("key-123");
+ const details = await provider.getPlaceDetails("place-2", "token-1");
+ expect(details.city).toBe("Some Town");
+ expect(details.formattedAddress).toBe("");
+ });
+
+ it("handles missing addressComponents entirely", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({ id: "place-3" }),
+ });
+ const provider = new GooglePlacesProvider("key-123");
+ const details = await provider.getPlaceDetails("place-3", "token-1");
+ expect(details).toEqual({
+ placeId: "place-3",
+ formattedAddress: "",
+ addressLine1: "",
+ city: "",
+ state: "",
+ postalCode: "",
+ countryCode: "",
+ });
+ });
+
+ it("throws with status and body text when the response is not ok", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: false,
+ status: 404,
+ text: async () => "Not found",
+ });
+ const provider = new GooglePlacesProvider("key-123");
+ await expect(provider.getPlaceDetails("bad-id", "token-1")).rejects.toThrow(
+ "Google Places details failed: 404 Not found",
+ );
+ });
+
+ it("encodes the placeId in the URL", async () => {
+ mockFetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({ id: "place with spaces" }),
+ });
+ const provider = new GooglePlacesProvider("key-123");
+ await provider.getPlaceDetails("place with spaces", "token-1");
+ expect(mockFetch).toHaveBeenCalledWith(
+ "https://places.googleapis.com/v1/places/place%20with%20spaces?sessionToken=token-1",
+ expect.anything(),
+ );
+ });
+ });
+});
diff --git a/src/lib/providers/ministry-platform/client.test.ts b/src/lib/providers/ministry-platform/client.test.ts
index 4c5321e..4ae7f40 100644
--- a/src/lib/providers/ministry-platform/client.test.ts
+++ b/src/lib/providers/ministry-platform/client.test.ts
@@ -15,6 +15,18 @@ vi.mock('@/lib/providers/ministry-platform/auth/client-credentials', () => ({
getClientCredentialsToken: vi.fn(),
}));
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('MinistryPlatformClient', () => {
let mockGetClientCredentialsToken: ReturnType;
diff --git a/src/lib/providers/ministry-platform/helper.test.ts b/src/lib/providers/ministry-platform/helper.test.ts
index fab6493..2feb593 100644
--- a/src/lib/providers/ministry-platform/helper.test.ts
+++ b/src/lib/providers/ministry-platform/helper.test.ts
@@ -1,6 +1,12 @@
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { z } from 'zod';
import { MPHelper, MPValidationError } from '@/lib/providers/ministry-platform/helper';
+import type {
+ CommunicationInfo,
+ FileUpdateParams,
+ FileUploadParams,
+ MessageInfo,
+} from '@/lib/providers/ministry-platform/types/provider.types';
/**
* MPHelper Tests
@@ -744,14 +750,17 @@ describe('MPHelper', () => {
describe('Communication Service Methods', () => {
it('should create communication without attachments', async () => {
- const communicationInfo = {
- Author_User_ID: 1,
+ const communicationInfo: CommunicationInfo = {
+ AuthorUserId: 1,
Subject: 'Test Subject',
Body: 'Test body
',
- Start_Date: '2024-01-01',
- From_Contact: 123,
- Reply_to_Contact: 123,
- To_Contact_List: '456,789',
+ StartDate: '2024-01-01',
+ FromContactId: 123,
+ ReplyToContactId: 123,
+ CommunicationType: 'Email',
+ Contacts: [456, 789],
+ IsBulkEmail: false,
+ SendToContactParents: false,
};
const createdCommunication = {
Communication_ID: 1,
@@ -766,14 +775,17 @@ describe('MPHelper', () => {
});
it('should create communication with attachments', async () => {
- const communicationInfo = {
- Author_User_ID: 1,
+ const communicationInfo: CommunicationInfo = {
+ AuthorUserId: 1,
Subject: 'Test with Attachment',
Body: 'See attached
',
- Start_Date: '2024-01-01',
- From_Contact: 123,
- Reply_to_Contact: 123,
- To_Contact_List: '456',
+ StartDate: '2024-01-01',
+ FromContactId: 123,
+ ReplyToContactId: 123,
+ CommunicationType: 'Email',
+ Contacts: [456],
+ IsBulkEmail: false,
+ SendToContactParents: false,
};
const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
const createdCommunication = { Communication_ID: 1, ...communicationInfo };
@@ -810,9 +822,9 @@ describe('MPHelper', () => {
});
it('should send message without attachments', async () => {
- const messageInfo = {
- From: 'sender@example.com',
- To: 'recipient@example.com',
+ const messageInfo: MessageInfo = {
+ FromAddress: { Address: 'sender@example.com', DisplayName: 'Sender' },
+ ToAddresses: [{ Address: 'recipient@example.com', DisplayName: 'Recipient' }],
Subject: 'Test Message',
Body: 'Hello
',
};
@@ -826,9 +838,9 @@ describe('MPHelper', () => {
});
it('should send message with attachments', async () => {
- const messageInfo = {
- From: 'sender@example.com',
- To: 'recipient@example.com',
+ const messageInfo: MessageInfo = {
+ FromAddress: { Address: 'sender@example.com', DisplayName: 'Sender' },
+ ToAddresses: [{ Address: 'recipient@example.com', DisplayName: 'Recipient' }],
Subject: 'Test with Attachment',
Body: 'Please see attached
',
};
@@ -912,7 +924,7 @@ describe('MPHelper', () => {
it('should upload files with upload parameters', async () => {
const mockFile = new File(['data'], 'doc.pdf', { type: 'application/pdf' });
- const uploadParams = { IsDefault: true, Description: 'Main document' };
+ const uploadParams: FileUploadParams = { isDefaultImage: true, description: 'Main document' };
const uploadedFiles = [{ File_ID: 2, File_Name: 'doc.pdf' }];
mockUploadFiles.mockResolvedValueOnce(uploadedFiles);
@@ -930,7 +942,7 @@ describe('MPHelper', () => {
describe('updateFile', () => {
it('should update file metadata only', async () => {
- const updateParams = { Description: 'Updated description' };
+ const updateParams: FileUpdateParams = { description: 'Updated description' };
const updatedFile = { File_ID: 1, File_Name: 'photo.jpg', Description: 'Updated description' };
mockUpdateFile.mockResolvedValueOnce(updatedFile);
@@ -945,7 +957,7 @@ describe('MPHelper', () => {
it('should update file content and metadata', async () => {
const mockFile = new File(['new content'], 'updated.jpg', { type: 'image/jpeg' });
- const updateParams = { Description: 'New photo' };
+ const updateParams: FileUpdateParams = { description: 'New photo' };
const updatedFile = { File_ID: 1, File_Name: 'updated.jpg' };
mockUpdateFile.mockResolvedValueOnce(updatedFile);
diff --git a/src/lib/providers/ministry-platform/provider.test.ts b/src/lib/providers/ministry-platform/provider.test.ts
index cf4aaf9..3ab048e 100644
--- a/src/lib/providers/ministry-platform/provider.test.ts
+++ b/src/lib/providers/ministry-platform/provider.test.ts
@@ -102,6 +102,12 @@ vi.mock('./services', () => ({
}));
import { MinistryPlatformProvider } from './provider';
+import type {
+ CommunicationInfo,
+ FileUpdateParams,
+ FileUploadParams,
+ MessageInfo,
+} from './types/provider.types';
describe('MinistryPlatformProvider', () => {
beforeEach(() => {
@@ -375,14 +381,17 @@ describe('MinistryPlatformProvider', () => {
describe('Communication operations', () => {
it('should delegate createCommunication to CommunicationService', async () => {
- const comm = {
- Author_User_ID: 1,
+ const comm: CommunicationInfo = {
+ AuthorUserId: 1,
Subject: 'Hi',
Body: 'x
',
- Start_Date: '2026-01-01',
- From_Contact: 1,
- Reply_to_Contact: 1,
- To_Contact_List: '2',
+ StartDate: '2026-01-01',
+ FromContactId: 1,
+ ReplyToContactId: 1,
+ CommunicationType: 'Email',
+ Contacts: [2],
+ IsBulkEmail: false,
+ SendToContactParents: false,
};
const created = { Communication_ID: 10, ...comm };
mockCreateCommunication.mockResolvedValueOnce(created);
@@ -416,9 +425,9 @@ describe('MinistryPlatformProvider', () => {
});
it('should delegate sendMessage to CommunicationService', async () => {
- const message = {
- From: 'a@example.com',
- To: 'b@example.com',
+ const message: MessageInfo = {
+ FromAddress: { Address: 'a@example.com', DisplayName: 'A' },
+ ToAddresses: [{ Address: 'b@example.com', DisplayName: 'B' }],
Subject: 'Test',
Body: 'Hi
',
};
@@ -467,9 +476,10 @@ describe('MinistryPlatformProvider', () => {
mockUploadFiles.mockResolvedValueOnce(uploaded);
const provider = MinistryPlatformProvider.getInstance();
- const result = await provider.uploadFiles('Contacts', 1, [file], { IsDefault: true });
+ const uploadParams: FileUploadParams = { isDefaultImage: true };
+ const result = await provider.uploadFiles('Contacts', 1, [file], uploadParams);
- expect(mockUploadFiles).toHaveBeenCalledWith('Contacts', 1, [file], { IsDefault: true });
+ expect(mockUploadFiles).toHaveBeenCalledWith('Contacts', 1, [file], uploadParams);
expect(result).toEqual(uploaded);
});
@@ -479,9 +489,10 @@ describe('MinistryPlatformProvider', () => {
mockUpdateFile.mockResolvedValueOnce(updated);
const provider = MinistryPlatformProvider.getInstance();
- const result = await provider.updateFile(1, file, { Description: 'desc' });
+ const updateParams: FileUpdateParams = { description: 'desc' };
+ const result = await provider.updateFile(1, file, updateParams);
- expect(mockUpdateFile).toHaveBeenCalledWith(1, file, { Description: 'desc' });
+ expect(mockUpdateFile).toHaveBeenCalledWith(1, file, updateParams);
expect(result).toEqual(updated);
});
diff --git a/src/lib/providers/ministry-platform/services/communication.service.test.ts b/src/lib/providers/ministry-platform/services/communication.service.test.ts
index dc93a67..470cfd5 100644
--- a/src/lib/providers/ministry-platform/services/communication.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/communication.service.test.ts
@@ -4,6 +4,18 @@ import type { MinistryPlatformClient } from '@/lib/providers/ministry-platform/c
import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client';
import type { CommunicationInfo, MessageInfo } from '@/lib/providers/ministry-platform/types';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('CommunicationService', () => {
let service: CommunicationService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/services/domain.service.test.ts b/src/lib/providers/ministry-platform/services/domain.service.test.ts
index 1758e9c..90ab7bd 100644
--- a/src/lib/providers/ministry-platform/services/domain.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/domain.service.test.ts
@@ -4,6 +4,18 @@ import type { MinistryPlatformClient } from '@/lib/providers/ministry-platform/c
import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client';
import type { DomainInfo } from '@/lib/providers/ministry-platform/types';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('DomainService', () => {
let service: DomainService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/services/file.service.test.ts b/src/lib/providers/ministry-platform/services/file.service.test.ts
index 780d752..a1be7b6 100644
--- a/src/lib/providers/ministry-platform/services/file.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/file.service.test.ts
@@ -3,6 +3,18 @@ import { FileService } from '@/lib/providers/ministry-platform/services/file.ser
import type { MinistryPlatformClient } from '@/lib/providers/ministry-platform/client';
import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('FileService', () => {
let service: FileService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/services/metadata.service.test.ts b/src/lib/providers/ministry-platform/services/metadata.service.test.ts
index ce1173d..b7c547d 100644
--- a/src/lib/providers/ministry-platform/services/metadata.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/metadata.service.test.ts
@@ -3,6 +3,18 @@ import { MetadataService } from '@/lib/providers/ministry-platform/services/meta
import type { MinistryPlatformClient } from '@/lib/providers/ministry-platform/client';
import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('MetadataService', () => {
let service: MetadataService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/services/procedure.service.test.ts b/src/lib/providers/ministry-platform/services/procedure.service.test.ts
index 151ef66..d35156a 100644
--- a/src/lib/providers/ministry-platform/services/procedure.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/procedure.service.test.ts
@@ -3,6 +3,18 @@ import { ProcedureService } from '@/lib/providers/ministry-platform/services/pro
import type { MinistryPlatformClient } from '@/lib/providers/ministry-platform/client';
import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client';
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('ProcedureService', () => {
let service: ProcedureService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/services/table.service.test.ts b/src/lib/providers/ministry-platform/services/table.service.test.ts
index 99f531f..d0fb8c9 100644
--- a/src/lib/providers/ministry-platform/services/table.service.test.ts
+++ b/src/lib/providers/ministry-platform/services/table.service.test.ts
@@ -15,6 +15,18 @@ import type { HttpClient } from '@/lib/providers/ministry-platform/utils/http-cl
* - Error handling for all operations
*/
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('TableService', () => {
let tableService: TableService;
let mockClient: MinistryPlatformClient;
diff --git a/src/lib/providers/ministry-platform/utils/http-client.test.ts b/src/lib/providers/ministry-platform/utils/http-client.test.ts
index b044d39..a872ce9 100644
--- a/src/lib/providers/ministry-platform/utils/http-client.test.ts
+++ b/src/lib/providers/ministry-platform/utils/http-client.test.ts
@@ -17,6 +17,18 @@ import { HttpClient } from '@/lib/providers/ministry-platform/utils/http-client'
const mockFetch = vi.fn();
global.fetch = mockFetch;
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('HttpClient', () => {
const baseUrl = 'https://api.ministryplatform.com';
const mockToken = 'test-access-token-123';
diff --git a/src/proxy.test.ts b/src/proxy.test.ts
index d1e8074..c11efdc 100644
--- a/src/proxy.test.ts
+++ b/src/proxy.test.ts
@@ -58,6 +58,18 @@ function createMockRequest(pathname: string, baseUrl = 'http://localhost:3000')
} as unknown as NextRequest;
}
+/**
+ * These tests deliberately drive failure paths, and the code under test logs
+ * them on purpose. Silence the channel so a real, unexpected error still
+ * stands out in the runner output instead of drowning in expected noise.
+ * `mockImplementation` keeps the spy recording, so assertions on what was
+ * logged still work.
+ */
+beforeEach(() => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
describe('proxy', () => {
beforeEach(() => {
vi.clearAllMocks();
diff --git a/src/services/domainTimezoneService.test.ts b/src/services/domainTimezoneService.test.ts
index 1399c0f..4069eac 100644
--- a/src/services/domainTimezoneService.test.ts
+++ b/src/services/domainTimezoneService.test.ts
@@ -152,3 +152,52 @@ describe('DomainTimezoneService', () => {
});
});
});
+
+/**
+ * Remaining guard clauses.
+ *
+ * These are the fail-fast paths that keep a bad time zone or an unparseable MP
+ * datetime from silently drifting to the server's local zone — the exact class
+ * of bug CLAUDE.md rule 16 exists to prevent, so they are pinned explicitly.
+ */
+describe('DomainTimezoneService guard clauses', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('rejects a whitespace-only time zone identifier', () => {
+ expect(() => resolveIanaTimezone(' ')).toThrow('Time zone identifier is required');
+ });
+
+ it('rejects an unparseable MP datetime rather than returning Invalid Date', async () => {
+ const service = freshService();
+
+ await expect(service.parseMpDatetime('not-a-date')).rejects.toThrow(
+ /unable to parse "not-a-date"/,
+ );
+ });
+
+ it('parses a non-wall-clock but valid datetime through the Date fallback', async () => {
+ const service = freshService();
+
+ const parsed = await service.parseMpDatetime('2026-03-14T12:00:00Z');
+
+ expect(parsed.toISOString()).toBe('2026-03-14T12:00:00.000Z');
+ });
+
+ it('clearCache forces the next lookup to refetch domain info', async () => {
+ mockGetDomainInfo.mockResolvedValue({ TimeZoneName: 'Eastern Standard Time' });
+ const service = freshService();
+
+ await service.getMpTimezone();
+ expect(mockGetDomainInfo).toHaveBeenCalledTimes(1);
+
+ // Without clearCache the second call is served from cache.
+ await service.getMpTimezone();
+ expect(mockGetDomainInfo).toHaveBeenCalledTimes(1);
+
+ service.clearCache();
+ await service.getMpTimezone();
+ expect(mockGetDomainInfo).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/src/services/familyService.test.ts b/src/services/familyService.test.ts
new file mode 100644
index 0000000..908f1e9
--- /dev/null
+++ b/src/services/familyService.test.ts
@@ -0,0 +1,806 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { Household } from "@/lib/dto/family";
+
+const { mockGetTableRecords, mockCreateTableRecords, mockUpdateTableRecords, mockGetDomainInfo } =
+ vi.hoisted(() => ({
+ mockGetTableRecords: vi.fn(),
+ mockCreateTableRecords: vi.fn(),
+ mockUpdateTableRecords: vi.fn(),
+ mockGetDomainInfo: vi.fn(),
+ }));
+
+vi.mock("@/lib/providers/ministry-platform", () => ({
+ MPHelper: class {
+ getTableRecords = mockGetTableRecords;
+ createTableRecords = mockCreateTableRecords;
+ updateTableRecords = mockUpdateTableRecords;
+ getDomainInfo = mockGetDomainInfo;
+ },
+}));
+
+const { mockRequireSecurityRole } = vi.hoisted(() => ({
+ mockRequireSecurityRole: vi.fn(async () => 42),
+}));
+
+vi.mock("@/services/authorizationService", () => ({
+ AuthorizationService: {
+ getInstance: () => ({
+ requireSecurityRole: mockRequireSecurityRole,
+ }),
+ },
+}));
+
+import { FamilyService, PartialSaveError } from "./familyService";
+import { DomainTimezoneService } from "./domainTimezoneService";
+
+function makeHousehold(overrides: Partial = {}): Household {
+ return {
+ householdId: 0,
+ householdName: "Smith",
+ householdPhone: "",
+ congregationId: 1,
+ sourceId: 18,
+ address: {
+ addressId: 0,
+ addressLine1: "123 Main St",
+ addressLine2: null,
+ city: "Springfield",
+ state: "IL",
+ region: null,
+ postalCode: "62701",
+ countryCode: "US",
+ },
+ alternateMailingAddress: {
+ addressId: 0,
+ addressLine1: null,
+ addressLine2: null,
+ city: null,
+ state: null,
+ region: null,
+ postalCode: "",
+ countryCode: null,
+ },
+ seasonStart: null,
+ seasonEnd: null,
+ repeatsAnnually: false,
+ areHeadsMarried: false,
+ members: [],
+ ...overrides,
+ };
+}
+
+describe("FamilyService", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ (FamilyService as any).instance = undefined;
+
+ (DomainTimezoneService as any).instance = null;
+ mockRequireSecurityRole.mockResolvedValue(42);
+ mockGetDomainInfo.mockResolvedValue({ TimeZoneName: "UTC" });
+ });
+
+ it("is a singleton", async () => {
+ const instance1 = await FamilyService.getInstance();
+ const instance2 = await FamilyService.getInstance();
+ expect(instance1).toBe(instance2);
+ });
+
+ describe("searchContacts", () => {
+ it("authorizes a read against Contacts", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ await service.searchContacts("smith");
+ expect(mockRequireSecurityRole).toHaveBeenCalledWith({ table: "Contacts", operation: "read" });
+ });
+
+ it("returns [] without querying when trimmed term is shorter than 2 chars", async () => {
+ const service = await FamilyService.getInstance();
+ const result = await service.searchContacts(" a ");
+ expect(result).toEqual([]);
+ expect(mockGetTableRecords).not.toHaveBeenCalled();
+ });
+
+ it("escapes special characters and queries by Display_Name prefix", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ await service.searchContacts("O'Brien%_");
+ expect(mockGetTableRecords).toHaveBeenCalledWith(
+ expect.objectContaining({
+ table: "Contacts",
+ filter: "Display_Name LIKE 'O''Brien[%][_]%' AND Contact_Status_ID = 1",
+ }),
+ );
+ });
+
+ it("maps rows preferring Email_Address, falling back to the household address, then empty", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([
+ { Contact_ID: 1, Display_Name: "Smith, John", Email_Address: "john@example.com" },
+ {
+ Contact_ID: 2,
+ Display_Name: "Smith, Jane",
+ Email_Address: null,
+ Household_ID_TABLE_Address_ID_TABLE_Address_Line_1: "123 Main St",
+ },
+ { Contact_ID: 3, Display_Name: "Smith, Joe", Email_Address: null },
+ ]);
+ const service = await FamilyService.getInstance();
+ const result = await service.searchContacts("smith");
+ expect(result).toEqual([
+ { contactId: 1, displayName: "Smith, John", detail: "john@example.com" },
+ { contactId: 2, displayName: "Smith, Jane", detail: "123 Main St" },
+ { contactId: 3, displayName: "Smith, Joe", detail: "" },
+ ]);
+ });
+ });
+
+ describe("resolveContactIdFromPage", () => {
+ it("authorizes a read against the given table", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Resolved_Contact_ID: 5 }]);
+ const service = await FamilyService.getInstance();
+ await service.resolveContactIdFromPage("Event_Participants", "Event_Participant_ID", 10, "Contact_ID");
+ expect(mockRequireSecurityRole).toHaveBeenCalledWith({
+ table: "Event_Participants",
+ operation: "read",
+ });
+ });
+
+ it("throws for a non-positive recordId", async () => {
+ const service = await FamilyService.getInstance();
+ await expect(
+ service.resolveContactIdFromPage("Event_Participants", "Event_Participant_ID", 0, "Contact_ID"),
+ ).rejects.toThrow("Expected positive integer");
+ expect(mockGetTableRecords).not.toHaveBeenCalled();
+ });
+
+ it("throws for an invalid primaryKey column name", async () => {
+ const service = await FamilyService.getInstance();
+ await expect(
+ service.resolveContactIdFromPage("Event_Participants", "bad; name", 10, "Contact_ID"),
+ ).rejects.toThrow("Invalid column name");
+ });
+
+ it("returns null without querying when contactIdField is blank", async () => {
+ const service = await FamilyService.getInstance();
+ const result = await service.resolveContactIdFromPage(
+ "Event_Participants",
+ "Event_Participant_ID",
+ 10,
+ " ",
+ );
+ expect(result).toBeNull();
+ expect(mockGetTableRecords).not.toHaveBeenCalled();
+ });
+
+ it("throws for an invalid contactIdField column name (no _TABLE)", async () => {
+ const service = await FamilyService.getInstance();
+ await expect(
+ service.resolveContactIdFromPage("Event_Participants", "Event_Participant_ID", 10, "bad; name"),
+ ).rejects.toThrow("Invalid column name");
+ });
+
+ it("uses the FK path directly when contactIdField traverses a _TABLE join", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Resolved_Contact_ID: 77 }]);
+ const service = await FamilyService.getInstance();
+ const result = await service.resolveContactIdFromPage(
+ "Event_Participants",
+ "Event_Participant_ID",
+ 10,
+ "Participant_ID_TABLE_Contact_ID",
+ );
+ expect(mockGetTableRecords).toHaveBeenCalledWith(
+ expect.objectContaining({
+ select: "Participant_ID_TABLE_Contact_ID AS Resolved_Contact_ID",
+ filter: "Event_Participant_ID = 10",
+ }),
+ );
+ expect(result).toBe(77);
+ });
+
+ it("returns null when the resolved id is 0", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Resolved_Contact_ID: 0 }]);
+ const service = await FamilyService.getInstance();
+ const result = await service.resolveContactIdFromPage(
+ "Event_Participants",
+ "Event_Participant_ID",
+ 10,
+ "Contact_ID",
+ );
+ expect(result).toBeNull();
+ });
+
+ it("returns null when no row is found", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ const result = await service.resolveContactIdFromPage(
+ "Event_Participants",
+ "Event_Participant_ID",
+ 10,
+ "Contact_ID",
+ );
+ expect(result).toBeNull();
+ });
+ });
+
+ describe("getHousehold", () => {
+ it("authorizes a read against Households", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ await service.getHousehold(1);
+ expect(mockRequireSecurityRole).toHaveBeenCalledWith({ table: "Households", operation: "read" });
+ });
+
+ it("throws for a non-positive contactId", async () => {
+ const service = await FamilyService.getInstance();
+ await expect(service.getHousehold(-1)).rejects.toThrow("Expected positive integer");
+ });
+
+ it("returns null when the contact has no Household_ID", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Contact_ID: 1, Household_ID: null }]);
+ const service = await FamilyService.getInstance();
+ const result = await service.getHousehold(1);
+ expect(result).toBeNull();
+ // Only the Contacts lookup ran — Promise.all for households/members never fired.
+ expect(mockGetTableRecords).toHaveBeenCalledTimes(1);
+ });
+
+ it("returns null when no contact row is found at all", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ const result = await service.getHousehold(1);
+ expect(result).toBeNull();
+ });
+
+ it("returns null when the household row itself is missing", async () => {
+ mockGetTableRecords
+ .mockResolvedValueOnce([{ Contact_ID: 1, Household_ID: 55 }])
+ .mockResolvedValueOnce([]) // households
+ .mockResolvedValueOnce([]); // members
+ const service = await FamilyService.getInstance();
+ const result = await service.getHousehold(1);
+ expect(result).toBeNull();
+ });
+
+ it("maps a full household with members, addresses, participant and donor", async () => {
+ mockGetTableRecords
+ .mockResolvedValueOnce([{ Contact_ID: 1, Household_ID: 55 }])
+ .mockResolvedValueOnce([
+ {
+ Household_ID: 55,
+ Household_Name: "Smith Family",
+ Home_Phone: "555-1234",
+ Congregation_ID: 2,
+ Household_Source_ID: 3,
+ Address_ID: 501,
+ Alternate_Mailing_Address: 502,
+ Season_Start: "2024-01-01",
+ Season_End: "0001-01-01T00:00:00",
+ Repeats_Annually: true,
+ Addr1_Line1: "123 Main St",
+ Addr1_Line2: "Apt 4",
+ Addr1_City: "Springfield",
+ Addr1_State: "IL",
+ Addr1_Postal: "62701",
+ Addr1_Country: "US",
+ Addr2_Line1: "PO Box 9",
+ Addr2_Line2: null,
+ Addr2_City: "Springfield",
+ Addr2_State: "IL",
+ Addr2_Postal: "62701",
+ Addr2_Country: "US",
+ },
+ ])
+ .mockResolvedValueOnce([
+ {
+ Contact_ID: 701,
+ Display_Name: "Smith, John",
+ First_Name: "John",
+ Middle_Name: null,
+ Maiden_Name: null,
+ Last_Name: "Smith",
+ Nickname: null,
+ Prefix_ID: null,
+ Suffix_ID: null,
+ Date_of_Birth: "1980-01-01",
+ Gender_ID: 1,
+ Marital_Status_ID: 2,
+ Mobile_Phone: "555-0000",
+ Email_Address: "john@example.com",
+ Bulk_Email_Opt_Out: false,
+ Contact_Status_ID: 1,
+ Primary_Language_ID: null,
+ Faith_Background_ID: null,
+ Household_Position_ID: 1,
+ Participant_Record: 801,
+ Donor_Record: 901,
+ Participant_Type_ID: 4,
+ Envelope_No: 1001,
+ },
+ {
+ Contact_ID: 702,
+ Display_Name: "Smith, Jane",
+ First_Name: "Jane",
+ Last_Name: "Smith",
+ Household_Position_ID: 2,
+ Participant_Record: null,
+ Donor_Record: null,
+ },
+ ]);
+
+ const service = await FamilyService.getInstance();
+ const result = await service.getHousehold(1);
+
+ expect(result).not.toBeNull();
+ expect(result!.householdId).toBe(55);
+ expect(result!.householdName).toBe("Smith Family");
+ expect(result!.householdPhone).toBe("555-1234");
+ expect(result!.congregationId).toBe(2);
+ expect(result!.sourceId).toBe(3);
+ expect(result!.seasonStart).toBe("2024-01-01");
+ expect(result!.seasonEnd).toBeNull(); // 0001-01-01 sentinel maps to null
+ expect(result!.repeatsAnnually).toBe(true);
+ expect(result!.areHeadsMarried).toBe(false);
+
+ expect(result!.address).toEqual({
+ addressId: 501,
+ addressLine1: "123 Main St",
+ addressLine2: "Apt 4",
+ city: "Springfield",
+ state: "IL",
+ region: null,
+ postalCode: "62701",
+ countryCode: "US",
+ });
+ expect(result!.alternateMailingAddress.addressId).toBe(502);
+
+ expect(result!.members).toHaveLength(2);
+ const [john, jane] = result!.members;
+ expect(john.contactId).toBe(701);
+ expect(john.birthDate).toBe("1980-01-01");
+ expect(john.participant).toEqual({
+ participantId: 801,
+ participantTypeId: 4,
+ notes: null,
+ });
+ expect(john.donorId).toBe(901);
+ expect(john.isDonor).toBe(true);
+ expect(john.envelopeNo).toBe(1001);
+
+ expect(jane.participant).toBeNull();
+ expect(jane.donorId).toBeNull();
+ expect(jane.isDonor).toBe(false);
+ expect(jane.birthDate).toBeNull();
+ expect(jane.firstName).toBe("Jane");
+ });
+ });
+
+ describe("getLookups", () => {
+ it("authorizes a read against Contacts and composes all lookup lists", async () => {
+ mockGetTableRecords
+ .mockResolvedValueOnce([{ Congregation_ID: 1, Congregation_Name: "Main Campus" }])
+ .mockResolvedValueOnce([{ Household_Source_ID: 1, Household_Source: "Web" }])
+ .mockResolvedValueOnce([{ Household_Position_ID: 1, Household_Position: "Head" }])
+ .mockResolvedValueOnce([{ Participant_Type_ID: 4, Participant_Type: "Member" }])
+ .mockResolvedValueOnce([{ Marital_Status_ID: 1, Marital_Status: "Single" }])
+ .mockResolvedValueOnce([{ Prefix_ID: 1, Prefix: "Mr." }])
+ .mockResolvedValueOnce([{ Suffix_ID: 1, Suffix: "Jr." }])
+ .mockResolvedValueOnce([{ Gender_ID: 1, Gender: "Male" }])
+ .mockResolvedValueOnce([{ Contact_Status_ID: 1, Contact_Status: "Active" }])
+ .mockResolvedValueOnce([{ Primary_Language_ID: 1, Primary_Language: "English" }])
+ .mockResolvedValueOnce([{ Faith_Background_ID: 1, Faith_Background: "Christian" }])
+ .mockResolvedValueOnce([
+ { Country_Code: "US", Country: "United States" },
+ { Country_Code: null, Country: "Bad Row" },
+ { Country_Code: "CA", Country: null },
+ ]);
+
+ const service = await FamilyService.getInstance();
+ const lookups = await service.getLookups();
+
+ expect(mockRequireSecurityRole).toHaveBeenCalledWith({ table: "Contacts", operation: "read" });
+ expect(lookups.congregations).toEqual([{ id: 1, name: "Main Campus" }]);
+ expect(lookups.sources).toEqual([{ id: 1, name: "Web" }]);
+ expect(lookups.householdPositions).toEqual([{ id: 1, name: "Head" }]);
+ expect(lookups.participantTypes).toEqual([{ id: 4, name: "Member" }]);
+ expect(lookups.maritalStatuses).toEqual([{ id: 1, name: "Single" }]);
+ expect(lookups.prefixes).toEqual([{ id: 1, name: "Mr." }]);
+ expect(lookups.suffixes).toEqual([{ id: 1, name: "Jr." }]);
+ expect(lookups.genders).toEqual([{ id: 1, name: "Male" }]);
+ expect(lookups.contactStatuses).toEqual([{ id: 1, name: "Active" }]);
+ expect(lookups.primaryLanguages).toEqual([{ id: 1, name: "English" }]);
+ expect(lookups.faithBackgrounds).toEqual([{ id: 1, name: "Christian" }]);
+ expect(lookups.countries).toEqual([{ code: "US", name: "United States" }]);
+ expect(lookups.states.length).toBeGreaterThan(0);
+ expect(lookups.states[0]).toEqual({ code: "AL", name: "Alabama" });
+ });
+ });
+
+ describe("getDefaults", () => {
+ it("returns a copy of the default family values", async () => {
+ const service = await FamilyService.getInstance();
+ const first = service.getDefaults();
+ first.congregationId = 999;
+ const second = service.getDefaults();
+ expect(second.congregationId).toBe(1);
+ expect(mockRequireSecurityRole).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("getNextEnvelopeNumber", () => {
+ it("authorizes a read against Contacts", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Highest: 100 }]);
+ const service = await FamilyService.getInstance();
+ await service.getNextEnvelopeNumber();
+ expect(mockRequireSecurityRole).toHaveBeenCalledWith({ table: "Contacts", operation: "read" });
+ });
+
+ it("returns 1 when there are no existing envelope numbers", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Highest: null }]);
+ const service = await FamilyService.getInstance();
+ const result = await service.getNextEnvelopeNumber();
+ expect(result).toBe(1);
+ });
+
+ it("returns 1 when no row is returned at all", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await FamilyService.getInstance();
+ const result = await service.getNextEnvelopeNumber();
+ expect(result).toBe(1);
+ });
+
+ it("returns highest + 1 when envelopes already exist", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Highest: 5000 }]);
+ const service = await FamilyService.getInstance();
+ const result = await service.getNextEnvelopeNumber();
+ expect(result).toBe(5001);
+ });
+ });
+
+ describe("saveHousehold", () => {
+ it("authorizes an update against Households before anything else", async () => {
+ mockRequireSecurityRole.mockRejectedValueOnce(new Error("Not authorized"));
+ const service = await FamilyService.getInstance();
+ await expect(service.saveHousehold(makeHousehold())).rejects.toThrow("Not authorized");
+ expect(mockCreateTableRecords).not.toHaveBeenCalled();
+ });
+
+ it("creates a new household, skips the blank alternate address, and creates a new member with a new participant and donor", async () => {
+ // 1. upsertAddress(main) -> create
+ mockCreateTableRecords
+ .mockResolvedValueOnce([{ Address_ID: 501 }]) // main address create
+ .mockResolvedValueOnce([{ Household_ID: 601 }]) // household create
+ .mockResolvedValueOnce([{ Contact_ID: 701 }]) // contact create
+ .mockResolvedValueOnce([{ Participant_ID: 801 }]) // participant create
+ .mockResolvedValueOnce([{ Donor_ID: 901 }]); // donor create
+
+ // Envelope conflict check -> no conflict
+ mockGetTableRecords.mockResolvedValueOnce([]);
+
+ const household = makeHousehold({
+ members: [
+ {
+ contactId: -1,
+ firstName: "John",
+ middleName: "",
+ maidenName: "",
+ lastName: "Smith",
+ nickname: "",
+ prefixId: 0,
+ suffixId: 0,
+ birthDate: null,
+ genderId: 0,
+ maritalStatusId: 0,
+ mobilePhone: "",
+ emailAddress: "",
+ bulkEmailOpt: false,
+ envelopeNo: 1001,
+ contactStatusId: 1,
+ primaryLanguageId: null,
+ faithBackgroundId: null,
+ householdPositionId: 1,
+ participant: { participantId: 0, participantTypeId: 4, notes: null },
+ donorId: null,
+ isDonor: true,
+ },
+ {
+ contactId: -2,
+ firstName: " ",
+ middleName: "",
+ maidenName: "",
+ lastName: "",
+ nickname: "",
+ prefixId: 0,
+ suffixId: 0,
+ birthDate: null,
+ genderId: 0,
+ maritalStatusId: 0,
+ mobilePhone: "",
+ emailAddress: "",
+ bulkEmailOpt: false,
+ envelopeNo: null,
+ contactStatusId: 1,
+ primaryLanguageId: null,
+ faithBackgroundId: null,
+ householdPositionId: 1,
+ participant: null,
+ donorId: null,
+ isDonor: false,
+ },
+ ],
+ });
+
+ const service = await FamilyService.getInstance();
+ const progress = await service.saveHousehold(household);
+
+ expect(progress.mainAddressId).toBe(501);
+ expect(progress.altAddressId).toBeNull();
+ expect(progress.householdId).toBe(601);
+ expect(progress.members).toHaveLength(1); // blank second member skipped
+
+ const saved = progress.members[0];
+ expect(saved.tempContactId).toBe(-1);
+ expect(saved.contactId).toBe(701);
+ expect(saved.participantId).toBe(801);
+ expect(saved.donorId).toBe(901);
+ expect(saved.envelopeNo).toBe(1001);
+ expect(saved.envelopeBumped).toBe(false);
+
+ // First create call was for the main address.
+ expect(mockCreateTableRecords.mock.calls[0][0]).toBe("Addresses");
+ expect(mockCreateTableRecords.mock.calls[1][0]).toBe("Households");
+ expect(mockCreateTableRecords.mock.calls[2][0]).toBe("Contacts");
+ expect(mockCreateTableRecords.mock.calls[3][0]).toBe("Participants");
+ expect(mockCreateTableRecords.mock.calls[4][0]).toBe("Donors");
+
+ // $userId comes solely from the authorization gate's return value.
+ for (const call of mockCreateTableRecords.mock.calls) {
+ expect(call[2]).toMatchObject({ $userId: 42 });
+ }
+
+ // Contact gets patched with the new Participant_Record and Donor_Record.
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Contacts",
+ [{ Contact_ID: 701, Participant_Record: 801 }],
+ expect.objectContaining({ $userId: 42 }),
+ );
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Contacts",
+ [{ Contact_ID: 701, Donor_Record: 901 }],
+ expect.objectContaining({ $userId: 42 }),
+ );
+ });
+
+ it("updates an existing household, address, member, participant and donor", async () => {
+ mockUpdateTableRecords.mockResolvedValue(undefined);
+ // Alternate address create (only new address in this scenario)
+ mockCreateTableRecords.mockResolvedValueOnce([{ Address_ID: 502 }]);
+ // Envelope conflict check (excluding existing donor) -> no conflict
+ mockGetTableRecords.mockResolvedValueOnce([]);
+
+ const household = makeHousehold({
+ householdId: 55,
+ address: {
+ addressId: 501,
+ addressLine1: "123 Main St",
+ addressLine2: null,
+ city: "Springfield",
+ state: "IL",
+ region: null,
+ postalCode: "62701",
+ countryCode: "US",
+ },
+ alternateMailingAddress: {
+ addressId: 0,
+ addressLine1: "PO Box 9",
+ addressLine2: null,
+ city: "Springfield",
+ state: "IL",
+ region: null,
+ postalCode: "62701",
+ countryCode: "US",
+ },
+ members: [
+ {
+ contactId: 701,
+ firstName: "John",
+ middleName: "",
+ maidenName: "",
+ lastName: "Smith",
+ nickname: "",
+ prefixId: 0,
+ suffixId: 0,
+ birthDate: "1980-05-01",
+ genderId: 1,
+ maritalStatusId: 1,
+ mobilePhone: "",
+ emailAddress: "",
+ bulkEmailOpt: false,
+ envelopeNo: 1002,
+ contactStatusId: 1,
+ primaryLanguageId: null,
+ faithBackgroundId: null,
+ householdPositionId: 1,
+ participant: { participantId: 801, participantTypeId: 4, notes: null },
+ donorId: 901,
+ isDonor: true,
+ },
+ ],
+ });
+
+ const service = await FamilyService.getInstance();
+ const progress = await service.saveHousehold(household);
+
+ expect(progress.mainAddressId).toBe(501); // existing, updated in place
+ expect(progress.altAddressId).toBe(502); // created
+ expect(progress.householdId).toBe(55);
+ expect(progress.members).toHaveLength(1);
+ expect(progress.members[0]).toEqual({
+ tempContactId: 701,
+ contactId: 701,
+ participantId: 801,
+ donorId: 901,
+ envelopeNo: 1002,
+ envelopeBumped: false,
+ });
+
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Addresses",
+ [expect.objectContaining({ Address_ID: 501 })],
+ expect.objectContaining({ partial: true, $userId: 42 }),
+ );
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Households",
+ [expect.objectContaining({ Household_ID: 55 })],
+ expect.objectContaining({ partial: true, $userId: 42 }),
+ );
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Participants",
+ [{ Participant_ID: 801, Participant_Type_ID: 4 }],
+ expect.objectContaining({ $userId: 42 }),
+ );
+ expect(mockUpdateTableRecords).toHaveBeenCalledWith(
+ "Donors",
+ [{ Donor_ID: 901, Envelope_No: 1002 }],
+ expect.objectContaining({ $userId: 42 }),
+ );
+
+ const donorConflictCall = mockGetTableRecords.mock.calls.find(
+ (c) => c[0].table === "Donors" && c[0].select === "Donor_ID",
+ );
+ expect(donorConflictCall![0].filter).toBe("Envelope_No = 1002 AND Donor_ID <> 901");
+ });
+
+ it("bumps the envelope number when the requested one conflicts, and reports envelopeBumped", async () => {
+ mockCreateTableRecords
+ .mockResolvedValueOnce([{ Household_ID: 601 }])
+ .mockResolvedValueOnce([{ Contact_ID: 701 }])
+ .mockResolvedValueOnce([{ Donor_ID: 901 }]);
+
+ mockGetTableRecords
+ .mockResolvedValueOnce([{ Donor_ID: 55 }]) // conflict on requested 1001
+ .mockResolvedValueOnce([{ Highest: 1050 }]) // getNextEnvelopeNumber -> 1051
+ .mockResolvedValueOnce([]); // no conflict on 1051
+
+ const household = makeHousehold({
+ address: { ...makeHousehold().address, addressLine1: null, postalCode: "" }, // no address content
+ members: [
+ {
+ contactId: -1,
+ firstName: "John",
+ middleName: "",
+ maidenName: "",
+ lastName: "Smith",
+ nickname: "",
+ prefixId: 0,
+ suffixId: 0,
+ birthDate: null,
+ genderId: 0,
+ maritalStatusId: 0,
+ mobilePhone: "",
+ emailAddress: "",
+ bulkEmailOpt: false,
+ envelopeNo: 1001,
+ contactStatusId: 1,
+ primaryLanguageId: null,
+ faithBackgroundId: null,
+ householdPositionId: 1,
+ participant: null,
+ donorId: null,
+ isDonor: true,
+ },
+ ],
+ });
+
+ const service = await FamilyService.getInstance();
+ const progress = await service.saveHousehold(household);
+
+ expect(progress.mainAddressId).toBeNull(); // no address content -> no create call
+ expect(progress.members[0].envelopeNo).toBe(1051);
+ expect(progress.members[0].envelopeBumped).toBe(true);
+ });
+
+ it("throws after 5 failed attempts to find a unique envelope number, wrapped in PartialSaveError", async () => {
+ mockCreateTableRecords
+ .mockResolvedValueOnce([{ Household_ID: 601 }])
+ .mockResolvedValueOnce([{ Contact_ID: 701 }]);
+
+ // Every conflict check returns a conflict; every "next number" call returns the same value.
+ mockGetTableRecords.mockImplementation(async (query: { table: string; select: string }) => {
+ if (query.table === "Donors" && query.select === "Donor_ID") {
+ return [{ Donor_ID: 55 }];
+ }
+ if (query.table === "Donors" && query.select === "MAX(Envelope_No) AS Highest") {
+ return [{ Highest: 1000 }];
+ }
+ return [];
+ });
+
+ const household = makeHousehold({
+ address: { ...makeHousehold().address, addressLine1: null, postalCode: "" },
+ members: [
+ {
+ contactId: -1,
+ firstName: "John",
+ middleName: "",
+ maidenName: "",
+ lastName: "Smith",
+ nickname: "",
+ prefixId: 0,
+ suffixId: 0,
+ birthDate: null,
+ genderId: 0,
+ maritalStatusId: 0,
+ mobilePhone: "",
+ emailAddress: "",
+ bulkEmailOpt: false,
+ envelopeNo: 1001,
+ contactStatusId: 1,
+ primaryLanguageId: null,
+ faithBackgroundId: null,
+ householdPositionId: 1,
+ participant: null,
+ donorId: null,
+ isDonor: true,
+ },
+ ],
+ });
+
+ const service = await FamilyService.getInstance();
+ const error = await service.saveHousehold(household).catch((e) => e);
+
+ expect(error).toBeInstanceOf(PartialSaveError);
+ expect((error as PartialSaveError).message).toContain(
+ "Could not find an available envelope number after 5 attempts",
+ );
+ expect((error as PartialSaveError).progress.householdId).toBe(601);
+ });
+
+ it("wraps a failure creating the main address in a PartialSaveError with the progress so far", async () => {
+ mockCreateTableRecords.mockRejectedValueOnce(new Error("address insert failed"));
+
+ const service = await FamilyService.getInstance();
+ const error = await service.saveHousehold(makeHousehold()).catch((e) => e);
+
+ expect(error).toBeInstanceOf(PartialSaveError);
+ expect((error as PartialSaveError).message).toBe("address insert failed");
+ expect((error as PartialSaveError).progress).toEqual({
+ mainAddressId: null,
+ altAddressId: null,
+ householdId: null,
+ members: [],
+ });
+ expect((error as PartialSaveError).underlying).toBeInstanceOf(Error);
+ });
+
+ it("wraps a non-Error throw's String() representation as the message", async () => {
+ mockCreateTableRecords.mockRejectedValueOnce("raw string failure");
+
+ const service = await FamilyService.getInstance();
+ const error = await service.saveHousehold(makeHousehold()).catch((e) => e);
+
+ expect(error).toBeInstanceOf(PartialSaveError);
+ expect((error as PartialSaveError).message).toBe("raw string failure");
+ expect((error as PartialSaveError).underlying).toBe("raw string failure");
+ });
+ });
+});
diff --git a/src/services/googlePlacesService.test.ts b/src/services/googlePlacesService.test.ts
new file mode 100644
index 0000000..4fa9355
--- /dev/null
+++ b/src/services/googlePlacesService.test.ts
@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+const { mockGetTableRecords } = vi.hoisted(() => ({
+ mockGetTableRecords: vi.fn(),
+}));
+
+vi.mock("@/lib/providers/ministry-platform", () => ({
+ MPHelper: class {
+ getTableRecords = mockGetTableRecords;
+ },
+}));
+
+const { mockAutocomplete, mockGetPlaceDetails, MockGooglePlacesProvider } = vi.hoisted(() => {
+ const mockAutocomplete = vi.fn();
+ const mockGetPlaceDetails = vi.fn();
+ class MockGooglePlacesProvider {
+ apiKey: string;
+ constructor(apiKey: string) {
+ this.apiKey = apiKey;
+ }
+ autocomplete = mockAutocomplete;
+ getPlaceDetails = mockGetPlaceDetails;
+ }
+ return { mockAutocomplete, mockGetPlaceDetails, MockGooglePlacesProvider };
+});
+
+vi.mock("@/lib/providers/google-places", () => ({
+ GooglePlacesProvider: MockGooglePlacesProvider,
+}));
+
+import { GooglePlacesService } from "./googlePlacesService";
+
+describe("GooglePlacesService", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ (GooglePlacesService as any).instance = undefined;
+ vi.unstubAllEnvs();
+ });
+
+ afterEach(() => {
+ vi.unstubAllEnvs();
+ });
+
+ it("is a singleton", async () => {
+ const instance1 = await GooglePlacesService.getInstance();
+ const instance2 = await GooglePlacesService.getInstance();
+ expect(instance1).toBe(instance2);
+ });
+
+ describe("resolveApiKey / isEnabled", () => {
+ it("resolves the key from MP configuration settings", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Value: "mp-key-123" }]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(true);
+ expect(mockGetTableRecords).toHaveBeenCalledWith(
+ expect.objectContaining({
+ table: "dp_Configuration_Settings",
+ filter: "Application_Code='COMMON' AND Key_Name='GoogleMapsAPIKey'",
+ }),
+ );
+ });
+
+ it("caches the resolved key so MP is queried only once", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Value: "mp-key-123" }]);
+ const service = await GooglePlacesService.getInstance();
+ await service.isEnabled();
+ await service.isEnabled();
+ expect(mockGetTableRecords).toHaveBeenCalledTimes(1);
+ });
+
+ it("falls back to the env var when MP has no value", async () => {
+ vi.stubEnv("GOOGLE_PLACES_API_KEY", "env-key-456");
+ mockGetTableRecords.mockResolvedValueOnce([{ Value: null }]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(true);
+ });
+
+ it("falls back to the env var when MP row Value is blank/whitespace", async () => {
+ vi.stubEnv("GOOGLE_PLACES_API_KEY", "env-key-456");
+ mockGetTableRecords.mockResolvedValueOnce([{ Value: " " }]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(true);
+ });
+
+ it("falls back to the env var when MP returns no rows", async () => {
+ vi.stubEnv("GOOGLE_PLACES_API_KEY", "env-key-456");
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(true);
+ });
+
+ it("falls back to the env var when the MP lookup throws", async () => {
+ vi.stubEnv("GOOGLE_PLACES_API_KEY", "env-key-456");
+ mockGetTableRecords.mockRejectedValueOnce(new Error("table permission denied"));
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(true);
+ });
+
+ it("resolves to disabled (null) when neither MP nor env provide a key", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(false);
+ });
+
+ it("treats a blank env var as disabled", async () => {
+ vi.stubEnv("GOOGLE_PLACES_API_KEY", " ");
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await GooglePlacesService.getInstance();
+ expect(await service.isEnabled()).toBe(false);
+ });
+ });
+
+ describe("getProvider / autocomplete / getPlaceDetails", () => {
+ it("throws a descriptive error when no key is configured", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([]);
+ const service = await GooglePlacesService.getInstance();
+ await expect(service.autocomplete("123 Main", "token")).rejects.toThrow(
+ "Google Places API key is not configured",
+ );
+ });
+
+ it("creates the provider once and reuses it across calls", async () => {
+ mockGetTableRecords.mockResolvedValueOnce([{ Value: "mp-key-123" }]);
+ mockAutocomplete.mockResolvedValue([]);
+ mockGetPlaceDetails.mockResolvedValue({
+ placeId: "p1",
+ formattedAddress: "",
+ addressLine1: "",
+ city: "",
+ state: "",
+ postalCode: "",
+ countryCode: "",
+ });
+
+ const service = await GooglePlacesService.getInstance();
+ await service.autocomplete("123 Main", "token-1");
+ await service.getPlaceDetails("p1", "token-1");
+
+ expect(mockAutocomplete).toHaveBeenCalledWith("123 Main", "token-1");
+ expect(mockGetPlaceDetails).toHaveBeenCalledWith("p1", "token-1");
+ // Only resolved once thanks to caching of both the key and the provider.
+ expect(mockGetTableRecords).toHaveBeenCalledTimes(1);
+ });
+ });
+});
diff --git a/vitest.config.mts b/vitest.config.mts
new file mode 100644
index 0000000..833d073
--- /dev/null
+++ b/vitest.config.mts
@@ -0,0 +1,71 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+ plugins: [react()],
+ test: {
+ environment: 'jsdom',
+ globals: true,
+ setupFiles: ['./src/test-setup.ts'],
+ include: ['src/**/*.{test,spec}.{ts,tsx}'],
+ exclude: ['node_modules', '.next'],
+ coverage: {
+ provider: 'v8',
+ reporter: ['text', 'json', 'html'],
+ // `include` is load-bearing. Without it the v8 provider only reports
+ // files that some test imported, so an untested file is invisible
+ // rather than counted as 0%. That masked ~1,600 uncovered statements
+ // and inflated the reported number from 48% to 83%.
+ //
+ // Note: this is the Vitest 5 spelling. The old `coverage.all: true`
+ // flag was REMOVED in Vitest 5 — setting it is a type error and does
+ // nothing. `include` is now the only way to widen the denominator.
+ include: ['src/**/*.{ts,tsx}'],
+ /**
+ * Statements and lines only, by deliberate choice.
+ *
+ * Branch and function coverage are noisier — a single added guard
+ * clause or a defensive `?? []` can drop branch coverage below a bar
+ * that nothing is actually wrong with, and a threshold people learn to
+ * override is worse than no threshold. Statements and lines move
+ * predictably with real test work.
+ *
+ * Set below the achieved figures (98.84% statements / 99.70% lines) so
+ * ordinary work has room, but above the 95% target so the suite cannot
+ * quietly slide back under it. Raise these when coverage rises; never
+ * lower them to make a red build green.
+ */
+ thresholds: {
+ statements: 97,
+ lines: 98,
+ },
+ // NOTE: directory exclusions must end in `**`. A bare trailing slash
+ // (e.g. 'src/components/ui/') matches nothing, so the files stay in the
+ // denominator — which is how the shadcn primitives were silently being
+ // counted before.
+ exclude: [
+ 'node_modules/**',
+ '.next/**',
+ 'src/test-setup.ts',
+ '**/*.d.ts',
+ '**/*.{test,spec}.{ts,tsx}',
+ 'src/lib/providers/ministry-platform/models/**', // Auto-generated files
+ 'src/lib/providers/ministry-platform/scripts/**', // Build-time CLI scripts
+ 'src/components/ui/**', // Vendored shadcn/ui primitives
+ '**/loading.tsx', // Declarative skeleton markup
+ 'src/app/layout.tsx', // Root font/metadata shell
+ 'src/app/(web)/layout.tsx', // Font/metadata shell
+ '**/index.ts', // Barrel re-exports
+ '**/types.ts', // Type-only modules
+ ],
+ },
+ },
+ resolve: {
+ alias: {
+ // `import.meta.dirname`, not `__dirname`: this file is ESM (.mts), and
+ // Vite's native config loader has no CommonJS globals.
+ '@': path.resolve(import.meta.dirname, './src'),
+ },
+ },
+});
diff --git a/vitest.config.ts b/vitest.config.ts
deleted file mode 100644
index 52a0268..0000000
--- a/vitest.config.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { defineConfig } from 'vitest/config';
-import react from '@vitejs/plugin-react';
-import path from 'path';
-
-export default defineConfig({
- plugins: [react()],
- test: {
- environment: 'jsdom',
- globals: true,
- setupFiles: ['./src/test-setup.ts'],
- include: ['src/**/*.{test,spec}.{ts,tsx}'],
- exclude: ['node_modules', '.next'],
- coverage: {
- provider: 'v8',
- reporter: ['text', 'json', 'html'],
- exclude: [
- 'node_modules/',
- '.next/',
- 'src/test-setup.ts',
- '**/*.d.ts',
- 'src/lib/providers/ministry-platform/models/', // Auto-generated files
- ],
- },
- },
- resolve: {
- alias: {
- '@': path.resolve(__dirname, './src'),
- },
- },
-});