@hazeljs/discovery 0.2.0-alpha.1

package/dist/__tests__/kubernetes-backend.test.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Kubernetes Backend Tests
+ * Uses mocked @kubernetes/client-node API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const kubernetes_backend_1 = require("../backends/kubernetes-backend");
+const types_1 = require("../types");
+const logger_1 = require("../utils/logger");
+// Suppress console logs during tests
+beforeAll(() => {
+    logger_1.DiscoveryLogger.setLogger({
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    });
+});
+afterAll(() => {
+    logger_1.DiscoveryLogger.resetLogger();
+});
+// Mock @kubernetes/client-node (optional peer dependency)
+jest.mock('@kubernetes/client-node', () => ({
+    CoreV1Api: class MockCoreV1Api {
+    },
+}), { virtual: true });
+function createMockK8sApi() {
+    return {
+        readNamespacedEndpoints: jest.fn(),
+        listNamespacedService: jest.fn(),
+    };
+}
+function createMockKubeConfig(api) {
+    return {
+        makeApiClient: jest.fn(() => api),
+    };
+}
+describe('KubernetesRegistryBackend', () => {
+    let k8sApi;
+    let backend;
+    beforeEach(() => {
+        k8sApi = createMockK8sApi();
+        const kubeConfig = createMockKubeConfig(k8sApi);
+        backend = new kubernetes_backend_1.KubernetesRegistryBackend(kubeConfig);
+    });
+    describe('constructor', () => {
+        it('should create with default config', () => {
+            expect(backend).toBeDefined();
+        });
+        it('should accept custom namespace and label selector', () => {
+            const api = createMockK8sApi();
+            const config = createMockKubeConfig(api);
+            const b = new kubernetes_backend_1.KubernetesRegistryBackend(config, {
+                namespace: 'production',
+                labelSelector: 'app=myapp',
+            });
+            expect(b).toBeDefined();
+        });
+    });
+    describe('register / deregister / heartbeat (no-ops)', () => {
+        it('register should be a no-op', async () => {
+            await expect(backend.register({
+                id: 'svc-1',
+                name: 'test',
+                host: 'localhost',
+                port: 3000,
+                status: types_1.ServiceStatus.UP,
+                lastHeartbeat: new Date(),
+                registeredAt: new Date(),
+            })).resolves.not.toThrow();
+        });
+        it('deregister should be a no-op', async () => {
+            await expect(backend.deregister('svc-1')).resolves.not.toThrow();
+        });
+        it('heartbeat should be a no-op', async () => {
+            await expect(backend.heartbeat('svc-1')).resolves.not.toThrow();
+        });
+        it('updateStatus should be a no-op', async () => {
+            await expect(backend.updateStatus('svc-1', types_1.ServiceStatus.DOWN)).resolves.not.toThrow();
+        });
+        it('cleanup should be a no-op', async () => {
+            await expect(backend.cleanup()).resolves.not.toThrow();
+        });
+    });
+    describe('getInstances', () => {
+        it('should return instances from endpoints', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: {
+                        annotations: {},
+                        labels: { app: 'my-service' },
+                        creationTimestamp: '2025-01-01T00:00:00Z',
+                    },
+                    subsets: [
+                        {
+                            addresses: [
+                                { ip: '10.0.0.1', targetRef: { name: 'pod-1' }, nodeName: 'node-1' },
+                                { ip: '10.0.0.2', targetRef: { name: 'pod-2' }, nodeName: 'node-2' },
+                            ],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toHaveLength(2);
+            expect(instances[0].id).toBe('my-service:10.0.0.1:8080');
+            expect(instances[0].host).toBe('10.0.0.1');
+            expect(instances[0].port).toBe(8080);
+            expect(instances[0].status).toBe(types_1.ServiceStatus.UP);
+            expect(instances[0].metadata?.podName).toBe('pod-1');
+            expect(instances[0].metadata?.nodeName).toBe('node-1');
+        });
+        it('should mark notReadyAddresses as STARTING', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: { labels: {} },
+                    subsets: [
+                        {
+                            addresses: [],
+                            notReadyAddresses: [{ ip: '10.0.0.3' }],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toHaveLength(1);
+            expect(instances[0].status).toBe(types_1.ServiceStatus.STARTING);
+        });
+        it('should handle multiple ports per address', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: { labels: {} },
+                    subsets: [
+                        {
+                            addresses: [{ ip: '10.0.0.1' }],
+                            ports: [{ port: 8080 }, { port: 8443 }],
+                        },
+                    ],
+                },
+            });
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toHaveLength(2);
+            expect(instances[0].port).toBe(8080);
+            expect(instances[1].port).toBe(8443);
+        });
+        it('should return empty array when no subsets', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: {},
+                },
+            });
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toEqual([]);
+        });
+        it('should return empty array on API error', async () => {
+            k8sApi.readNamespacedEndpoints.mockRejectedValueOnce(new Error('Not found'));
+            const instances = await backend.getInstances('non-existent');
+            expect(instances).toEqual([]);
+        });
+        it('should apply filters', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: {
+                        labels: {
+                            'topology.kubernetes.io/zone': 'us-east-1a',
+                        },
+                    },
+                    subsets: [
+                        {
+                            addresses: [{ ip: '10.0.0.1' }, { ip: '10.0.0.2' }],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instances = await backend.getInstances('my-service', {
+                status: types_1.ServiceStatus.UP,
+            });
+            expect(instances).toHaveLength(2);
+        });
+        it('should extract zone from labels', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: {
+                        labels: {
+                            'topology.kubernetes.io/zone': 'us-west-2a',
+                        },
+                    },
+                    subsets: [
+                        {
+                            addresses: [{ ip: '10.0.0.1' }],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instances = await backend.getInstances('my-service');
+            expect(instances[0].zone).toBe('us-west-2a');
+        });
+    });
+    describe('getInstance', () => {
+        it('should find instance by ID', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: { labels: {} },
+                    subsets: [
+                        {
+                            addresses: [{ ip: '10.0.0.1' }, { ip: '10.0.0.2' }],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instance = await backend.getInstance('my-service:10.0.0.2:8080');
+            expect(instance).toBeDefined();
+            expect(instance.host).toBe('10.0.0.2');
+        });
+        it('should return null for non-existent instance', async () => {
+            k8sApi.readNamespacedEndpoints.mockResolvedValueOnce({
+                body: {
+                    metadata: { labels: {} },
+                    subsets: [
+                        {
+                            addresses: [{ ip: '10.0.0.1' }],
+                            ports: [{ port: 8080 }],
+                        },
+                    ],
+                },
+            });
+            const instance = await backend.getInstance('my-service:10.0.0.99:8080');
+            expect(instance).toBeNull();
+        });
+    });
+    describe('getAllServices', () => {
+        it('should return service names from namespace', async () => {
+            k8sApi.listNamespacedService.mockResolvedValueOnce({
+                body: {
+                    items: [{ metadata: { name: 'svc-a' } }, { metadata: { name: 'svc-b' } }],
+                },
+            });
+            const services = await backend.getAllServices();
+            expect(services).toEqual(['svc-a', 'svc-b']);
+        });
+        it('should return empty array on error', async () => {
+            k8sApi.listNamespacedService.mockRejectedValueOnce(new Error('Forbidden'));
+            const services = await backend.getAllServices();
+            expect(services).toEqual([]);
+        });
+        it('should handle missing metadata', async () => {
+            k8sApi.listNamespacedService.mockResolvedValueOnce({
+                body: {
+                    items: [{ metadata: {} }, {}],
+                },
+            });
+            const services = await backend.getAllServices();
+            expect(services).toEqual(['', '']);
+        });
+    });
+});

