trac-msb 0.2.12 → 0.2.13

package/tests/unit/network/v1/connectionPolicies.test.js

@@ -0,0 +1,49 @@
+import { test } from 'brittle';
+
+import { resultToValidatorAction, SENDER_ACTION } from '../../../../src/core/network/protocols/connectionPolicies.js';
+import { ResultCode } from '../../../../src/utils/constants.js';
+
+test('connectionPolicies maps OK to SUCCESS', t => {
+    t.is(
+        resultToValidatorAction(ResultCode.OK),
+        SENDER_ACTION.SUCCESS
+    );
+});
+
+test('connectionPolicies maps TX_ALREADY_PENDING to NO_ROTATE', t => {
+    t.is(
+        resultToValidatorAction(ResultCode.TX_ALREADY_PENDING),
+        SENDER_ACTION.NO_ROTATE
+    );
+});
+
+test('connectionPolicies maps TX_COMMITTED_RECEIPT_MISSING to ROTATE', t => {
+    t.is(
+        resultToValidatorAction(ResultCode.TX_COMMITTED_RECEIPT_MISSING),
+        SENDER_ACTION.ROTATE
+    );
+});
+
+test('connectionPolicies maps unknown result code to UNDEFINED', t => {
+    t.is(
+        resultToValidatorAction(999999),
+        SENDER_ACTION.UNDEFINED
+    );
+});
+
+test('connectionPolicies maps every ResultCode constant to a concrete sender action', t => {
+    const unassigned = [];
+
+    for (const [name, code] of Object.entries(ResultCode)) {
+        const action = resultToValidatorAction(code);
+        if (action === SENDER_ACTION.UNDEFINED) {
+            unassigned.push(`${name}(${code})`);
+        }
+    }
+
+    t.alike(
+        unassigned,
+        [],
+        `Unassigned ResultCode entries in policy: ${unassigned.join(', ')}`
+    );
+});

package/tests/unit/network/v1/handlers/V1BaseOperationHandler.test.js

