@htlkg/data 0.0.1 → 0.0.3

package/src/hooks/data-hook-errors.property.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Property-Based Tests for Data Hook Error Handling
+ *
+ * Feature: htlkg-modular-architecture, Property 7: Data hook errors are handled
+ * Validates: Requirements 11.5
+ *
+ * Tests that data hooks correctly handle errors during data fetching.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fc from "fast-check";
+import { useBrands } from "./useBrands";
+import { useAccounts } from "./useAccounts";
+import { useUsers } from "./useUsers";
+import { useProducts } from "./useProducts";
+
+// Create separate mock functions for each model
+const mockBrandList = vi.fn();
+const mockAccountList = vi.fn();
+const mockUserList = vi.fn();
+const mockProductList = vi.fn();
+
+// Mock console.error to verify error logging
+const mockConsoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+vi.mock("../client", () => ({
+	generateClient: vi.fn(() => ({
+		models: {
+			Brand: { list: mockBrandList },
+			Account: { list: mockAccountList },
+			User: { list: mockUserList },
+			Product: { list: mockProductList },
+		},
+	})),
+}));
+
+describe("Data Hook Error Handling - Property 7: Data hook errors are handled", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockConsoleError.mockClear();
+	});
+
+	/**
+	 * Property: For any error during fetch, the error state should be set
+	 * and the error should be logged
+	 */
+	it("useBrands handles fetch errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.string({ minLength: 1 }), async (errorMessage) => {
+				// Reset mocks
+				mockBrandList.mockClear();
+				mockConsoleError.mockClear();
+
+				// Setup mock to throw an error
+				const testError = new Error(errorMessage);
+				mockBrandList.mockRejectedValue(testError);
+
+				const { error, loading, refetch } = useBrands({ autoFetch: false });
+
+				// Initially no error
+				expect(error.value).toBeNull();
+
+				// Trigger fetch
+				await refetch();
+
+				// Wait for async operations
+				await new Promise((resolve) => setTimeout(resolve, 10));
+
+				// Error state should be set
+				expect(error.value).toBeInstanceOf(Error);
+				expect(error.value?.message).toBe(errorMessage);
+
+				// Loading should be false after error
+				expect(loading.value).toBe(false);
+
+				// Error should be logged
+				expect(mockConsoleError).toHaveBeenCalled();
+				expect(mockConsoleError.mock.calls[0][0]).toContain("[useBrands]");
+			}),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any GraphQL errors array, the first error message should be used
+	 */
+	it("useBrands handles GraphQL errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.string({ minLength: 1 }), async (errorMessage) => {
+				// Reset mocks
+				mockBrandList.mockClear();
+				mockConsoleError.mockClear();
+
+				// Setup mock to return GraphQL errors
+				mockBrandList.mockResolvedValue({
+					data: null,
+					errors: [{ message: errorMessage }],
+				});
+
+				const { error, loading, refetch } = useBrands({ autoFetch: false });
+
+				// Trigger fetch
+				await refetch();
+
+				// Wait for async operations
+				await new Promise((resolve) => setTimeout(resolve, 10));
+
+				// Error state should be set with the GraphQL error message
+				expect(error.value).toBeInstanceOf(Error);
+				expect(error.value?.message).toBe(errorMessage);
+
+				// Loading should be false after error
+				expect(loading.value).toBe(false);
+
+				// Error should be logged
+				expect(mockConsoleError).toHaveBeenCalled();
+			}),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any error during useAccounts fetch, error handling should work
+	 */
+	it("useAccounts handles fetch errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.string({ minLength: 1 }), async (errorMessage) => {
+				// Reset mocks
+				mockAccountList.mockClear();
+				mockConsoleError.mockClear();
+
+				// Setup mock to throw an error
+				const testError = new Error(errorMessage);
+				mockAccountList.mockRejectedValue(testError);
+
+				const { error, loading, refetch } = useAccounts({ autoFetch: false });
+
+				// Trigger fetch
+				await refetch();
+
+				// Wait for async operations
+				await new Promise((resolve) => setTimeout(resolve, 10));
+
+				// Error state should be set
+				expect(error.value).toBeInstanceOf(Error);
+				expect(error.value?.message).toBe(errorMessage);
+
+				// Loading should be false after error
+				expect(loading.value).toBe(false);
+
+				// Error should be logged
+				expect(mockConsoleError).toHaveBeenCalled();
+				expect(mockConsoleError.mock.calls[0][0]).toContain("[useAccounts]");
+			}),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any error during useUsers fetch, error handling should work
+	 */
+	it("useUsers handles fetch errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.string({ minLength: 1 }), async (errorMessage) => {
+				// Reset mocks
+				mockUserList.mockClear();
+				mockConsoleError.mockClear();
+
+				// Setup mock to throw an error
+				const testError = new Error(errorMessage);
+				mockUserList.mockRejectedValue(testError);
+
+				const { error, loading, refetch } = useUsers({ autoFetch: false });
+
+				// Trigger fetch
+				await refetch();
+
+				// Wait for async operations
+				await new Promise((resolve) => setTimeout(resolve, 10));
+
+				// Error state should be set
+				expect(error.value).toBeInstanceOf(Error);
+				expect(error.value?.message).toBe(errorMessage);
+
+				// Loading should be false after error
+				expect(loading.value).toBe(false);
+
+				// Error should be logged
+				expect(mockConsoleError).toHaveBeenCalled();
+				expect(mockConsoleError.mock.calls[0][0]).toContain("[useUsers]");
+			}),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any error during useProducts fetch, error handling should work
+	 */
+	it("useProducts handles fetch errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.string({ minLength: 1 }), async (errorMessage) => {
+				// Reset mocks
+				mockProductList.mockClear();
+				mockConsoleError.mockClear();
+
+				// Setup mock to throw an error
+				const testError = new Error(errorMessage);
+				mockProductList.mockRejectedValue(testError);
+
+				const { error, loading, refetch } = useProducts({ autoFetch: false });
+
+				// Trigger fetch
+				await refetch();
+
+				// Wait for async operations
+				await new Promise((resolve) => setTimeout(resolve, 10));
+
+				// Error state should be set
+				expect(error.value).toBeInstanceOf(Error);
+				expect(error.value?.message).toBe(errorMessage);
+
+				// Loading should be false after error
+				expect(loading.value).toBe(false);
+
+				// Error should be logged
+				expect(mockConsoleError).toHaveBeenCalled();
+				expect(mockConsoleError.mock.calls[0][0]).toContain("[useProducts]");
+			}),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: After an error, refetch should clear the error and try again
+	 */
+	it("refetch clears previous errors", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.string({ minLength: 1 }),
+				fc.array(fc.record({ id: fc.string(), name: fc.string() })),
+				async (errorMessage, successData) => {
+					// Reset mocks
+					mockBrandList.mockClear();
+					mockConsoleError.mockClear();
+
+					// First call fails
+					mockBrandList.mockRejectedValueOnce(new Error(errorMessage));
+					// Second call succeeds
+					mockBrandList.mockResolvedValueOnce({ data: successData, errors: null });
+
+					const { error, brands, refetch } = useBrands({ autoFetch: false });
+
+					// First fetch - should error
+					await refetch();
+					await new Promise((resolve) => setTimeout(resolve, 10));
+
+					expect(error.value).toBeInstanceOf(Error);
+
+					// Second fetch - should succeed and clear error
+					await refetch();
+					await new Promise((resolve) => setTimeout(resolve, 10));
+
+					expect(error.value).toBeNull();
+					expect(brands.value).toEqual(successData);
+				},
+			),
+			{ numRuns: 30 },
+		);
+	});
+});

