push.rocks/smartproxy
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(rustproxy): Use cooperative cancellation for background tasks, prune stale caches and metric entries, and switch tests to dynamic port allocation to avoid port conflicts

Browse Source
This commit is contained in:
Jürgen Kunz
2026-02-24 20:56:37 +00:00
parent 755c81c042
commit 33cd5330c4
24 changed files with 535 additions and 560 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
test/helpers/port-allocator.ts Normal file
View File

@@ -0,0 +1,70 @@
import * as net from 'net';
/**
* Finds `count` free ports by binding to port 0 and reading the OS-assigned port.
* All servers are opened simultaneously to guarantee uniqueness.
* Returns an array of guaranteed-free ports.
*/
export async function findFreePorts(count: number): Promise<number[]> {
const servers: net.Server[] = [];
const ports: number[] = [];
// Open all servers simultaneously on port 0
await Promise.all(
Array.from({ length: count }, () =>
new Promise<void>((resolve, reject) => {
const server = net.createServer();
server.listen(0, '127.0.0.1', () => {
const addr = server.address() as net.AddressInfo;
ports.push(addr.port);
servers.push(server);
resolve();
});
server.on('error', reject);
})
)
);
// Close all servers
await Promise.all(
servers.map(
(server) => new Promise<void>((resolve) => server.close(() => resolve()))
)
);
return ports;
}
/**
* Verifies that all given ports are free (not listening).
* Useful as a cleanup assertion at the end of tests.
* Throws if any port is still in use.
*/
export async function assertPortsFree(ports: number[]): Promise<void> {
const results = await Promise.all(
ports.map(
(port) =>
new Promise<{ port: number; free: boolean }>((resolve) => {
const client = net.connect({ port, host: '127.0.0.1' });
client.on('connect', () => {
client.destroy();
resolve({ port, free: false });
});
client.on('error', () => {
resolve({ port, free: true });
});
client.setTimeout(1000, () => {
client.destroy();
resolve({ port, free: true });
});
})
)
);
const occupied = results.filter((r) => !r.free);
if (occupied.length > 0) {
throw new Error(
`Ports still in use after cleanup: ${occupied.map((r) => r.port).join(', ')}`
);
}
}

15
test/test.acme-http01-challenge.ts
View File

