@hazeljs/discovery 0.2.0-beta.8 → 0.2.0-beta.80

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

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Consul Backend Tests
+ * Uses mocked Consul client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const consul_backend_1 = require("../backends/consul-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();
+});
+function createMockConsul() {
+    return {
+        agent: {
+            service: {
+                register: jest.fn().mockResolvedValue(undefined),
+                deregister: jest.fn().mockResolvedValue(undefined),
+                list: jest.fn().mockResolvedValue({}),
+            },
+            check: {
+                pass: jest.fn().mockResolvedValue(undefined),
+                fail: jest.fn().mockResolvedValue(undefined),
+                warn: jest.fn().mockResolvedValue(undefined),
+                list: jest.fn().mockResolvedValue({}),
+            },
+        },
+        health: {
+            service: jest.fn().mockResolvedValue([]),
+        },
+        catalog: {
+            service: {
+                list: jest.fn().mockResolvedValue({}),
+            },
+        },
+    };
+}
+function createInstance(id, name = 'test-service', overrides = {}) {
+    return {
+        id,
+        name,
+        host: 'localhost',
+        port: 3000,
+        status: types_1.ServiceStatus.UP,
+        lastHeartbeat: new Date('2025-01-01T00:00:00Z'),
+        registeredAt: new Date('2025-01-01T00:00:00Z'),
+        tags: ['web'],
+        metadata: { version: '1.0' },
+        zone: 'us-east-1',
+        ...overrides,
+    };
+}
+describe('ConsulRegistryBackend', () => {
+    let consul;
+    let backend;
+    beforeEach(() => {
+        jest.useFakeTimers();
+        consul = createMockConsul();
+        backend = new consul_backend_1.ConsulRegistryBackend(consul);
+    });
+    afterEach(async () => {
+        await backend.close();
+        jest.useRealTimers();
+    });
+    describe('constructor', () => {
+        it('should use default TTL of 30s', () => {
+            expect(backend).toBeDefined();
+        });
+        it('should accept custom config', () => {
+            const b = new consul_backend_1.ConsulRegistryBackend(consul, { ttl: '60s' });
+            expect(b).toBeDefined();
+        });
+        it('should throw on invalid TTL format', () => {
+            expect(() => {
+                new consul_backend_1.ConsulRegistryBackend(consul, { ttl: 'invalid' });
+            }).toThrow();
+        });
+    });
+    describe('register', () => {
+        it('should call consul agent service register', async () => {
+            const instance = createInstance('svc-1', 'my-service');
+            await backend.register(instance);
+            expect(consul.agent.service.register).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'svc-1',
+                name: 'my-service',
+                address: 'localhost',
+                port: 3000,
+            }));
+        });
+        it('should start TTL check interval', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            // Advance timers past the TTL check interval (2/3 of 30s = 20s)
+            jest.advanceTimersByTime(21000);
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+    });
+    describe('deregister', () => {
+        it('should call consul agent service deregister', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            await backend.deregister('svc-1');
+            expect(consul.agent.service.deregister).toHaveBeenCalledWith('svc-1');
+        });
+        it('should stop TTL check interval', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            await backend.deregister('svc-1');
+            jest.clearAllMocks();
+            jest.advanceTimersByTime(30000);
+            // TTL check should NOT have been called after deregister
+            expect(consul.agent.check.pass).not.toHaveBeenCalled();
+        });
+    });
+    describe('heartbeat', () => {
+        it('should pass the TTL check', async () => {
+            await backend.heartbeat('svc-1');
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should not throw when consul fails', async () => {
+            consul.agent.check.pass.mockRejectedValueOnce(new Error('Consul error'));
+            await expect(backend.heartbeat('svc-1')).resolves.not.toThrow();
+        });
+    });
+    describe('getInstances', () => {
+        it('should return instances from consul health service', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                        Meta: { zone: 'us-east-1', registeredAt: '2025-01-01T00:00:00Z' },
+                        Tags: ['web'],
+                    },
+                    Checks: [{ Status: 'passing' }],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                        Meta: { zone: 'us-west-1' },
+                        Tags: ['api'],
+                    },
+                    Checks: [{ Status: 'passing' }],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toHaveLength(2);
+            expect(instances[0].id).toBe('svc-1');
+            expect(instances[0].host).toBe('10.0.0.1');
+        });
+        it('should set status based on check results', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                    },
+                    Checks: [{ Status: 'critical' }],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                    },
+                    Checks: [{ Status: 'warning' }],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service');
+            expect(instances[0].status).toBe(types_1.ServiceStatus.DOWN);
+            expect(instances[1].status).toBe(types_1.ServiceStatus.STARTING);
+        });
+        it('should filter instances', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                        Meta: { zone: 'us-east-1' },
+                    },
+                    Checks: [],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                        Meta: { zone: 'us-west-1' },
+                    },
+                    Checks: [],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service', { zone: 'us-east-1' });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].id).toBe('svc-1');
+        });
+        it('should return empty array on error', async () => {
+            consul.health.service.mockRejectedValueOnce(new Error('Consul error'));
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toEqual([]);
+        });
+    });
+    describe('getInstance', () => {
+        it('should return a specific instance', async () => {
+            consul.agent.service.list.mockResolvedValueOnce({
+                'svc-1': {
+                    ID: 'svc-1',
+                    Service: 'my-service',
+                    Address: '10.0.0.1',
+                    Port: 8080,
+                    Meta: { zone: 'us-east-1' },
+                    Tags: ['web'],
+                },
+            });
+            consul.agent.check.list.mockResolvedValueOnce({
+                'service:svc-1': { Status: 'passing' },
+            });
+            const instance = await backend.getInstance('svc-1');
+            expect(instance).toBeDefined();
+            expect(instance.id).toBe('svc-1');
+            expect(instance.status).toBe(types_1.ServiceStatus.UP);
+        });
+        it('should return null for non-existent instance', async () => {
+            consul.agent.service.list.mockResolvedValueOnce({});
+            const instance = await backend.getInstance('non-existent');
+            expect(instance).toBeNull();
+        });
+        it('should return null on error', async () => {
+            consul.agent.service.list.mockRejectedValueOnce(new Error('fail'));
+            const instance = await backend.getInstance('svc-1');
+            expect(instance).toBeNull();
+        });
+    });
+    describe('getAllServices', () => {
+        it('should return service names from catalog', async () => {
+            consul.catalog.service.list.mockResolvedValueOnce({
+                'service-a': [],
+                'service-b': [],
+                consul: [],
+            });
+            const services = await backend.getAllServices();
+            expect(services).toEqual(['service-a', 'service-b', 'consul']);
+        });
+        it('should return empty array on error', async () => {
+            consul.catalog.service.list.mockRejectedValueOnce(new Error('fail'));
+            const services = await backend.getAllServices();
+            expect(services).toEqual([]);
+        });
+    });
+    describe('updateStatus', () => {
+        it('should pass check for UP status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.UP);
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should fail check for DOWN status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.DOWN);
+            expect(consul.agent.check.fail).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should warn check for STARTING status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.STARTING);
+            expect(consul.agent.check.warn).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should not throw on error', async () => {
+            consul.agent.check.pass.mockRejectedValueOnce(new Error('fail'));
+            await expect(backend.updateStatus('svc-1', types_1.ServiceStatus.UP)).resolves.not.toThrow();
+        });
+    });
+    describe('close', () => {
+        it('should stop all TTL check intervals', async () => {
+            const i1 = createInstance('svc-1');
+            const i2 = createInstance('svc-2');
+            await backend.register(i1);
+            await backend.register(i2);
+            await backend.close();
+            jest.clearAllMocks();
+            jest.advanceTimersByTime(60000);
+            expect(consul.agent.check.pass).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,6 @@
+/**
+ * Kubernetes Backend Tests
+ * Uses mocked @kubernetes/client-node API
+ */
+export {};
+//# sourceMappingURL=kubernetes-backend.test.d.ts.map

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

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

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__/redis-backend.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redis Backend Tests
+ * Uses mocked ioredis client
+ */
+export {};
+//# sourceMappingURL=redis-backend.test.d.ts.map

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

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