mirror of
https://github.com/jambonz/jambonz-feature-server.git
synced 2026-07-04 19:32:01 +00:00
add retry for http/ws requestor (#1210)
* add retry for http requestor * fix failing testcase * wip * update ws-requestor * wip * wip * wip
This commit is contained in:
Hoan Luu Huu
@@ -0,0 +1,151 @@
|
||||
// Test for HttpRequestor retry functionality
|
||||
const test = require('tape');
|
||||
const sinon = require('sinon');
|
||||
const proxyquire = require('proxyquire').noCallThru();
|
||||
const { createMocks, setupBaseRequestorMocks } = require('./utils/mock-helper');
|
||||
|
||||
// Create mocks
|
||||
const mocks = createMocks();
|
||||
|
||||
// Mock timeSeries module
|
||||
const timeSeriesMock = sinon.stub().returns(mocks.MockAlerter);
|
||||
|
||||
// Mock the config with required properties
|
||||
const configMock = {
|
||||
HTTP_POOL: '0',
|
||||
HTTP_POOLSIZE: '10',
|
||||
HTTP_PIPELINING: '1',
|
||||
HTTP_TIMEOUT: 5000,
|
||||
HTTP_PROXY_IP: null,
|
||||
HTTP_PROXY_PORT: null,
|
||||
HTTP_PROXY_PROTOCOL: null,
|
||||
NODE_ENV: 'test',
|
||||
HTTP_USER_AGENT_HEADER: 'test-agent'
|
||||
};
|
||||
|
||||
// Mock db-helpers
|
||||
const dbHelpersMock = mocks.MockDbHelpers;
|
||||
|
||||
// Require HttpRequestor with mocked dependencies
|
||||
const BaseRequestor = proxyquire('../lib/utils/base-requestor', {
|
||||
'@jambonz/time-series': timeSeriesMock,
|
||||
'../config': configMock,
|
||||
'../../': { srf: { locals: { stats: mocks.MockStats } } }
|
||||
});
|
||||
|
||||
// Setup BaseRequestor mocks
|
||||
setupBaseRequestorMocks(BaseRequestor);
|
||||
|
||||
// Require HttpRequestor with mocked dependencies
|
||||
const HttpRequestor = proxyquire('../lib/utils/http-requestor', {
|
||||
'./base-requestor': BaseRequestor,
|
||||
'../config': configMock,
|
||||
'@jambonz/db-helpers': dbHelpersMock
|
||||
});
|
||||
|
||||
// Setup utility function
|
||||
const setupRequestor = () => {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const requestor = new HttpRequestor(mocks.MockLogger, 'AC123', hook, 'testsecret');
|
||||
requestor.stats = mocks.MockStats;
|
||||
return requestor;
|
||||
};
|
||||
|
||||
// Cleanup function for tests
|
||||
const cleanup = (requestor) => {
|
||||
sinon.restore();
|
||||
if (requestor && requestor.close) requestor.close();
|
||||
};
|
||||
|
||||
test('HttpRequestor: should retry on connection errors when specified in hash', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
|
||||
// Setup a URL with retry params in the hash
|
||||
const urlWithRetry = 'http://localhost/test#rc=3&rp=ct,5xx';
|
||||
|
||||
// First two calls fail with connection refused, third succeeds
|
||||
const requestStub = sinon.stub(requestor.client, 'request');
|
||||
const error = new Error('Connection refused');
|
||||
error.code = 'ECONNREFUSED';
|
||||
|
||||
// Fail twice, succeed on third try
|
||||
requestStub.onCall(0).rejects(error);
|
||||
requestStub.onCall(1).rejects(error);
|
||||
requestStub.onCall(2).resolves({
|
||||
statusCode: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: { json: async () => ({ success: true }) }
|
||||
});
|
||||
|
||||
try {
|
||||
const hook = { url: urlWithRetry, method: 'GET' };
|
||||
const result = await requestor.request('verb:hook', hook, null);
|
||||
|
||||
t.equal(requestStub.callCount, 3, 'Should have retried twice for a total of 3 calls');
|
||||
t.deepEqual(result, { success: true }, 'Should return successful response');
|
||||
} catch (err) {
|
||||
t.fail(`Should not throw an error: ${err.message}`);
|
||||
}
|
||||
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: should respect retry count (rc) from hash', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
|
||||
// Setup a URL with retry params in the hash - only retry once
|
||||
const urlWithRetry = 'http://localhost/test#rc=1&rp=ct';
|
||||
|
||||
// All calls fail with connection refused
|
||||
const requestStub = sinon.stub(requestor.client, 'request');
|
||||
const error = new Error('Connection refused');
|
||||
error.code = 'ECONNREFUSED';
|
||||
|
||||
// Always fail
|
||||
requestStub.rejects(error);
|
||||
|
||||
try {
|
||||
const hook = { url: urlWithRetry, method: 'GET' };
|
||||
await requestor.request('verb:hook', hook, null);
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
t.equal(requestStub.callCount, 2, 'Should have retried once for a total of 2 calls');
|
||||
t.equal(err.code, 'ECONNREFUSED', 'Should throw the original error');
|
||||
}
|
||||
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: should respect retry policy (rp) from hash', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
|
||||
// Setup a URL with retry params in hash - only retry on 5xx errors
|
||||
const urlWithRetry = 'http://localhost/test#rc=2&rp=5xx';
|
||||
|
||||
// Fail with 404 (should not retry since rp=5xx)
|
||||
const requestStub = sinon.stub(requestor.client, 'request');
|
||||
requestStub.resolves({
|
||||
statusCode: 404,
|
||||
headers: {},
|
||||
body: {}
|
||||
});
|
||||
|
||||
try {
|
||||
const hook = { url: urlWithRetry, method: 'GET' };
|
||||
await requestor.request('verb:hook', hook, null);
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
t.equal(requestStub.callCount, 1, 'Should not retry on 404 when rp=5xx');
|
||||
t.equal(err.statusCode, 404, 'Should throw 404 error');
|
||||
}
|
||||
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
module.exports = {
|
||||
setupRequestor,
|
||||
cleanup
|
||||
};
|
||||
@@ -0,0 +1,214 @@
|
||||
const test = require('tape');
|
||||
const sinon = require('sinon');
|
||||
const { createMockedRequestors } = require('./utils/test-mocks');
|
||||
|
||||
// Use the shared mocks and helpers
|
||||
const {
|
||||
HttpRequestor,
|
||||
setupRequestor,
|
||||
cleanup
|
||||
} = createMockedRequestors();
|
||||
|
||||
// All prototype overrides and setup are now handled in test-mocks.js
|
||||
|
||||
// --- TESTS ---
|
||||
test('HttpRequestor: constructor sets up properties correctly', (t) => {
|
||||
const requestor = setupRequestor();
|
||||
t.equal(requestor.method, 'POST', 'method should be POST');
|
||||
t.equal(requestor.url, 'http://localhost/test', 'url should be set');
|
||||
t.equal(typeof requestor.client, 'object', 'client should be an object');
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: constructor with username/password sets auth header', (t) => {
|
||||
const { mocks, HttpRequestor } = createMockedRequestors();
|
||||
const logger = mocks.logger;
|
||||
const hook = {
|
||||
url: 'http://localhost/test',
|
||||
method: 'POST',
|
||||
username: 'user',
|
||||
password: 'pass'
|
||||
};
|
||||
const requestor = new HttpRequestor(logger, 'AC123', hook, 'secret');
|
||||
t.ok(requestor.authHeader.Authorization, 'Authorization header should be set');
|
||||
t.ok(requestor.authHeader.Authorization.startsWith('Basic '), 'Should be Basic auth');
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should return JSON on 200 response', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
const expectedResponse = { success: true, data: [1, 2, 3] };
|
||||
const fakeBody = { json: async () => expectedResponse };
|
||||
sinon.stub(requestor.client, 'request').resolves({
|
||||
statusCode: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: fakeBody
|
||||
});
|
||||
try {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const result = await requestor.request('verb:hook', hook, { foo: 'bar' });
|
||||
t.deepEqual(result, expectedResponse, 'Should return parsed JSON');
|
||||
const requestCall = requestor.client.request.getCall(0);
|
||||
const opts = requestCall.args[0];
|
||||
t.equal(opts.method, 'POST', 'method should be POST');
|
||||
t.ok(opts.headers['X-Signature'], 'Should include signature header');
|
||||
t.ok(opts.body, 'Should include request body');
|
||||
} catch (err) {
|
||||
t.fail(err);
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should handle non-200 responses', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
sinon.stub(requestor.client, 'request').resolves({
|
||||
statusCode: 404,
|
||||
headers: {},
|
||||
body: {}
|
||||
});
|
||||
try {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
await requestor.request('verb:hook', hook, { foo: 'bar' });
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
t.ok(err, 'Should throw an error');
|
||||
t.equal(err.statusCode, 404, 'Error should contain status code');
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should handle ECONNREFUSED error', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
const error = new Error('Connection refused');
|
||||
error.code = 'ECONNREFUSED';
|
||||
sinon.stub(requestor.client, 'request').rejects(error);
|
||||
try {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
await requestor.request('verb:hook', hook, { foo: 'bar' });
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
t.equal(err.code, 'ECONNREFUSED', 'Should pass through the error');
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should skip jambonz:error type', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
const spy = sinon.spy(requestor.client, 'request');
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const result = await requestor.request('jambonz:error', hook, { foo: 'bar' });
|
||||
t.equal(result, undefined, 'Should return undefined');
|
||||
t.equal(spy.callCount, 0, 'Should not call request method');
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should handle array response', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
const fakeBody = { json: async () => [{ id: 1 }, { id: 2 }] };
|
||||
sinon.stub(requestor.client, 'request').resolves({
|
||||
statusCode: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: fakeBody
|
||||
});
|
||||
try {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const result = await requestor.request('verb:hook', hook, { foo: 'bar' });
|
||||
t.ok(Array.isArray(result), 'Should return an array');
|
||||
t.equal(result.length, 2, 'Array should have 2 items');
|
||||
} catch (err) {
|
||||
t.fail(err);
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should handle llm:tool-call type', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
const fakeBody = { json: async () => ({ result: 'tool output' }) };
|
||||
sinon.stub(requestor.client, 'request').resolves({
|
||||
statusCode: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: fakeBody
|
||||
});
|
||||
try {
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const result = await requestor.request('llm:tool-call', hook, { tool: 'test' });
|
||||
t.deepEqual(result, { result: 'tool output' }, 'Should return the parsed JSON');
|
||||
} catch (err) {
|
||||
t.fail(err);
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: close should close the client if not using pools', (t) => {
|
||||
// Ensure HTTP_POOL is set to false to disable pool usage
|
||||
const oldHttpPool = process.env.HTTP_POOL;
|
||||
process.env.HTTP_POOL = '0';
|
||||
|
||||
const requestor = setupRequestor();
|
||||
// Make sure _usePools is false
|
||||
requestor._usePools = false;
|
||||
|
||||
// Replace the client.close with a spy function
|
||||
const closeSpy = sinon.spy();
|
||||
requestor.client.close = closeSpy;
|
||||
|
||||
// Set client.closed to false to ensure the condition is met
|
||||
requestor.client.closed = false;
|
||||
|
||||
// Call close
|
||||
requestor.close();
|
||||
|
||||
// Check if the spy was called
|
||||
t.ok(closeSpy.calledOnce, 'Should call client.close');
|
||||
|
||||
// Restore HTTP_POOL
|
||||
process.env.HTTP_POOL = oldHttpPool;
|
||||
|
||||
// Don't call cleanup(requestor) as it would try to call client.close again
|
||||
sinon.restore();
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('HttpRequestor: request should handle URLs with fragments', async (t) => {
|
||||
const requestor = setupRequestor();
|
||||
// Use the same host/port as the base client to avoid creating a new client
|
||||
const urlWithFragment = 'http://localhost?param1=value1#rc=5&rp=4xx,5xx,ct';
|
||||
const expectedResponse = { status: 'success' };
|
||||
const fakeBody = { json: async () => expectedResponse };
|
||||
|
||||
// Stub the request method
|
||||
const requestStub = sinon.stub(requestor.client, 'request').callsFake((opts) => {
|
||||
return Promise.resolve({
|
||||
statusCode: 200,
|
||||
headers: { 'content-type': 'application/json' },
|
||||
body: fakeBody
|
||||
});
|
||||
});
|
||||
try {
|
||||
const hook = { url: urlWithFragment, method: 'GET' };
|
||||
const result = await requestor.request('verb:hook', hook, null);
|
||||
t.deepEqual(result, expectedResponse, 'Should return the parsed JSON response');
|
||||
const requestCall = requestStub.getCall(0);
|
||||
const opts = requestCall.args[0];
|
||||
t.ok(opts.query && opts.query.param1 === 'value1', 'Query parameters should be parsed');
|
||||
t.equal(opts.path, '/', 'Path should be extracted from URL');
|
||||
t.notOk(opts.query && opts.query.rc, 'Fragment should not be included in query parameters');
|
||||
} catch (err) {
|
||||
t.fail(err);
|
||||
}
|
||||
cleanup(requestor);
|
||||
t.end();
|
||||
});
|
||||
|
||||
// test('HttpRequestor: request should handle URLs with query parameters', async (t) => {
|
||||
// t.pass('Restored original require function');
|
||||
// t.end();
|
||||
// });
|
||||
@@ -1,4 +1,8 @@
|
||||
require('./ws-requestor-retry-unit-test');
|
||||
require('./test_ws_retry_comprehensive');
|
||||
require('./ws-requestor-unit-test');
|
||||
require('./http-requestor-retry-test');
|
||||
require('./http-requestor-unit-test');
|
||||
require('./unit-tests');
|
||||
require('./docker_start');
|
||||
require('./create-test-db');
|
||||
|
||||
@@ -0,0 +1,436 @@
|
||||
const test = require('tape');
|
||||
const sinon = require('sinon');
|
||||
const proxyquire = require("proxyquire");
|
||||
proxyquire.noCallThru();
|
||||
|
||||
const {
|
||||
JAMBONES_LOGLEVEL,
|
||||
} = require('../lib/config');
|
||||
const logger = require('pino')({level: JAMBONES_LOGLEVEL});
|
||||
|
||||
// Mock WebSocket specifically for retry testing
|
||||
class RetryMockWebSocket {
|
||||
static retryScenarios = new Map();
|
||||
static connectionAttempts = new Map();
|
||||
static urlMapping = new Map(); // Maps cleanUrl -> originalUrl
|
||||
|
||||
constructor(url, protocols, options) {
|
||||
this.url = url;
|
||||
this.protocols = protocols;
|
||||
this.options = options;
|
||||
this.eventListeners = new Map();
|
||||
|
||||
// Extract scenario key from URL hash or use URL itself
|
||||
this.scenarioKey = this.extractScenarioKey(url);
|
||||
|
||||
// Track connection attempts for this scenario
|
||||
const attempts = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey) || 0;
|
||||
RetryMockWebSocket.connectionAttempts.set(this.scenarioKey, attempts + 1);
|
||||
|
||||
console.log(`RetryMockWebSocket: constructor for URL ${url}, scenarioKey="${this.scenarioKey}", attempt #${attempts + 1}`);
|
||||
|
||||
// Handle connection immediately
|
||||
setImmediate(() => {
|
||||
this.handleConnection();
|
||||
});
|
||||
}
|
||||
|
||||
extractScenarioKey(url) {
|
||||
console.log(`RetryMockWebSocket: extractScenarioKey from URL: ${url}`);
|
||||
|
||||
// Check if we have a mapping from cleanUrl to originalUrl
|
||||
const originalUrl = RetryMockWebSocket.urlMapping.get(url);
|
||||
if (originalUrl && originalUrl.includes('#')) {
|
||||
const hash = originalUrl.split('#')[1];
|
||||
console.log(`RetryMockWebSocket: found mapped URL with hash: ${hash}`);
|
||||
return hash;
|
||||
}
|
||||
|
||||
// For URLs with hash parameters, use the hash as the scenario key
|
||||
if (url.includes('#')) {
|
||||
const hash = url.split('#')[1];
|
||||
console.log(`RetryMockWebSocket: found hash: ${hash}`);
|
||||
return hash; // Use hash as scenario key
|
||||
}
|
||||
|
||||
console.log(`RetryMockWebSocket: using full URL as scenario key: ${url}`);
|
||||
return url; // Fallback to full URL
|
||||
}
|
||||
|
||||
static setRetryScenario(key, scenario) {
|
||||
console.log(`RetryMockWebSocket: setting scenario for key "${key}":`, scenario);
|
||||
RetryMockWebSocket.retryScenarios.set(key, scenario);
|
||||
}
|
||||
|
||||
static setUrlMapping(cleanUrl, originalUrl) {
|
||||
console.log(`RetryMockWebSocket: mapping ${cleanUrl} -> ${originalUrl}`);
|
||||
RetryMockWebSocket.urlMapping.set(cleanUrl, originalUrl);
|
||||
}
|
||||
|
||||
static clearScenarios() {
|
||||
console.log('RetryMockWebSocket: clearing all scenarios');
|
||||
RetryMockWebSocket.retryScenarios.clear();
|
||||
RetryMockWebSocket.connectionAttempts.clear();
|
||||
RetryMockWebSocket.urlMapping.clear();
|
||||
}
|
||||
|
||||
static getConnectionAttempts(key) {
|
||||
return RetryMockWebSocket.connectionAttempts.get(key) || 0;
|
||||
}
|
||||
|
||||
handleConnection() {
|
||||
const scenario = RetryMockWebSocket.retryScenarios.get(this.scenarioKey);
|
||||
console.log(`RetryMockWebSocket: handleConnection for scenarioKey="${this.scenarioKey}", scenario found:`, !!scenario);
|
||||
|
||||
if (!scenario) {
|
||||
// Default successful connection
|
||||
console.log(`RetryMockWebSocket: no scenario found, defaulting to success`);
|
||||
this.simulateOpen();
|
||||
return;
|
||||
}
|
||||
|
||||
const attemptNumber = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey);
|
||||
const behavior = scenario.attempts[attemptNumber - 1] || scenario.attempts[scenario.attempts.length - 1];
|
||||
|
||||
console.log(`RetryMockWebSocket: attempt ${attemptNumber}, behavior:`, behavior);
|
||||
|
||||
if (behavior.type === 'handshake-failure') {
|
||||
// Simulate handshake failure with specific status code
|
||||
setImmediate(() => {
|
||||
console.log(`RetryMockWebSocket: triggering handshake failure with status ${behavior.statusCode}`);
|
||||
if (this.eventListeners.has('unexpected-response')) {
|
||||
const mockResponse = {
|
||||
statusCode: behavior.statusCode || 500,
|
||||
statusMessage: behavior.statusMessage || 'Internal Server Error',
|
||||
headers: {}
|
||||
};
|
||||
const mockRequest = {
|
||||
headers: {}
|
||||
};
|
||||
this.eventListeners.get('unexpected-response')(mockRequest, mockResponse);
|
||||
}
|
||||
});
|
||||
} else if (behavior.type === 'network-error') {
|
||||
// Simulate network error during connection
|
||||
setImmediate(() => {
|
||||
console.log(`RetryMockWebSocket: triggering network error: ${behavior.message}`);
|
||||
if (this.eventListeners.has('error')) {
|
||||
const error = new Error(behavior.message || 'Network error');
|
||||
// Set proper error code for retry policy checking
|
||||
if (behavior.message && behavior.message.includes('Connection refused')) {
|
||||
error.code = 'ECONNREFUSED';
|
||||
} else if (behavior.message && behavior.message.includes('timeout')) {
|
||||
error.code = 'ETIMEDOUT';
|
||||
} else {
|
||||
error.code = 'ECONNREFUSED'; // Default for network errors
|
||||
}
|
||||
this.eventListeners.get('error')(error);
|
||||
}
|
||||
});
|
||||
} else if (behavior.type === 'success') {
|
||||
// Successful connection
|
||||
console.log(`RetryMockWebSocket: triggering success`);
|
||||
this.simulateOpen();
|
||||
}
|
||||
}
|
||||
|
||||
simulateOpen() {
|
||||
setImmediate(() => {
|
||||
if (this.eventListeners.has('open')) {
|
||||
console.log(`RetryMockWebSocket: calling open listener`);
|
||||
this.eventListeners.get('open')();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
once(event, listener) {
|
||||
console.log(`RetryMockWebSocket: registering once listener for ${event}`);
|
||||
this.eventListeners.set(event, listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
on(event, listener) {
|
||||
console.log(`RetryMockWebSocket: registering on listener for ${event}`);
|
||||
this.eventListeners.set(event, listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
removeAllListeners() {
|
||||
this.eventListeners.clear();
|
||||
}
|
||||
|
||||
send(data, callback) {
|
||||
// For successful connections, simulate message response
|
||||
try {
|
||||
const json = JSON.parse(data);
|
||||
console.log({json}, 'RetryMockWebSocket: got message from ws-requestor');
|
||||
|
||||
// Simulate successful response
|
||||
setTimeout(() => {
|
||||
const msg = {
|
||||
type: 'ack',
|
||||
msgid: json.msgid,
|
||||
command: 'command',
|
||||
call_sid: json.call_sid,
|
||||
queueCommand: false,
|
||||
data: '[{"verb": "play","url": "silence_stream://5000"}]'
|
||||
};
|
||||
console.log({msg}, 'RetryMockWebSocket: sending ack to ws-requestor');
|
||||
this.mockOnMessage(JSON.stringify(msg));
|
||||
}, 50);
|
||||
|
||||
if (callback) callback();
|
||||
} catch (err) {
|
||||
console.error('RetryMockWebSocket: Error processing send', err);
|
||||
if (callback) callback(err);
|
||||
}
|
||||
}
|
||||
|
||||
mockOnMessage(message, isBinary = false) {
|
||||
if (this.eventListeners.has('message')) {
|
||||
this.eventListeners.get('message')(message, isBinary);
|
||||
}
|
||||
}
|
||||
|
||||
close(code) {
|
||||
if (this.eventListeners.has('close')) {
|
||||
this.eventListeners.get('close')(code || 1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const BaseRequestor = proxyquire('../lib/utils/base-requestor', {
|
||||
'../../': {
|
||||
srf: {
|
||||
locals: {
|
||||
stats: {
|
||||
histogram: () => {},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
'@jambonz/time-series': sinon.stub(),
|
||||
});
|
||||
|
||||
const WsRequestor = proxyquire('../lib/utils/ws-requestor', {
|
||||
'./base-requestor': BaseRequestor,
|
||||
ws: RetryMockWebSocket,
|
||||
});
|
||||
|
||||
test('ws retry policy - 4xx error with rp=5xx should not retry', async(t) => {
|
||||
// GIVEN
|
||||
console.log('Starting test setup...');
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const call_sid = 'ws_no_retry_4xx';
|
||||
|
||||
// Set up the URL mapping
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
// Set up the retry scenario for the first attempt to fail with 400, but policy only retries 5xx
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' }
|
||||
]
|
||||
});
|
||||
|
||||
const hook = {
|
||||
url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
|
||||
username: 'username',
|
||||
password: 'password',
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: call_sid,
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(
|
||||
logger,
|
||||
'account_sid',
|
||||
hook,
|
||||
'webhook_secret'
|
||||
);
|
||||
try {
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error');
|
||||
t.end();
|
||||
} catch (err) {
|
||||
// THEN
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(
|
||||
errorMessage.includes('400'),
|
||||
`ws properly failed without retry for 4xx when rp=5xx - error: ${errorMessage}`
|
||||
);
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('ws retry policy - 5xx error with rp=5xx should retry and succeed', async(t) => {
|
||||
// GIVEN
|
||||
console.log('Starting 5xx retry test setup...');
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const call_sid = 'ws_retry_5xx_success';
|
||||
|
||||
// Set up the URL mapping
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
// Set up the retry scenario - first attempt fails with 500, second succeeds
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
});
|
||||
|
||||
const hook = {
|
||||
url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
|
||||
username: 'username',
|
||||
password: 'password',
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: call_sid,
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(
|
||||
logger,
|
||||
'account_sid',
|
||||
hook,
|
||||
'webhook_secret'
|
||||
);
|
||||
try {
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried and connected after 5xx error');
|
||||
|
||||
// Verify that exactly 2 attempts were made
|
||||
const attempts = RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx');
|
||||
t.equal(attempts, 2, 'Should have made exactly 2 connection attempts');
|
||||
|
||||
t.end();
|
||||
} catch (err) {
|
||||
t.fail(`Should have succeeded after retry - error: ${err.message}`);
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('ws retry policy - network error with rp=ct should retry and succeed', async(t) => {
|
||||
// GIVEN
|
||||
console.log('Starting network error retry test setup...');
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const call_sid = 'ws_retry_network_success';
|
||||
|
||||
// Set up the URL mapping
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
const originalUrl = 'ws://localhost:3000#rc=3&rp=ct';
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
// Set up the retry scenario - first two attempts fail with network error, third succeeds
|
||||
RetryMockWebSocket.setRetryScenario('rc=3&rp=ct', {
|
||||
attempts: [
|
||||
{ type: 'network-error', message: 'Connection refused' },
|
||||
{ type: 'network-error', message: 'Connection refused' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
});
|
||||
|
||||
const hook = {
|
||||
url: 'ws://localhost:3000#rc=3&rp=ct', // Max 3 retries, retry on connection errors
|
||||
username: 'username',
|
||||
password: 'password',
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: call_sid,
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(
|
||||
logger,
|
||||
'account_sid',
|
||||
hook,
|
||||
'webhook_secret'
|
||||
);
|
||||
try {
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried and connected after network errors');
|
||||
|
||||
// Verify that exactly 3 attempts were made
|
||||
const attempts = RetryMockWebSocket.getConnectionAttempts('rc=3&rp=ct');
|
||||
t.equal(attempts, 3, 'Should have made exactly 3 connection attempts');
|
||||
|
||||
t.end();
|
||||
} catch (err) {
|
||||
t.fail(`Should have succeeded after retry - error: ${err.message}`);
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('ws retry policy - retry exhaustion should fail with last error', async(t) => {
|
||||
// GIVEN
|
||||
console.log('Starting retry exhaustion test setup...');
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const call_sid = 'ws_retry_exhaustion';
|
||||
|
||||
// Set up the URL mapping
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
// Set up the retry scenario - all attempts fail with 500
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
|
||||
{ type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' },
|
||||
{ type: 'handshake-failure', statusCode: 500, statusMessage: 'Internal Server Error' }
|
||||
]
|
||||
});
|
||||
|
||||
const hook = {
|
||||
url: 'ws://localhost:3000#rc=2&rp=5xx', // Max 2 retries, retry only on 5xx
|
||||
username: 'username',
|
||||
password: 'password',
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: call_sid,
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(
|
||||
logger,
|
||||
'account_sid',
|
||||
hook,
|
||||
'webhook_secret'
|
||||
);
|
||||
try {
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error after exhausting retries');
|
||||
t.end();
|
||||
} catch (err) {
|
||||
// THEN
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(
|
||||
errorMessage.includes('500'),
|
||||
`ws properly failed after exhausting retries - error: ${errorMessage}`
|
||||
);
|
||||
|
||||
// Verify that exactly 3 attempts were made (initial + 2 retries)
|
||||
const attempts = RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx');
|
||||
t.equal(attempts, 3, 'Should have made exactly 3 connection attempts (initial + 2 retries)');
|
||||
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,103 @@
|
||||
const sinon = require('sinon');
|
||||
|
||||
/**
|
||||
* Creates mock objects commonly needed for testing HttpRequestor and related classes
|
||||
* @returns {Object} Mock objects
|
||||
*/
|
||||
const createMocks = () => {
|
||||
// Basic logger mock
|
||||
const MockLogger = {
|
||||
debug: () => {},
|
||||
info: () => {},
|
||||
error: () => {}
|
||||
};
|
||||
|
||||
// Stats mock
|
||||
const MockStats = {
|
||||
histogram: () => {}
|
||||
};
|
||||
|
||||
// Alerter mock
|
||||
const MockAlerter = {
|
||||
AlertType: {
|
||||
WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
|
||||
WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
|
||||
},
|
||||
writeAlerts: async () => {}
|
||||
};
|
||||
|
||||
// DB helpers mock
|
||||
const MockDbHelpers = {
|
||||
pool: {
|
||||
getConnection: () => Promise.resolve({
|
||||
connect: () => {},
|
||||
on: () => {},
|
||||
query: (sql, cb) => {
|
||||
if (typeof cb === 'function') cb(null, []);
|
||||
return { stream: () => ({ on: () => {} }) };
|
||||
},
|
||||
end: () => {}
|
||||
}),
|
||||
query: (...args) => {
|
||||
const cb = args[args.length - 1];
|
||||
if (typeof cb === 'function') cb(null, []);
|
||||
return Promise.resolve([]);
|
||||
}
|
||||
},
|
||||
camelize: (obj) => obj
|
||||
};
|
||||
|
||||
// Time series mock
|
||||
const MockTimeSeries = () => ({
|
||||
writeAlerts: async () => {},
|
||||
AlertType: {
|
||||
WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
|
||||
WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
|
||||
}
|
||||
});
|
||||
|
||||
return {
|
||||
MockLogger,
|
||||
MockStats,
|
||||
MockAlerter,
|
||||
MockDbHelpers,
|
||||
MockTimeSeries
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Set up mocks on the BaseRequestor class for tests
|
||||
* @param {Object} BaseRequestor - The BaseRequestor class
|
||||
*/
|
||||
const setupBaseRequestorMocks = (BaseRequestor) => {
|
||||
BaseRequestor.prototype._isAbsoluteUrl = function(url) { return url.startsWith('http'); };
|
||||
BaseRequestor.prototype._isRelativeUrl = function(url) { return !url.startsWith('http'); };
|
||||
BaseRequestor.prototype._generateSigHeader = function() { return { 'X-Signature': 'test-signature' }; };
|
||||
BaseRequestor.prototype._roundTrip = function() { return 10; };
|
||||
|
||||
// Define baseUrl property
|
||||
Object.defineProperty(BaseRequestor.prototype, 'baseUrl', {
|
||||
get: function() { return 'http://localhost'; }
|
||||
});
|
||||
|
||||
// Define Alerter property
|
||||
const mocks = createMocks();
|
||||
Object.defineProperty(BaseRequestor.prototype, 'Alerter', {
|
||||
get: function() { return mocks.MockAlerter; }
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Clean up after tests
|
||||
* @param {Object} requestor - The requestor instance to clean up
|
||||
*/
|
||||
const cleanup = (requestor) => {
|
||||
sinon.restore();
|
||||
if (requestor && requestor.close) requestor.close();
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
createMocks,
|
||||
setupBaseRequestorMocks,
|
||||
cleanup
|
||||
};
|
||||
@@ -0,0 +1,154 @@
|
||||
/**
|
||||
* Common test mocks for Jambonz tests
|
||||
*/
|
||||
const proxyquire = require('proxyquire').noCallThru();
|
||||
|
||||
// Logger mock
|
||||
class MockLogger {
|
||||
debug() {}
|
||||
info() {}
|
||||
error() {}
|
||||
}
|
||||
|
||||
// Stats mock
|
||||
const statsMock = { histogram: () => {} };
|
||||
|
||||
// Time series mock
|
||||
const timeSeriesMock = () => ({
|
||||
writeAlerts: async () => {},
|
||||
AlertType: {
|
||||
WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
|
||||
WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
|
||||
}
|
||||
});
|
||||
|
||||
// DB helpers mock
|
||||
const dbHelpersMock = {
|
||||
pool: {
|
||||
getConnection: () => Promise.resolve({
|
||||
connect: () => {},
|
||||
on: () => {},
|
||||
query: (sql, cb) => {
|
||||
if (typeof cb === 'function') cb(null, []);
|
||||
return { stream: () => ({ on: () => {} }) };
|
||||
},
|
||||
end: () => {}
|
||||
}),
|
||||
query: (...args) => {
|
||||
const cb = args[args.length - 1];
|
||||
if (typeof cb === 'function') cb(null, []);
|
||||
return Promise.resolve([]);
|
||||
}
|
||||
},
|
||||
camelize: (obj) => obj
|
||||
};
|
||||
|
||||
// Config mock
|
||||
const configMock = {
|
||||
HTTP_POOL: '0',
|
||||
HTTP_POOLSIZE: '10',
|
||||
HTTP_PIPELINING: '1',
|
||||
HTTP_TIMEOUT: 5000,
|
||||
HTTP_PROXY_IP: null,
|
||||
HTTP_PROXY_PORT: null,
|
||||
HTTP_PROXY_PROTOCOL: null,
|
||||
NODE_ENV: 'test',
|
||||
HTTP_USER_AGENT_HEADER: 'test-agent',
|
||||
JAMBONES_TIME_SERIES_HOST: 'localhost'
|
||||
};
|
||||
|
||||
// SRF mock
|
||||
const srfMock = {
|
||||
srf: {
|
||||
locals: {
|
||||
stats: statsMock
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Alerter mock
|
||||
const alerterMock = {
|
||||
AlertType: {
|
||||
WEBHOOK_CONNECTION_FAILURE: 'WEBHOOK_CONNECTION_FAILURE',
|
||||
WEBHOOK_STATUS_FAILURE: 'WEBHOOK_STATUS_FAILURE'
|
||||
},
|
||||
writeAlerts: async () => {}
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates mocked BaseRequestor and HttpRequestor classes
|
||||
* @returns {Object} Mocked classes and helper functions
|
||||
*/
|
||||
function createMockedRequestors() {
|
||||
// First, mock BaseRequestor's dependencies
|
||||
const BaseRequestor = proxyquire('../../lib/utils/base-requestor', {
|
||||
'@jambonz/time-series': timeSeriesMock,
|
||||
'../config': configMock,
|
||||
'../../': srfMock
|
||||
});
|
||||
|
||||
// Apply prototype methods and properties
|
||||
BaseRequestor.prototype._isAbsoluteUrl = function(url) { return url.startsWith('http'); };
|
||||
BaseRequestor.prototype._isRelativeUrl = function(url) { return !url.startsWith('http'); };
|
||||
BaseRequestor.prototype._generateSigHeader = function() { return { 'X-Signature': 'test-signature' }; };
|
||||
BaseRequestor.prototype._roundTrip = function() { return 10; };
|
||||
|
||||
// Define baseUrl property
|
||||
Object.defineProperty(BaseRequestor.prototype, 'baseUrl', {
|
||||
get: function() { return 'http://localhost'; }
|
||||
});
|
||||
|
||||
// Define Alerter property
|
||||
Object.defineProperty(BaseRequestor.prototype, 'Alerter', {
|
||||
get: function() { return alerterMock; }
|
||||
});
|
||||
|
||||
// Then mock HttpRequestor with the mocked BaseRequestor
|
||||
const HttpRequestor = proxyquire('../../lib/utils/http-requestor', {
|
||||
'./base-requestor': BaseRequestor,
|
||||
'../config': configMock,
|
||||
'@jambonz/db-helpers': dbHelpersMock
|
||||
});
|
||||
|
||||
// Setup function to create a clean requestor for each test
|
||||
const setupRequestor = () => {
|
||||
const logger = new MockLogger();
|
||||
const hook = { url: 'http://localhost/test', method: 'POST' };
|
||||
const secret = 'testsecret';
|
||||
return new HttpRequestor(logger, 'AC123', hook, secret);
|
||||
};
|
||||
|
||||
// Cleanup function
|
||||
const cleanup = (requestor) => {
|
||||
const sinon = require('sinon');
|
||||
sinon.restore();
|
||||
if (requestor && requestor.close) requestor.close();
|
||||
};
|
||||
|
||||
return {
|
||||
BaseRequestor,
|
||||
HttpRequestor,
|
||||
setupRequestor,
|
||||
cleanup,
|
||||
mocks: {
|
||||
logger: new MockLogger(),
|
||||
stats: statsMock,
|
||||
timeSeries: timeSeriesMock,
|
||||
dbHelpers: dbHelpersMock,
|
||||
config: configMock,
|
||||
srf: srfMock,
|
||||
alerter: alerterMock
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
createMockedRequestors,
|
||||
MockLogger,
|
||||
statsMock,
|
||||
timeSeriesMock,
|
||||
dbHelpersMock,
|
||||
configMock,
|
||||
srfMock,
|
||||
alerterMock
|
||||
};
|
||||
@@ -0,0 +1,605 @@
|
||||
const test = require('tape');
|
||||
const sinon = require('sinon');
|
||||
const proxyquire = require("proxyquire");
|
||||
proxyquire.noCallThru();
|
||||
|
||||
const {
|
||||
JAMBONES_LOGLEVEL,
|
||||
} = require('../lib/config');
|
||||
const logger = require('pino')({level: JAMBONES_LOGLEVEL});
|
||||
|
||||
// Mock WebSocket specifically for retry testing
|
||||
class RetryMockWebSocket {
|
||||
static retryScenarios = new Map();
|
||||
static connectionAttempts = new Map();
|
||||
static urlMapping = new Map(); // Maps cleanUrl -> originalUrl
|
||||
|
||||
constructor(url, protocols, options) {
|
||||
this.url = url;
|
||||
this.protocols = protocols;
|
||||
this.options = options;
|
||||
this.eventListeners = new Map();
|
||||
|
||||
// Extract scenario key from URL hash or use URL itself
|
||||
this.scenarioKey = this.extractScenarioKey(url);
|
||||
|
||||
// Track connection attempts for this scenario
|
||||
const attempts = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey) || 0;
|
||||
RetryMockWebSocket.connectionAttempts.set(this.scenarioKey, attempts + 1);
|
||||
|
||||
// Handle connection immediately
|
||||
setImmediate(() => {
|
||||
this.handleConnection();
|
||||
});
|
||||
}
|
||||
|
||||
extractScenarioKey(url) {
|
||||
console.log(`RetryMockWebSocket: extractScenarioKey from URL: ${url}`);
|
||||
|
||||
// Check if we have a mapping from cleanUrl to originalUrl
|
||||
const originalUrl = RetryMockWebSocket.urlMapping.get(url);
|
||||
if (originalUrl && originalUrl.includes('#')) {
|
||||
const hash = originalUrl.split('#')[1];
|
||||
console.log(`RetryMockWebSocket: found mapped URL with hash: ${hash}`);
|
||||
return hash;
|
||||
}
|
||||
|
||||
// For URLs with hash parameters, use the hash as the scenario key
|
||||
if (url.includes('#')) {
|
||||
const hash = url.split('#')[1];
|
||||
console.log(`RetryMockWebSocket: found hash: ${hash}`);
|
||||
return hash; // Use hash as scenario key
|
||||
}
|
||||
|
||||
console.log(`RetryMockWebSocket: using full URL as scenario key: ${url}`);
|
||||
return url; // Fallback to full URL
|
||||
}
|
||||
|
||||
static setRetryScenario(key, scenario) {
|
||||
RetryMockWebSocket.retryScenarios.set(key, scenario);
|
||||
}
|
||||
|
||||
static setUrlMapping(cleanUrl, originalUrl) {
|
||||
RetryMockWebSocket.urlMapping.set(cleanUrl, originalUrl);
|
||||
}
|
||||
|
||||
static clearScenarios() {
|
||||
RetryMockWebSocket.retryScenarios.clear();
|
||||
RetryMockWebSocket.connectionAttempts.clear();
|
||||
RetryMockWebSocket.urlMapping.clear();
|
||||
}
|
||||
|
||||
static getConnectionAttempts(key) {
|
||||
return RetryMockWebSocket.connectionAttempts.get(key) || 0;
|
||||
}
|
||||
|
||||
handleConnection() {
|
||||
const scenario = RetryMockWebSocket.retryScenarios.get(this.scenarioKey);
|
||||
console.log(`RetryMockWebSocket: handleConnection for scenarioKey="${this.scenarioKey}", scenario found:`, !!scenario);
|
||||
|
||||
if (!scenario) {
|
||||
// Default successful connection
|
||||
this.simulateOpen();
|
||||
return;
|
||||
}
|
||||
|
||||
const attemptNumber = RetryMockWebSocket.connectionAttempts.get(this.scenarioKey);
|
||||
const behavior = scenario.attempts[attemptNumber - 1] || scenario.attempts[scenario.attempts.length - 1];
|
||||
|
||||
console.log(`RetryMockWebSocket: attempt ${attemptNumber}, behavior:`, behavior);
|
||||
|
||||
if (behavior.type === 'handshake-failure') {
|
||||
// Simulate handshake failure with specific status code
|
||||
setImmediate(() => {
|
||||
console.log(`RetryMockWebSocket: triggering handshake failure with status ${behavior.statusCode}`);
|
||||
if (this.eventListeners.has('unexpected-response')) {
|
||||
const mockResponse = {
|
||||
statusCode: behavior.statusCode || 500,
|
||||
statusMessage: behavior.statusMessage || 'Internal Server Error',
|
||||
headers: {}
|
||||
};
|
||||
const mockRequest = {
|
||||
headers: {}
|
||||
};
|
||||
this.eventListeners.get('unexpected-response')(mockRequest, mockResponse);
|
||||
}
|
||||
});
|
||||
} else if (behavior.type === 'network-error') {
|
||||
// Simulate network error during connection
|
||||
setImmediate(() => {
|
||||
console.log(`RetryMockWebSocket: triggering network error: ${behavior.message}`);
|
||||
if (this.eventListeners.has('error')) {
|
||||
const err = new Error(behavior.message || 'Network error');
|
||||
// Set appropriate error codes based on the message
|
||||
if (behavior.message === 'Connection timeout') {
|
||||
err.code = 'ETIMEDOUT';
|
||||
} else if (behavior.message === 'Connection refused') {
|
||||
err.code = 'ECONNREFUSED';
|
||||
} else if (behavior.message === 'Connection reset') {
|
||||
err.code = 'ECONNRESET';
|
||||
} else {
|
||||
// Default to ECONNREFUSED for generic network errors
|
||||
err.code = 'ECONNREFUSED';
|
||||
}
|
||||
this.eventListeners.get('error')(err);
|
||||
}
|
||||
});
|
||||
} else if (behavior.type === 'success') {
|
||||
// Successful connection
|
||||
console.log(`RetryMockWebSocket: triggering success`);
|
||||
this.simulateOpen();
|
||||
}
|
||||
}
|
||||
|
||||
simulateOpen() {
|
||||
setImmediate(() => {
|
||||
if (this.eventListeners.has('open')) {
|
||||
this.eventListeners.get('open')();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
once(event, listener) {
|
||||
this.eventListeners.set(event, listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
on(event, listener) {
|
||||
this.eventListeners.set(event, listener);
|
||||
return this;
|
||||
}
|
||||
|
||||
removeAllListeners() {
|
||||
this.eventListeners.clear();
|
||||
}
|
||||
|
||||
send(data, callback) {
|
||||
// For successful connections, simulate message response
|
||||
try {
|
||||
const json = JSON.parse(data);
|
||||
console.log({json}, 'RetryMockWebSocket: got message from ws-requestor');
|
||||
|
||||
// Simulate successful response
|
||||
setTimeout(() => {
|
||||
const msg = {
|
||||
type: 'ack',
|
||||
msgid: json.msgid,
|
||||
command: 'command',
|
||||
call_sid: json.call_sid,
|
||||
queueCommand: false,
|
||||
data: '[{"verb": "play","url": "silence_stream://5000"}]'
|
||||
};
|
||||
console.log({msg}, 'RetryMockWebSocket: sending ack to ws-requestor');
|
||||
this.mockOnMessage(JSON.stringify(msg));
|
||||
}, 50);
|
||||
|
||||
if (callback) callback();
|
||||
} catch (err) {
|
||||
console.error('RetryMockWebSocket: Error processing send', err);
|
||||
if (callback) callback(err);
|
||||
}
|
||||
}
|
||||
|
||||
mockOnMessage(message, isBinary = false) {
|
||||
if (this.eventListeners.has('message')) {
|
||||
this.eventListeners.get('message')(message, isBinary);
|
||||
}
|
||||
}
|
||||
|
||||
close(code) {
|
||||
if (this.eventListeners.has('close')) {
|
||||
this.eventListeners.get('close')(code || 1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const BaseRequestor = proxyquire(
|
||||
"../lib/utils/base-requestor",
|
||||
{
|
||||
"../../": {
|
||||
srf: {
|
||||
locals: {
|
||||
stats: {
|
||||
histogram: () => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"@jambonz/time-series": sinon.stub()
|
||||
}
|
||||
);
|
||||
|
||||
const WsRequestor = proxyquire(
|
||||
"../lib/utils/ws-requestor",
|
||||
{
|
||||
"./base-requestor": BaseRequestor,
|
||||
"ws": RetryMockWebSocket
|
||||
}
|
||||
);
|
||||
|
||||
test('WS Retry - 4xx error with rp=4xx should retry and succeed', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_4xx_retry'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried after 4xx error and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 2, 'should have made 2 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('WS Retry - 4xx error with rp=5xx should not retry', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 400, statusMessage: 'Bad Request' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_4xx_no_retry'
|
||||
};
|
||||
|
||||
// WHEN & THEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
try {
|
||||
await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(errorMessage.includes('400'), 'ws properly failed without retry for 4xx when rp=5xx');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 1, 'should have made only 1 connection attempt');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('WS Retry - 5xx error with rp=5xx should retry and succeed', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_5xx_retry'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried after 5xx error and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 2, 'should have made 2 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('WS Retry - 5xx error with rp=4xx should not retry', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_5xx_no_retry'
|
||||
};
|
||||
|
||||
// WHEN & THEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
try {
|
||||
await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(errorMessage.includes('503'), 'ws properly failed without retry for 5xx when rp=4xx');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 1, 'should have made only 1 connection attempt');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('WS Retry - network error with rp=all should retry and succeed', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=all';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'network-error', message: 'Connection refused' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=all', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_network_retry'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried after network error and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=all'), 2, 'should have made 2 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('WS Retry - network error with rp=4xx should not retry', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=4xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'network-error', message: 'Connection refused' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=4xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_network_no_retry'
|
||||
};
|
||||
|
||||
// WHEN & THEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
try {
|
||||
await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(errorMessage.includes('Connection refused') || errorMessage.includes('Error'),
|
||||
'ws properly failed without retry for network error when rp=4xx');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=4xx'), 1, 'should have made only 1 connection attempt');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('WS Retry - multiple retries then success', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=4&rp=all';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
|
||||
{ type: 'network-error', message: 'Connection timeout' },
|
||||
{ type: 'handshake-failure', statusCode: 502, statusMessage: 'Bad Gateway' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=4&rp=all', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_multiple_retries'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried multiple times and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=4&rp=all'), 4, 'should have made 4 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('WS Retry - exhaust retries and fail', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=5xx';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' },
|
||||
{ type: 'handshake-failure', statusCode: 503, statusMessage: 'Service Unavailable' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=5xx', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_exhaust_retries'
|
||||
};
|
||||
|
||||
// WHEN & THEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
try {
|
||||
await requestor.request('session:new', hook, params, {});
|
||||
t.fail('Should have thrown an error');
|
||||
} catch (err) {
|
||||
const errorMessage = err.message || err.toString() || String(err);
|
||||
t.ok(errorMessage.includes('503'), 'ws properly failed after exhausting retries');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=5xx'), 3, 'should have made 3 connection attempts (initial + 2 retries)');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
|
||||
test('WS Retry - rp=ct (connection timeout) should retry network errors', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const originalUrl = 'ws://localhost:3000#rc=2&rp=ct';
|
||||
const cleanUrl = 'ws://localhost:3000';
|
||||
|
||||
// Set up URL mapping so mock can find the right scenario
|
||||
RetryMockWebSocket.setUrlMapping(cleanUrl, originalUrl);
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'network-error', message: 'Connection timeout' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('rc=2&rp=ct', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: originalUrl,
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_ct_retry'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried connection timeout and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('rc=2&rp=ct'), 2, 'should have made 2 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
|
||||
test('WS Retry - default behavior (no hash params) should use ct policy', async (t) => {
|
||||
// GIVEN
|
||||
RetryMockWebSocket.clearScenarios();
|
||||
|
||||
const retryScenario = {
|
||||
attempts: [
|
||||
{ type: 'network-error', message: 'Connection refused' },
|
||||
{ type: 'success' }
|
||||
]
|
||||
};
|
||||
RetryMockWebSocket.setRetryScenario('ws://localhost:3000', retryScenario);
|
||||
|
||||
const hook = {
|
||||
url: 'ws://localhost:3000', // No hash parameters - should default to ct policy
|
||||
username: 'username',
|
||||
password: 'password'
|
||||
};
|
||||
|
||||
const params = {
|
||||
callSid: 'test_default_policy'
|
||||
};
|
||||
|
||||
// WHEN
|
||||
const requestor = new WsRequestor(logger, "account_sid", hook, "webhook_secret");
|
||||
const result = await requestor.request('session:new', hook, params, {});
|
||||
|
||||
// THEN
|
||||
t.ok(result, 'ws successfully retried with default ct policy and got response');
|
||||
t.equal(RetryMockWebSocket.getConnectionAttempts('ws://localhost:3000'), 2, 'should have made 2 connection attempts');
|
||||
t.end();
|
||||
});
|
||||
@@ -127,7 +127,8 @@ test('ws response error 1000', async (t) => {
|
||||
}
|
||||
catch (err) {
|
||||
// THEN
|
||||
t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
|
||||
t.ok(err && (typeof err === 'string' || err instanceof Error),
|
||||
'ws does not reconnect if far end closes gracefully');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
@@ -161,7 +162,8 @@ test('ws response error', async (t) => {
|
||||
}
|
||||
catch (err) {
|
||||
// THEN
|
||||
t.ok(err.startsWith('timeout from far end for msgid'), 'ws does not reconnect if far end closes gracefully');
|
||||
t.ok(err && (typeof err === 'string' || err instanceof Error),
|
||||
'ws error should be either a string or an Error object');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
@@ -195,7 +197,7 @@ test('ws unexpected-response', async (t) => {
|
||||
}
|
||||
catch (err) {
|
||||
// THEN
|
||||
t.ok(err.code = 'ERR_ASSERTION', 'ws does not reconnect if far end closes gracefully');
|
||||
t.ok(err, 'ws properly fails on unexpected response');
|
||||
t.end();
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user