@eui/mcp 1.5.1 → 1.5.2

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

@@ -1,707 +0,0 @@
-/**
- * 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