package/dist/__tests__/load-balancer-strategies.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Load Balancer Strategies Tests
+ */
+export {};
+//# sourceMappingURL=load-balancer-strategies.test.d.ts.map

package/dist/__tests__/load-balancer-strategies.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-balancer-strategies.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/load-balancer-strategies.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/__tests__/load-balancer-strategies.test.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Load Balancer Strategies Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const strategies_1 = require("../load-balancer/strategies");
+const types_1 = require("../types");
+describe('Load Balancer Strategies', () => {
+    const createInstance = (id, status = types_1.ServiceStatus.UP) => ({
+        id,
+        name: 'test-service',
+        host: 'localhost',
+        port: 3000,
+        status,
+        lastHeartbeat: new Date(),
+        registeredAt: new Date(),
+    });
+    describe('RoundRobinStrategy', () => {
+        it('should cycle through instances in order', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            expect(strategy.choose(instances)?.id).toBe('1');
+            expect(strategy.choose(instances)?.id).toBe('2');
+            expect(strategy.choose(instances)?.id).toBe('3');
+            expect(strategy.choose(instances)?.id).toBe('1'); // Cycles back
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+        it('should filter out unhealthy instances', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.UP),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+                createInstance('3', types_1.ServiceStatus.UP),
+            ];
+            const first = strategy.choose(instances);
+            const second = strategy.choose(instances);
+            expect([first?.id, second?.id]).toEqual(['1', '3']);
+        });
+    });
+    describe('RandomStrategy', () => {
+        it('should return a random instance', () => {
+            const strategy = new strategies_1.RandomStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+            expect(['1', '2', '3']).toContain(selected?.id);
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.RandomStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('LeastConnectionsStrategy', () => {
+        it('should select instance with least connections', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('2');
+            const selected = strategy.choose(instances);
+            expect(selected?.id).toBe('3');
+        });
+        it('should handle connection increments and decrements', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1')];
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+            strategy.decrementConnections('1');
+            strategy.decrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+        });
+        it('should not allow negative connections', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1')];
+            strategy.decrementConnections('1');
+            strategy.decrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('WeightedRoundRobinStrategy', () => {
+        it('should select instances based on weight', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                { ...createInstance('1'), metadata: { weight: 2 } },
+                { ...createInstance('2'), metadata: { weight: 1 } },
+            ];
+            const results = [];
+            for (let i = 0; i < 6; i++) {
+                const selected = strategy.choose(instances);
+                if (selected)
+                    results.push(selected.id);
+            }
+            // Should have more '1' than '2' due to weight
+            const count1 = results.filter((id) => id === '1').length;
+            const count2 = results.filter((id) => id === '2').length;
+            expect(count1).toBeGreaterThan(count2);
+        });
+        it('should default to weight 1 when weight is missing', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should handle invalid weight values', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                { ...createInstance('1'), metadata: { weight: 'invalid' } },
+                { ...createInstance('2'), metadata: { weight: -1 } },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('IPHashStrategy', () => {
+        it('should return same instance for same IP', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            const ip = '192.168.1.1';
+            const first = strategy.choose(instances, ip);
+            const second = strategy.choose(instances, ip);
+            expect(first?.id).toBe(second?.id);
+        });
+        it('should return first instance when no IP provided', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected?.id).toBe('1');
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances, '192.168.1.1')).toBeNull();
+        });
+    });
+    describe('ZoneAwareStrategy', () => {
+        it('should prefer instances in preferred zone', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                { ...createInstance('1'), zone: 'us-east-1' },
+                { ...createInstance('2'), zone: 'us-west-1' },
+                { ...createInstance('3'), zone: 'us-east-1' },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected?.zone).toBe('us-east-1');
+            expect(['1', '3']).toContain(selected?.id);
+        });
+        it('should fallback to any zone when preferred zone not available', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                { ...createInstance('1'), zone: 'us-west-1' },
+                { ...createInstance('2'), zone: 'eu-west-1' },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+            expect(['1', '2']).toContain(selected?.id);
+        });
+        it('should work without preferred zone', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('LoadBalancerFactory', () => {
+        it('should register and retrieve strategies', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            const customStrategy = new strategies_1.RoundRobinStrategy();
+            customStrategy.name = 'custom';
+            factory.register(customStrategy);
+            expect(factory.get('custom')).toBe(customStrategy);
+        });
+        it('should create default strategies', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(factory.get('round-robin')).toBeDefined();
+            expect(factory.get('random')).toBeDefined();
+            expect(factory.get('least-connections')).toBeDefined();
+            expect(factory.get('weighted-round-robin')).toBeDefined();
+            expect(factory.get('ip-hash')).toBeDefined();
+        });
+        it('should create zone-aware strategy with options', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            const strategy = factory.create('zone-aware', { zone: 'us-east-1' });
+            expect(strategy).toBeInstanceOf(strategies_1.ZoneAwareStrategy);
+            expect(strategy.name).toBe('zone-aware');
+        });
+        it('should throw error for unknown strategy', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(() => factory.create('unknown-strategy')).toThrow("Load balancing strategy 'unknown-strategy' not found");
+        });
+        it('should return undefined for non-existent strategy', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(factory.get('non-existent')).toBeUndefined();
+        });
+    });
+});

package/dist/__tests__/memory-backend.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Memory Backend Tests
+ */
+export {};
+//# sourceMappingURL=memory-backend.test.d.ts.map

package/dist/__tests__/memory-backend.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-backend.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/memory-backend.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}