package/src/hooks/data-hook-filters.property.test.ts

@@ -0,0 +1,263 @@
+/**
+ * Property-Based Tests for Data Hook Filters
+ *
+ * Feature: htlkg-modular-architecture, Property 6: Data hook filters are applied
+ * Validates: Requirements 11.4
+ *
+ * Tests that data hooks correctly apply filter options to GraphQL queries.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fc from "fast-check";
+import { useBrands } from "./useBrands";
+import { useAccounts } from "./useAccounts";
+import { useUsers } from "./useUsers";
+import { useProducts } from "./useProducts";
+import type { Brand, Account, Product } from "@htlkg/core/types";
+
+// Create separate mock functions for each model
+const mockBrandList = vi.fn();
+const mockAccountList = vi.fn();
+const mockUserList = vi.fn();
+const mockProductList = vi.fn();
+
+vi.mock("../client", () => ({
+	generateClient: vi.fn(() => ({
+		models: {
+			Brand: { list: mockBrandList },
+			Account: { list: mockAccountList },
+			User: { list: mockUserList },
+			Product: { list: mockProductList },
+		},
+	})),
+}));
+
+describe("Data Hook Filters - Property 6: Data hook filters are applied", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockBrandList.mockResolvedValue({ data: [], errors: null });
+		mockAccountList.mockResolvedValue({ data: [], errors: null });
+		mockUserList.mockResolvedValue({ data: [], errors: null });
+		mockProductList.mockResolvedValue({ data: [], errors: null });
+	});
+
+	/**
+	 * Property: For any filter options, the hook should pass those filters
+	 * to the GraphQL query
+	 */
+	it("useBrands applies filter options to GraphQL query", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.record({
+					accountId: fc.option(fc.string({ minLength: 1 }), { nil: undefined }),
+					activeOnly: fc.boolean(),
+					limit: fc.option(fc.integer({ min: 1, max: 100 }), { nil: undefined }),
+				}),
+				async (options) => {
+					// Reset mock before each property test iteration
+					mockBrandList.mockClear();
+
+					// Call hook with filter options
+					const { refetch } = useBrands({ ...options, autoFetch: false });
+					await refetch();
+
+					// Verify the mock was called
+					expect(mockBrandList).toHaveBeenCalledTimes(1);
+
+					const callArgs = mockBrandList.mock.calls[0][0];
+
+					// Check that limit is passed correctly
+					if (options.limit !== undefined) {
+						expect(callArgs.limit).toBe(options.limit);
+					}
+
+					// Check that filters are built correctly
+					if (callArgs.filter) {
+						if (options.accountId) {
+							expect(callArgs.filter.accountId).toEqual({ eq: options.accountId });
+						}
+
+						if (options.activeOnly) {
+							expect(callArgs.filter.status).toEqual({ eq: "active" });
+						}
+					}
+				},
+			),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any filter, the hook should only return items matching the filter
+	 */
+	it("useBrands returns only filtered brands", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.array(
+					fc.record({
+						id: fc.string(),
+						name: fc.string(),
+						accountId: fc.string(),
+						status: fc.constantFrom("active", "inactive", "maintenance", "suspended"),
+						timezone: fc.string(),
+						settings: fc.constant({}),
+					}),
+					{ minLength: 0, maxLength: 20 },
+				),
+				fc.constantFrom("active", "inactive", "maintenance", "suspended"),
+				async (mockBrands, filterStatus) => {
+					// Reset mock before each property test iteration
+					mockBrandList.mockClear();
+					mockBrandList.mockResolvedValue({ data: mockBrands, errors: null });
+
+					// Call hook with activeOnly filter
+					const { brands, refetch } = useBrands({
+						activeOnly: filterStatus === "active",
+						autoFetch: false,
+					});
+
+					await refetch();
+
+					// Wait for the hook to update
+					await new Promise((resolve) => setTimeout(resolve, 10));
+
+					// If activeOnly is true, verify all returned brands are active
+					if (filterStatus === "active") {
+						// The hook should have requested active brands
+						const callArgs = mockBrandList.mock.calls[0][0];
+						if (callArgs.filter) {
+							expect(callArgs.filter.status).toEqual({ eq: "active" });
+						}
+					}
+				},
+			),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any accountId filter, only brands from that account should be requested
+	 */
+	it("useBrands filters by accountId", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.string({ minLength: 1 }),
+				async (accountId) => {
+					// Reset mock before each property test iteration
+					mockBrandList.mockClear();
+
+					const { refetch } = useBrands({ accountId, autoFetch: false });
+					await refetch();
+
+					expect(mockBrandList).toHaveBeenCalledTimes(1);
+					const callArgs = mockBrandList.mock.calls[0][0];
+
+					// Verify accountId filter is applied
+					expect(callArgs.filter).toBeDefined();
+					expect(callArgs.filter.accountId).toEqual({ eq: accountId });
+				},
+			),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any filter options on useAccounts, filters should be passed to query
+	 */
+	it("useAccounts applies filter options to GraphQL query", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.record({
+					filter: fc.option(
+						fc.record({
+							status: fc.record({ eq: fc.string() }),
+						}),
+						{ nil: undefined },
+					),
+					limit: fc.option(fc.integer({ min: 1, max: 100 }), { nil: undefined }),
+				}),
+				async (options) => {
+					// Reset mock before each property test iteration
+					mockAccountList.mockClear();
+
+					const { refetch } = useAccounts({ ...options, autoFetch: false });
+					await refetch();
+
+					expect(mockAccountList).toHaveBeenCalledTimes(1);
+					const callArgs = mockAccountList.mock.calls[0][0];
+
+					// Check that limit is passed correctly
+					if (options.limit !== undefined) {
+						expect(callArgs.limit).toBe(options.limit);
+					}
+
+					// Check that filter is passed correctly
+					if (options.filter !== undefined) {
+						expect(callArgs.filter).toEqual(options.filter);
+					}
+				},
+			),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For any brandId or accountId filter on useUsers, filters should be applied
+	 */
+	it("useUsers applies brandId and accountId filters", async () => {
+		await fc.assert(
+			fc.asyncProperty(
+				fc.record({
+					brandId: fc.option(fc.string({ minLength: 1 }), { nil: undefined }),
+					accountId: fc.option(fc.string({ minLength: 1 }), { nil: undefined }),
+				}),
+				async (options) => {
+					// Reset mock before each property test iteration
+					mockUserList.mockClear();
+
+					const { refetch } = useUsers({ ...options, autoFetch: false });
+					await refetch();
+
+					expect(mockUserList).toHaveBeenCalledTimes(1);
+					const callArgs = mockUserList.mock.calls[0][0];
+
+					// Check that filters are built correctly
+					if (callArgs.filter) {
+						if (options.brandId) {
+							expect(callArgs.filter.brandIds).toEqual({ contains: options.brandId });
+						}
+
+						if (options.accountId) {
+							expect(callArgs.filter.accountIds).toEqual({ contains: options.accountId });
+						}
+					}
+				},
+			),
+			{ numRuns: 50 },
+		);
+	});
+
+	/**
+	 * Property: For activeOnly filter on useProducts, only active products should be requested
+	 */
+	it("useProducts applies activeOnly filter", async () => {
+		await fc.assert(
+			fc.asyncProperty(fc.boolean(), async (activeOnly) => {
+				// Reset mock before each property test iteration
+				mockProductList.mockClear();
+
+				const { refetch } = useProducts({ activeOnly, autoFetch: false });
+				await refetch();
+
+				expect(mockProductList).toHaveBeenCalledTimes(1);
+				const callArgs = mockProductList.mock.calls[0][0];
+
+				// If activeOnly is true, verify filter is applied
+				if (activeOnly && callArgs.filter) {
+					expect(callArgs.filter.isActive).toEqual({ eq: true });
+				}
+			}),
+			{ numRuns: 50 },
+		);
+	});
+});