trac-msb 0.2.13 → 0.2.15

package/tests/unit/network/services/ValidatorHealthCheckService.test.js

@@ -1,115 +0,0 @@
-import sinon from 'sinon';
-import { test } from 'brittle';
-import ValidatorHealthCheckService from '../../../../src/core/network/services/ValidatorHealthCheckService.js';
-import { createConfig, ENV } from '../../../../src/config/env.js';
-import { EventType } from '../../../../src/utils/constants.js';
-import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
-
-test('ValidatorHealthCheckService', () => {
-    test('throws when start is called before ready', async (t) => {
-        const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-        const service = new ValidatorHealthCheckService(config);
-
-        await t.exception(() => service.start(testKeyPair1.publicKey));
-        await service.close();
-    });
-
-    test('constructor rejects invalid interval', async (t) => {
-        const badConfig = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: -1 });
-
-        await t.exception.all(() => new ValidatorHealthCheckService(badConfig));
-    });
-
-    test('constructor defaults interval when missing', async (t) => {
-        const config = createConfig(ENV.MAINNET, {});
-        const service = new ValidatorHealthCheckService(config);
-        await service.ready();
-
-        t.is(service.start(testKeyPair1.publicKey), true);
-        t.is(service.start(testKeyPair1.publicKey), false);
-        await service.close();
-    });
-
-    test('stop returns false when no schedule exists', async (t) => {
-        const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-        const service = new ValidatorHealthCheckService(config);
-        await service.ready();
-
-        t.is(service.stop(testKeyPair1.publicKey), false);
-        await service.close();
-    });
-
-    test('has throws on invalid public key type', async (t) => {
-        const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-        const service = new ValidatorHealthCheckService(config);
-        await service.ready();
-
-        await t.exception.all(() => service.has(123));
-        await service.close();
-    });
-
-    test('start returns false when already scheduled', async (t) => {
-        const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-        const service = new ValidatorHealthCheckService(config);
-        await service.ready();
-
-        t.ok(service.start(testKeyPair1.publicKey));
-        t.is(service.start(testKeyPair1.publicKey), false);
-        await service.close();
-    });
-
-    test('emits health check on interval', async (t) => {
-        const clock = sinon.useFakeTimers({ now: 0 });
-        try {
-            const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-            const service = new ValidatorHealthCheckService(config);
-            await service.ready();
-
-            const emitted = new Promise(resolve => {
-                service.once(EventType.VALIDATOR_HEALTH_CHECK, (publicKey, requestId) => {
-                    resolve({ publicKey, requestId });
-                });
-            });
-            t.ok(service.start(testKeyPair1.publicKey));
-
-            await clock.tickAsync(1000);
-            const { publicKey, requestId } = await emitted;
-            t.is(publicKey, testKeyPair1.publicKey.toLowerCase());
-            t.ok(requestId);
-            await service.close();
-        } finally {
-            clock.restore();
-            sinon.restore();
-        }
-    });
-
-    test('stopAll cancels scheduled checks', async (t) => {
-        const clock = sinon.useFakeTimers({ now: 0 });
-        try {
-            const config = createConfig(ENV.MAINNET, { validatorHealthCheckInterval: 1000 });
-            const service = new ValidatorHealthCheckService(config);
-            await service.ready();
-            const emitted = [];
-            const waitForTwo = new Promise(resolve => {
-                service.on(EventType.VALIDATOR_HEALTH_CHECK, (publicKey, requestId) => {
-                    emitted.push({ publicKey, requestId });
-                    if (emitted.length === 2) resolve();
-                });
-            });
-            t.ok(service.start(testKeyPair1.publicKey));
-            t.ok(service.start(testKeyPair2.publicKey));
-
-            await clock.tickAsync(1000);
-            await waitForTwo;
-            t.is(emitted.length, 2);
-
-            await service.close();
-
-            await clock.tickAsync(1000);
-            t.is(emitted.length, 2);
-        } finally {
-            clock.restore();
-            sinon.restore();
-        }
-    });
-});

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

