trac-msb 0.2.11 → 0.2.12

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

@@ -1,193 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import V1LivenessOperationHandler from '../../../../../src/core/network/protocols/v1/handlers/V1LivenessOperationHandler.js';
-import V1LivenessRequest from '../../../../../src/core/network/protocols/v1/validators/V1LivenessRequest.js';
-import V1LivenessResponse from '../../../../../src/core/network/protocols/v1/validators/V1LivenessResponse.js';
-import { ResultCode } from '../../../../../src/utils/constants.js';
-import {V1ProtocolError} from '../../../../../src/core/network/protocols/v1/V1ProtocolError.js';
-
-// Backup original validators
-const originalReqValidate = V1LivenessRequest.prototype.validate;
-const originalResValidate = V1LivenessResponse.prototype.validate;
-
-const mockConfig = {
-    hrp: 'trac',
-    addressPrefix: 'trac',
-    networkId: 1,
-    disableRateLimit: true,
-    network: { hrp: 'trac' }
-};
-
-// Minimal wallet required so constructor does not break
-const mockWallet = {
-    getPublicKey: () => b4a.alloc(33, 2),
-    sign: () => b4a.alloc(64),
-    address: 'trac123z3gfpr2epjwww7ntm3m6ud2fhmq0tvts27p2f5mx3qkecsutlqfys769',
-    networkId: 1
-};
-
-class MockConnection {
-    constructor() {
-        this.remotePublicKey = b4a.alloc(32);
-        this.ended = false;
-        this.sentPayload = null;
-        this.flushCalled = false;
-        this.protocolSession = {
-            sendAndForget: () => {}
-        };
-    }
-
-    async flush() {
-        this.flushCalled = true;
-        return true;
-    }
-
-    end() {
-        this.ended = true;
-    }
-}
-
-const mockRateLimiter = {
-    v1HandleRateLimit: () => {}
-};
-
-test('handleRequest: request validation and response send -> covers success and error branches', async (t) => {
-
-    // -------- SUCCESS FLOW (does not validate real payload) --------
-    {
-        V1LivenessRequest.prototype.validate = async () => {};
-
-        const handler = new V1LivenessOperationHandler(
-            mockWallet,
-            mockRateLimiter,
-            {},
-            mockConfig
-        );
-
-        handler.displayError = () => {};
-
-        const conn = new MockConnection();
-
-        await handler.handleRequest({ id: 'msg-success' }, conn);
-
-        // Real factory is not being asserted
-        t.pass('Success path executed');
-    }
-
-    // -------- VALIDATION ERROR + endConnection true --------
-    {
-        V1LivenessRequest.prototype.validate = async () => {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Validation Fail', true);
-        };
-
-        const handler = new V1LivenessOperationHandler(
-            mockWallet,
-            mockRateLimiter,
-            {},
-            mockConfig
-        );
-
-        handler.displayError = () => {};
-
-        const conn = new MockConnection();
-
-        await handler.handleRequest({ id: 'msg-end' }, conn);
-
-        t.ok(conn.ended);
-        t.ok(conn.flushCalled);
-    }
-
-    // -------- VALIDATION ERROR without endConnection --------
-    {
-        V1LivenessRequest.prototype.validate = async () => {
-            throw new V1ProtocolError(ResultCode.INVALID_PAYLOAD, 'Validation Fail No End', false);
-        };
-
-        const handler = new V1LivenessOperationHandler(
-            mockWallet,
-            mockRateLimiter,
-            {},
-            mockConfig
-        );
-
-        handler.displayError = () => {};
-
-        const conn = new MockConnection();
-
-        await handler.handleRequest({ id: 'msg-no-end' }, conn);
-
-        t.absent(conn.ended);
-        t.absent(conn.flushCalled);
-    }
-
-    // -------- SEND FAILURE (second catch block) --------
-    {
-        V1LivenessRequest.prototype.validate = async () => {};
-
-        const handler = new V1LivenessOperationHandler(
-            mockWallet,
-            mockRateLimiter,
-            {},
-            mockConfig
-        );
-
-        handler.displayError = () => {};
-
-        const conn = new MockConnection();
-
-        conn.protocolSession.sendAndForget = () => {
-            throw new Error('send fail');
-        };
-
-        await handler.handleRequest({ id: 'msg-send-fail' }, conn);
-
-        t.ok(conn.ended);
-    }
-});
-
-test('handleResponse: resolvePendingResponse result handling -> covers success and delegated error branches', async (t) => {
-
-    const handler = new V1LivenessOperationHandler(
-        mockWallet,
-        mockRateLimiter,
-        {},
-        mockConfig
-    );
-
-    // resolvePendingResponse success path
-    {
-        let extractorCalled = false;
-
-        handler.resolvePendingResponse = async (msg, conn, val, extractor) => {
-            extractor({ liveness_response: { result: 1 } });
-            extractorCalled = true;
-        };
-
-        await handler.handleResponse({ id: 'msg-1' }, new MockConnection());
-
-        t.ok(extractorCalled);
-    }
-
-    // resolvePendingResponse error path
-    {
-        handler.resolvePendingResponse = async () => {
-            throw new Error('Fail');
-        };
-
-        let handled = false;
-
-        handler.handlePendingResponseError = () => {
-            handled = true;
-        };
-
-        await handler.handleResponse({ id: 'msg-2' }, new MockConnection());
-
-        t.ok(handled);
-    }
-});
-
-test('validators cleanup: restore original validator methods', async (t) => {
-    V1LivenessRequest.prototype.validate = originalReqValidate;
-    V1LivenessResponse.prototype.validate = originalResValidate;
-    t.pass();
-});

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

