@geekmidas/client 0.4.0 → 0.5.0

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

@@ -9,549 +9,549 @@ 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;
-              };
-            };
-          };
-        };
-      };
-    };
-  };
+	'/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>
-  );
+	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);
-      });
-    });
-  });
+	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);
+			});
+		});
+	});
 });