@hazeljs/gateway 0.2.0-beta.41

package/dist/__tests__/gateway.test.js

@@ -0,0 +1,257 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gateway_1 = require("../gateway");
+const decorators_1 = require("../decorators");
+const discovery_1 = require("@hazeljs/discovery");
+const axios_1 = __importDefault(require("axios"));
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('GatewayServer', () => {
+    let backend;
+    beforeEach(async () => {
+        backend = new discovery_1.MemoryRegistryBackend();
+        await backend.register({
+            id: 'user-1',
+            name: 'user-service',
+            host: 'localhost',
+            port: 3001,
+            protocol: 'http',
+            status: discovery_1.ServiceStatus.UP,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+        });
+        mockedAxios.create.mockReturnValue({
+            request: jest.fn().mockResolvedValue({
+                status: 200,
+                headers: {},
+                data: { id: 1, name: 'Alice' },
+            }),
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('handleRequest', () => {
+        it('should return 404 when no route matches', async () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+            });
+            const response = await gateway.handleRequest({
+                method: 'GET',
+                path: '/unknown/path',
+                headers: {},
+            });
+            expect(response.status).toBe(404);
+            expect(response.body).toMatchObject({ error: 'No matching gateway route' });
+        });
+        it('should return 405 when method not allowed', async () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+                methods: ['POST'],
+            });
+            const response = await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            expect(response.status).toBe(405);
+            expect(response.body).toMatchObject({ error: 'Method not allowed' });
+        });
+        it('should proxy request to service and return response', async () => {
+            const mockRequest = jest.fn().mockResolvedValue({
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+                data: { id: 1, name: 'Alice' },
+            });
+            mockedAxios.create.mockReturnValue({ request: mockRequest });
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+            });
+            const response = await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual({ id: 1, name: 'Alice' });
+            expect(mockRequest).toHaveBeenCalled();
+        });
+        it('should return 429 with Retry-After when rate limit exceeded', async () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+                rateLimit: { strategy: 'sliding-window', max: 1, window: 60000 },
+            });
+            await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            const response = await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            expect(response.status).toBe(429);
+            expect(response.headers['Retry-After']).toBeDefined();
+            expect(response.body).toMatchObject({ error: 'Too Many Requests' });
+        });
+        it('should return 502 when service proxy throws', async () => {
+            await backend.deregister('user-1');
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+            });
+            const response = await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            expect(response.status).toBe(502);
+            expect(response.body).toMatchObject({ error: 'Bad Gateway' });
+        });
+        it('should emit route:error on proxy failure', async () => {
+            await backend.deregister('user-1');
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({
+                path: '/api/users/**',
+                serviceName: 'user-service',
+            });
+            const errorHandler = jest.fn();
+            gateway.on('route:error', errorHandler);
+            await gateway.handleRequest({
+                method: 'GET',
+                path: '/api/users/1',
+                headers: {},
+            });
+            expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({
+                route: '/api/users/**',
+                service: 'user-service',
+            }));
+        });
+    });
+    describe('fromConfig', () => {
+        it('should create gateway with routes from config', () => {
+            const gateway = gateway_1.GatewayServer.fromConfig({
+                discovery: { cacheEnabled: false },
+                routes: [
+                    { path: '/a', serviceName: 'svc-a' },
+                    { path: '/b', serviceName: 'svc-b' },
+                ],
+            }, backend);
+            expect(gateway.getRoutes()).toEqual(['/a', '/b']);
+        });
+    });
+    describe('fromClass', () => {
+        it('should create gateway from decorated class', () => {
+            let TestGateway = class TestGateway {
+            };
+            __decorate([
+                (0, decorators_1.Route)('/api/test/**'),
+                (0, decorators_1.ServiceRoute)('test-service'),
+                __metadata("design:type", Object)
+            ], TestGateway.prototype, "testRoute", void 0);
+            TestGateway = __decorate([
+                (0, decorators_1.Gateway)({})
+            ], TestGateway);
+            const gateway = gateway_1.GatewayServer.fromClass(TestGateway, backend);
+            expect(gateway.getRoutes()).toContain('/api/test/**');
+        });
+    });
+    describe('lifecycle', () => {
+        it('should start and stop canaries', () => {
+            const gateway = gateway_1.GatewayServer.fromConfig({
+                discovery: { cacheEnabled: false },
+                routes: [
+                    {
+                        path: '/api/orders/**',
+                        serviceName: 'order-service',
+                        canary: {
+                            stable: { version: 'v1', weight: 90 },
+                            canary: { version: 'v2', weight: 10 },
+                            promotion: {
+                                strategy: 'error-rate',
+                                errorThreshold: 5,
+                                evaluationWindow: '5m',
+                                autoPromote: true,
+                                autoRollback: true,
+                                steps: [10, 25, 50, 75, 100],
+                                stepInterval: '10m',
+                            },
+                        },
+                    },
+                ],
+            }, backend);
+            expect(() => gateway.startCanaries()).not.toThrow();
+            expect(() => gateway.stop()).not.toThrow();
+        });
+        it('stop should close discovery client', async () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({ path: '/x', serviceName: 'user-service' });
+            gateway.stop();
+            expect(backend).toBeDefined();
+        });
+    });
+    describe('getters', () => {
+        it('getMetrics should return GatewayMetrics', () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            gateway.addRoute({ path: '/x', serviceName: 'user-service' });
+            const metrics = gateway.getMetrics();
+            expect(metrics).toBeDefined();
+            expect(metrics.getSnapshot).toBeDefined();
+        });
+        it('getCanaryEngine should return engine for canary route', () => {
+            const gateway = gateway_1.GatewayServer.fromConfig({
+                discovery: { cacheEnabled: false },
+                routes: [
+                    {
+                        path: '/api/orders/**',
+                        serviceName: 'order-service',
+                        canary: {
+                            stable: { version: 'v1', weight: 90 },
+                            canary: { version: 'v2', weight: 10 },
+                            promotion: {
+                                strategy: 'error-rate',
+                                errorThreshold: 5,
+                                evaluationWindow: '5m',
+                                autoPromote: true,
+                                autoRollback: true,
+                                steps: [10, 25, 50, 75, 100],
+                                stepInterval: '10m',
+                            },
+                        },
+                    },
+                ],
+            }, backend);
+            const engine = gateway.getCanaryEngine('/api/orders/**');
+            expect(engine).toBeDefined();
+            expect(gateway.getCanaryEngine('/nonexistent')).toBeUndefined();
+        });
+        it('getDiscoveryClient should return the client', () => {
+            const gateway = new gateway_1.GatewayServer({ discovery: { cacheEnabled: false } }, backend);
+            const client = gateway.getDiscoveryClient();
+            expect(client).toBeDefined();
+            expect(client.getInstances).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/hazel-integration.test.d.ts

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

package/dist/__tests__/hazel-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hazel-integration.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/hazel-integration.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/hazel-integration.test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hazel_integration_1 = require("../hazel-integration");
+const gateway_1 = require("../gateway");
+const discovery_1 = require("@hazeljs/discovery");
+const axios_1 = __importDefault(require("axios"));
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('createGatewayHandler', () => {
+    let backend;
+    beforeEach(async () => {
+        backend = new discovery_1.MemoryRegistryBackend();
+        await backend.register({
+            id: 'svc-1',
+            name: 'user-service',
+            host: 'localhost',
+            port: 3001,
+            protocol: 'http',
+            status: discovery_1.ServiceStatus.UP,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+        });
+        mockedAxios.create.mockReturnValue({
+            request: jest.fn().mockResolvedValue({
+                status: 200,
+                headers: { 'content-type': 'application/json' },
+                data: { id: 1, name: 'Alice' },
+            }),
+        });
+    });
+    it('should create handler that forwards to gateway and returns true', async () => {
+        const gateway = gateway_1.GatewayServer.fromConfig({
+            discovery: { cacheEnabled: false },
+            routes: [{ path: '/api/users/**', serviceName: 'user-service' }],
+        }, backend);
+        const handler = (0, hazel_integration_1.createGatewayHandler)(gateway);
+        const req = {
+            method: 'GET',
+            url: '/api/users/1',
+            headers: { 'content-type': 'application/json' },
+        };
+        const res = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            writableEnded: false,
+        };
+        const context = {
+            method: 'GET',
+            url: '/api/users/1',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+        };
+        const handled = await handler(req, res, context);
+        expect(handled).toBe(true);
+        expect(res.writeHead).toHaveBeenCalledWith(200, expect.any(Object));
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({ id: 1, name: 'Alice' }));
+    });
+    it('should return 404 response when no route matches', async () => {
+        const gateway = gateway_1.GatewayServer.fromConfig({
+            discovery: { cacheEnabled: false },
+            routes: [{ path: '/api/users/**', serviceName: 'user-service' }],
+        }, backend);
+        const handler = (0, hazel_integration_1.createGatewayHandler)(gateway);
+        const req = {
+            method: 'GET',
+            url: '/unknown/path',
+            headers: {},
+        };
+        const res = {
+            writeHead: jest.fn(),
+            end: jest.fn(),
+            writableEnded: false,
+        };
+        const context = {
+            method: 'GET',
+            url: '/unknown/path',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+        };
+        const handled = await handler(req, res, context);
+        expect(handled).toBe(true);
+        expect(res.writeHead).toHaveBeenCalledWith(404, expect.any(Object));
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({ error: 'No matching gateway route', path: '/unknown/path' }));
+    });
+});