@@ -1,17 +0,0 @@
-// This runner is auto-generated by Brittle
-
-import { default as test } from 'brittle';
-
-async function runTests() {
-    test.pause();
-    await import('./ValidatorHealthCheckService.test.js');
-    await import('./TransactionRateLimiterService.test.js');
-    await import('./ConnectionManager.test.js');
-    await import('./MessageOrchestrator.test.js');
-    await import('./PendingRequestService.test.js');
-    await import('./TransactionCommitService.test.js');
-    await import('./TransactionPoolService.test.js');
-    test.resume();
-}
-
-await runTests();

package/tests/unit/network/utils/v1TestUtils.js

@@ -1,153 +0,0 @@
-import b4a from 'b4a';
-import sinon from 'sinon';
-import { config } from '../../../helpers/config.js';
-import { NetworkOperationType, V1_PROTOCOL_PAYLOAD_MAX_SIZE } from '../../../../src/utils/constants.js';
-import { encodeV1networkOperation } from '../../../../src/utils/protobuf/operationHelpers.js';
-import NetworkMessageRouterV1 from '../../../../src/core/network/protocols/v1/NetworkMessageRouter.js';
-import V1LivenessOperationHandler from '../../../../src/core/network/protocols/v1/handlers/V1LivenessOperationHandler.js';
-import V1BroadcastTransactionOperationHandler from '../../../../src/core/network/protocols/v1/handlers/V1BroadcastTransactionOperationHandler.js';
-
-const resolveStub = (stubSource) => {
-    if (typeof stubSource === 'function') {
-        return stubSource;
-    }
-    if (stubSource && typeof stubSource.stub === 'function') {
-        return stubSource.stub.bind(stubSource);
-    }
-    throw new Error('Stub source must provide a stub function');
-};
-
-export const makeConnection = (stubSource) => {
-    const stub = resolveStub(stubSource);
-    return {
-        remotePublicKey: b4a.alloc(32, 0x01),
-        protocolSession: {
-            setV1AsPreferredProtocol: stub()
-        },
-        end: stub()
-    };
-};
-
-export const makeHandlers = (sandbox) => ({
-    livenessRequest: sandbox.stub(V1LivenessOperationHandler.prototype, 'handleRequest').resolves(),
-    livenessResponse: sandbox.stub(V1LivenessOperationHandler.prototype, 'handleResponse').resolves(),
-    broadcastRequest: sandbox.stub(V1BroadcastTransactionOperationHandler.prototype, 'handleRequest').resolves(),
-    broadcastResponse: sandbox.stub(V1BroadcastTransactionOperationHandler.prototype, 'handleResponse').resolves()
-});
-
-export const makeRouter = (t, { walletAddress = 'test-wallet' } = {}) => {
-    const sandbox = sinon.createSandbox();
-    if (t && typeof t.teardown === 'function') {
-        t.teardown(() => sandbox.restore());
-    }
-    sandbox.stub(console, 'error');
-
-    const handlerStubs = makeHandlers(sandbox);
-    const router = new NetworkMessageRouterV1(
-        {},
-        { address: walletAddress },
-        {},
-        {},
-        {},
-        {},
-        config
-    );
-
-    return { router, handlerStubs, sandbox };
-};
-
-export const makeRouterContext = (t, options) => {
-    const { router, handlerStubs, sandbox } = makeRouter(t, options);
-    const connection = makeConnection(sandbox);
-    return { router, handlerStubs, sandbox, connection };
-};
-
-export const buildMessage = (type, extra = {}) => encodeV1networkOperation({
-    type,
-    id: '1',
-    ...extra
-});
-
-export const buildEmptyMessage = () => b4a.alloc(0);
-
-export const buildOversizedMessage = () => b4a.alloc(V1_PROTOCOL_PAYLOAD_MAX_SIZE + 1, 0x01);
-
-export const buildMalformedMessage = () => b4a.from([0x07]);
-
-export const buildMaxSizeMessage = () => {
-    const basePayload = {
-        type: NetworkOperationType.LIVENESS_REQUEST,
-        id: '1',
-        capabilities: ['']
-    };
-    const baseLength = encodeV1networkOperation(basePayload).length;
-    let fillerLength = Math.max(0, V1_PROTOCOL_PAYLOAD_MAX_SIZE - baseLength - 1);
-    let buffer = encodeV1networkOperation({
-        ...basePayload,
-        capabilities: ['a'.repeat(fillerLength)]
-    });
-
-    if (buffer.length !== V1_PROTOCOL_PAYLOAD_MAX_SIZE) {
-        const delta = V1_PROTOCOL_PAYLOAD_MAX_SIZE - buffer.length;
-        fillerLength = Math.max(0, fillerLength + delta);
-        buffer = encodeV1networkOperation({
-            ...basePayload,
-            capabilities: ['a'.repeat(fillerLength)]
-        });
-    }
-
-    if (buffer.length !== V1_PROTOCOL_PAYLOAD_MAX_SIZE) {
-        throw new Error(
-            `Failed to build payload of size ${V1_PROTOCOL_PAYLOAD_MAX_SIZE}, got ${buffer.length}`
-        );
-    }
-
-    return buffer;
-};
-
-export const getUnsupportedType = () => {
-    const values = Object.values(NetworkOperationType).map(Number);
-    return Math.max(...values) + 1;
-};
-
-export const assertDisconnected = (t, connection, message = 'should end connection') => {
-    t.ok(connection.end.calledOnce, message);
-};
-
-export const assertPreferredSet = (t, connection, message = 'should set preferred protocol') => {
-    t.ok(connection.protocolSession.setV1AsPreferredProtocol.calledOnce, message);
-};
-
-export const assertPreferredNotSet = (t, connection, message = 'should not set preferred protocol') => {
-    t.ok(connection.protocolSession.setV1AsPreferredProtocol.notCalled, message);
-};
-
-export const assertNoHandlersCalled = (t, handlerStubs) => {
-    for (const [key, stub] of Object.entries(handlerStubs)) {
-        t.ok(stub.notCalled, `${key} not called`);
-    }
-};
-
-export const assertOnlyHandlerCalled = (t, handlerStubs, expectedKey) => {
-    for (const [key, stub] of Object.entries(handlerStubs)) {
-        if (key === expectedKey) {
-            t.ok(stub.calledOnce, `${key} called`);
-        } else {
-            t.ok(stub.notCalled, `${key} not called`);
-        }
-    }
-};
-
-export const assertRejected = (
-    t,
-    { connection, handlerStubs, preferred = 'not', disconnectMessage } = {}
-) => {
-    if (preferred === 'set') {
-        assertPreferredSet(t, connection);
-    } else {
-        assertPreferredNotSet(t, connection);
-    }
-
-    assertDisconnected(t, connection, disconnectMessage);
-    assertNoHandlersCalled(t, handlerStubs);
-};

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

