@furystack/rest-service 10.0.28 → 10.1.0

package/esm/proxy-manager.spec.js

@@ -0,0 +1,1781 @@
+import { getPort } from '@furystack/core/port-generator';
+import { Injector } from '@furystack/inject';
+import { usingAsync } from '@furystack/utils';
+import { mkdirSync, writeFileSync } from 'fs';
+import { createServer as createHttpServer } from 'http';
+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';
+describe('ProxyManager', () => {
+    // Create a temporary directory for test files
+    const testDir = join(tmpdir(), 'furystack-proxy-test');
+    beforeAll(() => {
+        try {
+            mkdirSync(testDir, { recursive: true });
+        }
+        catch (error) {
+            // Directory might already exist
+        }
+    });
+    // Helper function to convert RawData to string
+    const rawDataToString = (data) => Buffer.isBuffer(data)
+        ? data.toString('utf8')
+        : Array.isArray(data)
+            ? Buffer.concat(data).toString('utf8')
+            : Buffer.from(data).toString('utf8');
+    // Helper function to create a simple echo server
+    const createEchoServer = (port, handler) => {
+        const server = createHttpServer(handler ||
+            ((req, res) => {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ url: req.url, method: req.method }));
+            }));
+        return new Promise((resolve) => {
+            server.listen(port, () => resolve(server));
+        });
+    };
+    // Helper function to create a WebSocket test server
+    const createWsTestServer = (port, onConnection) => {
+        const server = createHttpServer();
+        const wss = new WebSocketServer({ server });
+        wss.on('connection', onConnection);
+        return new Promise((resolve) => {
+            server.listen(port, () => resolve({ server, wss }));
+        });
+    };
+    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);
+                const proxyPort = getPort();
+                const targetPort = getPort();
+                // Create a test file for the target server
+                const testFile = join(testDir, 'test.json');
+                writeFileSync(testFile, JSON.stringify({
+                    message: 'Hello from target server',
+                    url: '/test',
+                    timestamp: Date.now(),
+                }));
+                // Set up target server (static file server) - serve files from testDir
+                await staticServerManager.addStaticSite({
+                    baseUrl: '/',
+                    path: testDir,
+                    port: targetPort,
+                });
+                // Set up proxy server
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/old',
+                    targetBaseUrl: `http://localhost:${targetPort}`,
+                    pathRewrite: (path) => path.replace('/path', ''),
+                    sourcePort: proxyPort,
+                });
+                const result = await fetch(`http://127.0.0.1:${proxyPort}/old/path/test.json`);
+                expect(result.status).toBe(200);
+                expect(result.url).toBe(`http://127.0.0.1:${proxyPort}/old/path/test.json`);
+                const responseData = (await result.json());
+                expect(responseData.message).toBe('Hello from target server');
+                expect(responseData.url).toBe('/test');
+            });
+        });
+        it('Should preserve query strings when proxying', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create a simple echo server that returns query parameters
+                const targetServer = createHttpServer((req, res) => {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ url: req.url, query: req.url?.split('?')[1] || '' }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test?foo=bar&baz=qux`);
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.query).toBe('foo=bar&baz=qux');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle header transformation', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const staticServerManager = injector.getInstance(StaticServerManager);
+                const proxyPort = getPort();
+                const targetPort = getPort();
+                // Create a test file that returns headers
+                const headersFile = join(testDir, 'headers.json');
+                writeFileSync(headersFile, JSON.stringify({
+                    message: 'Headers test',
+                    receivedHeaders: '{{HEADERS}}', // Placeholder for dynamic content
+                }));
+                // Set up target server
+                await staticServerManager.addStaticSite({
+                    baseUrl: '/',
+                    path: testDir,
+                    port: targetPort,
+                });
+                // Set up proxy server with header transformation
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/old',
+                    targetBaseUrl: `http://localhost:${targetPort}`,
+                    pathRewrite: (path) => path.replace('/path', ''),
+                    sourcePort: proxyPort,
+                    headers: () => ({
+                        'X-Custom-Header': 'custom-value',
+                        Authorization: 'Bearer new-token',
+                    }),
+                });
+                const result = await fetch(`http://127.0.0.1:${proxyPort}/old/path/headers.json`, {
+                    headers: {
+                        Authorization: 'Bearer old-token',
+                        'User-Agent': 'test-agent',
+                    },
+                });
+                expect(result.status).toBe(200);
+                const responseData = (await result.json());
+                expect(responseData.message).toBe('Headers test');
+            });
+        });
+        it('Should handle cookie transformation', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const staticServerManager = injector.getInstance(StaticServerManager);
+                const proxyPort = getPort();
+                const targetPort = getPort();
+                // Create a test file for cookies
+                const cookiesFile = join(testDir, 'cookies.json');
+                writeFileSync(cookiesFile, JSON.stringify({
+                    message: 'Cookies test',
+                    receivedCookies: '{{COOKIES}}', // Placeholder for dynamic content
+                }));
+                // Set up target server
+                await staticServerManager.addStaticSite({
+                    baseUrl: '/',
+                    path: testDir,
+                    port: targetPort,
+                });
+                // Set up proxy server with cookie transformation
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/old',
+                    targetBaseUrl: `http://localhost:${targetPort}`,
+                    pathRewrite: (path) => path.replace('/path', ''),
+                    sourcePort: proxyPort,
+                    cookies: (originalCookies) => [...originalCookies, 'newCookie=newValue', 'sessionId=updated-session'],
+                });
+                const result = await fetch(`http://127.0.0.1:${proxyPort}/old/path/cookies.json`, {
+                    headers: {
+                        Cookie: 'oldCookie=oldValue; sessionId=old-session',
+                    },
+                });
+                expect(result.status).toBe(200);
+                const responseData = (await result.json());
+                expect(responseData.message).toBe('Cookies test');
+            });
+        });
+        it('Should handle POST requests with JSON body', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create an echo server that returns the request body
+                const targetServer = createHttpServer((req, res) => {
+                    const chunks = [];
+                    req.on('data', (chunk) => {
+                        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                    });
+                    req.on('end', () => {
+                        const body = Buffer.concat(chunks).toString('utf8');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ received: JSON.parse(body), method: req.method }));
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const testData = { name: 'test', value: 123, nested: { key: 'value' } };
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/data`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(testData),
+                    });
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.received).toEqual(testData);
+                    expect(data.method).toBe('POST');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle response cookies transformation', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create a server that sets cookies
+                const targetServer = createHttpServer((_req, res) => {
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Set-Cookie': ['sessionId=abc123; HttpOnly', 'theme=dark; Path=/'],
+                    });
+                    res.end(JSON.stringify({ message: 'Cookies set' }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        responseCookies: (cookies) => {
+                            // Transform the cookies
+                            return cookies.map((cookie) => cookie.replace('sessionId=abc123', 'sessionId=xyz789'));
+                        },
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    expect(result.status).toBe(200);
+                    const setCookieHeader = result.headers.get('set-cookie');
+                    expect(setCookieHeader).toContain('sessionId=xyz789');
+                    expect(setCookieHeader).not.toContain('sessionId=abc123');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        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);
+                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,
+                });
+                // Set up proxy server
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/old',
+                    targetBaseUrl: `http://localhost:${targetPort}`,
+                    pathRewrite: (path) => path.replace('/path', ''),
+                    sourcePort: proxyPort,
+                });
+                try {
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/different/path`);
+                    // Should not proxy, request should be handled by other handlers or return 404
+                    expect(result.status).not.toBe(200);
+                }
+                catch (error) {
+                    // Connection error is expected when no handler matches
+                    expect(error).toBeDefined();
+                }
+            });
+        });
+        it('Should handle exact URL matches', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const staticServerManager = injector.getInstance(StaticServerManager);
+                const proxyPort = getPort();
+                const targetPort = getPort();
+                // Create a test file
+                const exactFile = join(testDir, 'exact.json');
+                writeFileSync(exactFile, JSON.stringify({
+                    message: 'Exact match test',
+                    url: '/exact',
+                }));
+                // Set up target server
+                await staticServerManager.addStaticSite({
+                    baseUrl: '/',
+                    path: testDir,
+                    port: targetPort,
+                });
+                // Set up proxy server
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/exact',
+                    targetBaseUrl: `http://localhost:${targetPort}`,
+                    pathRewrite: (path) => path, // Keep the path as-is
+                    sourcePort: proxyPort,
+                });
+                const result = await fetch(`http://127.0.0.1:${proxyPort}/exact/exact.json`);
+                expect(result.status).toBe(200);
+                const responseData = (await result.json());
+                expect(responseData.message).toBe('Exact match test');
+                expect(responseData.url).toBe('/exact');
+            });
+        });
+        it('Should handle server errors gracefully', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                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({
+                    sourceBaseUrl: '/api',
+                    targetBaseUrl: `http://localhost:${unavailablePort}`,
+                    sourcePort: proxyPort,
+                });
+                const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                expect(result.status).toBe(502); // Bad Gateway
+                expect(await result.text()).toBe('Bad Gateway');
+            });
+        });
+        it('Should emit onProxyFailed event on error', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const proxyPort = getPort();
+                const unavailablePort = getPort();
+                let failedEvent;
+                proxyManager.subscribe('onProxyFailed', (event) => {
+                    failedEvent = event;
+                });
+                // Set up proxy to non-existent target
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/api',
+                    targetBaseUrl: `http://localhost:${unavailablePort}`,
+                    sourcePort: proxyPort,
+                });
+                await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                expect(failedEvent).toBeDefined();
+                expect(failedEvent?.from).toBe('/api');
+                expect(failedEvent?.to).toContain(`http://localhost:${unavailablePort}`);
+            });
+        });
+        it('Should validate targetBaseUrl on addProxy', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                await expect(proxyManager.addProxy({
+                    sourceBaseUrl: '/api',
+                    targetBaseUrl: 'not-a-valid-url',
+                    sourcePort: getPort(),
+                })).rejects.toThrow('Invalid targetBaseUrl');
+            });
+        });
+        it('Should filter hop-by-hop headers', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                // Create a server that captures headers
+                const targetServer = createHttpServer((req, res) => {
+                    receivedHeaders = { ...req.headers };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ message: 'ok' }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        headers: (original) => {
+                            // Verify that Connection header was filtered from original headers
+                            expect(original.connection).toBeUndefined();
+                            return original;
+                        },
+                    });
+                    await fetch(`http://127.0.0.1:${proxyPort}/api/test`, {
+                        headers: {
+                            Connection: 'keep-alive',
+                            'X-Custom-Header': 'should-be-forwarded',
+                            'X-Hop-Header': 'test-value',
+                        },
+                    });
+                    // Note: fetch() may add its own Connection header when making the request
+                    // The important thing is that custom headers are forwarded
+                    expect(receivedHeaders['x-custom-header']).toBe('should-be-forwarded');
+                    expect(receivedHeaders['x-hop-header']).toBe('test-value');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should preserve multiple Set-Cookie headers from target', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = createHttpServer((_req, res) => {
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Set-Cookie': ['cookieA=a; Path=/; HttpOnly', 'cookieB=b; Path=/', 'cookieC=c; Path=/'],
+                    });
+                    res.end(JSON.stringify({ ok: true }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    expect(result.status).toBe(200);
+                    const anyHeaders = result.headers;
+                    const cookies = anyHeaders.getSetCookie?.();
+                    if (cookies) {
+                        expect(cookies.length).toBeGreaterThanOrEqual(3);
+                        expect(cookies.join('\n')).toContain('cookieA=a');
+                        expect(cookies.join('\n')).toContain('cookieB=b');
+                        expect(cookies.join('\n')).toContain('cookieC=c');
+                    }
+                    else {
+                        // Fallback: combined header still should contain at least one cookie
+                        const setCookieHeader = result.headers.get('set-cookie');
+                        expect(setCookieHeader).toBeTruthy();
+                        expect(setCookieHeader).toContain('cookieA=a');
+                    }
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should add X-Forwarded headers to target request', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let received = {};
+                const targetServer = createHttpServer((req, res) => {
+                    received = { ...req.headers };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    expect(received['x-forwarded-for']).toBeTruthy();
+                    expect(received['x-forwarded-host']).toBeTruthy();
+                    expect(received['x-forwarded-proto']).toBeTruthy();
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should abort upstream when client disconnects', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let chunksWritten = 0;
+                let closedEarly = false;
+                const totalChunks = 100;
+                const targetServer = createHttpServer((_req, res) => {
+                    res.writeHead(200, { 'Content-Type': 'text/plain' });
+                    const interval = setInterval(() => {
+                        chunksWritten++;
+                        res.write('chunk\n');
+                        if (chunksWritten >= totalChunks) {
+                            clearInterval(interval);
+                            res.end('done');
+                        }
+                    }, 5);
+                    res.on('close', () => {
+                        closedEarly = chunksWritten < totalChunks;
+                        clearInterval(interval);
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const controller = new AbortController();
+                    const fetchPromise = fetch(`http://127.0.0.1:${proxyPort}/api/stream`, { signal: controller.signal }).then(async (response) => {
+                        // Start reading the body stream
+                        const reader = response.body?.getReader();
+                        if (!reader)
+                            throw new Error('No body');
+                        // Read one chunk
+                        await reader.read();
+                        // Then abort
+                        controller.abort();
+                        // Try to read more (should fail)
+                        return reader.read();
+                    });
+                    await expect(fetchPromise).rejects.toBeDefined();
+                    // Give the server a moment to receive the abort
+                    await new Promise((r) => setTimeout(r, 100));
+                    expect(closedEarly).toBe(true);
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle request timeout', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let failedEvent;
+                proxyManager.subscribe('onProxyFailed', (event) => {
+                    failedEvent = event;
+                });
+                // Create a server that delays response longer than timeout
+                const targetServer = createHttpServer((_req, res) => {
+                    // Delay for 2 seconds (longer than our 100ms timeout)
+                    setTimeout(() => {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ message: 'delayed response' }));
+                    }, 2000);
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        timeout: 100, // Very short timeout to trigger quickly
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    // Should return 502 Bad Gateway due to timeout
+                    expect(result.status).toBe(502);
+                    expect(await result.text()).toBe('Bad Gateway');
+                    // Should emit onProxyFailed event
+                    expect(failedEvent).toBeDefined();
+                    expect(failedEvent?.from).toBe('/api');
+                    expect(failedEvent?.to).toContain(`http://localhost:${targetPort}`);
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should complete successfully when response is faster than timeout', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create a fast-responding server
+                const targetServer = createHttpServer((_req, res) => {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ message: 'fast response' }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        timeout: 5000, // Generous timeout
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    // Should succeed
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.message).toBe('fast response');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should use default timeout when not specified', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create a server with moderate delay (500ms)
+                const targetServer = createHttpServer((_req, res) => {
+                    setTimeout(() => {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ message: 'response after delay' }));
+                    }, 500);
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    // No timeout specified - should use default 30000ms
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        // timeout not specified - uses default
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    // Should succeed with default timeout
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.message).toBe('response after delay');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+    });
+    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);
+                const proxyPort = getPort();
+                await expect(proxyManager.addProxy({
+                    sourceBaseUrl: '/api',
+                    targetBaseUrl: 'ftp://example.com',
+                    sourcePort: proxyPort,
+                })).rejects.toThrow('Invalid targetBaseUrl protocol');
+            });
+        });
+        it('Should handle invalid target URL created by pathRewrite', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let failedEvent;
+                proxyManager.subscribe('onProxyFailed', (event) => {
+                    failedEvent = event;
+                });
+                // Create a simple server
+                const targetServer = createHttpServer((_req, res) => {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ message: 'ok' }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        // PathHelper.joinUrl now properly handles edge cases, making previously
+                        // "invalid" URLs valid. The test now verifies that the proxy still works
+                        // even with unusual pathRewrite results.
+                        pathRewrite: () => '://unusual-but-valid',
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    // With PathHelper.joinUrl, the URL is now valid and routes to the target server
+                    // The target server returns 200, demonstrating robust URL handling
+                    expect(result.status).toBe(200);
+                    const body = await result.json();
+                    expect(body).toStrictEqual({ message: 'ok' });
+                    // No error event should be emitted since the request succeeded
+                    expect(failedEvent).toBeUndefined();
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle number-type header values', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                let transformedHeaders;
+                const targetServer = createHttpServer((req, res) => {
+                    receivedHeaders = { ...req.headers };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        headers: (original) => {
+                            transformedHeaders = {
+                                ...original,
+                                'X-Custom-Number': 12345,
+                                'X-Custom-String': 'string-value',
+                            };
+                            return transformedHeaders;
+                        },
+                    });
+                    await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    // Verify headers transformer was called and returns correct types
+                    expect(transformedHeaders).toBeDefined();
+                    expect(transformedHeaders?.['X-Custom-Number']).toBe(12345);
+                    expect(transformedHeaders?.['X-Custom-String']).toBe('string-value');
+                    // Verify string header was forwarded
+                    expect(receivedHeaders['x-custom-string']).toBe('string-value');
+                    // Number headers get converted to strings by the proxy logic
+                    expect(receivedHeaders['x-custom-number']).toBe('12345');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle array-type header values', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                const targetServer = createHttpServer((req, res) => {
+                    receivedHeaders = { ...req.headers };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        headers: () => ({
+                            'X-Array-Header': ['value1', 'value2', 'value3'],
+                        }),
+                    });
+                    await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    expect(receivedHeaders['x-array-header']).toBe('value1, value2, value3');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle undefined header values', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                const targetServer = createHttpServer((req, res) => {
+                    receivedHeaders = { ...req.headers };
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        headers: () => ({
+                            'X-Defined-Header': 'defined',
+                            'X-Undefined-Header': undefined,
+                        }),
+                    });
+                    await fetch(`http://127.0.0.1:${proxyPort}/api/test`);
+                    expect(receivedHeaders['x-defined-header']).toBe('defined');
+                    expect(receivedHeaders['x-undefined-header']).toBeUndefined();
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+    });
+    describe('WebSocket proxy functionality', () => {
+        it('Should proxy WebSocket connections when enabled', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const { server: targetServer, wss: targetWss } = await createWsTestServer(targetPort, (ws) => {
+                    ws.on('message', (data) => {
+                        ws.send(`echo: ${rawDataToString(data)}`);
+                    });
+                });
+                try {
+                    // Set up proxy with WebSocket support
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    // Connect WebSocket client through proxy
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            clientWs.send('hello');
+                        });
+                        clientWs.on('message', (data) => {
+                            expect(rawDataToString(data)).toBe('echo: hello');
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle bidirectional WebSocket communication', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws) => {
+                    // Send messages to client
+                    ws.send('server-message-1');
+                    ws.send('server-message-2');
+                    ws.on('message', (data) => {
+                        const message = Buffer.isBuffer(data)
+                            ? data.toString('utf8')
+                            : Array.isArray(data)
+                                ? Buffer.concat(data).toString('utf8')
+                                : Buffer.from(data).toString('utf8');
+                        ws.send(`received: ${message}`);
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    const receivedMessages = [];
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            clientWs.send('client-message-1');
+                            clientWs.send('client-message-2');
+                        });
+                        clientWs.on('message', (data) => {
+                            const message = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            receivedMessages.push(message);
+                            if (receivedMessages.length >= 4) {
+                                expect(receivedMessages).toContain('server-message-1');
+                                expect(receivedMessages).toContain('server-message-2');
+                                expect(receivedMessages).toContain('received: client-message-1');
+                                expect(receivedMessages).toContain('received: client-message-2');
+                                clientWs.close();
+                                resolve();
+                            }
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should not proxy WebSocket when disabled', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    // Set up proxy WITHOUT WebSocket support
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: false,
+                    });
+                    // Try to connect WebSocket client through proxy
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve) => {
+                        clientWs.on('error', (error) => {
+                            // Should fail because WebSocket is not enabled
+                            expect(error).toBeDefined();
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('open', () => {
+                            // Should not open successfully
+                            clientWs.close();
+                            resolve();
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should preserve WebSocket subprotocols', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedProtocol;
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws, req) => {
+                    receivedProtocol = req.headers['sec-websocket-protocol'];
+                    ws.send('connected');
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`, ['v1.chat', 'v2.chat']);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            // Wait for server message
+                        });
+                        clientWs.on('message', (data) => {
+                            const message = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            expect(message).toBe('connected');
+                            expect(receivedProtocol).toContain('v1.chat');
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket path rewriting', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedPath;
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws, req) => {
+                    receivedPath = req.url;
+                    ws.send('connected');
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/old/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                        pathRewrite: (path) => path.replace('/chat', '/api/chat'),
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/old/ws/chat`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('message', (data) => {
+                            const message = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            expect(message).toBe('connected');
+                            expect(receivedPath).toBe('/api/chat');
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket connection closure from client', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let serverClosed = false;
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws) => {
+                    ws.on('close', () => {
+                        serverClosed = true;
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            clientWs.close();
+                        });
+                        clientWs.on('close', () => {
+                            // Give server time to process close event
+                            setTimeout(() => {
+                                expect(serverClosed).toBe(true);
+                                resolve();
+                            }, 100);
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket connection closure from server', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws) => {
+                    // Close connection immediately after opening
+                    ws.send('goodbye');
+                    setTimeout(() => ws.close(), 50);
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        let messageReceived = false;
+                        clientWs.on('message', (data) => {
+                            const message = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            expect(message).toBe('goodbye');
+                            messageReceived = true;
+                        });
+                        clientWs.on('close', () => {
+                            expect(messageReceived).toBe(true);
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should emit onWebSocketProxyFailed event on error', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const proxyPort = getPort();
+                const unavailablePort = getPort();
+                let failedEvent;
+                proxyManager.subscribe('onWebSocketProxyFailed', (event) => {
+                    failedEvent = event;
+                });
+                await proxyManager.addProxy({
+                    sourceBaseUrl: '/ws',
+                    targetBaseUrl: `http://localhost:${unavailablePort}`,
+                    sourcePort: proxyPort,
+                    enableWebsockets: true,
+                });
+                const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                await new Promise((resolve) => {
+                    clientWs.on('error', () => {
+                        // Expected error
+                    });
+                    clientWs.on('close', () => {
+                        // Give time for event to be emitted
+                        setTimeout(() => {
+                            expect(failedEvent).toBeDefined();
+                            expect(failedEvent?.from).toBe('/ws');
+                            expect(failedEvent?.to).toContain(`http://localhost:${unavailablePort}`);
+                            resolve();
+                        }, 100);
+                    });
+                });
+            });
+        });
+        it('Should handle large WebSocket messages', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws) => {
+                    ws.on('message', (data) => {
+                        // Echo back the large message
+                        ws.send(data);
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    // Create a large message (1MB)
+                    const largeMessage = 'x'.repeat(1024 * 1024);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            clientWs.send(largeMessage);
+                        });
+                        clientWs.on('message', (data) => {
+                            const dataStr = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            expect(dataStr.length).toBe(largeMessage.length);
+                            expect(dataStr).toBe(largeMessage);
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle binary WebSocket messages', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws) => {
+                    ws.on('message', (data) => {
+                        // Echo back the binary data
+                        ws.send(data);
+                    });
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    // Create binary data
+                    const binaryData = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0xff, 0xfe, 0xfd]);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('open', () => {
+                            clientWs.send(binaryData);
+                        });
+                        clientWs.on('message', (data) => {
+                            expect(Buffer.isBuffer(data)).toBe(true);
+                            expect(Buffer.compare(data, binaryData)).toBe(0);
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should apply header transformations to WebSocket upgrade', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                // Create target WebSocket server
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                targetWss.on('connection', (ws, req) => {
+                    receivedHeaders = { ...req.headers };
+                    ws.send('connected');
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                        headers: () => ({
+                            'X-Custom-Header': 'custom-value',
+                            'X-Auth-Token': 'bearer-token',
+                        }),
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('message', (data) => {
+                            const message = Buffer.isBuffer(data)
+                                ? data.toString('utf8')
+                                : Array.isArray(data)
+                                    ? Buffer.concat(data).toString('utf8')
+                                    : Buffer.from(data).toString('utf8');
+                            expect(message).toBe('connected');
+                            expect(receivedHeaders['x-custom-header']).toBe('custom-value');
+                            expect(receivedHeaders['x-auth-token']).toBe('bearer-token');
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket upgrade timeout', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                // Create a server that delays WebSocket upgrade longer than timeout
+                const targetServer = createHttpServer();
+                targetServer.on('upgrade', () => {
+                    // Don't respond to upgrade - let it timeout
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                        timeout: 200, // Short timeout
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        const timeoutId = setTimeout(() => {
+                            // If we haven't resolved by now, the test failed
+                            reject(new Error('Test timeout - WebSocket did not fail as expected'));
+                        }, 2000);
+                        clientWs.on('error', () => {
+                            // Expected error
+                        });
+                        clientWs.on('close', () => {
+                            // Give time for event to be emitted
+                            setTimeout(() => {
+                                clearTimeout(timeoutId);
+                                // The timeout test might not always trigger the event reliably
+                                // Just verify the connection was closed
+                                resolve();
+                            }, 300);
+                        });
+                    });
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        }, 10000);
+        it('Should handle unusual path in WebSocket upgrade with PathHelper', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let failedEvent;
+                proxyManager.subscribe('onWebSocketProxyFailed', (event) => {
+                    failedEvent = event;
+                });
+                // Create target server that will receive the WebSocket connection
+                const targetServer = createHttpServer();
+                const targetWss = new WebSocketServer({ server: targetServer });
+                let connectionReceived = false;
+                targetWss.on('connection', () => {
+                    connectionReceived = true;
+                });
+                await new Promise((resolve) => {
+                    targetServer.listen(targetPort, () => resolve());
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                        // PathHelper.joinUrl now properly handles edge cases, making previously
+                        // "invalid" URLs valid. The WebSocket connection succeeds.
+                        pathRewrite: () => '://unusual-but-valid',
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws/test`);
+                    await new Promise((resolve) => {
+                        clientWs.on('open', () => {
+                            // Connection successful thanks to robust URL handling
+                            clientWs.close();
+                        });
+                        clientWs.on('close', () => {
+                            // Give time for event to be processed
+                            setTimeout(() => {
+                                // No error event should be emitted since the connection succeeded
+                                expect(failedEvent).toBeUndefined();
+                                expect(connectionReceived).toBe(true);
+                                resolve();
+                            }, 100);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket header value types (number, array, undefined)', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedHeaders = {};
+                // Create target WebSocket server
+                const { server: targetServer, wss: targetWss } = await createWsTestServer(targetPort, (ws, req) => {
+                    receivedHeaders = { ...req.headers };
+                    ws.send('connected');
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                        headers: () => ({
+                            'X-Number-Header': 42,
+                            'X-Array-Header': ['val1', 'val2'],
+                            'X-Undefined-Header': undefined,
+                            'X-String-Header': 'string-value',
+                        }),
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('message', (data) => {
+                            expect(rawDataToString(data)).toBe('connected');
+                            expect(receivedHeaders['x-number-header']).toBe('42');
+                            expect(receivedHeaders['x-array-header']).toBe('val1, val2');
+                            expect(receivedHeaders['x-string-header']).toBe('string-value');
+                            expect(receivedHeaders['x-undefined-header']).toBeUndefined();
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket connections with query parameters', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                let receivedUrl;
+                const { server: targetServer, wss: targetWss } = await createWsTestServer(targetPort, (ws, req) => {
+                    receivedUrl = req.url;
+                    ws.send('connected');
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws/channel?token=abc123&user=test`);
+                    await new Promise((resolve, reject) => {
+                        clientWs.on('message', (data) => {
+                            expect(rawDataToString(data)).toBe('connected');
+                            expect(receivedUrl).toBe('/channel?token=abc123&user=test');
+                            clientWs.close();
+                            resolve();
+                        });
+                        clientWs.on('error', (err) => {
+                            clientWs.close();
+                            reject(err);
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle WebSocket close with code and reason', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const { server: targetServer, wss: targetWss } = await createWsTestServer(targetPort, (ws) => {
+                    ws.close(1008, 'Policy Violation');
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/ws',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                        enableWebsockets: true,
+                    });
+                    const clientWs = new WebSocket(`ws://127.0.0.1:${proxyPort}/ws`);
+                    await new Promise((resolve) => {
+                        clientWs.on('close', (code, reason) => {
+                            expect(code).toBe(1008);
+                            expect(reason.toString()).toBe('Policy Violation');
+                            resolve();
+                        });
+                    });
+                }
+                finally {
+                    targetWss.close();
+                    targetServer.close();
+                }
+            });
+        });
+    });
+    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);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (req, res) => {
+                    const chunks = [];
+                    req.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+                    req.on('end', () => {
+                        const body = Buffer.concat(chunks).toString('utf8');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ method: req.method, body: JSON.parse(body) }));
+                    });
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const testData = { id: 1, name: 'updated' };
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/resource/1`, {
+                        method: 'PUT',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(testData),
+                    });
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.method).toBe('PUT');
+                    expect(data.body).toEqual(testData);
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle PATCH requests with body', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (req, res) => {
+                    const chunks = [];
+                    req.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+                    req.on('end', () => {
+                        const body = Buffer.concat(chunks).toString('utf8');
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ method: req.method, body: JSON.parse(body) }));
+                    });
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const testData = { name: 'patched' };
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/resource/1`, {
+                        method: 'PATCH',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(testData),
+                    });
+                    expect(result.status).toBe(200);
+                    const data = (await result.json());
+                    expect(data.method).toBe('PATCH');
+                    expect(data.body).toEqual(testData);
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle DELETE requests', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (_req, res) => {
+                    res.writeHead(204, { 'Content-Type': 'application/json' });
+                    res.end();
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/resource/1`, {
+                        method: 'DELETE',
+                    });
+                    expect(result.status).toBe(204);
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle OPTIONS requests (CORS preflight)', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (_req, res) => {
+                    res.writeHead(200, {
+                        'Access-Control-Allow-Origin': '*',
+                        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                    });
+                    res.end();
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/resource`, {
+                        method: 'OPTIONS',
+                    });
+                    expect(result.status).toBe(200);
+                    expect(result.headers.get('access-control-allow-origin')).toBe('*');
+                    expect(result.headers.get('access-control-allow-methods')).toContain('DELETE');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle HEAD requests', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (_req, res) => {
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Content-Length': '100',
+                    });
+                    res.end();
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/resource`, {
+                        method: 'HEAD',
+                    });
+                    expect(result.status).toBe(200);
+                    expect(result.headers.get('content-type')).toBe('application/json');
+                    expect(result.headers.get('content-length')).toBe('100');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle 4xx client error responses', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (_req, res) => {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Not Found' }));
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/nonexistent`);
+                    expect(result.status).toBe(404);
+                    const data = (await result.json());
+                    expect(data.error).toBe('Not Found');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+        it('Should handle 5xx server error responses', async () => {
+            await usingAsync(new Injector(), async (injector) => {
+                const proxyManager = injector.getInstance(ProxyManager);
+                const targetPort = getPort();
+                const proxyPort = getPort();
+                const targetServer = await createEchoServer(targetPort, (_req, res) => {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Internal Server Error' }));
+                });
+                try {
+                    await proxyManager.addProxy({
+                        sourceBaseUrl: '/api',
+                        targetBaseUrl: `http://localhost:${targetPort}`,
+                        sourcePort: proxyPort,
+                    });
+                    const result = await fetch(`http://127.0.0.1:${proxyPort}/api/error`);
+                    expect(result.status).toBe(500);
+                    const data = (await result.json());
+                    expect(data.error).toBe('Internal Server Error');
+                }
+                finally {
+                    targetServer.close();
+                }
+            });
+        });
+    });
+});
+//# sourceMappingURL=proxy-manager.spec.js.map