@@ -0,0 +1,284 @@
+import test from 'brittle';
+import V1BaseOperationHandler from '../../../../../src/core/network/protocols/v1/handlers/V1BaseOperationHandler.js';
+import {V1ProtocolError, V1UnexpectedError} from '../../../../../src/core/network/protocols/v1/V1ProtocolError.js';
+
+class MockRateLimiter {
+    constructor() { this.called = false; }
+    v1HandleRateLimit(conn) {
+        this.called = true;
+        this.conn = conn;
+    }
+}
+
+class MockPendingReqService {
+    constructor() {
+        this.entries = {};
+        this.stopped = [];
+        this.resolved = [];
+        this.rejected = [];
+        this.shouldReject = true;
+    }
+    getPendingRequest(id) { return this.entries[id]; }
+    stopPendingRequestTimeout(id) { this.stopped.push(id); }
+    resolvePendingRequest(id, code) { this.resolved.push({ id, code }); }
+    rejectPendingRequest(id, err) {
+        if (this.shouldReject) this.rejected.push({ id, err });
+        return this.shouldReject;
+    }
+}
+
+const mockConfig = { disableRateLimit: false };
+
+test('constructor: stores provided config -> config getter returns same reference', async (t) => {
+    const handler = new V1BaseOperationHandler(null, null, mockConfig);
+    t.is(handler.config, mockConfig, 'Should return the config passed in the constructor');
+});
+
+test('applyRateLimit: rate limit enabled -> calls rate limiter with connection', async (t) => {
+    const rateLimiter = new MockRateLimiter();
+    const handler = new V1BaseOperationHandler(rateLimiter, null, mockConfig);
+    const conn = { id: 1 };
+
+    handler.applyRateLimit(conn);
+
+    t.ok(rateLimiter.called, 'Should call the rate limiter when enabled');
+    t.is(rateLimiter.conn, conn, 'Should pass the connection to the rate limiter');
+});
+
+test('applyRateLimit: disableRateLimit=true -> skips rate limiter call', async (t) => {
+    const rateLimiter = new MockRateLimiter();
+    const handler = new V1BaseOperationHandler(rateLimiter, null, { disableRateLimit: true });
+
+    handler.applyRateLimit({});
+
+    t.absent(rateLimiter.called, 'Should NOT call the rate limiter when disableRateLimit is true');
+});
+
+test('resolvePendingResponse: pending request missing -> returns false', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    const result = await handler.resolvePendingResponse({ id: 'msg-123' }, {}, {}, () => {}, {});
+
+    t.is(result, false, 'Should return false if the pending request does not exist');
+});
+
+test('resolvePendingResponse: valid pending response -> stops timeout and resolves request', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    pendingReq.entries['msg-123'] = { id: 'msg-123' };
+
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    let validated = false;
+    const validatorMock = { async validate() { validated = true; } };
+    const extractCodeMock = () => 'SUCCESS';
+
+    const result = await handler.resolvePendingResponse(
+        { id: 'msg-123' },
+        {},
+        validatorMock,
+        extractCodeMock,
+        {}
+    );
+
+    t.is(result, true, 'Should return true after resolving the request');
+    t.is(pendingReq.stopped[0], 'msg-123', 'Should stop the timeout');
+    t.ok(validated, 'Should call validation');
+    t.is(pendingReq.resolved[0].code, 'SUCCESS', 'Should extract resultCode and resolve');
+});
+
+test('resolvePendingResponse: validator throws -> propagates validation error', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    pendingReq.entries['msg-123'] = { id: 'msg-123' };
+
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    const validatorMock = {
+        async validate() { throw new Error('Validation Failed'); }
+    };
+
+    await t.exception(async () => {
+        await handler.resolvePendingResponse(
+            { id: 'msg-123' },
+            {},
+            validatorMock,
+            () => {},
+            {}
+        );
+    }, /Validation Failed/, 'Should propagate the validation error');
+});
+
+test('handlePendingResponseError: request already rejected -> does not close connection', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    pendingReq.shouldReject = false;
+
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    let ended = false;
+    const connMock = { end: () => { ended = true; } };
+
+    handler.handlePendingResponseError('msg-123', connMock, new Error('test'), 'step');
+
+    t.absent(ended, 'Should NOT end the connection if the request was already rejected');
+});
+
+test('handlePendingResponseError: unknown native error -> maps to V1UnexpectedError', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    // Bypass display logic for isolation
+    handler.displayError = () => {};
+
+    let ended = false;
+    const connMock = {
+        end: () => { ended = true; },
+        remotePublicKey: Buffer.alloc(32)
+    };
+
+    handler.handlePendingResponseError(
+        'msg-123',
+        connMock,
+        new Error('Random native error'),
+        'test-step'
+    );
+
+    t.is(pendingReq.rejected.length, 1, 'Should reject the pending request');
+
+    const capturedError = pendingReq.rejected[0].err;
+
+    t.ok(capturedError instanceof V1UnexpectedError, 'Should map to V1UnexpectedError');
+    t.is(capturedError.message, 'Random native error', 'Should preserve original message');
+    t.absent(ended, 'V1UnexpectedError should not close the connection by default');
+});
+
+test('handlePendingResponseError: protocol error with endConnection=true -> does not close connection directly', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    handler.displayError = () => {};
+
+    let ended = false;
+    const connMock = {
+        end: () => { ended = true; },
+        remotePublicKey: Buffer.alloc(32)
+    };
+
+    const protocolError = new V1ProtocolError(999, 'FATAL_ERROR', true);
+
+    handler.handlePendingResponseError(
+        'msg-123',
+        connMock,
+        protocolError,
+        'test-step'
+    );
+
+    t.is(
+        pendingReq.rejected[0].err,
+        protocolError,
+        'Should pass protocol error without wrapping'
+    );
+
+    t.absent(ended, 'Connection closing is delegated to ConnectionManager');
+});
+
+test('handlePendingResponseError: delegates logging -> calls displayError', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, { hrp: 'trac' });
+
+    let called = false;
+    handler.displayError = () => { called = true; };
+
+    handler.handlePendingResponseError(
+        'msg-1',
+        { end() {}, remotePublicKey: Buffer.alloc(32) },
+        new Error('boom'),
+        'step'
+    );
+
+    t.ok(called);
+});
+
+test('handlePendingResponseError: protocol-shaped error -> keeps original error instance', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    const protocolError = new V1ProtocolError(123, 'protocol-shaped', false);
+
+    handler.displayError = () => {};
+
+    handler.handlePendingResponseError(
+        'msg-1',
+        { end() {}, remotePublicKey: Buffer.alloc(32) },
+        protocolError,
+        'step'
+    );
+
+    t.is(
+        pendingReq.rejected[0].err,
+        protocolError,
+        'Should not wrap protocol error'
+    );
+});
+
+test('handlePendingResponseError: undefined error -> uses Unexpected error fallback', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    handler.displayError = () => {};
+
+    handler.handlePendingResponseError(
+        'msg-123',
+        { end() {}, remotePublicKey: Buffer.alloc(32) },
+        undefined,
+        'step'
+    );
+
+    const captured = pendingReq.rejected[0].err;
+
+    t.ok(captured instanceof V1UnexpectedError);
+    t.is(captured.message, 'Unexpected error');
+});
+
+test('displayError: real implementation with invalid config -> throws', async (t) => {
+    const pendingReq = new MockPendingReqService();
+
+    const handler = new V1BaseOperationHandler(
+        null,
+        pendingReq,
+        {} // intentionally invalid config
+    );
+
+    const originalConsoleError = console.error;
+    console.error = () => {};
+
+    await t.exception(() => {
+        handler.displayError(
+            'step',
+            Buffer.alloc(33, 1),
+            new Error('boom')
+        );
+    });
+
+    console.error = originalConsoleError;
+
+    t.pass();
+});
+
+test('handlePendingResponseError: primitive error value -> uses Unexpected error fallback', async (t) => {
+    const pendingReq = new MockPendingReqService();
+    const handler = new V1BaseOperationHandler(null, pendingReq, mockConfig);
+
+    handler.displayError = () => {};
+
+    handler.handlePendingResponseError(
+        'msg-123',
+        { end() {}, remotePublicKey: Buffer.alloc(32) },
+        'string error',
+        'step'
+    );
+
+    const captured = pendingReq.rejected[0].err;
+
+    t.ok(captured instanceof V1UnexpectedError);
+    t.is(captured.message, 'Unexpected error');
+});