@@ -1,15 +0,0 @@
-// Aggregator for V1 handlers unit tests
-
-import { default as test } from 'brittle';
-
-async function runTests() {
-    test.pause();
-
-    await import('./handlers/V1BaseOperationHandler.test.js');
-    await import('./handlers/V1BroadcastTransactionOperationHandler.test.js');
-    await import('./handlers/V1LivenessOperationHandler.test.js');
-
-    test.resume();
-}
-
-await runTests();

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

@@ -1,19 +0,0 @@
-import { default as test } from 'brittle';
-
-async function runTests() {
-    test.pause();
-    await import('./v1.handlers.test.js');
-    await import('./V1BaseOperation.test.js');
-    await import('./V1LivenessRequest.test.js');
-    await import('./V1LivenessResponse.test.js');
-    await import('./V1BroadcastTransactionRequest.test.js');
-    await import('./V1ResultCode.test.js');
-    await import('./connectionPolicies.test.js');
-    await import('./V1BroadcastTransactionResponse.test.js');
-    await import('./V1ValidationSchema.test.js');
-    await import('./V1BroadcastTransactionOperationHandler.test.js');
-    await import('./NetworkMessageRouterV1.test.js');
-    test.resume();
-}
-
-await runTests();

package/tests/unit/network/v1/v1ValidationSchema/broadcastTransactionRequest.test.js

@@ -1,119 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    SIGNATURE_BYTE_LENGTH,
-    MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const bytes = (len, fill = 1) => b4a.alloc(len, fill);
-
-const validFixture = {
-    type: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST,
-    id: 'test-id',
-    timestamp: Date.now(),
-    broadcast_transaction_request: {
-        data: bytes(16, 1),
-        nonce: bytes(NONCE_BYTE_LENGTH, 2),
-        signature: bytes(SIGNATURE_BYTE_LENGTH, 3),
-    },
-    capabilities: ['cap:a'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'broadcast_transaction_request', 'capabilities'];
-const valueFields = ['data', 'nonce', 'signature'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - happy path', t => {
-    t.ok(v.validateV1BroadcastTransactionRequest(validFixture), 'valid BROADCAST_TRANSACTION_REQUEST should pass');
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1BroadcastTransactionRequest.bind(v),
-        validFixture,
-        'broadcast_transaction_request',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.BROADCAST_TRANSACTION_REQUEST
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1BroadcastTransactionRequest.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1BroadcastTransactionRequest.bind(v),
-        validFixture,
-        'broadcast_transaction_request',
-        valueFields,
-        not_allowed_data_types,
-        {
-            skipInvalidType: (field, invalidType) => field === 'data' && b4a.isBuffer(invalidType),
-        }
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - data size limits', t => {
-    const min = structuredClone(validFixture);
-    min.broadcast_transaction_request.data = bytes(1, 1);
-    t.ok(v.validateV1BroadcastTransactionRequest(min), 'data length 1 should pass');
-
-    const max = structuredClone(validFixture);
-    max.broadcast_transaction_request.data = bytes(MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE, 1);
-    t.ok(v.validateV1BroadcastTransactionRequest(max), `data length ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE} should pass`);
-
-    const tooLarge = structuredClone(validFixture);
-    tooLarge.broadcast_transaction_request.data = bytes(MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE + 1, 1);
-    t.absent(v.validateV1BroadcastTransactionRequest(tooLarge), `data length ${MAX_PARTIAL_TX_PAYLOAD_BYTE_SIZE + 1} should fail`);
-
-    const empty = structuredClone(validFixture);
-    empty.broadcast_transaction_request.data = bytes(0, 0);
-    t.absent(v.validateV1BroadcastTransactionRequest(empty), 'data length 0 should fail');
-
-    const zeroFilled = structuredClone(validFixture);
-    zeroFilled.broadcast_transaction_request.data = bytes(16, 0);
-    t.ok(v.validateV1BroadcastTransactionRequest(zeroFilled), 'zero-filled data should pass (allowZero)');
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1BroadcastTransactionRequest.bind(v),
-        validFixture,
-        'broadcast_transaction_request',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionRequest - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1BroadcastTransactionRequest.bind(v),
-        validFixture,
-        'broadcast_transaction_request',
-        ['nonce', 'signature']
-    );
-});
-