package/dist/__tests__/route-matcher.test.d.ts

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

package/dist/__tests__/route-matcher.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-matcher.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/route-matcher.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/route-matcher.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const route_matcher_1 = require("../routing/route-matcher");
+describe('matchRoute', () => {
+    describe('exact matches', () => {
+        it('should match exact paths', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/users', '/api/users');
+            expect(result.matched).toBe(true);
+        });
+        it('should not match different paths', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/users', '/api/orders');
+            expect(result.matched).toBe(false);
+        });
+        it('should normalize paths', () => {
+            const result = (0, route_matcher_1.matchRoute)('api/users', '/api/users');
+            expect(result.matched).toBe(true);
+        });
+    });
+    describe('parameter matches', () => {
+        it('should match path parameters', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/users/:id', '/api/users/123');
+            expect(result.matched).toBe(true);
+            expect(result.params).toEqual({ id: '123' });
+        });
+        it('should match multiple parameters', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/:service/:id', '/api/users/456');
+            expect(result.matched).toBe(true);
+            expect(result.params).toEqual({ service: 'users', id: '456' });
+        });
+    });
+    describe('wildcard matches', () => {
+        it('should match single-segment wildcard', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/*/users', '/api/v2/users');
+            expect(result.matched).toBe(true);
+        });
+        it('should not match multi-segment with single wildcard', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/*/users', '/api/v2/v3/users');
+            expect(result.matched).toBe(false);
+        });
+    });
+    describe('catch-all (**)', () => {
+        it('should match everything under prefix', () => {
+            expect((0, route_matcher_1.matchRoute)('/api/users/**', '/api/users').matched).toBe(true);
+            expect((0, route_matcher_1.matchRoute)('/api/users/**', '/api/users/123').matched).toBe(true);
+            expect((0, route_matcher_1.matchRoute)('/api/users/**', '/api/users/123/orders').matched).toBe(true);
+        });
+        it('should not match different prefix', () => {
+            expect((0, route_matcher_1.matchRoute)('/api/users/**', '/api/orders').matched).toBe(false);
+        });
+        it('should capture remaining path', () => {
+            const result = (0, route_matcher_1.matchRoute)('/api/users/**', '/api/users/123/orders');
+            expect(result.remainingPath).toBe('/123/orders');
+        });
+    });
+});
+describe('sortRoutesBySpecificity', () => {
+    it('should sort most specific first', () => {
+        const routes = ['/api/**', '/api/users/:id', '/api/users/me', '/api/users/*'];
+        const sorted = (0, route_matcher_1.sortRoutesBySpecificity)(routes);
+        // /api/users/me (most specific - all literal segments)
+        expect(sorted[0]).toBe('/api/users/me');
+        // /api/users/:id (param is less specific than literal)
+        // /api/users/* (wildcard is less specific than param)
+        // /api/** (catch-all is least specific)
+        expect(sorted[sorted.length - 1]).toBe('/api/**');
+    });
+});

