infrahub-sdk 0.0.8 → 0.0.9

package/src/rest.test.ts

@@ -0,0 +1,1107 @@
+import { InfrahubClient, InfrahubClientOptions } from './index';
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+// We need to mock node-fetch since the SDK uses it internally
+jest.mock('node-fetch', () => {
+  const originalModule = jest.requireActual('node-fetch') as any;
+  return {
+    __esModule: true,
+    ...originalModule,
+    default: jest.fn()
+  };
+});
+
+import fetch from 'node-fetch';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const mockedFetch = fetch as any;
+
+// The SDK now extracts URL, method, headers, body from Request objects before calling fetch
+// So the mock receives (url: string, options: {method, headers, body, ...})
+
+// Helper to extract URL - now receives string directly
+function extractUrl(input: any): string {
+  return String(input);
+}
+
+// Helper to extract headers from fetch options
+function extractHeaders(options: any): Headers | undefined {
+  if (options && options.headers) {
+    // headers could be Headers object or plain object
+    if (options.headers instanceof Headers) {
+      return options.headers;
+    }
+    return new Headers(options.headers);
+  }
+  return undefined;
+}
+
+// Helper to extract method from fetch options
+function extractMethod(options: any): string | undefined {
+  return options?.method;
+}
+
+// Helper to extract body from fetch options
+function extractBody(options: any): any | undefined {
+  if (options?.body) {
+    try {
+      // body could be string, Buffer, or ReadableStream
+      if (typeof options.body === 'string') {
+        return JSON.parse(options.body);
+      }
+      // Handle Buffer
+      if (Buffer.isBuffer(options.body)) {
+        return JSON.parse(options.body.toString());
+      }
+      // Handle ReadableStream - try to read it as a string
+      if (options.body.toString && typeof options.body.toString === 'function') {
+        const str = options.body.toString();
+        if (str !== '[object ReadableStream]' && str !== '[object Object]') {
+          return JSON.parse(str);
+        }
+      }
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+describe('REST Client', () => {
+  const baseURL = 'https://example.com';
+  const token = 'test-token';
+  let client: InfrahubClient;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    const options: InfrahubClientOptions = {
+      address: baseURL,
+      token: token
+    };
+    client = new InfrahubClient(options);
+  });
+
+  describe('REST Client Initialization', () => {
+    it('should initialize rest client', () => {
+      expect(client.rest).toBeDefined();
+    });
+
+    it('should have GET method available', () => {
+      expect(client.rest.GET).toBeDefined();
+      expect(typeof client.rest.GET).toBe('function');
+    });
+
+    it('should have POST method available', () => {
+      expect(client.rest.POST).toBeDefined();
+      expect(typeof client.rest.POST).toBe('function');
+    });
+
+    it('should have middleware use method', () => {
+      expect(client.rest.use).toBeDefined();
+      expect(typeof client.rest.use).toBe('function');
+    });
+
+    it('should expose rest client publicly', () => {
+      expect(client.rest).toBeDefined();
+      // Verify the rest client has the expected structure from openapi-fetch
+      expect(typeof client.rest.GET).toBe('function');
+      expect(typeof client.rest.POST).toBe('function');
+      expect(typeof client.rest.PUT).toBe('function');
+      expect(typeof client.rest.DELETE).toBe('function');
+      expect(typeof client.rest.PATCH).toBe('function');
+    });
+  });
+
+  describe('REST Client Middleware', () => {
+    it('should be able to add custom middleware', () => {
+      const middlewareSpy = jest.fn();
+
+      // Add custom middleware - this should not throw
+      expect(() => {
+        client.rest.use({
+          onRequest: (req) => {
+            middlewareSpy(req);
+            return req;
+          }
+        });
+      }).not.toThrow();
+    });
+
+    it('should include X-INFRAHUB-KEY header in requests', async () => {
+      let capturedHeaders: Headers | undefined;
+
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedHeaders = extractHeaders(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({ version: '1.0.0' }),
+          text: async () => JSON.stringify({ version: '1.0.0' })
+        };
+      });
+
+      await client.rest.GET('/api/info');
+
+      expect(mockedFetch).toHaveBeenCalled();
+      expect(capturedHeaders?.get('X-INFRAHUB-KEY')).toBe(token);
+      expect(capturedHeaders?.get('content-type')).toBe('application/json');
+    });
+
+    it('should update auth header when token changes via setAuthToken', async () => {
+      const newToken = 'new-test-token';
+      let capturedHeaders: Headers | undefined;
+
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedHeaders = extractHeaders(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      // Update the token
+      client.setAuthToken(newToken);
+
+      await client.rest.GET('/api/info');
+
+      expect(capturedHeaders?.get('X-INFRAHUB-KEY')).toBe(newToken);
+    });
+  });
+
+  describe('REST API Endpoints - GET Requests', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should call GET /api/info endpoint', async () => {
+      const mockData = {
+        version: '1.0.0',
+        deployment_id: 'test-deployment'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockData,
+        text: async () => JSON.stringify(mockData)
+      }));
+
+      const result = await client.rest.GET('/api/info');
+
+      expect(result.data).toEqual(mockData);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call GET /api/config endpoint', async () => {
+      const mockConfig = {
+        main: {
+          default_branch: 'main'
+        }
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockConfig,
+        text: async () => JSON.stringify(mockConfig)
+      }));
+
+      const result = await client.rest.GET('/api/config');
+
+      expect(result.data).toEqual(mockConfig);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call GET /api/schema endpoint', async () => {
+      const mockSchema = {
+        nodes: [],
+        generics: [],
+        version: '1.0'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockSchema,
+        text: async () => JSON.stringify(mockSchema)
+      }));
+
+      const result = await client.rest.GET('/api/schema');
+
+      expect(result.data).toEqual(mockSchema);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call GET /api/schema/summary endpoint', async () => {
+      const mockSummary = {
+        nodes: ['Node1', 'Node2']
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockSummary,
+        text: async () => JSON.stringify(mockSummary)
+      }));
+
+      const result = await client.rest.GET('/api/schema/summary');
+
+      expect(result.data).toEqual(mockSummary);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call GET /api/schema/{schema_kind} with path parameter', async () => {
+      const mockSchemaKind = {
+        name: 'TestNode',
+        namespace: 'Test'
+      };
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockSchemaKind,
+          text: async () => JSON.stringify(mockSchemaKind)
+        };
+      });
+
+      const result = await client.rest.GET('/api/schema/{schema_kind}', {
+        params: {
+          path: { schema_kind: 'TestNode' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/schema/TestNode');
+      expect(result.data).toEqual(mockSchemaKind);
+    });
+
+    it('should call GET /api/menu endpoint', async () => {
+      const mockMenu = {
+        items: [{ label: 'Item 1' }]
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockMenu,
+        text: async () => JSON.stringify(mockMenu)
+      }));
+
+      const result = await client.rest.GET('/api/menu');
+
+      expect(result.data).toEqual(mockMenu);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call GET /api/artifact/{artifact_id} with path parameter', async () => {
+      const mockArtifact = {
+        id: 'artifact-123',
+        content: 'test content'
+      };
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockArtifact,
+          text: async () => JSON.stringify(mockArtifact)
+        };
+      });
+
+      const result = await client.rest.GET('/api/artifact/{artifact_id}', {
+        params: {
+          path: { artifact_id: 'artifact-123' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/artifact/artifact-123');
+      expect(result.data).toEqual(mockArtifact);
+    });
+
+    it('should call GET /api/storage/object/{identifier} with path parameter', async () => {
+      const mockContent = 'file content';
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'text/plain' }),
+          json: async () => mockContent,
+          text: async () => mockContent
+        };
+      });
+
+      await client.rest.GET('/api/storage/object/{identifier}', {
+        params: {
+          path: { identifier: 'file-123' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/storage/object/file-123');
+    });
+
+    it('should call GET /api/transform/python/{transform_id} with path parameter', async () => {
+      const mockTransform = {
+        result: 'transformed data'
+      };
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockTransform,
+          text: async () => JSON.stringify(mockTransform)
+        };
+      });
+
+      const result = await client.rest.GET('/api/transform/python/{transform_id}', {
+        params: {
+          path: { transform_id: 'transform-123' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/transform/python/transform-123');
+      expect(result.data).toEqual(mockTransform);
+    });
+
+    it('should call GET /api/transform/jinja2/{transform_id} with path parameter', async () => {
+      const mockTransform = {
+        result: 'jinja2 transformed data'
+      };
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockTransform,
+          text: async () => JSON.stringify(mockTransform)
+        };
+      });
+
+      const result = await client.rest.GET('/api/transform/jinja2/{transform_id}', {
+        params: {
+          path: { transform_id: 'transform-456' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/transform/jinja2/transform-456');
+      expect(result.data).toEqual(mockTransform);
+    });
+
+    it('should call GET /api/query/{query_id} with path parameter', async () => {
+      const mockQueryResult = {
+        data: { test: 'value' }
+      };
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockQueryResult,
+          text: async () => JSON.stringify(mockQueryResult)
+        };
+      });
+
+      const result = await client.rest.GET('/api/query/{query_id}', {
+        params: {
+          path: { query_id: 'query-789' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/query/query-789');
+      expect(result.data).toEqual(mockQueryResult);
+    });
+
+    it('should call GET /api/diff/files endpoint', async () => {
+      const mockDiff = {
+        files: ['file1.txt', 'file2.txt']
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockDiff,
+        text: async () => JSON.stringify(mockDiff)
+      }));
+
+      const result = await client.rest.GET('/api/diff/files');
+
+      expect(result.data).toEqual(mockDiff);
+    });
+
+    it('should call GET /api/diff/artifacts endpoint', async () => {
+      const mockDiff = {
+        artifacts: ['artifact1', 'artifact2']
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockDiff,
+        text: async () => JSON.stringify(mockDiff)
+      }));
+
+      const result = await client.rest.GET('/api/diff/artifacts');
+
+      expect(result.data).toEqual(mockDiff);
+    });
+
+    it('should call GET /api/file/{repository_id}/{file_path} with path parameters', async () => {
+      const mockFileContent = 'file content here';
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'text/plain' }),
+          json: async () => mockFileContent,
+          text: async () => mockFileContent
+        };
+      });
+
+      await client.rest.GET('/api/file/{repository_id}/{file_path}', {
+        params: {
+          path: { repository_id: 'repo-123', file_path: 'src/index.ts' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/file/repo-123/src');
+    });
+  });
+
+  describe('REST API Endpoints - POST Requests', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should call POST /api/auth/login endpoint', async () => {
+      const mockLoginResponse = {
+        access_token: 'jwt-token',
+        token_type: 'bearer'
+      };
+
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockLoginResponse,
+          text: async () => JSON.stringify(mockLoginResponse)
+        };
+      });
+
+      const result = await client.rest.POST('/api/auth/login', {
+        body: {
+          username: 'testuser',
+          password: 'testpass'
+        }
+      });
+
+      expect(capturedMethod).toBe('POST');
+      expect(result.data).toEqual(mockLoginResponse);
+    });
+
+    it('should call POST /api/auth/refresh endpoint', async () => {
+      const mockRefreshResponse = {
+        access_token: 'new-jwt-token',
+        token_type: 'bearer'
+      };
+
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockRefreshResponse,
+          text: async () => JSON.stringify(mockRefreshResponse)
+        };
+      });
+
+      const result = await client.rest.POST('/api/auth/refresh');
+
+      expect(capturedMethod).toBe('POST');
+      expect(result.data).toEqual(mockRefreshResponse);
+    });
+
+    it('should call POST /api/auth/logout endpoint', async () => {
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({ success: true }),
+          text: async () => JSON.stringify({ success: true })
+        };
+      });
+
+      const result = await client.rest.POST('/api/auth/logout');
+
+      expect(capturedMethod).toBe('POST');
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should call POST /api/artifact/generate/{artifact_definition_id} with path parameter', async () => {
+      const mockGenerateResponse = {
+        artifact_id: 'generated-artifact-123'
+      };
+
+      let capturedUrl: string | undefined;
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (url: any, options: any) => {
+        capturedUrl = extractUrl(url);
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockGenerateResponse,
+          text: async () => JSON.stringify(mockGenerateResponse)
+        };
+      });
+
+      const result = await client.rest.POST('/api/artifact/generate/{artifact_definition_id}', {
+        params: {
+          path: { artifact_definition_id: 'def-123' }
+        }
+      });
+
+      expect(capturedUrl).toContain('/api/artifact/generate/def-123');
+      expect(capturedMethod).toBe('POST');
+      expect(result.data).toEqual(mockGenerateResponse);
+    });
+
+    it('should call POST /api/schema/load endpoint with body', async () => {
+      const mockLoadResponse = {
+        success: true,
+        schema_hash: 'abc123'
+      };
+
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockLoadResponse,
+          text: async () => JSON.stringify(mockLoadResponse)
+        };
+      });
+
+      const schemaToLoad = {
+        schemas: [{
+          version: '1.0',
+          extensions: {}
+        }]
+      };
+
+      const result = await client.rest.POST('/api/schema/load', {
+        body: schemaToLoad
+      } as any);
+
+      expect(capturedMethod).toBe('POST');
+      expect(result.data).toEqual(mockLoadResponse);
+    });
+
+    it('should call POST /api/schema/check endpoint', async () => {
+      const mockCheckResponse = {
+        valid: true,
+        errors: []
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockCheckResponse,
+        text: async () => JSON.stringify(mockCheckResponse)
+      }));
+
+      const schemaToCheck = {
+        schemas: [{
+          version: '1.0',
+          extensions: {}
+        }]
+      };
+
+      const result = await client.rest.POST('/api/schema/check', {
+        body: schemaToCheck
+      } as any);
+
+      expect(result.data).toEqual(mockCheckResponse);
+    });
+
+    it('should call POST /api/query/{query_id} with path parameter and body', async () => {
+      const mockQueryResponse = {
+        data: { results: [] }
+      };
+
+      let capturedUrl: string | undefined;
+      let capturedMethod: string | undefined;
+      mockedFetch.mockImplementation(async (url: any, options: any) => {
+        capturedUrl = extractUrl(url);
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => mockQueryResponse,
+          text: async () => JSON.stringify(mockQueryResponse)
+        };
+      });
+
+      const queryVariables = { variables: { 'limit': '10' } };
+
+      const result = await client.rest.POST('/api/query/{query_id}', {
+        params: {
+          path: { query_id: 'my-query' }
+        },
+        body: queryVariables
+      });
+
+      expect(capturedUrl).toContain('/api/query/my-query');
+      expect(capturedMethod).toBe('POST');
+      expect(result.data).toEqual(mockQueryResponse);
+    });
+
+    it('should call POST /api/storage/upload/content endpoint', async () => {
+      const mockUploadResponse = {
+        identifier: 'uploaded-123',
+        checksum: 'sha256:abc'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockUploadResponse,
+        text: async () => JSON.stringify(mockUploadResponse)
+      }));
+
+      const result = await client.rest.POST('/api/storage/upload/content', {
+        body: { content: 'test content' }
+      } as any);
+
+      expect(result.data).toEqual(mockUploadResponse);
+    });
+  });
+
+  describe('REST API Error Handling', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should handle 401 Unauthorized error', async () => {
+      const mockError = {
+        detail: 'Not authenticated'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockError,
+        text: async () => JSON.stringify(mockError)
+      }));
+
+      const result = await client.rest.GET('/api/info');
+
+      expect(result.error).toBeDefined();
+      expect(result.response?.status).toBe(401);
+    });
+
+    it('should handle 403 Forbidden error', async () => {
+      const mockError = {
+        detail: 'Permission denied'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: false,
+        status: 403,
+        statusText: 'Forbidden',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockError,
+        text: async () => JSON.stringify(mockError)
+      }));
+
+      const result = await client.rest.GET('/api/schema');
+
+      expect(result.error).toBeDefined();
+      expect(result.response?.status).toBe(403);
+    });
+
+    it('should handle 404 Not Found error', async () => {
+      const mockError = {
+        detail: 'Resource not found'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockError,
+        text: async () => JSON.stringify(mockError)
+      }));
+
+      const result = await client.rest.GET('/api/artifact/{artifact_id}', {
+        params: {
+          path: { artifact_id: 'non-existent' }
+        }
+      });
+
+      expect(result.error).toBeDefined();
+      expect(result.response?.status).toBe(404);
+    });
+
+    it('should handle 500 Internal Server Error', async () => {
+      const mockError = {
+        detail: 'Internal server error'
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockError,
+        text: async () => JSON.stringify(mockError)
+      }));
+
+      const result = await client.rest.GET('/api/info');
+
+      expect(result.error).toBeDefined();
+      expect(result.response?.status).toBe(500);
+    });
+
+    it('should handle 422 Validation Error', async () => {
+      const mockError = {
+        detail: [
+          {
+            loc: ['body', 'name'],
+            msg: 'field required',
+            type: 'value_error.missing'
+          }
+        ]
+      };
+
+      mockedFetch.mockImplementation(async () => ({
+        ok: false,
+        status: 422,
+        statusText: 'Unprocessable Entity',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        json: async () => mockError,
+        text: async () => JSON.stringify(mockError)
+      }));
+
+      const result = await client.rest.POST('/api/schema/load', {
+        body: { schemas: [] }
+      } as any);
+
+      expect(result.error).toBeDefined();
+      expect(result.response?.status).toBe(422);
+    });
+
+    it('should handle network errors gracefully', async () => {
+      mockedFetch.mockImplementation(async () => {
+        throw new Error('Network request failed');
+      });
+
+      await expect(client.rest.GET('/api/info')).rejects.toThrow('Network request failed');
+    });
+
+    it('should handle timeout errors', async () => {
+      mockedFetch.mockImplementation(async () => {
+        throw new Error('Request timeout');
+      });
+
+      await expect(client.rest.GET('/api/info')).rejects.toThrow('Request timeout');
+    });
+  });
+
+  describe('REST Client with TLS Configuration', () => {
+    it('should create REST client with TLS config - rejectUnauthorized false', () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL,
+        token: token,
+        tls: {
+          rejectUnauthorized: false
+        }
+      };
+      const tlsClient = new InfrahubClient(options);
+
+      expect(tlsClient.rest).toBeDefined();
+      expect(tlsClient.rest.GET).toBeDefined();
+      expect(tlsClient.rest.POST).toBeDefined();
+    });
+
+    it('should create REST client with custom CA certificate', () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL,
+        token: token,
+        tls: {
+          ca: '-----BEGIN CERTIFICATE-----\nMockCA\n-----END CERTIFICATE-----'
+        }
+      };
+      const tlsClient = new InfrahubClient(options);
+
+      expect(tlsClient.rest).toBeDefined();
+    });
+
+    it('should create REST client with client certificate for mutual TLS', () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL,
+        token: token,
+        tls: {
+          cert: '-----BEGIN CERTIFICATE-----\nMockCert\n-----END CERTIFICATE-----',
+          key: '-----BEGIN PRIVATE KEY-----\nMockKey\n-----END PRIVATE KEY-----'
+        }
+      };
+      const tlsClient = new InfrahubClient(options);
+
+      expect(tlsClient.rest).toBeDefined();
+    });
+
+    it('should create REST client with full TLS configuration', () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL,
+        token: token,
+        tls: {
+          rejectUnauthorized: true,
+          ca: '-----BEGIN CERTIFICATE-----\nMockCA\n-----END CERTIFICATE-----',
+          cert: '-----BEGIN CERTIFICATE-----\nMockCert\n-----END CERTIFICATE-----',
+          key: '-----BEGIN PRIVATE KEY-----\nMockKey\n-----END PRIVATE KEY-----'
+        }
+      };
+      const tlsClient = new InfrahubClient(options);
+
+      expect(tlsClient.rest).toBeDefined();
+      expect(tlsClient.rest.GET).toBeDefined();
+      expect(tlsClient.rest.POST).toBeDefined();
+    });
+  });
+
+  describe('REST Client without Token', () => {
+    it('should initialize REST client without token', () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL
+      };
+      const noTokenClient = new InfrahubClient(options);
+
+      expect(noTokenClient.rest).toBeDefined();
+    });
+
+    it('should not include X-INFRAHUB-KEY header when no token is provided', async () => {
+      const options: InfrahubClientOptions = {
+        address: baseURL
+      };
+      const noTokenClient = new InfrahubClient(options);
+
+      let capturedHeaders: Headers | undefined;
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedHeaders = extractHeaders(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await noTokenClient.rest.GET('/api/info');
+
+      // When no token is set, the header should not be present or be empty
+      const authHeader = capturedHeaders?.get('X-INFRAHUB-KEY');
+      expect(!authHeader).toBe(true);
+    });
+  });
+
+  describe('REST Client URL Construction', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should construct correct base URL for REST requests', async () => {
+      let capturedUrl: string | undefined;
+
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await client.rest.GET('/api/info');
+
+      expect(capturedUrl).toBe(`${baseURL}/api/info`);
+    });
+
+    it('should handle trailing slash in base URL', async () => {
+      const optionsWithSlash: InfrahubClientOptions = {
+        address: `${baseURL}/`,
+        token: token
+      };
+      const clientWithSlash = new InfrahubClient(optionsWithSlash);
+
+      let capturedUrl: string | undefined;
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await clientWithSlash.rest.GET('/api/info');
+
+      // The URL should contain /api/info
+      expect(capturedUrl).toContain('/api/info');
+    });
+  });
+
+  describe('REST Client Query Parameters', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should include query parameters in GET request', async () => {
+      let capturedUrl: string | undefined;
+
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await client.rest.GET('/api/diff/files', {
+        params: {
+          query: {
+            branch: 'test-branch'
+          }
+        }
+      });
+
+      expect(capturedUrl).toContain('branch=test-branch');
+    });
+
+    it('should handle multiple query parameters', async () => {
+      let capturedUrl: string | undefined;
+
+      mockedFetch.mockImplementation(async (request: any) => {
+        capturedUrl = extractUrl(request);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await client.rest.GET('/api/schema', {
+        params: {
+          query: {
+            branch: 'test-branch'
+          }
+        }
+      });
+
+      expect(capturedUrl).toContain('branch=test-branch');
+    });
+  });
+
+  describe('REST Client HTTP Methods', () => {
+    beforeEach(() => {
+      mockedFetch.mockReset();
+    });
+
+    it('should use correct HTTP method for GET requests', async () => {
+      let capturedMethod: string | undefined;
+
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await client.rest.GET('/api/info');
+
+      expect(capturedMethod).toBe('GET');
+    });
+
+    it('should use correct HTTP method for POST requests', async () => {
+      let capturedMethod: string | undefined;
+
+      mockedFetch.mockImplementation(async (_url: any, options: any) => {
+        capturedMethod = extractMethod(options);
+        return {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'Content-Type': 'application/json' }),
+          json: async () => ({}),
+          text: async () => '{}'
+        };
+      });
+
+      await client.rest.POST('/api/auth/login', {
+        body: { username: 'test', password: 'test' }
+      });
+
+      expect(capturedMethod).toBe('POST');
+    });
+  });
+});