package/tests/unit/network/v1/v1ValidationSchema/broadcastTransactionResponse.test.js

@@ -1,136 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    ResultCode,
-    SIGNATURE_BYTE_LENGTH,
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    assertNoThrowAndAbsent,
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const validFixture = {
-    type: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE,
-    id: 'test-id',
-    timestamp: Date.now(),
-    broadcast_transaction_response: {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-        proof: b4a.from('deadbeef', 'hex'),
-        timestamp: Date.now(),
-        result: ResultCode.OK,
-    },
-    capabilities: ['cap:a'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'broadcast_transaction_response', 'capabilities'];
-const valueFields = ['nonce', 'signature', 'result'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - happy path', t => {
-    t.ok(v.validateV1BroadcastTransactionResponse(validFixture), 'valid BROADCAST_TRANSACTION_RESPONSE should pass');
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - payload/type mismatch (request payload + response type)', t => {
-    const op = structuredClone(validFixture);
-    delete op.broadcast_transaction_response;
-    op.broadcast_transaction_request = {
-        data: b4a.alloc(16, 1),
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 2),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 3),
-    };
-
-    assertNoThrowAndAbsent(
-        t,
-        v.validateV1BroadcastTransactionResponse.bind(v),
-        op,
-        'broadcast_transaction_request payload with type=BROADCAST_TRANSACTION_RESPONSE'
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1BroadcastTransactionResponse.bind(v),
-        validFixture,
-        'broadcast_transaction_response',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1BroadcastTransactionResponse.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1BroadcastTransactionResponse.bind(v),
-        validFixture,
-        'broadcast_transaction_response',
-        valueFields,
-        not_allowed_data_types,
-        {
-            skipInvalidType: (field, invalidType) => field === 'result' && typeof invalidType === 'number',
-        }
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - result value validation', t => {
-    const negative = structuredClone(validFixture);
-    negative.broadcast_transaction_response.result = -1;
-    t.absent(v.validateV1BroadcastTransactionResponse(negative), 'negative result should fail');
-
-    const nonInteger = structuredClone(validFixture);
-    nonInteger.broadcast_transaction_response.result = 1.1;
-    t.absent(v.validateV1BroadcastTransactionResponse(nonInteger), 'non-integer result should fail');
-
-    const nan = structuredClone(validFixture);
-    nan.broadcast_transaction_response.result = NaN;
-    t.absent(v.validateV1BroadcastTransactionResponse(nan), 'result NaN should fail');
-
-    const infinity = structuredClone(validFixture);
-    infinity.broadcast_transaction_response.result = Infinity;
-    t.absent(v.validateV1BroadcastTransactionResponse(infinity), 'result Infinity should fail');
-
-    const unknownCode = structuredClone(validFixture);
-    unknownCode.broadcast_transaction_response.result = Math.max(...Object.values(ResultCode)) + 1;
-    t.absent(v.validateV1BroadcastTransactionResponse(unknownCode), 'unknown result code should fail');
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1BroadcastTransactionResponse.bind(v),
-        validFixture,
-        'broadcast_transaction_response',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1BroadcastTransactionResponse - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1BroadcastTransactionResponse.bind(v),
-        validFixture,
-        'broadcast_transaction_response',
-        ['nonce', 'signature']
-    );
-});