package/dist/__tests__/service-proxy.test.d.ts

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

package/dist/__tests__/service-proxy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-proxy.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/service-proxy.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/service-proxy.test.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_proxy_1 = require("../proxy/service-proxy");
+const discovery_1 = require("@hazeljs/discovery");
+const resilience_1 = require("@hazeljs/resilience");
+const axios_1 = __importDefault(require("axios"));
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('ServiceProxy', () => {
+    let backend;
+    let discoveryClient;
+    beforeEach(async () => {
+        backend = new discovery_1.MemoryRegistryBackend();
+        await backend.register({
+            id: 'svc-1',
+            name: 'test-service',
+            host: 'localhost',
+            port: 4000,
+            protocol: 'http',
+            status: discovery_1.ServiceStatus.UP,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+        });
+        discoveryClient = new discovery_1.DiscoveryClient({ cacheEnabled: false }, backend);
+        const mockRequest = jest.fn().mockResolvedValue({
+            status: 200,
+            headers: {},
+            data: { ok: true },
+        });
+        mockedAxios.create.mockReturnValue({ request: mockRequest });
+    });
+    afterEach(() => {
+        discoveryClient.close();
+    });
+    it('should forward request to discovered instance', async () => {
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, { serviceName: 'test-service' });
+        const request = {
+            method: 'GET',
+            path: '/items',
+            headers: {},
+        };
+        const response = await proxy.forward(request);
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual({ ok: true });
+    });
+    it('should throw when no instances available', async () => {
+        await backend.deregister('svc-1');
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, { serviceName: 'test-service' });
+        await expect(proxy.forward({ method: 'GET', path: '/x', headers: {} })).rejects.toThrow('No instances available');
+    });
+    it('should apply stripPrefix and addPrefix', async () => {
+        const mockRequest = jest.fn().mockResolvedValue({
+            status: 200,
+            headers: {},
+            data: {},
+        });
+        mockedAxios.create.mockReturnValue({ request: mockRequest });
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, {
+            serviceName: 'test-service',
+            stripPrefix: '/api',
+            addPrefix: '/v1',
+        });
+        await proxy.forward({
+            method: 'GET',
+            path: '/api/items',
+            headers: {},
+        });
+        expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+            url: '/v1/items',
+        }));
+    });
+    it('getMetrics should return MetricsCollector', () => {
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, { serviceName: 'test-service' });
+        const m = proxy.getMetrics();
+        expect(m).toBeDefined();
+        expect(m.getSnapshot).toBeDefined();
+    });
+    it('getServiceName should return service name', () => {
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, { serviceName: 'my-service' });
+        expect(proxy.getServiceName()).toBe('my-service');
+    });
+    it('should throw RateLimitError when rate limit exceeded', async () => {
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, {
+            serviceName: 'test-service',
+            rateLimit: { strategy: 'sliding-window', max: 1, window: 60000 },
+        });
+        await proxy.forward({ method: 'GET', path: '/x', headers: {} });
+        await expect(proxy.forward({ method: 'GET', path: '/x', headers: {} })).rejects.toThrow(resilience_1.RateLimitError);
+        await expect(proxy.forward({ method: 'GET', path: '/x', headers: {} })).rejects.toThrow('Rate limit exceeded');
+    });
+    it('forwardToVersion should merge filter with version', async () => {
+        await backend.register({
+            id: 'svc-2',
+            name: 'test-service',
+            host: 'localhost',
+            port: 4001,
+            protocol: 'http',
+            status: discovery_1.ServiceStatus.UP,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+            metadata: { version: 'v2' },
+        });
+        const proxy = new service_proxy_1.ServiceProxy(discoveryClient, { serviceName: 'test-service' });
+        const response = await proxy.forwardToVersion({ method: 'GET', path: '/x', headers: {} }, 'v2');
+        expect(response.status).toBe(200);
+    });
+});