@@ -1,151 +0,0 @@
-import { test } from 'brittle';
-import { NetworkOperationType } from '../../../../src/utils/constants.js';
-import {
-    assertDisconnected,
-    assertOnlyHandlerCalled,
-    assertPreferredSet,
-    assertRejected,
-    buildEmptyMessage,
-    buildMalformedMessage,
-    buildMaxSizeMessage,
-    buildMessage,
-    buildOversizedMessage,
-    getUnsupportedType,
-    makeRouterContext
-} from '../utils/v1TestUtils.js';
-
-const SUPPORTED_OPERATION_CASES = [
-    {
-        name: 'LIVENESS_REQUEST -> liveness.handleRequest',
-        type: NetworkOperationType.LIVENESS_REQUEST,
-        handlerKey: 'livenessRequest'
-    },
-    {
-        name: 'LIVENESS_RESPONSE -> liveness.handleResponse',
-        type: NetworkOperationType.LIVENESS_RESPONSE,
-        handlerKey: 'livenessResponse'
-    },
-    {
-        name: 'BROADCAST_TRANSACTION_REQUEST -> broadcast.handleRequest',
-        type: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST,
-        handlerKey: 'broadcastRequest'
-    },
-    {
-        name: 'BROADCAST_TRANSACTION_RESPONSE -> broadcast.handleResponse',
-        type: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE,
-        handlerKey: 'broadcastResponse'
-    }
-];
-
-const runRejectionCase = async (t, message, { preferred = 'not' } = {}) => {
-    const { router, handlerStubs, connection } = makeRouterContext(t);
-    await router.route(message, connection);
-    assertRejected(t, { connection, handlerStubs, preferred });
-};
-
-test('NetworkMessageRouterV1', async (t) => {
-    await t.test('pre-validation', async (t) => {
-        const cases = [
-            { name: 'rejects null message', message: null },
-            { name: 'rejects non-buffer message', message: 'not-a-buffer' },
-            { name: 'rejects empty buffer', message: buildEmptyMessage() },
-            { name: 'rejects oversized buffer', message: buildOversizedMessage() }
-        ];
-
-        for (const { name, message } of cases) {
-            await t.test(name, async (t) => {
-                await runRejectionCase(t, message);
-            });
-        }
-
-        await t.test('accepts max size payload', async (t) => {
-            const { router, handlerStubs, connection } = makeRouterContext(t);
-            const maxSizePayload = buildMaxSizeMessage();
-
-            await router.route(maxSizePayload, connection);
-
-            assertPreferredSet(t, connection);
-            t.ok(connection.end.notCalled, 'should not end connection');
-            t.ok(handlerStubs.livenessRequest.calledOnce, 'liveness handler called');
-        });
-    });
-
-    await t.test('decode failures', async (t) => {
-        await t.test('disconnects on decode error', async (t) => {
-            await runRejectionCase(t, buildMalformedMessage());
-        });
-    });
-
-    await t.test('type validation', async (t) => {
-        const invalidTypeCases = [
-            { name: 'rejects type 0', message: buildMessage(0) },
-            {
-                name: 'rejects missing type (defaults to 0)',
-                message: buildMessage(NetworkOperationType.LIVENESS_REQUEST, { type: undefined })
-            }
-        ];
-
-        for (const { name, message } of invalidTypeCases) {
-            await t.test(name, async (t) => {
-                await runRejectionCase(t, message);
-            });
-        }
-
-        await t.test('unsupported type disconnects after setting preferred protocol', async (t) => {
-            await runRejectionCase(t, buildMessage(getUnsupportedType()), { preferred: 'set' });
-        });
-    });
-
-    await t.test('routing', async (t) => {
-        for (const { name, type, handlerKey } of SUPPORTED_OPERATION_CASES) {
-            await t.test(name, async (t) => {
-                const { router, handlerStubs, connection } = makeRouterContext(t);
-
-                await router.route(buildMessage(type), connection);
-
-                assertPreferredSet(t, connection);
-                t.ok(connection.end.notCalled, 'should not end connection');
-                assertOnlyHandlerCalled(t, handlerStubs, handlerKey);
-
-                const handler = handlerStubs[handlerKey];
-                t.is(handler.firstCall.args[0].type, type, 'passes decoded message');
-                t.is(handler.firstCall.args[1], connection, 'passes connection');
-            });
-        }
-
-        const handlerErrorCases = [
-            {
-                name: 'liveness handler throws',
-                type: NetworkOperationType.LIVENESS_REQUEST,
-                handlerKey: 'livenessRequest',
-                error: new Error('handler-fail')
-            },
-            {
-                name: 'broadcast request handler throws',
-                type: NetworkOperationType.BROADCAST_TRANSACTION_REQUEST,
-                handlerKey: 'broadcastRequest',
-                error: new Error('broadcast-request-fail')
-            },
-            {
-                name: 'broadcast response handler throws',
-                type: NetworkOperationType.BROADCAST_TRANSACTION_RESPONSE,
-                handlerKey: 'broadcastResponse',
-                error: new Error('broadcast-response-fail')
-            }
-        ];
-
-        for (const { name, type, handlerKey, error } of handlerErrorCases) {
-            await t.test(name, async (t) => {
-                const { router, handlerStubs, connection } = makeRouterContext(t);
-
-                handlerStubs[handlerKey].rejects(error);
-
-                await router.route(buildMessage(type), connection);
-
-                assertPreferredSet(t, connection);
-                t.ok(handlerStubs[handlerKey].calledOnce, 'handler called');
-                assertDisconnected(t, connection);
-            });
-        }
-    });
-});