@furystack/rest-service 13.0.0 → 14.1.0

package/esm/proxy-manager.spec.js

@@ -1,5 +1,5 @@
 import { getPort } from '@furystack/core/port-generator';
-import { Injector } from '@furystack/inject';
+import { createInjector } from '@furystack/inject';
 import { usingAsync } from '@furystack/utils';
 import { mkdirSync, writeFileSync } from 'fs';
 import { createServer as createHttpServer } from 'http';
@@ -7,8 +7,9 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { beforeAll, describe, expect, it } from 'vitest';
 import { WebSocket, WebSocketServer } from 'ws';
-import { ProxyManager } from './proxy-manager.js';
-import { StaticServerManager } from './static-server-manager.js';
+import { useProxy } from './helpers.js';
+import { ServerTelemetryToken } from './server-telemetry.js';
+import { useStaticFiles } from './helpers.js';
 describe('ProxyManager', () => {
     // Create a temporary directory for test files
     const testDir = join(tmpdir(), 'furystack-proxy-test');
@@ -48,9 +49,7 @@ describe('ProxyManager', () => {
     };
     describe('Basic proxy functionality', () => {
         it('Should proxy requests from source URL to target URL', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                const staticServerManager = injector.getInstance(StaticServerManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const targetPort = getPort();
                 // Create a test file for the target server
@@ -61,13 +60,10 @@ describe('ProxyManager', () => {
                     timestamp: Date.now(),
                 }));
                 // Set up target server (static file server) - serve files from testDir
-                await staticServerManager.addStaticSite({
-                    baseUrl: '/',
-                    path: testDir,
-                    port: targetPort,
-                });
+                await useStaticFiles({ injector, baseUrl: '/', path: testDir, port: targetPort });
                 // Set up proxy server
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/old',
                     targetBaseUrl: `http://localhost:${targetPort}`,
                     pathRewrite: (path) => path.replace('/path', ''),
@@ -82,8 +78,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should preserve query strings when proxying', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create a simple echo server that returns query parameters
@@ -95,7 +90,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -111,9 +107,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle header transformation', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                const staticServerManager = injector.getInstance(StaticServerManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const targetPort = getPort();
                 // Create a test file that returns headers
@@ -123,13 +117,10 @@ describe('ProxyManager', () => {
                     receivedHeaders: '{{HEADERS}}', // Placeholder for dynamic content
                 }));
                 // Set up target server
-                await staticServerManager.addStaticSite({
-                    baseUrl: '/',
-                    path: testDir,
-                    port: targetPort,
-                });
+                await useStaticFiles({ injector, baseUrl: '/', path: testDir, port: targetPort });
                 // Set up proxy server with header transformation
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/old',
                     targetBaseUrl: `http://localhost:${targetPort}`,
                     pathRewrite: (path) => path.replace('/path', ''),
@@ -151,9 +142,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle cookie transformation', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                const staticServerManager = injector.getInstance(StaticServerManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const targetPort = getPort();
                 // Create a test file for cookies
@@ -163,13 +152,10 @@ describe('ProxyManager', () => {
                     receivedCookies: '{{COOKIES}}', // Placeholder for dynamic content
                 }));
                 // Set up target server
-                await staticServerManager.addStaticSite({
-                    baseUrl: '/',
-                    path: testDir,
-                    port: targetPort,
-                });
+                await useStaticFiles({ injector, baseUrl: '/', path: testDir, port: targetPort });
                 // Set up proxy server with cookie transformation
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/old',
                     targetBaseUrl: `http://localhost:${targetPort}`,
                     pathRewrite: (path) => path.replace('/path', ''),
@@ -187,8 +173,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle POST requests with JSON body', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create an echo server that returns the request body
@@ -207,7 +192,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -229,8 +215,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle response cookies transformation', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create a server that sets cookies
@@ -245,7 +230,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -266,22 +252,17 @@ describe('ProxyManager', () => {
             });
         });
         it('Should not match requests outside source base URL', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                const staticServerManager = injector.getInstance(StaticServerManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const targetPort = getPort();
                 // Create a test file
                 const testFile = join(testDir, 'test.json');
                 writeFileSync(testFile, JSON.stringify({ message: 'test' }));
                 // Set up target server
-                await staticServerManager.addStaticSite({
-                    baseUrl: '/',
-                    path: testDir,
-                    port: targetPort,
-                });
+                await useStaticFiles({ injector, baseUrl: '/', path: testDir, port: targetPort });
                 // Set up proxy server
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/old',
                     targetBaseUrl: `http://localhost:${targetPort}`,
                     pathRewrite: (path) => path.replace('/path', ''),
@@ -299,9 +280,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle exact URL matches', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                const staticServerManager = injector.getInstance(StaticServerManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const targetPort = getPort();
                 // Create a test file
@@ -311,13 +290,10 @@ describe('ProxyManager', () => {
                     url: '/exact',
                 }));
                 // Set up target server
-                await staticServerManager.addStaticSite({
-                    baseUrl: '/',
-                    path: testDir,
-                    port: targetPort,
-                });
+                await useStaticFiles({ injector, baseUrl: '/', path: testDir, port: targetPort });
                 // Set up proxy server
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/exact',
                     targetBaseUrl: `http://localhost:${targetPort}`,
                     pathRewrite: (path) => path, // Keep the path as-is
@@ -331,12 +307,12 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle server errors gracefully', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const unavailablePort = getPort(); // Get a valid port number that doesn't have a server
                 // Set up proxy to non-existent target
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/api',
                     targetBaseUrl: `http://localhost:${unavailablePort}`,
                     sourcePort: proxyPort,
@@ -347,16 +323,16 @@ describe('ProxyManager', () => {
             });
         });
         it('Should emit onProxyFailed event on error', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const unavailablePort = getPort();
                 let failedEvent;
-                proxyManager.subscribe('onProxyFailed', (event) => {
+                injector.get(ServerTelemetryToken).subscribe('onProxyFailed', (event) => {
                     failedEvent = event;
                 });
                 // Set up proxy to non-existent target
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/api',
                     targetBaseUrl: `http://localhost:${unavailablePort}`,
                     sourcePort: proxyPort,
@@ -368,9 +344,9 @@ describe('ProxyManager', () => {
             });
         });
         it('Should validate targetBaseUrl on addProxy', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
-                await expect(proxyManager.addProxy({
+            await usingAsync(createInjector(), async (injector) => {
+                await expect(useProxy({
+                    injector,
                     sourceBaseUrl: '/api',
                     targetBaseUrl: 'not-a-valid-url',
                     sourcePort: getPort(),
@@ -378,8 +354,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should filter hop-by-hop headers', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -393,7 +368,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -421,8 +397,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should preserve multiple Set-Cookie headers from target', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = createHttpServer((_req, res) => {
@@ -436,7 +411,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -464,8 +440,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should add X-Forwarded headers to target request', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let received = {};
@@ -478,7 +453,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -494,8 +470,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should abort upstream when client disconnects', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let chunksWritten = 0;
@@ -520,7 +495,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -549,12 +525,11 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle request timeout', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let failedEvent;
-                proxyManager.subscribe('onProxyFailed', (event) => {
+                injector.get(ServerTelemetryToken).subscribe('onProxyFailed', (event) => {
                     failedEvent = event;
                 });
                 // Create a server that delays response longer than timeout
@@ -569,7 +544,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -590,8 +566,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should complete successfully when response is faster than timeout', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create a fast-responding server
@@ -603,7 +578,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -621,8 +597,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should use default timeout when not specified', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create a server with moderate delay (500ms)
@@ -637,7 +612,8 @@ describe('ProxyManager', () => {
                 });
                 try {
                     // No timeout specified - should use default 30000ms
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -657,10 +633,10 @@ describe('ProxyManager', () => {
     });
     describe('Edge cases and error handling', () => {
         it('Should validate invalid protocol (non-HTTP/HTTPS)', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
-                await expect(proxyManager.addProxy({
+                await expect(useProxy({
+                    injector,
                     sourceBaseUrl: '/api',
                     targetBaseUrl: 'ftp://example.com',
                     sourcePort: proxyPort,
@@ -668,12 +644,11 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle invalid target URL created by pathRewrite', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let failedEvent;
-                proxyManager.subscribe('onProxyFailed', (event) => {
+                injector.get(ServerTelemetryToken).subscribe('onProxyFailed', (event) => {
                     failedEvent = event;
                 });
                 // Create a simple server
@@ -685,7 +660,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -709,8 +685,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle number-type header values', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -724,7 +699,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -753,8 +729,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle array-type header values', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -767,7 +742,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -784,8 +760,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle undefined header values', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -798,7 +773,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -819,8 +795,7 @@ describe('ProxyManager', () => {
     });
     describe('WebSocket proxy functionality', () => {
         it('Should proxy WebSocket connections when enabled', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -831,7 +806,8 @@ describe('ProxyManager', () => {
                 });
                 try {
                     // Set up proxy with WebSocket support
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -861,8 +837,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle bidirectional WebSocket communication', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -885,7 +860,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -927,8 +903,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should not proxy WebSocket when disabled', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -939,7 +914,8 @@ describe('ProxyManager', () => {
                 });
                 try {
                     // Set up proxy WITHOUT WebSocket support
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -968,8 +944,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should preserve WebSocket subprotocols', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedProtocol;
@@ -984,7 +959,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1019,8 +995,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket path rewriting', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedPath;
@@ -1035,7 +1010,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/old/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1068,8 +1044,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket connection closure from client', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let serverClosed = false;
@@ -1085,7 +1060,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1116,8 +1092,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket connection closure from server', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -1132,7 +1107,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1167,15 +1143,15 @@ describe('ProxyManager', () => {
             });
         });
         it('Should emit onWebSocketProxyFailed event on error', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const proxyPort = getPort();
                 const unavailablePort = getPort();
                 let failedEvent;
-                proxyManager.subscribe('onWebSocketProxyFailed', (event) => {
+                injector.get(ServerTelemetryToken).subscribe('onWebSocketProxyFailed', (event) => {
                     failedEvent = event;
                 });
-                await proxyManager.addProxy({
+                await useProxy({
+                    injector,
                     sourceBaseUrl: '/ws',
                     targetBaseUrl: `http://localhost:${unavailablePort}`,
                     sourcePort: proxyPort,
@@ -1199,8 +1175,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle large WebSocket messages', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -1216,7 +1191,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1253,8 +1229,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle binary WebSocket messages', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create target WebSocket server
@@ -1270,7 +1245,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1302,8 +1278,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should apply header transformations to WebSocket upgrade', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -1318,7 +1293,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1355,8 +1331,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket upgrade timeout', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 // Create a server that delays WebSocket upgrade longer than timeout
@@ -1368,7 +1343,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1401,12 +1377,11 @@ describe('ProxyManager', () => {
             });
         }, 10000);
         it('Should handle unusual path in WebSocket upgrade with PathHelper', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let failedEvent;
-                proxyManager.subscribe('onWebSocketProxyFailed', (event) => {
+                injector.get(ServerTelemetryToken).subscribe('onWebSocketProxyFailed', (event) => {
                     failedEvent = event;
                 });
                 // Create target server that will receive the WebSocket connection
@@ -1420,7 +1395,8 @@ describe('ProxyManager', () => {
                     targetServer.listen(targetPort, () => resolve());
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1453,8 +1429,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket header value types (number, array, undefined)', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedHeaders = {};
@@ -1464,7 +1439,8 @@ describe('ProxyManager', () => {
                     ws.send('connected');
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1500,8 +1476,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket connections with query parameters', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 let receivedUrl;
@@ -1510,7 +1485,8 @@ describe('ProxyManager', () => {
                     ws.send('connected');
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1537,15 +1513,15 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle WebSocket close with code and reason', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const { server: targetServer, wss: targetWss } = await createWsTestServer(targetPort, (ws) => {
                     ws.close(1008, 'Policy Violation');
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/ws',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1569,8 +1545,7 @@ describe('ProxyManager', () => {
     });
     describe('HTTP Methods and Status Codes', () => {
         it('Should handle PUT requests with body', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (req, res) => {
@@ -1583,7 +1558,8 @@ describe('ProxyManager', () => {
                     });
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1605,8 +1581,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle PATCH requests with body', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (req, res) => {
@@ -1619,7 +1594,8 @@ describe('ProxyManager', () => {
                     });
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1641,8 +1617,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle DELETE requests', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (_req, res) => {
@@ -1650,7 +1625,8 @@ describe('ProxyManager', () => {
                     res.end();
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1666,8 +1642,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle OPTIONS requests (CORS preflight)', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (_req, res) => {
@@ -1679,7 +1654,8 @@ describe('ProxyManager', () => {
                     res.end();
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1697,8 +1673,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle HEAD requests', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (_req, res) => {
@@ -1709,7 +1684,8 @@ describe('ProxyManager', () => {
                     res.end();
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1727,8 +1703,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle 4xx client error responses', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (_req, res) => {
@@ -1736,7 +1711,8 @@ describe('ProxyManager', () => {
                     res.end(JSON.stringify({ error: 'Not Found' }));
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,
@@ -1752,8 +1728,7 @@ describe('ProxyManager', () => {
             });
         });
         it('Should handle 5xx server error responses', async () => {
-            await usingAsync(new Injector(), async (injector) => {
-                const proxyManager = injector.getInstance(ProxyManager);
+            await usingAsync(createInjector(), async (injector) => {
                 const targetPort = getPort();
                 const proxyPort = getPort();
                 const targetServer = await createEchoServer(targetPort, (_req, res) => {
@@ -1761,7 +1736,8 @@ describe('ProxyManager', () => {
                     res.end(JSON.stringify({ error: 'Internal Server Error' }));
                 });
                 try {
-                    await proxyManager.addProxy({
+                    await useProxy({
+                        injector,
                         sourceBaseUrl: '/api',
                         targetBaseUrl: `http://localhost:${targetPort}`,
                         sourcePort: proxyPort,