773 lines
24 KiB
TypeScript
773 lines
24 KiB
TypeScript
/**
|
|
* Tests for the unified route-based configuration system
|
|
*/
|
|
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
|
|
|
// Import from core modules
|
|
import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
|
|
|
|
// Import route utilities
|
|
import {
|
|
findMatchingRoutes,
|
|
findBestMatchingRoute,
|
|
routeMatchesDomain,
|
|
routeMatchesPort,
|
|
routeMatchesPath,
|
|
routeMatchesHeaders,
|
|
mergeRouteConfigs,
|
|
generateRouteId,
|
|
cloneRoute
|
|
} from '../ts/proxies/smart-proxy/utils/route-utils.js';
|
|
|
|
import {
|
|
validateRouteConfig,
|
|
validateRoutes,
|
|
isValidDomain,
|
|
isValidPort,
|
|
hasRequiredPropertiesForAction,
|
|
assertValidRoute
|
|
} from '../ts/proxies/smart-proxy/utils/route-validator.js';
|
|
|
|
import { SocketHandlers } from '../ts/proxies/smart-proxy/utils/socket-handlers.js';
|
|
|
|
// Import test helpers
|
|
import { loadTestCertificates } from './helpers/certificates.js';
|
|
|
|
import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
|
|
|
|
// --------------------------------- Route Creation Tests ---------------------------------
|
|
|
|
tap.test('Routes: Should create basic HTTP route', async () => {
|
|
const httpRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'localhost', port: 3000 }] },
|
|
name: 'Basic HTTP Route'
|
|
};
|
|
|
|
expect(httpRoute.match.ports).toEqual(80);
|
|
expect(httpRoute.match.domains).toEqual('example.com');
|
|
expect(httpRoute.action.type).toEqual('forward');
|
|
expect(httpRoute.action.targets?.[0]?.host).toEqual('localhost');
|
|
expect(httpRoute.action.targets?.[0]?.port).toEqual(3000);
|
|
expect(httpRoute.name).toEqual('Basic HTTP Route');
|
|
});
|
|
|
|
tap.test('Routes: Should create HTTPS route with TLS termination', async () => {
|
|
const httpsRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'secure.example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'localhost', port: 8080 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
name: 'HTTPS Route'
|
|
};
|
|
|
|
expect(httpsRoute.match.ports).toEqual(443);
|
|
expect(httpsRoute.match.domains).toEqual('secure.example.com');
|
|
expect(httpsRoute.action.type).toEqual('forward');
|
|
expect(httpsRoute.action.tls?.mode).toEqual('terminate');
|
|
expect(httpsRoute.action.tls?.certificate).toEqual('auto');
|
|
expect(httpsRoute.action.targets?.[0]?.host).toEqual('localhost');
|
|
expect(httpsRoute.action.targets?.[0]?.port).toEqual(8080);
|
|
expect(httpsRoute.name).toEqual('HTTPS Route');
|
|
});
|
|
|
|
tap.test('Routes: Should create HTTP to HTTPS redirect', async () => {
|
|
const redirectRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: {
|
|
type: 'socket-handler',
|
|
socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
|
|
},
|
|
name: 'HTTP to HTTPS Redirect for example.com'
|
|
};
|
|
|
|
expect(redirectRoute.match.ports).toEqual(80);
|
|
expect(redirectRoute.match.domains).toEqual('example.com');
|
|
expect(redirectRoute.action.type).toEqual('socket-handler');
|
|
expect(redirectRoute.action.socketHandler).toBeDefined();
|
|
});
|
|
|
|
tap.test('Routes: Should create complete HTTPS server with redirects', async () => {
|
|
const routes: IRouteConfig[] = [
|
|
{
|
|
match: { ports: 443, domains: 'example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'localhost', port: 8080 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
name: 'HTTPS Terminate Route for example.com'
|
|
},
|
|
{
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: {
|
|
type: 'socket-handler',
|
|
socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
|
|
},
|
|
name: 'HTTP to HTTPS Redirect for example.com'
|
|
}
|
|
];
|
|
|
|
expect(routes.length).toEqual(2);
|
|
|
|
const httpsRoute = routes[0];
|
|
expect(httpsRoute.match.ports).toEqual(443);
|
|
expect(httpsRoute.match.domains).toEqual('example.com');
|
|
expect(httpsRoute.action.type).toEqual('forward');
|
|
expect(httpsRoute.action.tls?.mode).toEqual('terminate');
|
|
|
|
const redirectRoute = routes[1];
|
|
expect(redirectRoute.match.ports).toEqual(80);
|
|
expect(redirectRoute.action.type).toEqual('socket-handler');
|
|
expect(redirectRoute.action.socketHandler).toBeDefined();
|
|
});
|
|
|
|
tap.test('Routes: Should create load balancer route', async () => {
|
|
const lbRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'app.example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: ['10.0.0.1', '10.0.0.2', '10.0.0.3'], port: 8080 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' },
|
|
loadBalancing: { algorithm: 'round-robin' }
|
|
},
|
|
name: 'Load Balanced Route'
|
|
};
|
|
|
|
expect(lbRoute.match.domains).toEqual('app.example.com');
|
|
expect(lbRoute.action.type).toEqual('forward');
|
|
expect(Array.isArray(lbRoute.action.targets?.[0]?.host)).toBeTrue();
|
|
expect((lbRoute.action.targets?.[0]?.host as string[]).length).toEqual(3);
|
|
expect((lbRoute.action.targets?.[0]?.host as string[])[0]).toEqual('10.0.0.1');
|
|
expect(lbRoute.action.targets?.[0]?.port).toEqual(8080);
|
|
expect(lbRoute.action.tls?.mode).toEqual('terminate');
|
|
});
|
|
|
|
tap.test('Routes: Should create API route with CORS', async () => {
|
|
const apiRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'api.example.com', path: '/v1/*' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'localhost', port: 3000 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
headers: {
|
|
response: {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
|
|
'Access-Control-Allow-Headers': 'Content-Type, Authorization',
|
|
'Access-Control-Max-Age': '86400'
|
|
}
|
|
},
|
|
priority: 100,
|
|
name: 'API Route'
|
|
};
|
|
|
|
expect(apiRoute.match.domains).toEqual('api.example.com');
|
|
expect(apiRoute.match.path).toEqual('/v1/*');
|
|
expect(apiRoute.action.type).toEqual('forward');
|
|
expect(apiRoute.action.tls?.mode).toEqual('terminate');
|
|
expect(apiRoute.action.targets?.[0]?.host).toEqual('localhost');
|
|
expect(apiRoute.action.targets?.[0]?.port).toEqual(3000);
|
|
|
|
expect(apiRoute.headers).toBeDefined();
|
|
if (apiRoute.headers?.response) {
|
|
expect(apiRoute.headers.response['Access-Control-Allow-Origin']).toEqual('*');
|
|
expect(apiRoute.headers.response['Access-Control-Allow-Methods']).toInclude('GET');
|
|
}
|
|
});
|
|
|
|
tap.test('Routes: Should create WebSocket route', async () => {
|
|
const wsRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'ws.example.com', path: '/socket' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'localhost', port: 5000 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' },
|
|
websocket: { enabled: true, pingInterval: 15000 }
|
|
},
|
|
priority: 100,
|
|
name: 'WebSocket Route'
|
|
};
|
|
|
|
expect(wsRoute.match.domains).toEqual('ws.example.com');
|
|
expect(wsRoute.match.path).toEqual('/socket');
|
|
expect(wsRoute.action.type).toEqual('forward');
|
|
expect(wsRoute.action.tls?.mode).toEqual('terminate');
|
|
expect(wsRoute.action.targets?.[0]?.host).toEqual('localhost');
|
|
expect(wsRoute.action.targets?.[0]?.port).toEqual(5000);
|
|
|
|
expect(wsRoute.action.websocket).toBeDefined();
|
|
if (wsRoute.action.websocket) {
|
|
expect(wsRoute.action.websocket.enabled).toBeTrue();
|
|
expect(wsRoute.action.websocket.pingInterval).toEqual(15000);
|
|
}
|
|
});
|
|
|
|
// Static file serving has been removed - should be handled by external servers
|
|
|
|
tap.test('SmartProxy: Should create instance with route-based config', async () => {
|
|
const certs = loadTestCertificates();
|
|
|
|
const proxy = new SmartProxy({
|
|
routes: [
|
|
{
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'localhost', port: 3000 }] },
|
|
name: 'HTTP Route'
|
|
},
|
|
{
|
|
match: { ports: 443, domains: 'secure.example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'localhost', port: 8443 }],
|
|
tls: {
|
|
mode: 'terminate',
|
|
certificate: { key: certs.privateKey, cert: certs.publicKey }
|
|
}
|
|
},
|
|
name: 'HTTPS Route'
|
|
}
|
|
],
|
|
defaults: {
|
|
target: {
|
|
host: 'localhost',
|
|
port: 8080
|
|
},
|
|
security: {
|
|
ipAllowList: ['127.0.0.1', '192.168.0.*'],
|
|
maxConnections: 100
|
|
}
|
|
},
|
|
initialDataTimeout: 10000,
|
|
inactivityTimeout: 300000,
|
|
enableDetailedLogging: true
|
|
});
|
|
|
|
expect(typeof proxy).toEqual('object');
|
|
expect(typeof proxy.start).toEqual('function');
|
|
expect(typeof proxy.stop).toEqual('function');
|
|
});
|
|
|
|
// --------------------------------- Edge Case Tests ---------------------------------
|
|
|
|
tap.test('Edge Case - Empty Routes Array', async () => {
|
|
const emptyRoutes: IRouteConfig[] = [];
|
|
const matches = findMatchingRoutes(emptyRoutes, { domain: 'example.com', port: 80 });
|
|
|
|
expect(matches).toBeInstanceOf(Array);
|
|
expect(matches.length).toEqual(0);
|
|
|
|
const bestMatch = findBestMatchingRoute(emptyRoutes, { domain: 'example.com', port: 80 });
|
|
expect(bestMatch).toBeUndefined();
|
|
});
|
|
|
|
tap.test('Edge Case - Multiple Matching Routes with Same Priority', async () => {
|
|
const route1: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server1', port: 3000 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
const route2: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server2', port: 3000 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
const route3: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server3', port: 3000 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
|
|
route1.priority = 100;
|
|
route2.priority = 100;
|
|
route3.priority = 100;
|
|
|
|
const routes = [route1, route2, route3];
|
|
|
|
const matches = findMatchingRoutes(routes, { domain: 'example.com', port: 80 });
|
|
|
|
expect(matches.length).toEqual(3);
|
|
|
|
const bestMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 80 });
|
|
expect(bestMatch).not.toBeUndefined();
|
|
});
|
|
|
|
tap.test('Edge Case - Wildcard Domains and Path Matching', async () => {
|
|
const wildcardApiRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: '*.example.com', path: '/api/*' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'api-server', port: 3000 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
priority: 100,
|
|
name: 'API Route for *.example.com'
|
|
};
|
|
|
|
const exactApiRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'api.example.com', path: '/api/*' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'specific-api-server', port: 3001 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
priority: 200,
|
|
name: 'API Route for api.example.com'
|
|
};
|
|
|
|
const routes = [wildcardApiRoute, exactApiRoute];
|
|
|
|
const matches = findMatchingRoutes(routes, { domain: 'api.example.com', path: '/api/users', port: 443 });
|
|
|
|
expect(matches.length).toEqual(2);
|
|
|
|
const bestMatch = findBestMatchingRoute(routes, { domain: 'api.example.com', path: '/api/users', port: 443 });
|
|
expect(bestMatch).not.toBeUndefined();
|
|
if (bestMatch) {
|
|
expect(bestMatch.action.targets[0].port).toEqual(3001);
|
|
}
|
|
|
|
const otherMatches = findMatchingRoutes(routes, { domain: 'other.example.com', path: '/api/products', port: 443 });
|
|
expect(otherMatches.length).toEqual(1);
|
|
expect(otherMatches[0].action.targets[0].port).toEqual(3000);
|
|
});
|
|
|
|
tap.test('Edge Case - Disabled Routes', async () => {
|
|
const enabledRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server1', port: 3000 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
const disabledRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server2', port: 3001 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
disabledRoute.enabled = false;
|
|
|
|
const routes = [enabledRoute, disabledRoute];
|
|
|
|
const matches = findMatchingRoutes(routes, { domain: 'example.com', port: 80 });
|
|
|
|
expect(matches.length).toEqual(1);
|
|
expect(matches[0].action.targets[0].port).toEqual(3000);
|
|
});
|
|
|
|
tap.test('Edge Case - Complex Path and Headers Matching', async () => {
|
|
const complexRoute: IRouteConfig = {
|
|
match: {
|
|
domains: 'api.example.com',
|
|
ports: 443,
|
|
path: '/api/v2/*',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': 'valid-key'
|
|
}
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{
|
|
host: 'internal-api',
|
|
port: 8080
|
|
}],
|
|
tls: {
|
|
mode: 'terminate',
|
|
certificate: 'auto'
|
|
}
|
|
},
|
|
name: 'Complex API Route'
|
|
};
|
|
|
|
const matchingPath = routeMatchesPath(complexRoute, '/api/v2/users');
|
|
expect(matchingPath).toBeTrue();
|
|
|
|
const matchingHeaders = routeMatchesHeaders(complexRoute, {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': 'valid-key',
|
|
'Accept': 'application/json'
|
|
});
|
|
expect(matchingHeaders).toBeTrue();
|
|
|
|
const nonMatchingPath = routeMatchesPath(complexRoute, '/api/v1/users');
|
|
expect(nonMatchingPath).toBeFalse();
|
|
|
|
const nonMatchingHeaders = routeMatchesHeaders(complexRoute, {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': 'invalid-key'
|
|
});
|
|
expect(nonMatchingHeaders).toBeFalse();
|
|
});
|
|
|
|
tap.test('Edge Case - Port Range Matching', async () => {
|
|
const portRangeRoute: IRouteConfig = {
|
|
match: {
|
|
domains: 'example.com',
|
|
ports: [{ from: 8000, to: 9000 }]
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{
|
|
host: 'backend',
|
|
port: 3000
|
|
}]
|
|
},
|
|
name: 'Port Range Route'
|
|
};
|
|
|
|
expect(routeMatchesPort(portRangeRoute, 8000)).toBeTrue();
|
|
expect(routeMatchesPort(portRangeRoute, 8500)).toBeTrue();
|
|
expect(routeMatchesPort(portRangeRoute, 9000)).toBeTrue();
|
|
|
|
expect(routeMatchesPort(portRangeRoute, 7999)).toBeFalse();
|
|
expect(routeMatchesPort(portRangeRoute, 9001)).toBeFalse();
|
|
|
|
const multiRangeRoute: IRouteConfig = {
|
|
match: {
|
|
domains: 'example.com',
|
|
ports: [
|
|
{ from: 80, to: 90 },
|
|
{ from: 8000, to: 9000 }
|
|
]
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{
|
|
host: 'backend',
|
|
port: 3000
|
|
}]
|
|
},
|
|
name: 'Multi Range Route'
|
|
};
|
|
|
|
expect(routeMatchesPort(multiRangeRoute, 85)).toBeTrue();
|
|
expect(routeMatchesPort(multiRangeRoute, 8500)).toBeTrue();
|
|
expect(routeMatchesPort(multiRangeRoute, 100)).toBeFalse();
|
|
});
|
|
|
|
// --------------------------------- Wildcard Domain Tests ---------------------------------
|
|
|
|
tap.test('Wildcard Domain Handling', async () => {
|
|
const simpleDomainRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server1', port: 3000 }] },
|
|
name: 'HTTP Route for example.com'
|
|
};
|
|
const wildcardSubdomainRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: '*.example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server2', port: 3001 }] },
|
|
name: 'HTTP Route for *.example.com'
|
|
};
|
|
const specificSubdomainRoute: IRouteConfig = {
|
|
match: { ports: 80, domains: 'api.example.com' },
|
|
action: { type: 'forward', targets: [{ host: 'server3', port: 3002 }] },
|
|
name: 'HTTP Route for api.example.com'
|
|
};
|
|
|
|
specificSubdomainRoute.priority = 200;
|
|
wildcardSubdomainRoute.priority = 100;
|
|
simpleDomainRoute.priority = 50;
|
|
|
|
const routes = [simpleDomainRoute, wildcardSubdomainRoute, specificSubdomainRoute];
|
|
|
|
expect(routeMatchesDomain(simpleDomainRoute, 'example.com')).toBeTrue();
|
|
expect(routeMatchesDomain(simpleDomainRoute, 'sub.example.com')).toBeFalse();
|
|
|
|
expect(routeMatchesDomain(wildcardSubdomainRoute, 'any.example.com')).toBeTrue();
|
|
expect(routeMatchesDomain(wildcardSubdomainRoute, 'nested.sub.example.com')).toBeTrue();
|
|
expect(routeMatchesDomain(wildcardSubdomainRoute, 'example.com')).toBeFalse();
|
|
|
|
expect(routeMatchesDomain(specificSubdomainRoute, 'api.example.com')).toBeTrue();
|
|
expect(routeMatchesDomain(specificSubdomainRoute, 'other.example.com')).toBeFalse();
|
|
expect(routeMatchesDomain(specificSubdomainRoute, 'sub.api.example.com')).toBeFalse();
|
|
|
|
const specificSubdomainRequest = { domain: 'api.example.com', port: 80 };
|
|
const bestSpecificMatch = findBestMatchingRoute(routes, specificSubdomainRequest);
|
|
expect(bestSpecificMatch).not.toBeUndefined();
|
|
if (bestSpecificMatch) {
|
|
const matchedPort = bestSpecificMatch.action.targets[0].port;
|
|
console.log(`Matched route with port: ${matchedPort}`);
|
|
|
|
expect(bestSpecificMatch.priority).toEqual(200);
|
|
}
|
|
|
|
const otherSubdomainRequest = { domain: 'other.example.com', port: 80 };
|
|
const bestWildcardMatch = findBestMatchingRoute(routes, otherSubdomainRequest);
|
|
expect(bestWildcardMatch).not.toBeUndefined();
|
|
if (bestWildcardMatch) {
|
|
const matchedPort = bestWildcardMatch.action.targets[0].port;
|
|
console.log(`Matched route with port: ${matchedPort}`);
|
|
|
|
expect(bestWildcardMatch.priority).toEqual(100);
|
|
}
|
|
});
|
|
|
|
// --------------------------------- Integration Tests ---------------------------------
|
|
|
|
tap.test('Route Integration - Combining Multiple Route Types', async () => {
|
|
const routes: IRouteConfig[] = [
|
|
{
|
|
match: { ports: 443, domains: 'example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'web-server', port: 8080 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
name: 'HTTPS Terminate Route for example.com'
|
|
},
|
|
{
|
|
match: { ports: 80, domains: 'example.com' },
|
|
action: {
|
|
type: 'socket-handler',
|
|
socketHandler: SocketHandlers.httpRedirect('https://{domain}:443{path}', 301)
|
|
},
|
|
name: 'HTTP to HTTPS Redirect for example.com'
|
|
},
|
|
{
|
|
match: { ports: 443, domains: 'api.example.com', path: '/v1/*' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'api-server', port: 3000 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' }
|
|
},
|
|
headers: {
|
|
response: {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
|
|
'Access-Control-Allow-Headers': 'Content-Type, Authorization',
|
|
'Access-Control-Max-Age': '86400'
|
|
}
|
|
},
|
|
priority: 100,
|
|
name: 'API Route for api.example.com'
|
|
},
|
|
{
|
|
match: { ports: 443, domains: 'ws.example.com', path: '/live' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'websocket-server', port: 5000 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' },
|
|
websocket: { enabled: true }
|
|
},
|
|
priority: 100,
|
|
name: 'WebSocket Route for ws.example.com'
|
|
},
|
|
{
|
|
match: { ports: 443, domains: 'legacy.example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'legacy-server', port: 443 }],
|
|
tls: { mode: 'passthrough' }
|
|
},
|
|
name: 'HTTPS Passthrough Route for legacy.example.com'
|
|
}
|
|
];
|
|
|
|
const validationResult = validateRoutes(routes);
|
|
expect(validationResult.valid).toBeTrue();
|
|
expect(validationResult.errors.length).toEqual(0);
|
|
|
|
const webServerMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 443 });
|
|
expect(webServerMatch).not.toBeUndefined();
|
|
if (webServerMatch) {
|
|
expect(webServerMatch.action.type).toEqual('forward');
|
|
expect(webServerMatch.action.targets[0].host).toEqual('web-server');
|
|
}
|
|
|
|
const webRedirectMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 80 });
|
|
expect(webRedirectMatch).not.toBeUndefined();
|
|
if (webRedirectMatch) {
|
|
expect(webRedirectMatch.action.type).toEqual('socket-handler');
|
|
}
|
|
|
|
const apiMatch = findBestMatchingRoute(routes, {
|
|
domain: 'api.example.com',
|
|
port: 443,
|
|
path: '/v1/users'
|
|
});
|
|
expect(apiMatch).not.toBeUndefined();
|
|
if (apiMatch) {
|
|
expect(apiMatch.action.type).toEqual('forward');
|
|
expect(apiMatch.action.targets[0].host).toEqual('api-server');
|
|
}
|
|
|
|
const wsMatch = findBestMatchingRoute(routes, {
|
|
domain: 'ws.example.com',
|
|
port: 443,
|
|
path: '/live'
|
|
});
|
|
expect(wsMatch).not.toBeUndefined();
|
|
if (wsMatch) {
|
|
expect(wsMatch.action.type).toEqual('forward');
|
|
expect(wsMatch.action.targets[0].host).toEqual('websocket-server');
|
|
expect(wsMatch.action.websocket?.enabled).toBeTrue();
|
|
}
|
|
|
|
const legacyMatch = findBestMatchingRoute(routes, {
|
|
domain: 'legacy.example.com',
|
|
port: 443
|
|
});
|
|
expect(legacyMatch).not.toBeUndefined();
|
|
if (legacyMatch) {
|
|
expect(legacyMatch.action.type).toEqual('forward');
|
|
expect(legacyMatch.action.tls?.mode).toEqual('passthrough');
|
|
}
|
|
});
|
|
|
|
// --------------------------------- Protocol Match Field Tests ---------------------------------
|
|
|
|
tap.test('Routes: Should accept protocol field on route match', async () => {
|
|
const httpOnlyRoute: IRouteConfig = {
|
|
match: {
|
|
ports: 443,
|
|
domains: 'api.example.com',
|
|
protocol: 'http',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'backend', port: 8080 }],
|
|
tls: {
|
|
mode: 'terminate',
|
|
certificate: 'auto',
|
|
},
|
|
},
|
|
name: 'HTTP-only Route',
|
|
};
|
|
|
|
const validation = validateRouteConfig(httpOnlyRoute);
|
|
expect(validation.valid).toBeTrue();
|
|
|
|
expect(httpOnlyRoute.match.protocol).toEqual('http');
|
|
});
|
|
|
|
tap.test('Routes: Should accept protocol tcp on route match', async () => {
|
|
const tcpOnlyRoute: IRouteConfig = {
|
|
match: {
|
|
ports: 443,
|
|
domains: 'db.example.com',
|
|
protocol: 'tcp',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'db-server', port: 5432 }],
|
|
tls: {
|
|
mode: 'passthrough',
|
|
},
|
|
},
|
|
name: 'TCP-only Route',
|
|
};
|
|
|
|
const validation = validateRouteConfig(tcpOnlyRoute);
|
|
expect(validation.valid).toBeTrue();
|
|
|
|
expect(tcpOnlyRoute.match.protocol).toEqual('tcp');
|
|
});
|
|
|
|
tap.test('Routes: Protocol field should work with terminate-and-reencrypt', async () => {
|
|
const reencryptRoute: IRouteConfig = {
|
|
match: { ports: 443, domains: 'secure.example.com' },
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'backend', port: 443 }],
|
|
tls: { mode: 'terminate-and-reencrypt', certificate: 'auto' }
|
|
},
|
|
name: 'Reencrypt HTTP Route'
|
|
};
|
|
|
|
reencryptRoute.match.protocol = 'http';
|
|
|
|
const validation = validateRouteConfig(reencryptRoute);
|
|
expect(validation.valid).toBeTrue();
|
|
|
|
expect(reencryptRoute.action.tls?.mode).toEqual('terminate-and-reencrypt');
|
|
expect(reencryptRoute.match.protocol).toEqual('http');
|
|
});
|
|
|
|
tap.test('Routes: Protocol field should not affect domain/port matching', async () => {
|
|
const routeWithProtocol: IRouteConfig = {
|
|
match: {
|
|
ports: 443,
|
|
domains: 'example.com',
|
|
protocol: 'http',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'backend', port: 8080 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' },
|
|
},
|
|
name: 'With Protocol',
|
|
priority: 10,
|
|
};
|
|
|
|
const routeWithoutProtocol: IRouteConfig = {
|
|
match: {
|
|
ports: 443,
|
|
domains: 'example.com',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'fallback', port: 8081 }],
|
|
tls: { mode: 'terminate', certificate: 'auto' },
|
|
},
|
|
name: 'Without Protocol',
|
|
priority: 5,
|
|
};
|
|
|
|
const routes = [routeWithProtocol, routeWithoutProtocol];
|
|
|
|
const matches = findMatchingRoutes(routes, { domain: 'example.com', port: 443 });
|
|
expect(matches.length).toEqual(2);
|
|
|
|
const best = findBestMatchingRoute(routes, { domain: 'example.com', port: 443 });
|
|
expect(best).not.toBeUndefined();
|
|
expect(best!.name).toEqual('With Protocol');
|
|
});
|
|
|
|
tap.test('Routes: Protocol field preserved through route cloning', async () => {
|
|
const original: IRouteConfig = {
|
|
match: {
|
|
ports: 8443,
|
|
domains: 'clone-test.example.com',
|
|
protocol: 'http',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'backend', port: 3000 }],
|
|
tls: { mode: 'terminate-and-reencrypt', certificate: 'auto' },
|
|
},
|
|
name: 'Clone Test',
|
|
};
|
|
|
|
const cloned = cloneRoute(original);
|
|
|
|
expect(cloned.match.protocol).toEqual('http');
|
|
expect(cloned.action.tls?.mode).toEqual('terminate-and-reencrypt');
|
|
|
|
cloned.match.protocol = 'tcp';
|
|
expect(original.match.protocol).toEqual('http');
|
|
});
|
|
|
|
tap.test('Routes: Protocol field preserved through route merging', async () => {
|
|
const base: IRouteConfig = {
|
|
match: {
|
|
ports: 443,
|
|
domains: 'merge-test.example.com',
|
|
protocol: 'http',
|
|
},
|
|
action: {
|
|
type: 'forward',
|
|
targets: [{ host: 'backend', port: 3000 }],
|
|
tls: { mode: 'terminate-and-reencrypt', certificate: 'auto' },
|
|
},
|
|
name: 'Merge Base',
|
|
};
|
|
|
|
const merged = mergeRouteConfigs(base, { name: 'Merged Route' });
|
|
expect(merged.match.protocol).toEqual('http');
|
|
expect(merged.name).toEqual('Merged Route');
|
|
});
|
|
|
|
export default tap.start();
|