@geekmidas/client 9.0.2 → 10.0.0-alpha.0

package/src/__tests__/openapi-hooks.spec.tsx

@@ -1,557 +0,0 @@
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-/**
- * @vitest-environment jsdom
- */
-import { renderHook, waitFor } from '@testing-library/react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createOpenAPIHooks } from '../openapi-hooks';
-import './setup';
-
-// Test OpenAPI types
-interface TestPaths {
-	'/users': {
-		get: {
-			operationId: 'listUsers';
-			parameters?: {
-				query?: {
-					page?: number;
-					limit?: number;
-					search?: string;
-				};
-			};
-			responses: {
-				200: {
-					content: {
-						'application/json': {
-							users: Array<{
-								id: string;
-								name: string;
-								email: string;
-							}>;
-							total: number;
-						};
-					};
-				};
-			};
-		};
-		post: {
-			operationId: 'createUser';
-			requestBody: {
-				content: {
-					'application/json': {
-						name: string;
-						email: string;
-						password: string;
-					};
-				};
-			};
-			responses: {
-				201: {
-					content: {
-						'application/json': {
-							id: string;
-							name: string;
-							email: string;
-						};
-					};
-				};
-			};
-		};
-	};
-	'/users/{id}': {
-		parameters: {
-			path: {
-				id: string;
-			};
-		};
-		get: {
-			operationId: 'getUser';
-			responses: {
-				200: {
-					content: {
-						'application/json': {
-							id: string;
-							name: string;
-							email: string;
-							createdAt: string;
-						};
-					};
-				};
-			};
-		};
-		patch: {
-			operationId: 'updateUser';
-			requestBody: {
-				content: {
-					'application/json': {
-						name?: string;
-						email?: string;
-					};
-				};
-			};
-			responses: {
-				200: {
-					content: {
-						'application/json': {
-							id: string;
-							name: string;
-							email: string;
-						};
-					};
-				};
-			};
-		};
-		delete: {
-			operationId: 'deleteUser';
-			responses: {
-				204: {};
-			};
-		};
-	};
-	'/posts/{postId}': {
-		get: {
-			operationId: 'getPost';
-			parameters: {
-				path: {
-					postId: string;
-				};
-				query?: {
-					includeAuthor?: boolean;
-				};
-			};
-			responses: {
-				200: {
-					content: {
-						'application/json': {
-							id: string;
-							title: string;
-							content: string;
-							authorId: string;
-							author?: {
-								id: string;
-								name: string;
-							};
-						};
-					};
-				};
-			};
-		};
-	};
-}
-
-// Note: fetch is mocked by MSW in setup.ts
-
-// Test wrapper
-function createWrapper() {
-	const queryClient = new QueryClient({
-		defaultOptions: {
-			queries: { retry: false },
-			mutations: { retry: false },
-		},
-	});
-
-	return ({ children }: { children: any }) => (
-		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-	);
-}
-
-describe('createOpenAPIHooks', () => {
-	const operations = {
-		listUsers: { path: '/users', method: 'get' },
-		createUser: { path: '/users', method: 'post' },
-		getUser: { path: '/users/{id}', method: 'get' },
-		updateUser: { path: '/users/{id}', method: 'patch' },
-		deleteUser: { path: '/users/{id}', method: 'delete' },
-		getPost: { path: '/posts/{postId}', method: 'get' },
-	};
-
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe('useQuery', () => {
-		it('should fetch data for simple GET operation', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(() => api.useQuery('listUsers'), {
-				wrapper: createWrapper(),
-			});
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toEqual({
-				users: [
-					{ id: '1', name: 'John Doe', email: 'john@example.com' },
-					{ id: '2', name: 'Jane Smith', email: 'jane@example.com' },
-				],
-			});
-		});
-
-		it('should handle query parameters', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(
-				() =>
-					api.useQuery('listUsers', {
-						// query: { page: 2, limit: 10, search: 'john' },
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			// Query parameters are handled by MSW, verify data structure
-			expect(result.current.data).toBeDefined();
-		});
-
-		it('should handle path parameters', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(
-				() =>
-					api.useQuery('getUser', {
-						params: { id: '123' },
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toEqual({
-				id: '123',
-				name: 'John Doe',
-				email: 'john@example.com',
-			});
-		});
-
-		it('should handle both path and query parameters', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(
-				() =>
-					api.useQuery('getPost', {
-						params: { postId: '456' },
-						query: { includeAuthor: true },
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toEqual({
-				id: '456',
-				title: 'Test Post',
-				content: 'Test content',
-				authorId: '123',
-				author: { id: '123', name: 'John' },
-			});
-		});
-
-		it('should use proper query key for caching', async () => {
-			// MSW will handle the responses
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result: result1 } = renderHook(
-				() =>
-					api.useQuery('listUsers', {
-						query: { page: 1 },
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			const { result: result2 } = renderHook(
-				() =>
-					api.useQuery('listUsers', {
-						query: { page: 1 },
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			await waitFor(() => {
-				expect(result1.current.isSuccess).toBe(true);
-				expect(result2.current.isSuccess).toBe(true);
-			});
-
-			// Both queries should have the same data due to caching
-			expect(result1.current.data).toEqual(result2.current.data);
-		});
-	});
-
-	describe('useMutation', () => {
-		it('should handle POST mutation', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(() => api.useMutation('createUser'), {
-				wrapper: createWrapper(),
-			});
-
-			result.current.mutate({
-				body: {
-					name: 'New User',
-					email: 'new@example.com',
-					password: 'secret123',
-				},
-			});
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toEqual({
-				id: '123',
-				name: 'New User',
-				email: 'new@example.com',
-			});
-		});
-
-		it('should handle PATCH mutation with path params', async () => {
-			// MSW will return the predefined response from setup.ts
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(() => api.useMutation('updateUser'), {
-				wrapper: createWrapper(),
-			});
-
-			result.current.mutate({
-				params: { id: '123' },
-				body: { name: 'Updated Name' },
-			});
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toEqual({
-				id: '123',
-				name: 'Updated Name',
-				email: 'john@example.com',
-			});
-		});
-
-		it('should handle DELETE mutation returning void', async () => {
-			// MSW will return 204 No Content for DELETE
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(() => api.useMutation('deleteUser'), {
-				wrapper: createWrapper(),
-			});
-
-			result.current.mutate({
-				params: { id: '123' },
-			});
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(result.current.data).toBeUndefined();
-		});
-
-		it('should handle mutation options', async () => {
-			// MSW will handle the response
-
-			const onSuccess = vi.fn();
-			const onError = vi.fn();
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(
-				() =>
-					api.useMutation('createUser', {
-						onSuccess,
-						onError,
-					}),
-				{ wrapper: createWrapper() },
-			);
-
-			result.current.mutate({
-				body: {
-					name: 'Test',
-					email: 'test@test.com',
-					password: 'password',
-				},
-			});
-
-			await waitFor(() => {
-				expect(result.current.isSuccess).toBe(true);
-			});
-
-			expect(onSuccess).toHaveBeenCalled();
-			expect(onSuccess.mock.calls[0]?.[0]).toEqual({
-				id: '123',
-				name: 'Test',
-				email: 'test@test.com',
-			});
-			expect(onError).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('buildEndpoint', () => {
-		it('should use operation registry when provided', () => {
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			// The endpoint should be built correctly based on the registry
-			const { result } = renderHook(() => api.useQuery('listUsers'), {
-				wrapper: createWrapper(),
-			});
-
-			// Wait for the query to be initiated
-			expect(result.current.isLoading).toBe(true);
-		});
-
-		it('should work without operation registry', () => {
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-			});
-
-			// Without registry, it should use operationId as fallback
-			const { result } = renderHook(() => api.useQuery('listUsers'), {
-				wrapper: createWrapper(),
-			});
-
-			expect(result.current.isLoading).toBe(true);
-		});
-	});
-
-	describe('type inference', () => {
-		it('should infer correct response types', () => {
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(() => api.useQuery('listUsers'), {
-				wrapper: createWrapper(),
-			});
-
-			// Type test - this should compile without errors
-			if (result.current.data) {
-				const users: Array<{ id: string; name: string; email: string }> =
-					result.current.data.users;
-				const total: number = result.current.data.total;
-				expect(users).toBeDefined();
-				expect(total).toBeDefined();
-			}
-		});
-
-		it('should enforce required parameters', () => {
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			// This test is about type checking, not runtime behavior
-			// The TypeScript compiler enforces these constraints:
-
-			// ✓ This compiles - no params required for listUsers
-			const listUsersHook = () => api.useQuery('listUsers');
-
-			// ✓ This compiles - params are provided for getUser
-			const getUserHook = () =>
-				api.useQuery('getUser', { params: { id: '123' } });
-
-			// ✗ This would not compile - missing required params
-			// const invalidHook = () => api.useQuery('getUser');
-
-			expect(listUsersHook).toBeDefined();
-			expect(getUserHook).toBeDefined();
-		});
-
-		it('should handle optional parameters correctly', () => {
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			// All valid ways to call listUsers - wrapped in functions
-			const hook1 = () => api.useQuery('listUsers');
-			const hook2 = () => api.useQuery('listUsers', {});
-			const hook3 = () => api.useQuery('listUsers', { query: {} });
-			const hook4 = () => api.useQuery('listUsers', { query: { page: 1 } });
-			const hook5 = () =>
-				api.useQuery('listUsers', { query: { page: 1, limit: 10 } });
-
-			expect(hook1).toBeDefined();
-			expect(hook2).toBeDefined();
-			expect(hook3).toBeDefined();
-			expect(hook4).toBeDefined();
-			expect(hook5).toBeDefined();
-		});
-	});
-
-	describe('error handling', () => {
-		it.skip('should handle fetch errors', async () => {
-			// This test is skipped because we need a way to trigger actual fetch errors
-			// The current implementation always returns successful responses from MSW
-		});
-
-		it('should handle non-ok responses', async () => {
-			// MSW will return 404 for user id '404'
-
-			const api = createOpenAPIHooks<TestPaths>({
-				baseURL: 'https://api.example.com',
-				operations,
-			});
-
-			const { result } = renderHook(
-				() => api.useQuery('getUser', { params: { id: '404' } }),
-				{ wrapper: createWrapper() },
-			);
-
-			await waitFor(() => {
-				expect(result.current.isError).toBe(true);
-			});
-		});
-	});
-});