kubeview-mcp 1.0.0

package/dist/tests/kubernetes/PodOperations.test.js

@@ -0,0 +1,209 @@
+import { PodOperations } from '../../src/kubernetes/resources/PodOperations';
+import * as k8s from '@kubernetes/client-node';
+import { WatchEventType } from '../../src/kubernetes/BaseResourceOperations';
+// Mock KubernetesClient and Watch
+jest.mock('../../src/kubernetes/KubernetesClient');
+jest.mock('@kubernetes/client-node', () => ({
+    ...jest.requireActual('@kubernetes/client-node'),
+    Watch: jest.fn(),
+}));
+describe('PodOperations', () => {
+    let mockClient;
+    let podOperations;
+    let mockCoreV1Api;
+    let mockCustomObjectsApi;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Setup mock CoreV1Api
+        mockCoreV1Api = {
+            readNamespacedPod: jest.fn(),
+            listNamespacedPod: jest.fn(),
+            listPodForAllNamespaces: jest.fn(),
+            readNamespacedPodLog: jest.fn(),
+        };
+        // Setup mock CustomObjectsApi
+        mockCustomObjectsApi = {
+            getNamespacedCustomObject: jest.fn(),
+        };
+        // Setup mock client
+        mockClient = {
+            core: mockCoreV1Api,
+            kubeConfig: {
+                makeApiClient: jest.fn().mockReturnValue(mockCustomObjectsApi),
+            },
+            logger: {
+                error: jest.fn(),
+            },
+            config: {
+                logger: {
+                    error: jest.fn(),
+                    info: jest.fn(),
+                    warn: jest.fn(),
+                    debug: jest.fn(),
+                },
+            },
+        };
+        // Create PodOperations instance
+        podOperations = new PodOperations(mockClient);
+    });
+    describe('Read-only Operations', () => {
+        describe('get', () => {
+            it('should get a pod by name', async () => {
+                const mockPod = { metadata: { name: 'test-pod' } };
+                mockCoreV1Api.readNamespacedPod.mockResolvedValue(mockPod);
+                const result = await podOperations.get('test-pod', { namespace: 'default' });
+                expect(result).toBe(mockPod);
+                expect(mockCoreV1Api.readNamespacedPod).toHaveBeenCalledWith({
+                    name: 'test-pod',
+                    namespace: 'default',
+                });
+            });
+            it('should handle errors when getting a pod', async () => {
+                const error = new Error('Not found');
+                mockCoreV1Api.readNamespacedPod.mockRejectedValue(error);
+                await expect(podOperations.get('test-pod')).rejects.toThrow();
+            });
+        });
+        describe('list', () => {
+            it('should list pods in a namespace', async () => {
+                const mockPodList = { items: [{ metadata: { name: 'test-pod' } }] };
+                mockCoreV1Api.listNamespacedPod.mockResolvedValue(mockPodList);
+                const result = await podOperations.list({ namespace: 'default' });
+                expect(result).toBe(mockPodList);
+                expect(mockCoreV1Api.listNamespacedPod).toHaveBeenCalledWith(expect.objectContaining({
+                    namespace: 'default',
+                }));
+            });
+            it('should list pods across all namespaces', async () => {
+                const mockPodList = { items: [{ metadata: { name: 'test-pod' } }] };
+                mockCoreV1Api.listPodForAllNamespaces.mockResolvedValue(mockPodList);
+                const result = await podOperations.list();
+                expect(result).toBe(mockPodList);
+                expect(mockCoreV1Api.listPodForAllNamespaces).toHaveBeenCalled();
+            });
+            it('should handle errors when listing pods', async () => {
+                const error = new Error('List failed');
+                mockCoreV1Api.listNamespacedPod.mockRejectedValue(error);
+                await expect(podOperations.list({ namespace: 'default' })).rejects.toThrow();
+            });
+        });
+        describe('watch', () => {
+            it('should watch pods for changes', async () => {
+                const mockCallback = jest.fn();
+                const abortFn = jest.fn();
+                const mockWatchInstance = {
+                    watch: jest.fn().mockImplementation((_path, _opts, onData, _onError) => {
+                        onData('ADDED', { metadata: { name: 'test-pod' } });
+                        return { abort: abortFn };
+                    }),
+                };
+                k8s.Watch.mockReturnValue(mockWatchInstance);
+                const cleanup = podOperations.watch(mockCallback, { namespace: 'default' });
+                // Wait for async startWatch to complete
+                await new Promise((r) => setImmediate(r));
+                cleanup();
+                expect(abortFn).toHaveBeenCalled();
+            });
+            it('should handle watch errors', () => {
+                const mockCallback = jest.fn();
+                const error = new Error('Watch error');
+                const mockWatchInstance = {
+                    watch: jest.fn().mockImplementation((_path, _opts, _onData, onError) => {
+                        onError(error);
+                        return { abort: jest.fn() };
+                    }),
+                };
+                k8s.Watch.mockImplementation(() => mockWatchInstance);
+                podOperations.watch(mockCallback, { namespace: 'default' });
+                expect(mockCallback).toHaveBeenCalledWith({
+                    type: WatchEventType.ERROR,
+                    object: error,
+                });
+            });
+        });
+        describe('getLogs', () => {
+            it('should get pod logs', async () => {
+                const mockLogs = 'test logs';
+                mockCoreV1Api.readNamespacedPodLog.mockResolvedValue(mockLogs);
+                const result = await podOperations.getLogs('test-pod', {
+                    namespace: 'default',
+                    container: 'test-container',
+                    follow: true,
+                    tailLines: 100,
+                    previous: false,
+                    timestamps: true,
+                });
+                expect(result).toBe(mockLogs);
+                expect(mockCoreV1Api.readNamespacedPodLog).toHaveBeenCalledWith({
+                    name: 'test-pod',
+                    namespace: 'default',
+                    container: 'test-container',
+                    follow: true,
+                    tailLines: 100,
+                    previous: false,
+                    timestamps: true,
+                });
+            });
+            it('should handle errors when getting logs', async () => {
+                const error = new Error('Logs not available');
+                mockCoreV1Api.readNamespacedPodLog.mockRejectedValue(error);
+                await expect(podOperations.getLogs('test-pod')).rejects.toThrow();
+            });
+        });
+        describe('streamLogs', () => {
+            it('should stream pod logs', () => {
+                const mockLogs = 'test logs';
+                mockCoreV1Api.readNamespacedPodLog.mockResolvedValue(mockLogs);
+                const onData = jest.fn();
+                const cleanup = podOperations.streamLogs('test-pod', onData, {
+                    namespace: 'default',
+                    container: 'test-container',
+                    follow: true,
+                });
+                expect(mockCoreV1Api.readNamespacedPodLog).toHaveBeenCalledWith({
+                    name: 'test-pod',
+                    namespace: 'default',
+                    container: 'test-container',
+                    follow: true,
+                });
+                cleanup();
+            });
+        });
+        describe('getMetrics', () => {
+            it('should get pod metrics', async () => {
+                const mockMetrics = { usage: { cpu: '100m', memory: '100Mi' } };
+                mockCustomObjectsApi.getNamespacedCustomObject.mockResolvedValue(mockMetrics);
+                const result = await podOperations.getMetrics('test-pod', { namespace: 'default' });
+                expect(result).toBe(mockMetrics);
+                expect(mockCustomObjectsApi.getNamespacedCustomObject).toHaveBeenCalledWith({
+                    group: 'metrics.k8s.io',
+                    version: 'v1beta1',
+                    namespace: 'default',
+                    plural: 'pods',
+                    name: 'test-pod',
+                });
+            });
+            it('should handle errors when getting metrics', async () => {
+                const error = new Error('Metrics not available');
+                mockCustomObjectsApi.getNamespacedCustomObject.mockRejectedValue(error);
+                await expect(podOperations.getMetrics('test-pod')).rejects.toThrow();
+            });
+        });
+    });
+    describe('Unsupported Operations', () => {
+        it('should throw error for create operation', async () => {
+            await expect(podOperations.create({})).rejects.toThrow('Create operation is not supported in read-only mode');
+        });
+        it('should throw error for update operation', async () => {
+            await expect(podOperations.update({})).rejects.toThrow('Update operation is not supported in read-only mode');
+        });
+        it('should throw error for patch operation', async () => {
+            await expect(podOperations.patch('test-pod', {})).rejects.toThrow('Patch operation is not supported in read-only mode');
+        });
+        it('should throw error for delete operation', async () => {
+            await expect(podOperations.delete('test-pod')).rejects.toThrow('Delete operation is not supported in read-only mode');
+        });
+    });
+});
+//# sourceMappingURL=PodOperations.test.js.map