@@ -1,9 +1,12 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import { SmartProxy, SocketHandlers } from '../ts/index.js';
import * as net from 'net';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
// Test that HTTP-01 challenges are properly processed when the initial data arrives
tap.test('should correctly handle HTTP-01 challenge requests with initial data chunk', async (tapTest) => {
const [PORT] = await findFreePorts(1);
// Prepare test data
const challengeToken = 'test-acme-http01-challenge-token';
const challengeResponse = 'mock-response-for-challenge';
@@ -37,7 +40,7 @@ tap.test('should correctly handle HTTP-01 challenge requests with initial data c
routes: [{
name: 'acme-challenge-route',
match: {
ports: 47700,
ports: PORT,
path: '/.well-known/acme-challenge/*'
},
action: {
@@ -60,7 +63,7 @@ tap.test('should correctly handle HTTP-01 challenge requests with initial data c
// Connect to the proxy and send the HTTP-01 challenge request
await new Promise<void>((resolve, reject) => {
testClient.connect(47700, 'localhost', () => {
testClient.connect(PORT, 'localhost', () => {
// Send HTTP request for the challenge token
testClient.write(
`GET ${challengePath} HTTP/1.1\r\n` +
@@ -86,10 +89,13 @@ tap.test('should correctly handle HTTP-01 challenge requests with initial data c
// Cleanup
testClient.destroy();
await proxy.stop();
await assertPortsFree([PORT]);
});
// Test that non-existent challenge tokens return 404
tap.test('should return 404 for non-existent challenge tokens', async (tapTest) => {
const [PORT] = await findFreePorts(1);
// Create a socket handler that behaves like a real ACME handler
const acmeHandler = SocketHandlers.httpServer((req, res) => {
if (req.url?.startsWith('/.well-known/acme-challenge/')) {
@@ -113,7 +119,7 @@ tap.test('should return 404 for non-existent challenge tokens', async (tapTest)
routes: [{
name: 'acme-challenge-route',
match: {
ports: 47701,
ports: PORT,
path: '/.well-known/acme-challenge/*'
},
action: {
@@ -135,7 +141,7 @@ tap.test('should return 404 for non-existent challenge tokens', async (tapTest)
// Connect and send a request for a non-existent token
await new Promise<void>((resolve, reject) => {
testClient.connect(47701, 'localhost', () => {
testClient.connect(PORT, 'localhost', () => {
testClient.write(
'GET /.well-known/acme-challenge/invalid-token HTTP/1.1\r\n' +
'Host: test.example.com\r\n' +
@@ -157,6 +163,7 @@ tap.test('should return 404 for non-existent challenge tokens', async (tapTest)
// Cleanup
testClient.destroy();
await proxy.stop();
await assertPortsFree([PORT]);
});
export default tap.start();

40
test/test.connection-forwarding.ts
View File

@@ -5,6 +5,7 @@ import * as fs from 'fs';
import * as path from 'path';
import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
// Setup test infrastructure
const testCertPath = path.join(process.cwd(), 'test', 'helpers', 'test-cert.pem');
@@ -13,8 +14,14 @@ const testKeyPath = path.join(process.cwd(), 'test', 'helpers', 'test-key.pem');
let testServer: net.Server;
let tlsTestServer: tls.Server;
let smartProxy: SmartProxy;
let PROXY_TCP_PORT: number;
let PROXY_TLS_PORT: number;
let TCP_SERVER_PORT: number;
let TLS_SERVER_PORT: number;
tap.test('setup test servers', async () => {
[PROXY_TCP_PORT, PROXY_TLS_PORT, TCP_SERVER_PORT, TLS_SERVER_PORT] = await findFreePorts(4);
// Create TCP test server
testServer = net.createServer((socket) => {
socket.write('Connected to TCP test server\n');
@@ -24,8 +31,8 @@ tap.test('setup test servers', async () => {
});
await new Promise<void>((resolve) => {
testServer.listen(47712, '127.0.0.1', () => {
console.log('TCP test server listening on port 47712');
testServer.listen(TCP_SERVER_PORT, '127.0.0.1', () => {
console.log(`TCP test server listening on port ${TCP_SERVER_PORT}`);
resolve();
});
});
@@ -45,8 +52,8 @@ tap.test('setup test servers', async () => {
);
await new Promise<void>((resolve) => {
tlsTestServer.listen(47713, '127.0.0.1', () => {
console.log('TLS test server listening on port 47713');
tlsTestServer.listen(TLS_SERVER_PORT, '127.0.0.1', () => {
console.log(`TLS test server listening on port ${TLS_SERVER_PORT}`);
resolve();
});
});
@@ -60,13 +67,13 @@ tap.test('should forward TCP connections correctly', async () => {
{
name: 'tcp-forward',
match: {
ports: 47710,
ports: PROXY_TCP_PORT,
},
action: {
type: 'forward',
targets: [{
host: '127.0.0.1',
port: 47712,
port: TCP_SERVER_PORT,
}],
},
},
@@ -77,7 +84,7 @@ tap.test('should forward TCP connections correctly', async () => {
// Test TCP forwarding
const client = await new Promise<net.Socket>((resolve, reject) => {
const socket = net.connect(47710, '127.0.0.1', () => {
const socket = net.connect(PROXY_TCP_PORT, '127.0.0.1', () => {
console.log('Connected to proxy');
resolve(socket);
});
@@ -106,7 +113,7 @@ tap.test('should handle TLS passthrough correctly', async () => {
{
name: 'tls-passthrough',
match: {
ports: 47711,
ports: PROXY_TLS_PORT,
domains: 'test.example.com',
},
action: {
@@ -116,7 +123,7 @@ tap.test('should handle TLS passthrough correctly', async () => {
},
targets: [{
host: '127.0.0.1',
port: 47713,
port: TLS_SERVER_PORT,
}],
},
},
@@ -129,7 +136,7 @@ tap.test('should handle TLS passthrough correctly', async () => {
const client = await new Promise<tls.TLSSocket>((resolve, reject) => {
const socket = tls.connect(
{
port: 47711,
port: PROXY_TLS_PORT,
host: '127.0.0.1',
servername: 'test.example.com',
rejectUnauthorized: false,
@@ -164,7 +171,7 @@ tap.test('should handle SNI-based forwarding', async () => {
{
name: 'domain-a',
match: {
ports: 47711,
ports: PROXY_TLS_PORT,
domains: 'a.example.com',
},
action: {
@@ -174,14 +181,14 @@ tap.test('should handle SNI-based forwarding', async () => {
},
targets: [{
host: '127.0.0.1',
port: 47713,
port: TLS_SERVER_PORT,
}],
},
},
{
name: 'domain-b',
match: {
ports: 47711,
ports: PROXY_TLS_PORT,
domains: 'b.example.com',
},
action: {
@@ -191,7 +198,7 @@ tap.test('should handle SNI-based forwarding', async () => {
},
targets: [{
host: '127.0.0.1',
port: 47713,
port: TLS_SERVER_PORT,
}],
},
},
@@ -204,7 +211,7 @@ tap.test('should handle SNI-based forwarding', async () => {
const clientA = await new Promise<tls.TLSSocket>((resolve, reject) => {
const socket = tls.connect(
{
port: 47711,
port: PROXY_TLS_PORT,
host: '127.0.0.1',
servername: 'a.example.com',
rejectUnauthorized: false,
@@ -231,7 +238,7 @@ tap.test('should handle SNI-based forwarding', async () => {
const clientB = await new Promise<tls.TLSSocket>((resolve, reject) => {
const socket = tls.connect(
{
port: 47711,
port: PROXY_TLS_PORT,
host: '127.0.0.1',
servername: 'b.example.com',
rejectUnauthorized: false,
@@ -261,6 +268,7 @@ tap.test('should handle SNI-based forwarding', async () => {
tap.test('cleanup', async () => {
testServer.close();
tlsTestServer.close();
await assertPortsFree([PROXY_TCP_PORT, PROXY_TLS_PORT, TCP_SERVER_PORT, TLS_SERVER_PORT]);
});
export default tap.start();

14
test/test.forwarding-regression.ts
View File

@@ -1,9 +1,12 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
// Test to verify port forwarding works correctly
tap.test('forward connections should not be immediately closed', async (t) => {
const [PROXY_PORT, SERVER_PORT] = await findFreePorts(2);
// Create a backend server that accepts connections
const testServer = net.createServer((socket) => {
console.log('Client connected to test server');
@@ -21,8 +24,8 @@ tap.test('forward connections should not be immediately closed', async (t) => {
// Listen on a non-privileged port
await new Promise<void>((resolve) => {
testServer.listen(47721, '127.0.0.1', () => {
console.log('Test server listening on port 47721');
testServer.listen(SERVER_PORT, '127.0.0.1', () => {
console.log(`Test server listening on port ${SERVER_PORT}`);
resolve();
});
});
@@ -34,13 +37,13 @@ tap.test('forward connections should not be immediately closed', async (t) => {
{
name: 'forward-test',
match: {
ports: 47720,
ports: PROXY_PORT,
},
action: {
type: 'forward',
targets: [{
host: '127.0.0.1',
port: 47721,
port: SERVER_PORT,
}],
},
},
@@ -51,7 +54,7 @@ tap.test('forward connections should not be immediately closed', async (t) => {
// Create a client connection through the proxy
const client = net.createConnection({
port: 47720,
port: PROXY_PORT,
host: '127.0.0.1',
});
@@ -105,6 +108,7 @@ tap.test('forward connections should not be immediately closed', async (t) => {
client.end();
await smartProxy.stop();
testServer.close();
await assertPortsFree([PROXY_PORT, SERVER_PORT]);
});
export default tap.start();

29
test/test.http-port8080-forwarding.ts
View File

@@ -1,10 +1,13 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import { SmartProxy } from '../ts/index.js';
import * as http from 'http';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
tap.test('should forward HTTP connections on port 8080', async (tapTest) => {
const [PROXY_PORT, TARGET_PORT] = await findFreePorts(2);
// Create a mock HTTP server to act as our target
const targetPort = 47732;
const targetPort = TARGET_PORT;
let receivedRequest = false;
let receivedPath = '';
@@ -36,7 +39,7 @@ tap.test('should forward HTTP connections on port 8080', async (tapTest) => {
routes: [{
name: 'test-route',
match: {
ports: 47730
ports: PROXY_PORT
// Remove domain restriction for HTTP connections
// Domain matching happens after HTTP headers are received
},
@@ -46,16 +49,16 @@ tap.test('should forward HTTP connections on port 8080', async (tapTest) => {
}
}]
});
await proxy.start();
// Give the proxy a moment to fully initialize
await new Promise(resolve => setTimeout(resolve, 500));
// Make an HTTP request to port 8080
const options = {
hostname: 'localhost',
port: 47730,
port: PROXY_PORT,
path: '/.well-known/acme-challenge/test-token',
method: 'GET',
headers: {
@@ -97,14 +100,17 @@ tap.test('should forward HTTP connections on port 8080', async (tapTest) => {
await new Promise<void>((resolve) => {
targetServer.close(() => resolve());
});
// Wait a bit to ensure port is fully released
await new Promise(resolve => setTimeout(resolve, 500));
await assertPortsFree([PROXY_PORT, TARGET_PORT]);
});
tap.test('should handle basic HTTP request forwarding', async (tapTest) => {
const [PROXY_PORT, TARGET_PORT] = await findFreePorts(2);
// Create a simple target server
const targetPort = 47733;
const targetPort = TARGET_PORT;
let receivedRequest = false;
const targetServer = http.createServer((req, res) => {
@@ -126,7 +132,7 @@ tap.test('should handle basic HTTP request forwarding', async (tapTest) => {
routes: [{
name: 'simple-forward',
match: {
ports: 47731
ports: PROXY_PORT
// Remove domain restriction for HTTP connections
},
action: {
@@ -142,7 +148,7 @@ tap.test('should handle basic HTTP request forwarding', async (tapTest) => {
// Make request
const options = {
hostname: 'localhost',
port: 47731,
port: PROXY_PORT,
path: '/test',
method: 'GET',
headers: {
@@ -184,9 +190,10 @@ tap.test('should handle basic HTTP request forwarding', async (tapTest) => {
await new Promise<void>((resolve) => {
targetServer.close(() => resolve());
});
// Wait a bit to ensure port is fully released
await new Promise(resolve => setTimeout(resolve, 500));
await assertPortsFree([PROXY_PORT, TARGET_PORT]);
});
export default tap.start();

8
test/test.long-lived-connections.ts
View File

@@ -2,15 +2,17 @@ import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import * as tls from 'tls';
import { SmartProxy } from '../ts/index.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
let testProxy: SmartProxy;
let targetServer: net.Server;
const ECHO_PORT = 47200;
const PROXY_PORT = 47201;
let ECHO_PORT: number;
let PROXY_PORT: number;
// Create a simple echo server as target
tap.test('setup test environment', async () => {
[ECHO_PORT, PROXY_PORT] = await findFreePorts(2);
// Create target server that echoes data back
targetServer = net.createServer((socket) => {
console.log('Target server: client connected');
@@ -148,6 +150,8 @@ tap.test('cleanup', async () => {
resolve();
});
});
await assertPortsFree([ECHO_PORT, PROXY_PORT]);
});
export default tap.start();

8
test/test.metrics-new.ts
View File

@@ -2,14 +2,16 @@ import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as plugins from '../ts/plugins.js';
import { SmartProxy } from '../ts/index.js';
import * as net from 'net';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
let smartProxyInstance: SmartProxy;
let echoServer: net.Server;
const echoServerPort = 47300;
const proxyPort = 47301;
let echoServerPort: number;
let proxyPort: number;
// Create an echo server for testing
tap.test('should create echo server for testing', async () => {
[echoServerPort, proxyPort] = await findFreePorts(2);
echoServer = net.createServer((socket) => {
socket.on('data', (data) => {
socket.write(data); // Echo back the data
@@ -267,6 +269,8 @@ tap.test('should clean up resources', async () => {
resolve();
});
});
await assertPortsFree([echoServerPort, proxyPort]);
});
export default tap.start();

17
test/test.perf-improvements.ts
View File

@@ -7,15 +7,16 @@ import * as net from 'net';
import * as tls from 'tls';
import * as fs from 'fs';
import * as path from 'path';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
// ---------------------------------------------------------------------------
// Port assignments (47600–47620 range to avoid conflicts)
// Port assignments (dynamically allocated to avoid conflicts)
// ---------------------------------------------------------------------------
const HTTP_ECHO_PORT = 47600; // backend HTTP echo server
const PROXY_HTTP_PORT = 47601; // SmartProxy plain HTTP forwarding
const PROXY_HTTPS_PORT = 47602; // SmartProxy TLS-terminate HTTPS forwarding
const TCP_ECHO_PORT = 47603; // backend TCP echo server
const PROXY_TCP_PORT = 47604; // SmartProxy plain TCP forwarding
let HTTP_ECHO_PORT: number;
let PROXY_HTTP_PORT: number;
let PROXY_HTTPS_PORT: number;
let TCP_ECHO_PORT: number;
let PROXY_TCP_PORT: number;
// ---------------------------------------------------------------------------
// Shared state
@@ -88,6 +89,8 @@ async function waitForMetrics(
// 1. Setup backend servers
// ===========================================================================
tap.test('setup - backend servers', async () => {
[HTTP_ECHO_PORT, PROXY_HTTP_PORT, PROXY_HTTPS_PORT, TCP_ECHO_PORT, PROXY_TCP_PORT] = await findFreePorts(5);
// HTTP echo server: POST → echo:<body>, GET → ok
httpEchoServer = http.createServer((req, res) => {
if (req.method === 'POST') {
@@ -467,6 +470,8 @@ tap.test('cleanup', async () => {
resolve();
});
});
await assertPortsFree([HTTP_ECHO_PORT, PROXY_HTTP_PORT, PROXY_HTTPS_PORT, TCP_ECHO_PORT, PROXY_TCP_PORT]);
});
export default tap.start();

9
test/test.port-forwarding-fix.ts
View File

@@ -1,17 +1,19 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
let echoServer: net.Server;
let proxy: SmartProxy;
const ECHO_PORT = 47400;
const PROXY_PORT_1 = 47401;
const PROXY_PORT_2 = 47402;
let ECHO_PORT: number;
let PROXY_PORT_1: number;
let PROXY_PORT_2: number;
tap.test('port forwarding should not immediately close connections', async (tools) => {
// Set a timeout for this test
tools.timeout(10000); // 10 seconds
[ECHO_PORT, PROXY_PORT_1, PROXY_PORT_2] = await findFreePorts(3);
// Create an echo server
echoServer = await new Promise<net.Server>((resolve, reject) => {
const server = net.createServer((socket) => {
@@ -96,6 +98,7 @@ tap.test('cleanup', async () => {
});
});
}
await assertPortsFree([ECHO_PORT, PROXY_PORT_1, PROXY_PORT_2]);
});
export default tap.start();

89
test/test.port-mapping.ts
View File

@@ -9,13 +9,14 @@ import {
createPortOffset
} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
import type { IRouteConfig, IRouteContext } from '../ts/proxies/smart-proxy/models/route-types.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
// Test server and client utilities
let testServers: Array<{ server: net.Server; port: number }> = [];
let smartProxy: SmartProxy;
const TEST_PORT_START = 47750;
const PROXY_PORT_START = 48750;
let TEST_PORTS: number[]; // 3 test server ports
let PROXY_PORTS: number[]; // 6 proxy ports
const TEST_DATA = 'Hello through dynamic port mapper!';
// Cleanup function to close all servers and proxies
@@ -101,53 +102,60 @@ function createTestClient(port: number, data: string): Promise<string> {
// Set up test environment
tap.test('setup port mapping test environment', async () => {
const allPorts = await findFreePorts(9);
TEST_PORTS = allPorts.slice(0, 3);
PROXY_PORTS = allPorts.slice(3, 9);
// Create multiple test servers on different ports
await Promise.all([
createTestServer(TEST_PORT_START), // Server on port 47750
createTestServer(TEST_PORT_START + 1), // Server on port 47751
createTestServer(TEST_PORT_START + 2), // Server on port 47752
createTestServer(TEST_PORTS[0]),
createTestServer(TEST_PORTS[1]),
createTestServer(TEST_PORTS[2]),
]);
// Compute dynamic offset between proxy and test ports
const portOffset = TEST_PORTS[1] - PROXY_PORTS[1];
// Create a SmartProxy with dynamic port mapping routes
smartProxy = new SmartProxy({
routes: [
// Simple function that returns the same port (identity mapping)
createPortMappingRoute({
sourcePortRange: PROXY_PORT_START,
sourcePortRange: PROXY_PORTS[0],
targetHost: 'localhost',
portMapper: (context) => TEST_PORT_START,
portMapper: (context) => TEST_PORTS[0],
name: 'Identity Port Mapping'
}),
// Offset port mapping from 48751 to 47751 (offset -1000)
// Offset port mapping using dynamic offset
createOffsetPortMappingRoute({
ports: PROXY_PORT_START + 1,
ports: PROXY_PORTS[1],
targetHost: 'localhost',
offset: -1000,
name: 'Offset Port Mapping (-1000)'
offset: portOffset,
name: `Offset Port Mapping (${portOffset})`
}),
// Dynamic route with conditional port mapping
createDynamicRoute({
ports: [PROXY_PORT_START + 2, PROXY_PORT_START + 3],
ports: [PROXY_PORTS[2], PROXY_PORTS[3]],
targetHost: (context) => {
// Dynamic host selection based on port
return context.port === PROXY_PORT_START + 2 ? 'localhost' : '127.0.0.1';
return context.port === PROXY_PORTS[2] ? 'localhost' : '127.0.0.1';
},
portMapper: (context) => {
// Port mapping logic based on incoming port
if (context.port === PROXY_PORT_START + 2) {
return TEST_PORT_START;
if (context.port === PROXY_PORTS[2]) {
return TEST_PORTS[0];
} else {
return TEST_PORT_START + 2;
return TEST_PORTS[2];
}
},
name: 'Dynamic Host and Port Mapping'
}),
// Smart load balancer for domain-based routing
createSmartLoadBalancer({
ports: PROXY_PORT_START + 4,
ports: PROXY_PORTS[4],
domainTargets: {
'test1.example.com': 'localhost',
'test2.example.com': '127.0.0.1'
@@ -155,9 +163,9 @@ tap.test('setup port mapping test environment', async () => {
portMapper: (context) => {
// Use different backend ports based on domain
if (context.domain === 'test1.example.com') {
return TEST_PORT_START;
return TEST_PORTS[0];
} else {
return TEST_PORT_START + 1;
return TEST_PORTS[1];
}
},
defaultTarget: 'localhost',
@@ -165,44 +173,45 @@ tap.test('setup port mapping test environment', async () => {
})
]
});
// Start the SmartProxy
await smartProxy.start();
});
// Test 1: Simple identity port mapping (48750 -> 47750)
// Test 1: Simple identity port mapping
tap.test('should map port using identity function', async () => {
const response = await createTestClient(PROXY_PORT_START, TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORT_START} says: ${TEST_DATA}`);
const response = await createTestClient(PROXY_PORTS[0], TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORTS[0]} says: ${TEST_DATA}`);
});
// Test 2: Offset port mapping (48751 -> 47751)
// Test 2: Offset port mapping
tap.test('should map port using offset function', async () => {
const response = await createTestClient(PROXY_PORT_START + 1, TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORT_START + 1} says: ${TEST_DATA}`);
const response = await createTestClient(PROXY_PORTS[1], TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORTS[1]} says: ${TEST_DATA}`);
});
// Test 3: Dynamic port and host mapping (conditional logic)
tap.test('should map port using dynamic logic', async () => {
const response = await createTestClient(PROXY_PORT_START + 2, TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORT_START} says: ${TEST_DATA}`);
const response = await createTestClient(PROXY_PORTS[2], TEST_DATA);
expect(response).toEqual(`Server ${TEST_PORTS[0]} says: ${TEST_DATA}`);
});
// Test 4: Test reuse of createPortOffset helper
tap.test('should use createPortOffset helper for port mapping', async () => {
// Test the createPortOffset helper
const offsetFn = createPortOffset(-1000);
// Test the createPortOffset helper with dynamic offset
const portOffset = TEST_PORTS[1] - PROXY_PORTS[1];
const offsetFn = createPortOffset(portOffset);
const context = {
port: PROXY_PORT_START + 1,
port: PROXY_PORTS[1],
clientIp: '127.0.0.1',
serverIp: '127.0.0.1',
isTls: false,
timestamp: Date.now(),
connectionId: 'test-connection'
} as IRouteContext;
const mappedPort = offsetFn(context);
expect(mappedPort).toEqual(TEST_PORT_START + 1);
expect(mappedPort).toEqual(TEST_PORTS[1]);
});
// Test 5: Test error handling for invalid port mapping functions
@@ -210,7 +219,7 @@ tap.test('should handle errors in port mapping functions', async () => {
// Create a route with a function that throws an error
const errorRoute: IRouteConfig = {
match: {
ports: PROXY_PORT_START + 5
ports: PROXY_PORTS[5]
},
action: {
type: 'forward',
@@ -229,7 +238,7 @@ tap.test('should handle errors in port mapping functions', async () => {
// The connection should fail or timeout
try {
await createTestClient(PROXY_PORT_START + 5, TEST_DATA);
await createTestClient(PROXY_PORTS[5], TEST_DATA);
// Connection should not succeed
expect(false).toBeTrue();
} catch (error) {
@@ -254,6 +263,8 @@ tap.test('cleanup port mapping test environment', async () => {
testServers = [];
smartProxy = null as any;
}
await assertPortsFree([...TEST_PORTS, ...PROXY_PORTS]);
});
export default tap.start();

41
test/test.smartproxy.ts
View File

@@ -1,11 +1,19 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
let testServer: net.Server;
let smartProxy: SmartProxy;
const TEST_SERVER_PORT = 47770;
const PROXY_PORT = 47771;
let TEST_SERVER_PORT: number;
let PROXY_PORT: number;
let CUSTOM_HOST_PORT: number;
let CUSTOM_IP_PROXY_PORT: number;
let CUSTOM_IP_TARGET_PORT: number;
let CHAIN_DEFAULT_1_PORT: number;
let CHAIN_DEFAULT_2_PORT: number;
let CHAIN_PRESERVED_1_PORT: number;
let CHAIN_PRESERVED_2_PORT: number;
const TEST_DATA = 'Hello through port proxy!';
// Track all created servers and proxies for proper cleanup
@@ -64,6 +72,7 @@ function createTestClient(port: number, data: string): Promise<string> {
// SETUP: Create a test server and a PortProxy instance.
tap.test('setup port proxy test environment', async () => {
[TEST_SERVER_PORT, PROXY_PORT, CUSTOM_HOST_PORT, CUSTOM_IP_PROXY_PORT, CUSTOM_IP_TARGET_PORT, CHAIN_DEFAULT_1_PORT, CHAIN_DEFAULT_2_PORT, CHAIN_PRESERVED_1_PORT, CHAIN_PRESERVED_2_PORT] = await findFreePorts(9);
testServer = await createTestServer(TEST_SERVER_PORT);
smartProxy = new SmartProxy({
routes: [
@@ -110,7 +119,7 @@ tap.test('should forward TCP connections to custom host', async () => {
{
name: 'custom-host-route',
match: {
ports: PROXY_PORT + 1
ports: CUSTOM_HOST_PORT
},
action: {
type: 'forward',
@@ -128,9 +137,9 @@ tap.test('should forward TCP connections to custom host', async () => {
}
});
allProxies.push(customHostProxy); // Track this proxy
await customHostProxy.start();
const response = await createTestClient(PROXY_PORT + 1, TEST_DATA);
const response = await createTestClient(CUSTOM_HOST_PORT, TEST_DATA);
expect(response).toEqual(`Echo: ${TEST_DATA}`);
await customHostProxy.stop();
@@ -143,8 +152,8 @@ tap.test('should forward TCP connections to custom host', async () => {
// Modified to work in Docker/CI environments without needing 127.0.0.2
tap.test('should forward connections to custom IP', async () => {
// Set up ports that are FAR apart to avoid any possible confusion
const forcedProxyPort = PROXY_PORT + 2; // 4003 - The port that our proxy listens on
const targetServerPort = TEST_SERVER_PORT + 200; // 4200 - Target test server on different port
const forcedProxyPort = CUSTOM_IP_PROXY_PORT;
const targetServerPort = CUSTOM_IP_TARGET_PORT;
// Create a test server listening on a unique port on 127.0.0.1 (works in all environments)
const testServer2 = await createTestServer(targetServerPort, '127.0.0.1');
@@ -252,13 +261,13 @@ tap.test('should support optional source IP preservation in chained proxies', as
{
name: 'first-proxy-default-route',
match: {
ports: PROXY_PORT + 4
ports: CHAIN_DEFAULT_1_PORT
},
action: {
type: 'forward',
targets: [{
host: 'localhost',
port: PROXY_PORT + 5
port: CHAIN_DEFAULT_2_PORT
}]
}
}
@@ -274,7 +283,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
{
name: 'second-proxy-default-route',
match: {
ports: PROXY_PORT + 5
ports: CHAIN_DEFAULT_2_PORT
},
action: {
type: 'forward',
@@ -296,7 +305,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
await secondProxyDefault.start();
await firstProxyDefault.start();
const response1 = await createTestClient(PROXY_PORT + 4, TEST_DATA);
const response1 = await createTestClient(CHAIN_DEFAULT_1_PORT, TEST_DATA);
expect(response1).toEqual(`Echo: ${TEST_DATA}`);
await firstProxyDefault.stop();
await secondProxyDefault.stop();
@@ -313,13 +322,13 @@ tap.test('should support optional source IP preservation in chained proxies', as
{
name: 'first-proxy-preserved-route',
match: {
ports: PROXY_PORT + 6
ports: CHAIN_PRESERVED_1_PORT
},
action: {
type: 'forward',
targets: [{
host: 'localhost',
port: PROXY_PORT + 7
port: CHAIN_PRESERVED_2_PORT
}]
}
}
@@ -337,7 +346,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
{
name: 'second-proxy-preserved-route',
match: {
ports: PROXY_PORT + 7
ports: CHAIN_PRESERVED_2_PORT
},
action: {
type: 'forward',
@@ -361,7 +370,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
await secondProxyPreserved.start();
await firstProxyPreserved.start();
const response2 = await createTestClient(PROXY_PORT + 6, TEST_DATA);
const response2 = await createTestClient(CHAIN_PRESERVED_1_PORT, TEST_DATA);
expect(response2).toEqual(`Echo: ${TEST_DATA}`);
await firstProxyPreserved.stop();
await secondProxyPreserved.stop();
@@ -446,6 +455,8 @@ tap.test('cleanup port proxy test environment', async () => {
// Verify all resources are cleaned up
expect(allProxies.length).toEqual(0);
expect(allServers.length).toEqual(0);
await assertPortsFree([TEST_SERVER_PORT, PROXY_PORT, CUSTOM_HOST_PORT, CUSTOM_IP_PROXY_PORT, CUSTOM_IP_TARGET_PORT, CHAIN_DEFAULT_1_PORT, CHAIN_DEFAULT_2_PORT, CHAIN_PRESERVED_1_PORT, CHAIN_PRESERVED_2_PORT]);
});
export default tap.start();

8
test/test.socket-handler-race.ts
View File

@@ -1,12 +1,15 @@
import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/index.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
tap.test('should handle async handler that sets up listeners after delay', async () => {
const [PORT] = await findFreePorts(1);
const proxy = new SmartProxy({
routes: [{
name: 'delayed-setup-handler',
match: { ports: 7777 },
match: { ports: PORT },
action: {
type: 'socket-handler',
socketHandler: async (socket, context) => {
@@ -41,7 +44,7 @@ tap.test('should handle async handler that sets up listeners after delay', async
});
await new Promise<void>((resolve, reject) => {
client.connect(7777, 'localhost', () => {
client.connect(PORT, 'localhost', () => {
// Send initial data immediately - this tests the race condition
client.write('initial-message\n');
resolve();
@@ -78,6 +81,7 @@ tap.test('should handle async handler that sets up listeners after delay', async
expect(response).toContain('RECEIVED: test-message');
await proxy.stop();
await assertPortsFree([PORT]);
});
export default tap.start();

25
test/test.socket-handler.ts
View File

@@ -2,15 +2,19 @@ import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as net from 'net';
import { SmartProxy } from '../ts/index.js';
import type { IRouteConfig } from '../ts/index.js';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
let proxy: SmartProxy;
let PORT: number;
tap.test('setup socket handler test', async () => {
[PORT] = await findFreePorts(1);
// Create a simple socket handler route
const routes: IRouteConfig[] = [{
name: 'echo-handler',
match: {
ports: 47780
match: {
ports: PORT
// No domains restriction - matches all connections
},
action: {
@@ -43,11 +47,11 @@ tap.test('should handle socket with custom function', async () => {
let response = '';
await new Promise<void>((resolve, reject) => {
client.connect(47780, 'localhost', () => {
client.connect(PORT, 'localhost', () => {
console.log('Client connected to proxy');
resolve();
});
client.on('error', reject);
});
@@ -78,7 +82,7 @@ tap.test('should handle async socket handler', async () => {
// Update route with async handler
await proxy.updateRoutes([{
name: 'async-handler',
match: { ports: 47780 },
match: { ports: PORT },
action: {
type: 'socket-handler',
socketHandler: async (socket, context) => {
@@ -108,12 +112,12 @@ tap.test('should handle async socket handler', async () => {
});
await new Promise<void>((resolve, reject) => {
client.connect(47780, 'localhost', () => {
client.connect(PORT, 'localhost', () => {
// Send initial data to trigger the handler
client.write('test data\n');
resolve();
});
client.on('error', reject);
});
@@ -131,7 +135,7 @@ tap.test('should handle errors in socket handler', async () => {
// Update route with error-throwing handler
await proxy.updateRoutes([{
name: 'error-handler',
match: { ports: 47780 },
match: { ports: PORT },
action: {
type: 'socket-handler',
socketHandler: (socket, context) => {
@@ -148,12 +152,12 @@ tap.test('should handle errors in socket handler', async () => {
});
await new Promise<void>((resolve, reject) => {
client.connect(47780, 'localhost', () => {
client.connect(PORT, 'localhost', () => {
// Connection established - send data to trigger handler
client.write('trigger\n');
resolve();
});
client.on('error', () => {
// Ignore client errors - we expect the connection to be closed
});
@@ -168,6 +172,7 @@ tap.test('should handle errors in socket handler', async () => {
tap.test('cleanup', async () => {
await proxy.stop();
await assertPortsFree([PORT]);
});
export default tap.start();

28
test/test.throughput.ts
View File

@@ -8,24 +8,25 @@ import * as https from 'https';
import * as fs from 'fs';
import * as path from 'path';
import { fileURLToPath } from 'url';
import { findFreePorts, assertPortsFree } from './helpers/port-allocator.js';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
// ────────────────────────────────────────────────────────────────────────────
// Port assignments (unique to avoid conflicts with other tests)
// Port assignments (dynamically allocated to avoid conflicts)
// ────────────────────────────────────────────────────────────────────────────
const TCP_ECHO_PORT = 47500;
const HTTP_ECHO_PORT = 47501;
const TLS_ECHO_PORT = 47502;
const PROXY_TCP_PORT = 47510;
const PROXY_HTTP_PORT = 47511;
const PROXY_TLS_PASS_PORT = 47512;
const PROXY_TLS_TERM_PORT = 47513;
const PROXY_SOCKET_PORT = 47514;
const PROXY_MULTI_A_PORT = 47515;
const PROXY_MULTI_B_PORT = 47516;
const PROXY_TP_HTTP_PORT = 47517;
let TCP_ECHO_PORT: number;
let HTTP_ECHO_PORT: number;
let TLS_ECHO_PORT: number;
let PROXY_TCP_PORT: number;
let PROXY_HTTP_PORT: number;
let PROXY_TLS_PASS_PORT: number;
let PROXY_TLS_TERM_PORT: number;
let PROXY_SOCKET_PORT: number;
let PROXY_MULTI_A_PORT: number;
let PROXY_MULTI_B_PORT: number;
let PROXY_TP_HTTP_PORT: number;
// ────────────────────────────────────────────────────────────────────────────
// Test certificates
@@ -49,6 +50,8 @@ async function pollMetrics(proxy: SmartProxy): Promise<void> {
// Setup: backend servers
// ════════════════════════════════════════════════════════════════════════════
tap.test('setup - TCP echo server', async () => {
[TCP_ECHO_PORT, HTTP_ECHO_PORT, TLS_ECHO_PORT, PROXY_TCP_PORT, PROXY_HTTP_PORT, PROXY_TLS_PASS_PORT, PROXY_TLS_TERM_PORT, PROXY_SOCKET_PORT, PROXY_MULTI_A_PORT, PROXY_MULTI_B_PORT, PROXY_TP_HTTP_PORT] = await findFreePorts(11);
tcpEchoServer = net.createServer((socket) => {
socket.on('data', (data) => socket.write(data));
socket.on('error', () => {});
@@ -700,6 +703,7 @@ tap.test('cleanup - close backend servers', async () => {
await new Promise<void>((resolve) => httpEchoServer.close(() => resolve()));
await new Promise<void>((resolve) => tlsEchoServer.close(() => resolve()));
console.log('All backend servers closed');
await assertPortsFree([TCP_ECHO_PORT, HTTP_ECHO_PORT, TLS_ECHO_PORT, PROXY_TCP_PORT, PROXY_HTTP_PORT, PROXY_TLS_PASS_PORT, PROXY_TLS_TERM_PORT, PROXY_SOCKET_PORT, PROXY_MULTI_A_PORT, PROXY_MULTI_B_PORT, PROXY_TP_HTTP_PORT]);
});
export default tap.start();