@eui/mcp 1.0.3 → 1.2.0

package/dist/loader/__tests__/remote-documentation-source.test.js

@@ -0,0 +1,707 @@
+/**
+ * Unit tests for RemoteDocumentationSource
+ * Feature: url-based-documentation-path
+ * Tests successful fetch, polling, 304 responses, error handling, and cleanup
+ * Requirements: 5.1, 5.2, 5.4, 5.5, 8.4, 8.5
+ */
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { RemoteDocumentationSource } from '../remote-documentation-source.js';
+import { HttpClient } from '../http-client.js';
+// Helper to create minimal valid CompodocDocumentation
+const createMockDocumentation = (id = 'default') => ({
+    components: [{ name: `Component${id}`, id: `comp-${id}`, file: 'test.ts', type: 'component', deprecated: false }],
+    modules: [],
+    directives: [],
+    pipes: [],
+    classes: [],
+    interfaces: [],
+    injectables: [],
+});
+describe('RemoteDocumentationSource Unit Tests', () => {
+    let source;
+    let originalFetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useRealTimers();
+        // Store original fetch method
+        originalFetch = HttpClient.prototype.fetch;
+    });
+    afterEach(async () => {
+        // Restore original fetch method
+        HttpClient.prototype.fetch = originalFetch;
+        if (source) {
+            await source.dispose();
+        }
+    });
+    describe('Successful Fetch and Parse (Requirement 5.1)', () => {
+        it('should successfully fetch and parse documentation from URL', async () => {
+            const mockDoc = createMockDocumentation('test1');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(true);
+            expect(result.data).toBeDefined();
+            expect(result.data?.components).toHaveLength(1);
+            expect(result.data?.components[0].name).toBe('Componenttest1');
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+        it('should store fetched documentation in currentData', async () => {
+            const mockDoc = createMockDocumentation('test2');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            const currentData = source.getCurrentData();
+            expect(currentData).toBeDefined();
+            expect(currentData?.components[0].name).toBe('Componenttest2');
+        });
+        it('should cache documentation with ETag header', async () => {
+            const mockDoc = createMockDocumentation('cached');
+            const headers = new Map();
+            headers.set('ETag', '"abc123"');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers,
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            // Second load should include If-None-Match header
+            mockFetch.mockResolvedValue({
+                status: 304,
+                statusText: 'Not Modified',
+                data: '',
+                headers: new Map(),
+            });
+            const result = await source.load();
+            expect(result.success).toBe(true);
+            expect(result.data).toBeDefined();
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            // Verify conditional header was sent
+            const calls = mockFetch.mock.calls;
+            const conditionalHeaders = calls[1]?.[1];
+            expect(conditionalHeaders?.get('If-None-Match')).toBe('"abc123"');
+        });
+        it('should parse complex documentation structures', async () => {
+            const complexDoc = {
+                components: [
+                    { name: 'Button', id: 'btn-1', file: 'button.ts', type: 'component', deprecated: false, selector: 'app-button' },
+                    { name: 'Input', id: 'inp-1', file: 'input.ts', type: 'component', deprecated: true, deprecationMessage: 'Use Input2' },
+                ],
+                modules: [
+                    { name: 'AppModule', id: 'mod-1', file: 'app.module.ts', type: 'module', deprecated: false },
+                ],
+                directives: [],
+                pipes: [],
+                classes: [],
+                interfaces: [],
+                injectables: [],
+            };
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(complexDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(true);
+            expect(result.data?.components).toHaveLength(2);
+            expect(result.data?.modules).toHaveLength(1);
+            expect(result.data?.components[1].deprecationMessage).toBe('Use Input2');
+        });
+    });
+    describe('Polling Interval Timing (Requirement 5.1, 5.2)', () => {
+        it('should start polling at configured interval', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('poll1');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000, // 10 seconds
+            });
+            await source.load();
+            mockFetch.mockClear();
+            source.startMonitoring();
+            // Advance time by 10 seconds
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve(); // Allow promises to resolve
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            // Advance another 10 seconds
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            jest.useRealTimers();
+        });
+        it('should not start polling if already monitoring', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('poll2');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+            });
+            await source.load();
+            mockFetch.mockClear();
+            source.startMonitoring();
+            source.startMonitoring(); // Call again
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            // Should only poll once, not twice
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            jest.useRealTimers();
+        });
+        it('should stop polling when stopMonitoring is called', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('poll3');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+            });
+            await source.load();
+            mockFetch.mockClear();
+            source.startMonitoring();
+            // Advance time and verify polling happens
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            // Stop monitoring
+            await source.stopMonitoring();
+            mockFetch.mockClear();
+            // Advance time again - should not poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(mockFetch).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+        it('should invoke onReload callback when polling detects changes', async () => {
+            jest.useFakeTimers();
+            const mockDoc1 = createMockDocumentation('v1');
+            const mockDoc2 = createMockDocumentation('v2');
+            let callCount = 0;
+            const mockFetch = jest.fn().mockImplementation(() => {
+                callCount++;
+                return Promise.resolve({
+                    status: 200,
+                    statusText: 'OK',
+                    data: JSON.stringify(callCount === 1 ? mockDoc1 : mockDoc2),
+                    headers: new Map(),
+                });
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            const onReloadSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onReload: onReloadSpy,
+            });
+            await source.load();
+            expect(onReloadSpy).not.toHaveBeenCalled(); // Not called on initial load
+            source.startMonitoring();
+            // Advance time to trigger poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(onReloadSpy).toHaveBeenCalledTimes(1);
+            expect(onReloadSpy).toHaveBeenCalledWith(expect.objectContaining({
+                components: expect.arrayContaining([
+                    expect.objectContaining({ name: 'Componentv2' })
+                ])
+            }));
+            jest.useRealTimers();
+        });
+    });
+    describe('304 Not Modified Response Handling (Requirement 8.4)', () => {
+        it('should use cached data when server returns 304', async () => {
+            const mockDoc = createMockDocumentation('cached');
+            const headers = new Map();
+            headers.set('ETag', '"version1"');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers,
+            })
+                .mockResolvedValueOnce({
+                status: 304,
+                statusText: 'Not Modified',
+                data: '',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            // First load
+            const result1 = await source.load();
+            expect(result1.success).toBe(true);
+            expect(result1.data?.components[0].name).toBe('Componentcached');
+            // Second load with 304
+            const result2 = await source.load();
+            expect(result2.success).toBe(true);
+            expect(result2.data?.components[0].name).toBe('Componentcached');
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        it('should not invoke onReload callback when polling returns 304', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('unchanged');
+            const headers = new Map();
+            headers.set('ETag', '"same"');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers,
+            })
+                .mockResolvedValue({
+                status: 304,
+                statusText: 'Not Modified',
+                data: '',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            const onReloadSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onReload: onReloadSpy,
+            });
+            await source.load();
+            source.startMonitoring();
+            // Advance time to trigger poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            // onReload should not be called for 304
+            expect(onReloadSpy).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+        it('should send conditional headers when cache exists', async () => {
+            const mockDoc = createMockDocumentation('test');
+            const headers = new Map();
+            headers.set('ETag', '"etag123"');
+            headers.set('Last-Modified', 'Wed, 21 Oct 2015 07:28:00 GMT');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers,
+            })
+                .mockResolvedValueOnce({
+                status: 304,
+                statusText: 'Not Modified',
+                data: '',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            await source.load(); // Second load
+            // Verify conditional headers were sent on second call
+            const calls = mockFetch.mock.calls;
+            const conditionalHeaders = calls[1]?.[1];
+            expect(conditionalHeaders?.get('If-None-Match')).toBe('"etag123"');
+            expect(conditionalHeaders?.get('If-Modified-Since')).toBe('Wed, 21 Oct 2015 07:28:00 GMT');
+        });
+    });
+    describe('Error Handling During Polling (Requirement 5.4)', () => {
+        it('should continue using cached data when polling encounters error', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('stable');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            })
+                .mockRejectedValue(new Error('Network error'));
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+            });
+            await source.load();
+            const dataBefore = source.getCurrentData();
+            source.startMonitoring();
+            // Advance time to trigger poll with error
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            const dataAfter = source.getCurrentData();
+            // Data should remain unchanged
+            expect(dataAfter).toEqual(dataBefore);
+            expect(dataAfter?.components[0].name).toBe('Componentstable');
+            jest.useRealTimers();
+        });
+        it('should invoke onError callback when polling fails', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('test');
+            const networkError = new Error('Connection timeout');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            })
+                .mockRejectedValue(networkError);
+            HttpClient.prototype.fetch = mockFetch;
+            const onErrorSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onError: onErrorSpy,
+            });
+            await source.load();
+            source.startMonitoring();
+            // Advance time to trigger poll with error
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(onErrorSpy).toHaveBeenCalledTimes(1);
+            expect(onErrorSpy).toHaveBeenCalledWith(expect.objectContaining({
+                message: 'Connection timeout'
+            }));
+            jest.useRealTimers();
+        });
+        it('should handle HTTP errors during polling gracefully', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            })
+                .mockResolvedValue({
+                status: 500,
+                statusText: 'Internal Server Error',
+                data: '',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            const onErrorSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onError: onErrorSpy,
+            });
+            await source.load();
+            const dataBefore = source.getCurrentData();
+            source.startMonitoring();
+            // Advance time to trigger poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            // Should invoke error callback
+            expect(onErrorSpy).toHaveBeenCalled();
+            // Data should remain unchanged
+            expect(source.getCurrentData()).toEqual(dataBefore);
+            jest.useRealTimers();
+        });
+        it('should handle parse errors during polling gracefully', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn()
+                .mockResolvedValueOnce({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            })
+                .mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: 'invalid json {',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            const onErrorSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onError: onErrorSpy,
+            });
+            await source.load();
+            const dataBefore = source.getCurrentData();
+            source.startMonitoring();
+            // Advance time to trigger poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            // Should invoke error callback
+            expect(onErrorSpy).toHaveBeenCalled();
+            // Data should remain unchanged
+            expect(source.getCurrentData()).toEqual(dataBefore);
+            jest.useRealTimers();
+        });
+    });
+    describe('Cleanup on Dispose (Requirement 5.5, 8.5)', () => {
+        it('should stop polling when dispose is called', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+            });
+            await source.load();
+            mockFetch.mockClear();
+            source.startMonitoring();
+            await source.dispose();
+            // Advance time - should not poll
+            jest.advanceTimersByTime(10000);
+            await Promise.resolve();
+            expect(mockFetch).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+        it('should clear cached data when dispose is called', async () => {
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            expect(source.getCurrentData()).toBeDefined();
+            await source.dispose();
+            expect(source.getCurrentData()).toBeUndefined();
+        });
+        it('should clear callbacks when dispose is called', async () => {
+            jest.useFakeTimers();
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            const onReloadSpy = jest.fn();
+            const onErrorSpy = jest.fn();
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 10000,
+                onReload: onReloadSpy,
+                onError: onErrorSpy,
+            });
+            await source.load();
+            await source.dispose();
+            // Callbacks should be cleared and not invoked
+            // This is verified by the fact that dispose clears the callbacks
+            expect(onReloadSpy).not.toHaveBeenCalled();
+            expect(onErrorSpy).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+        it('should handle dispose when not monitoring', async () => {
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            // Dispose without starting monitoring
+            await expect(source.dispose()).resolves.not.toThrow();
+        });
+        it('should handle multiple dispose calls gracefully', async () => {
+            const mockDoc = createMockDocumentation('test');
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(mockDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            await source.load();
+            await source.dispose();
+            // Second dispose should not throw
+            await expect(source.dispose()).resolves.not.toThrow();
+        });
+    });
+    describe('Error Scenarios', () => {
+        it('should return error for non-200 status codes', async () => {
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 404,
+                statusText: 'Not Found',
+                data: '',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error).toContain('404');
+        });
+        it('should return error for invalid JSON', async () => {
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: 'not valid json {',
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error).toMatch(/parse|json/i);
+        });
+        it('should return error for invalid documentation structure', async () => {
+            const invalidDoc = { components: 'not an array' };
+            const mockFetch = jest.fn().mockResolvedValue({
+                status: 200,
+                statusText: 'OK',
+                data: JSON.stringify(invalidDoc),
+                headers: new Map(),
+            });
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error).toMatch(/must be an array/i);
+        });
+        it('should return error for network failures', async () => {
+            const mockFetch = jest.fn().mockRejectedValue(new Error('Network connection failed'));
+            HttpClient.prototype.fetch = mockFetch;
+            source = new RemoteDocumentationSource({
+                url: 'https://example.com/docs.json',
+                timeout: 5000,
+                maxRetries: 3,
+                pollingInterval: 60000,
+            });
+            const result = await source.load();
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error).toContain('Network connection failed');
+        });
+    });
+});
+//# sourceMappingURL=remote-documentation-source.test.js.map