package/dist/tests/kubernetes/PodOperations.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PodOperations.test.js","sourceRoot":"","sources":["../../../tests/kubernetes/PodOperations.test.ts"],"names":[],"mappings":"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"}

package/dist/tests/kubernetes/RetryStrategy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RetryStrategy.test.d.ts.map

package/dist/tests/kubernetes/RetryStrategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryStrategy.test.d.ts","sourceRoot":"","sources":["../../../tests/kubernetes/RetryStrategy.test.ts"],"names":[],"mappings":""}

package/dist/tests/kubernetes/RetryStrategy.test.js

@@ -0,0 +1,419 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { RetryStrategy, RetryBuilder, RETRY_PRESETS, Retryable, } from '../../src/kubernetes/RetryStrategy';
+import { KubernetesError, NetworkError, TimeoutError } from '../../src/kubernetes/ErrorHandling';
+describe('RetryStrategy', () => {
+    describe('Basic Retry Operations', () => {
+        it('should succeed on first attempt', async () => {
+            const strategy = new RetryStrategy({ maxAttempts: 3 });
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                return 'success';
+            });
+            expect(result.success).toBe(true);
+            expect(result.value).toBe('success');
+            expect(result.attempts).toBe(1);
+            expect(attempts).toBe(1);
+        });
+        it('should retry on failure and succeed', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                jitterFactor: 0,
+                isRetryable: () => true,
+            });
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                if (attempts < 3) {
+                    throw new Error('Temporary failure');
+                }
+                return 'success';
+            });
+            expect(result.success).toBe(true);
+            expect(result.value).toBe('success');
+            expect(result.attempts).toBe(3);
+            expect(attempts).toBe(3);
+        });
+        it('should fail after max attempts', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                jitterFactor: 0,
+                isRetryable: () => true,
+            });
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                throw new Error(`Failure ${attempts}`);
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.error.message).toBe('Failure 3');
+            expect(result.attempts).toBe(3);
+            expect(attempts).toBe(3);
+        });
+        it('should not retry non-retryable errors', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+            });
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                throw new KubernetesError('Auth failed', 'AUTH_ERROR', 401, false);
+            });
+            expect(result.success).toBe(false);
+            expect(result.attempts).toBe(1);
+            expect(attempts).toBe(1);
+        });
+        it('should retry retryable Kubernetes errors', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                jitterFactor: 0,
+            });
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                if (attempts < 2) {
+                    throw new NetworkError('Network issue');
+                }
+                return 'recovered';
+            });
+            expect(result.success).toBe(true);
+            expect(result.value).toBe('recovered');
+            expect(result.attempts).toBe(2);
+        });
+    });
+    describe('Exponential Backoff', () => {
+        it('should apply exponential backoff', async () => {
+            const delays = [];
+            const strategy = new RetryStrategy({
+                maxAttempts: 4,
+                initialDelayMs: 100,
+                backoffMultiplier: 2,
+                jitterFactor: 0,
+                onRetry: (_attempt, _error, nextDelay) => {
+                    delays.push(nextDelay);
+                },
+                isRetryable: () => true,
+            });
+            await strategy.execute(async () => {
+                throw new Error('Always fails');
+            });
+            expect(delays).toHaveLength(3); // 3 retries after initial attempt
+            expect(delays[0]).toBe(100); // 100ms
+            expect(delays[1]).toBe(200); // 100 * 2
+            expect(delays[2]).toBe(400); // 100 * 2^2
+        });
+        it('should respect maxDelayMs', async () => {
+            const delays = [];
+            const strategy = new RetryStrategy({
+                maxAttempts: 5,
+                initialDelayMs: 100,
+                maxDelayMs: 300,
+                backoffMultiplier: 2,
+                jitterFactor: 0,
+                onRetry: (_attempt, _error, nextDelay) => {
+                    delays.push(nextDelay);
+                },
+                isRetryable: () => true,
+            });
+            await strategy.execute(async () => {
+                throw new Error('Always fails');
+            });
+            expect(delays[0]).toBe(100);
+            expect(delays[1]).toBe(200);
+            expect(delays[2]).toBe(300); // Capped at maxDelayMs
+            expect(delays[3]).toBe(300); // Still capped
+        });
+        it('should apply jitter', async () => {
+            const delays = [];
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 1000,
+                jitterFactor: 0.5,
+                onRetry: (_attempt, _error, nextDelay) => {
+                    delays.push(nextDelay);
+                },
+                isRetryable: () => true,
+            });
+            await strategy.execute(async () => {
+                throw new Error('Always fails');
+            });
+            // With 0.5 jitter factor, delay should be between 500ms and 1500ms
+            expect(delays[0]).toBeGreaterThanOrEqual(500);
+            expect(delays[0]).toBeLessThanOrEqual(1500);
+        });
+    });
+    describe('Timeout Handling', () => {
+        it('should timeout long-running operations', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 1,
+                timeoutMs: 100,
+                isRetryable: () => true,
+            });
+            const result = await strategy.execute(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 200));
+                return 'should not reach';
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBeInstanceOf(Error);
+            expect(result.error.message).toContain('timed out');
+        });
+        it('should stop retrying when total timeout exceeded', async () => {
+            let attempts = 0;
+            const strategy = new RetryStrategy({
+                maxAttempts: 10,
+                initialDelayMs: 100,
+                timeoutMs: 250, // Total timeout
+                jitterFactor: 0,
+            });
+            const result = await strategy.execute(async () => {
+                attempts++;
+                throw new Error('Retry me');
+            });
+            expect(result.success).toBe(false);
+            expect(attempts).toBeLessThan(10); // Should stop before max attempts
+            expect(result.totalTimeMs).toBeLessThanOrEqual(300); // Some buffer for execution
+        });
+    });
+    describe('Custom Retry Logic', () => {
+        it('should use custom isRetryable function', async () => {
+            let attempts = 0;
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                isRetryable: (error) => {
+                    return error.message.includes('retry');
+                },
+            });
+            // Should retry
+            const result1 = await strategy.execute(async () => {
+                attempts++;
+                if (attempts < 2) {
+                    throw new Error('Please retry this');
+                }
+                return 'success';
+            });
+            expect(result1.success).toBe(true);
+            expect(attempts).toBe(2);
+            // Should not retry
+            attempts = 0;
+            const result2 = await strategy.execute(async () => {
+                attempts++;
+                throw new Error('Do not attempt again');
+            });
+            expect(result2.success).toBe(false);
+            expect(attempts).toBe(1);
+        });
+        it('should call onRetry callback', async () => {
+            const retryEvents = [];
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                jitterFactor: 0,
+                onRetry: (_attempt, _error, nextDelay) => {
+                    retryEvents.push({
+                        attempt: _attempt,
+                        error: _error.message,
+                        nextDelay,
+                    });
+                },
+                isRetryable: () => true,
+            });
+            await strategy.execute(async () => {
+                throw new Error('Failure');
+            });
+            expect(retryEvents).toHaveLength(2); // 2 retries after initial
+            expect(retryEvents[0].attempt).toBe(1);
+            expect(retryEvents[0].error).toBe('Failure');
+            expect(retryEvents[1].attempt).toBe(2);
+        });
+    });
+    describe('Retry Presets', () => {
+        it('should use FAST preset', async () => {
+            const strategy = new RetryStrategy(RETRY_PRESETS.FAST);
+            const start = Date.now();
+            await strategy.execute(async () => {
+                throw new Error('Fast fail');
+            });
+            const duration = Date.now() - start;
+            expect(duration).toBeLessThan(2000); // Fast preset should complete quickly
+        });
+        it('should use AGGRESSIVE preset', async () => {
+            const strategy = new RetryStrategy({ ...RETRY_PRESETS.AGGRESSIVE, isRetryable: () => true });
+            let attempts = 0;
+            await strategy.execute(async () => {
+                attempts++;
+                throw new Error('Need many retries');
+            });
+            expect(attempts).toBe(5); // Aggressive preset has 5 max attempts
+        }, 20000);
+        it('should use NONE preset', async () => {
+            const strategy = new RetryStrategy(RETRY_PRESETS.NONE);
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                throw new Error('No retry');
+            });
+            expect(result.success).toBe(false);
+            expect(attempts).toBe(1); // No retries
+        });
+    });
+    describe('RetryBuilder', () => {
+        it('should build retry strategy with fluent API', async () => {
+            const strategy = new RetryBuilder()
+                .withMaxAttempts(2)
+                .withInitialDelay(50)
+                .withMaxDelay(100)
+                .withBackoffMultiplier(2)
+                .withJitterFactor(0)
+                .withTimeout(1000)
+                .withRetryableCheck(() => true)
+                .build();
+            let attempts = 0;
+            const result = await strategy.execute(async () => {
+                attempts++;
+                if (attempts < 2) {
+                    throw new Error('Retry once');
+                }
+                return 'built';
+            });
+            expect(result.success).toBe(true);
+            expect(result.value).toBe('built');
+            expect(attempts).toBe(2);
+        });
+        it('should build with preset', async () => {
+            const strategy = new RetryBuilder()
+                .withPreset('FAST')
+                .withMaxAttempts(2) // Override preset
+                .withRetryableCheck(() => true)
+                .build();
+            let attempts = 0;
+            await strategy.execute(async () => {
+                attempts++;
+                throw new Error('Fail');
+            });
+            expect(attempts).toBe(2); // Our override
+        });
+    });
+    describe('Wrap Function', () => {
+        it('should wrap function with retry logic', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 3,
+                initialDelayMs: 10,
+                isRetryable: () => true,
+            });
+            let attempts = 0;
+            const unreliableFunction = async (value) => {
+                attempts++;
+                if (attempts < 2) {
+                    throw new Error('Temporary issue');
+                }
+                return `Processed: ${value}`;
+            };
+            const reliableFunction = strategy.wrap(unreliableFunction);
+            const result = await reliableFunction('test');
+            expect(result).toBe('Processed: test');
+            expect(attempts).toBe(2);
+        });
+        it('should throw on wrapped function failure', async () => {
+            const strategy = new RetryStrategy({
+                maxAttempts: 2,
+                initialDelayMs: 10,
+            });
+            const alwaysFails = async () => {
+                throw new Error('Permanent failure');
+            };
+            const wrapped = strategy.wrap(alwaysFails);
+            await expect(wrapped()).rejects.toThrow('Permanent failure');
+        });
+    });
+    describe('Retryable Decorator', () => {
+        it('should make method retryable', async () => {
+            class TestService {
+                attempts = 0;
+                async unreliableMethod() {
+                    this.attempts++;
+                    if (this.attempts < 2) {
+                        throw new TimeoutError('Timeout');
+                    }
+                    return 'success';
+                }
+                async noRetryMethod() {
+                    this.attempts++;
+                    throw new Error('Should not retry');
+                }
+            }
+            __decorate([
+                Retryable({
+                    maxAttempts: 3,
+                    initialDelayMs: 10,
+                    jitterFactor: 0,
+                }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], TestService.prototype, "unreliableMethod", null);
+            __decorate([
+                Retryable(RETRY_PRESETS.NONE),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], TestService.prototype, "noRetryMethod", null);
+            const service = new TestService();
+            // Test retryable method
+            const result = await service.unreliableMethod();
+            expect(result).toBe('success');
+            expect(service.attempts).toBe(2);
+            // Test no-retry method
+            service.attempts = 0;
+            await expect(service.noRetryMethod()).rejects.toThrow('Should not retry');
+            expect(service.attempts).toBe(1);
+        });
+    });
+    describe('Error Type Detection', () => {
+        it('should retry on network-related error messages', async () => {
+            const networkErrors = [
+                'ECONNREFUSED: Connection refused',
+                'ENOTFOUND: DNS lookup failed',
+                'ETIMEDOUT: Request timed out',
+                'ECONNRESET: Connection reset',
+                'EPIPE: Broken pipe',
+                'Network error occurred',
+                'Request timeout',
+                'socket hang up',
+                'Service Unavailable',
+                'Bad Gateway',
+                'Gateway Timeout',
+            ];
+            for (const errorMessage of networkErrors) {
+                const strategy = new RetryStrategy({
+                    maxAttempts: 2,
+                    initialDelayMs: 1,
+                });
+                let attempts = 0;
+                const result = await strategy.execute(async () => {
+                    attempts++;
+                    if (attempts < 2) {
+                        throw new Error(errorMessage);
+                    }
+                    return 'recovered';
+                });
+                expect(result.success).toBe(true);
+                expect(attempts).toBe(2);
+            }
+        });
+    });
+});
+//# sourceMappingURL=RetryStrategy.test.js.map