package/dist/__tests__/traffic-mirror.test.d.ts

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

package/dist/__tests__/traffic-mirror.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traffic-mirror.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/traffic-mirror.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/traffic-mirror.test.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const traffic_mirror_1 = require("../middleware/traffic-mirror");
+const discovery_1 = require("@hazeljs/discovery");
+const axios_1 = __importDefault(require("axios"));
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('TrafficMirror', () => {
+    let backend;
+    let discoveryClient;
+    beforeEach(async () => {
+        backend = new discovery_1.MemoryRegistryBackend();
+        await backend.register({
+            id: 'mirror-1',
+            name: 'shadow-service',
+            host: 'localhost',
+            port: 5000,
+            protocol: 'http',
+            status: discovery_1.ServiceStatus.UP,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+        });
+        discoveryClient = new discovery_1.DiscoveryClient({ cacheEnabled: false }, backend);
+        mockedAxios.create.mockReturnValue({
+            request: jest.fn().mockResolvedValue({}),
+        });
+    });
+    afterEach(() => {
+        discoveryClient.close();
+    });
+    it('should mirror request when percentage allows', async () => {
+        const mockRequest = jest.fn().mockResolvedValue({});
+        mockedAxios.create.mockReturnValue({ request: mockRequest });
+        const mirror = new traffic_mirror_1.TrafficMirror({ service: 'shadow-service', percentage: 100, waitForResponse: true }, discoveryClient);
+        await mirror.mirror({
+            method: 'GET',
+            path: '/api/test',
+            headers: {},
+        });
+        expect(mockRequest).toHaveBeenCalled();
+    });
+    it('should not fail when mirror service has no instances', async () => {
+        const mirror = new traffic_mirror_1.TrafficMirror({ service: 'non-existent-service', percentage: 100 }, discoveryClient);
+        await expect(mirror.mirror({
+            method: 'GET',
+            path: '/api/test',
+            headers: {},
+        })).resolves.not.toThrow();
+    });
+    it('should include X-Mirror headers when mirroring', async () => {
+        const mockRequest = jest.fn().mockResolvedValue({});
+        mockedAxios.create.mockReturnValue({ request: mockRequest });
+        const mirror = new traffic_mirror_1.TrafficMirror({ service: 'shadow-service', percentage: 100, waitForResponse: true }, discoveryClient);
+        await mirror.mirror({
+            method: 'POST',
+            path: '/api/test',
+            headers: { 'content-type': 'application/json' },
+            body: { foo: 'bar' },
+        });
+        expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+            headers: expect.objectContaining({
+                'X-Mirror': 'true',
+                'X-Mirror-Source': 'hazeljs-gateway',
+            }),
+        }));
+    });
+});

package/dist/__tests__/version-router.test.d.ts

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

package/dist/__tests__/version-router.test.d.ts.map

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