trac-msb 0.2.11 → 0.2.12

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

@@ -1,54 +0,0 @@
-import { test } from 'brittle';
-import sinon from 'sinon';
-import b4a from 'b4a';
-import { config } from '../../helpers/config.js';
-import NetworkMessageRouter from '../../../src/core/network/protocols/legacy/NetworkMessageRouter.js';
-import LegacyGetRequestHandler from '../../../src/core/network/protocols/legacy/handlers/LegacyGetRequestHandler.js';
-import LegacyResponseHandler from '../../../src/core/network/protocols/legacy/handlers/LegacyResponseHandler.js';
-import { NETWORK_MESSAGE_TYPES } from '../../../src/utils/constants.js';
-
-const makeConnection = (sandbox) => ({
-    remotePublicKey: b4a.alloc(32, 0x01),
-    protocolSession: {
-        setLegacyAsPreferredProtocol: sandbox.stub()
-    },
-    end: sandbox.stub()
-});
-
-const makeRouterContext = (t) => {
-    const sandbox = sinon.createSandbox();
-    t.teardown(() => sandbox.restore());
-
-    const getHandler = sandbox.stub(LegacyGetRequestHandler.prototype, 'handle').resolves();
-    const responseHandler = sandbox.stub(LegacyResponseHandler.prototype, 'handle').resolves();
-    const router = new NetworkMessageRouter({}, { address: 'test-wallet' }, {}, {}, config);
-    const connection = makeConnection(sandbox);
-
-    return { connection, getHandler, responseHandler, router };
-};
-
-test('LegacyNetworkMessageRouter', async (t) => {
-    await t.test('routes legacy string GET messages', async (t) => {
-        const { connection, getHandler, responseHandler, router } = makeRouterContext(t);
-        const message = NETWORK_MESSAGE_TYPES.GET.VALIDATOR;
-
-        await router.route(message, connection);
-
-        t.ok(connection.protocolSession.setLegacyAsPreferredProtocol.calledOnce, 'should prefer legacy protocol');
-        t.ok(getHandler.calledOnce, 'should route GET message');
-        t.ok(responseHandler.notCalled, 'should not route response handler');
-        t.is(getHandler.firstCall.args[0], message, 'passes GET message through to handler');
-    });
-
-    await t.test('routes legacy object response messages', async (t) => {
-        const { connection, getHandler, responseHandler, router } = makeRouterContext(t);
-        const message = { op: NETWORK_MESSAGE_TYPES.RESPONSE.VALIDATOR };
-
-        await router.route(message, connection);
-
-        t.ok(connection.protocolSession.setLegacyAsPreferredProtocol.calledOnce, 'should prefer legacy protocol');
-        t.ok(responseHandler.calledOnce, 'should route response message');
-        t.ok(getHandler.notCalled, 'should not route GET handler');
-        t.is(responseHandler.firstCall.args[0], message, 'passes response message through to handler');
-    });
-});

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

@@ -1,127 +0,0 @@
-import { test } from 'brittle';
-import sinon from 'sinon';
-import b4a from 'b4a';
-
-import NetworkWalletFactory from '../../../src/core/network/identity/NetworkWalletFactory.js';
-import ProtocolSession from '../../../src/core/network/protocols/ProtocolSession.js';
-import { ResultCode } from '../../../src/utils/constants.js';
-import { config } from '../../helpers/config.js';
-import { testKeyPair1 } from '../../fixtures/apply.fixtures.js';
-
-function createWallet() {
-    const keyPair = {
-        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
-        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
-    };
-    return NetworkWalletFactory.provide({
-        enableWallet: false,
-        keyPair,
-        networkPrefix: config.addressPrefix
-    });
-}
-
-function makeProtocol(sendStub) {
-    return {
-        send: sendStub ?? sinon.stub().resolves(ResultCode.OK),
-        sendAndForget: sinon.stub(),
-        decode: sinon.stub(),
-        close: sinon.stub()
-    };
-}
-
-test('ProtocolSession', (t) => {
-    t.teardown(() => sinon.restore());
-
-    test('probe sets preferred protocol to v1 on OK', async (t) => {
-        const v1Send = sinon.stub().resolves(ResultCode.OK);
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(v1Send),
-            createWallet(),
-            config
-        );
-
-        await session.probe();
-        t.is(session.preferredProtocol, session.supportedProtocols.V1);
-        t.ok(v1Send.calledOnce);
-    });
-
-    test('probe sets preferred protocol to legacy on non-OK', async (t) => {
-        const v1Send = sinon.stub().resolves(ResultCode.TIMEOUT);
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(v1Send),
-            createWallet(),
-            config
-        );
-
-        await session.probe();
-        t.is(session.preferredProtocol, session.supportedProtocols.LEGACY);
-        t.ok(v1Send.calledOnce);
-    });
-
-    test('probe sets preferred protocol to legacy on rejection', async (t) => {
-        const v1Send = sinon.stub().rejects(new Error('boom'));
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(v1Send),
-            createWallet(),
-            config
-        );
-
-        await session.probe();
-        t.is(session.preferredProtocol, session.supportedProtocols.LEGACY);
-        t.ok(v1Send.calledOnce);
-    });
-
-    test('sendHealthCheck returns OK when preferred is v1', async (t) => {
-        const v1Send = sinon.stub().resolves(ResultCode.OK);
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(v1Send),
-            createWallet(),
-            config
-        );
-
-        session.setV1AsPreferredProtocol();
-        const result = await session.sendHealthCheck();
-        t.is(result, ResultCode.OK);
-        t.ok(v1Send.calledOnce);
-    });
-
-    test('sendHealthCheck returns OK when preferred is legacy', async (t) => {
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(),
-            createWallet(),
-            config
-        );
-
-        session.setLegacyAsPreferredProtocol();
-        const result = await session.sendHealthCheck();
-        t.is(result, ResultCode.OK);
-    });
-
-    test('sendHealthCheck returns UNSPECIFIED when not probed', async (t) => {
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(),
-            createWallet(),
-            config
-        );
-
-        const result = await session.sendHealthCheck();
-        t.is(result, ResultCode.UNSPECIFIED);
-    });
-
-    test('isHealthCheckSupported throws when not probed', async (t) => {
-        const session = new ProtocolSession(
-            makeProtocol(),
-            makeProtocol(),
-            createWallet(),
-            config
-        );
-
-        await t.exception.all(() => session.isHealthCheckSupported());
-    });
-});

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

@@ -1,450 +0,0 @@
-import sinon from "sinon";
-import { hook, test } from 'brittle'
-import { default as EventEmitter } from "bare-events"
-import { testKeyPair1, testKeyPair2, testKeyPair3, testKeyPair4, testKeyPair5, testKeyPair6, testKeyPair7, testKeyPair8 } from "../../../fixtures/apply.fixtures.js";
-import ConnectionManager, { ConnectionManagerError } from "../../../../src/core/network/services/ConnectionManager.js";
-import { tick } from "../../../helpers/setupApplyTests.js";
-import b4a from 'b4a'
-import { createConfig, ENV } from "../../../../src/config/env.js";
-import { EventType, ResultCode } from "../../../../src/utils/constants.js";
-
-const createConnection = (key) => {
-    const emitter = new EventEmitter()
-    emitter.protocolSession = {
-        has: (name) => name === 'legacy',
-        send: sinon.stub().resolves(),
-    };
-    emitter.connected = true
-    emitter.remotePublicKey = b4a.from(key, 'hex')
-
-    return { key: b4a.from(key, 'hex'), connection: emitter }
-}
-
-const createV1Connection = (key, sendHealthCheckStub = sinon.stub().resolves(ResultCode.OK)) => {
-    const emitter = new EventEmitter()
-    emitter.protocolSession = {
-        sendHealthCheck: sendHealthCheckStub
-    };
-    emitter.connected = true
-    emitter.remotePublicKey = b4a.from(key, 'hex')
-    emitter.end = sinon.stub()
-
-    return { key: b4a.from(key, 'hex'), connection: emitter }
-}
-
-const makeHealthCheckService = () => {
-    const emitter = new EventEmitter();
-    emitter.has = sinon.stub().returns(true);
-    emitter.stop = sinon.stub();
-    return emitter;
-};
-
-const makeManager = (maxValidators = 6, conns = connections) => {
-    const merged = createConfig(ENV.DEVELOPMENT, { maxValidators })
-    const connectionManager = new ConnectionManager(merged)
-
-    conns.forEach(({ key, connection }) => {
-        connectionManager.addValidator(key, connection)
-    });
-
-    return connectionManager
-}
-
-const reset = () => {
-    sinon.restore()
-    connections.forEach(connection => {
-        connection.connection.protocolSession.send.resetHistory()
-    })
-}
-
-let connections
-hook('Initialize state', async () => {
-    connections = [
-        createConnection(testKeyPair1.publicKey),
-        createConnection(testKeyPair2.publicKey),
-        createConnection(testKeyPair3.publicKey),
-        createConnection(testKeyPair4.publicKey),
-    ]
-});
-
-test('ConnectionManager', () => {
-    test('addValidator', async t => {
-        test('adds a validator', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
-            const data = createConnection(testKeyPair5.publicKey)
-            connectionManager.addValidator(data.key, data.connection)
-            t.is(connectionManager.connectionCount(), connections.length + 1, 'should have the same length')
-        })
-
-        test('dont surpass maxConnections', async t => {
-            reset()
-            const maxConnections = 5
-            const connectionManager = makeManager(maxConnections)
-            t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
-
-            const toAdd = createConnection(testKeyPair5.publicKey)
-            connectionManager.addValidator(toAdd.key, toAdd.connection)
-            t.is(connectionManager.connectionCount(), maxConnections, 'should match the max connections')
-
-            const toNotAdd = createConnection(testKeyPair6.publicKey)
-            connectionManager.addValidator(toNotAdd.key, toNotAdd.connection)
-            t.is(connectionManager.connectionCount(), maxConnections, 'should not increase length')
-        })
-
-        test('does not add new validator when pool is full', async t => {
-            reset()
-            const maxConnections = 2
-            const localConnections = [
-                createConnection(testKeyPair1.publicKey),
-                createConnection(testKeyPair2.publicKey),
-            ]
-
-            const connectionManager = makeManager(maxConnections)
-            localConnections.forEach(({ key, connection }) => {
-                connectionManager.addValidator(key, connection)
-            })
-
-            t.is(connectionManager.connectionCount(), maxConnections, 'pool should be full')
-
-            const newConn = createConnection(testKeyPair3.publicKey)
-            connectionManager.addValidator(newConn.key, newConn.connection)
-
-            t.is(connectionManager.connectionCount(), maxConnections, 'should stay at max size')
-            t.not(connectionManager.connected(newConn.key), 'new validator should not be in the pool')
-
-            const remainingOld = localConnections.filter(c => connectionManager.connected(c.key)).length
-            t.is(remainingOld, 2, 'all of the old validators should remain')
-        })
-    })
-
-    test('connected', async t => {
-        test('true', async t => {
-            reset()
-            const connectionManager = makeManager()
-            connections.forEach(con => {
-                t.ok(connectionManager.connected(con.key), 'should respond true')
-            })
-        })
-
-        test('false', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.ok(!connectionManager.connected(testKeyPair6.publicKey), 'should respond false')
-        })
-    })
-
-    test('sendSingleMessage', async t => {
-        test('returns exact resultCode from protocolSession.send', async t => {
-            reset()
-            const data = createConnection(testKeyPair1.publicKey)
-            data.connection.protocolSession.send = sinon.stub().resolves(ResultCode.TIMEOUT)
-            const connectionManager = makeManager(6, [data])
-
-            const result = await connectionManager.sendSingleMessage({ payload: 1 }, testKeyPair1.publicKey)
-
-            t.is(result, ResultCode.TIMEOUT, 'should return the exact result code from protocol session')
-            t.ok(data.connection.protocolSession.send.calledOnce, 'should invoke protocolSession.send')
-        })
-
-        test('throws ConnectionManagerError when validator is disconnected', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            try {
-                await connectionManager.sendSingleMessage({ payload: 1 }, testKeyPair8.publicKey)
-                t.fail('expected sendSingleMessage to throw')
-            } catch (error) {
-                t.ok(error instanceof ConnectionManagerError, 'should throw ConnectionManagerError')
-                t.ok(error.message.includes('is not connected'), 'should include disconnected validator details')
-            }
-        })
-
-        test('throws ConnectionManagerError when protocolSession is missing', async t => {
-            reset()
-            const emitter = new EventEmitter()
-            emitter.connected = true
-            emitter.remotePublicKey = b4a.from(testKeyPair6.publicKey, 'hex')
-            emitter.end = sinon.stub()
-            const data = {
-                key: b4a.from(testKeyPair6.publicKey, 'hex'),
-                connection: emitter,
-            }
-
-            const connectionManager = makeManager(6, [data])
-
-            try {
-                await connectionManager.sendSingleMessage({ payload: 1 }, testKeyPair6.publicKey)
-                t.fail('expected sendSingleMessage to throw')
-            } catch (error) {
-                t.ok(error instanceof ConnectionManagerError, 'should throw ConnectionManagerError')
-                t.ok(error.message.includes('no valid connection found'), 'should include protocol session details')
-            }
-        })
-    })
-
-    // Note: These tests were commented out because connectionManager.send is being deprecated. When it is completely removed, the tests should be deleted.
-    // test('send', async t => {
-    //     // test('triggers send on messenger', async t => {
-    //     //     reset()
-    //     //     const connectionManager = makeManager()
-
-    //     //     const target = connectionManager.send([1,2,3,4])
-
-    //     //     const totalCalls = connections.reduce((sum, con) => sum + con.connection.protocolSession.send.callCount, 0)
-    //     //     t.is(totalCalls, 1, 'should send to exactly one validator')
-    //     //     t.ok(target, 'should return a target public key')
-    //     // })
-
-    //     test('does not throw on individual send errors', async t => {
-    //         reset()
-    //         const errorConnections = [
-    //             createConnection(testKeyPair7.publicKey),
-    //             createConnection(testKeyPair8.publicKey),
-    //         ]
-
-    //         errorConnections.forEach(con => {
-    //             con.connection.protocolSession.send = sinon.stub().throws(new Error())
-    //         })
-
-    //         const connectionManager = makeManager(5, errorConnections)
-
-    //         t.is(errorConnections.length, 2, 'should have two connections')
-    //         connectionManager.send([1,2,3,4])
-    //         t.ok(true, 'send should not throw even if individual sends fail')
-    //     })
-    // })
-
-    test('on close', async t => {
-        test('removes from list', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            const connectionCount = connectionManager.connectionCount()
-
-            connections[1].connection.connected = false
-            connections[1].connection.emit('close')
-            await tick()
-            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
-        })
-    })
-
-    test('remove', async t => {
-        test('removes a validator by public key', async t => {
-            reset()
-            const connectionManager = makeManager()
-            const previousCount = connectionManager.connectionCount()
-            const lastValidator = connections.shift()
-
-            t.ok(connectionManager.connected(lastValidator.key), 'should be connected')
-            connectionManager.remove(lastValidator.key)
-
-            t.is(connectionManager.connectionCount(), previousCount - 1, 'should reduce the connection count')
-            t.ok(!connectionManager.connected(lastValidator.key), 'should be connected')
-        })
-    })
-
-    test('on close', async t => {
-        test('removes from list', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            const connectionCount = connectionManager.connectionCount()
-
-            connections[1].connection.connected = false
-            connections[1].connection.emit('close')
-            await tick()
-            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
-        })
-    })
-
-    test('health checks (strict)', async t => {
-        test('keeps validator on OK response', async t => {
-            try {
-                const v1Conn = createV1Connection(testKeyPair1.publicKey, sinon.stub().resolves(ResultCode.OK));
-                const connectionManager = makeManager(6, [v1Conn]);
-                const healthCheckService = makeHealthCheckService();
-                connectionManager.subscribeToHealthChecks(healthCheckService);
-
-                healthCheckService.emit(
-                    EventType.VALIDATOR_HEALTH_CHECK,
-                    testKeyPair1.publicKey,
-                    "123456"
-                );
-
-                await tick();
-                t.ok(connectionManager.connected(v1Conn.key));
-                t.is(healthCheckService.stop.callCount, 0);
-            } finally {
-                sinon.restore();
-            }
-        });
-
-        test('removes validator on non-OK response', async t => {
-            try {
-                const v1Conn = createV1Connection(testKeyPair2.publicKey, sinon.stub().resolves(ResultCode.TIMEOUT));
-                const connectionManager = makeManager(6, [v1Conn]);
-                const healthCheckService = makeHealthCheckService();
-                connectionManager.subscribeToHealthChecks(healthCheckService);
-
-                healthCheckService.emit(
-                    EventType.VALIDATOR_HEALTH_CHECK,
-                    testKeyPair2.publicKey,
-                    "123456"
-                );
-
-                await tick();
-                t.ok(!connectionManager.connected(v1Conn.key));
-                t.ok(healthCheckService.stop.callCount >= 1);
-            } finally {
-                sinon.restore();
-            }
-        });
-
-        test('removes validator on send rejection', async t => {
-            try {
-                const v1Conn = createV1Connection(testKeyPair3.publicKey, sinon.stub().rejects(new Error('boom')));
-                const connectionManager = makeManager(6, [v1Conn]);
-                const healthCheckService = makeHealthCheckService();
-                connectionManager.subscribeToHealthChecks(healthCheckService);
-
-                healthCheckService.emit(
-                    EventType.VALIDATOR_HEALTH_CHECK,
-                    testKeyPair3.publicKey,
-                    "123456"
-                );
-
-                await tick();
-                t.ok(!connectionManager.connected(v1Conn.key));
-                t.ok(healthCheckService.stop.callCount >= 1);
-            } finally {
-                sinon.restore();
-            }
-        });
-
-        test('ignores malformed health check events', async t => {
-            try {
-                const v1Conn = createV1Connection(testKeyPair5.publicKey, sinon.stub().resolves(ResultCode.OK));
-                const connectionManager = makeManager(6, [v1Conn]);
-                let handler = null;
-                const healthCheckService = {
-                    on: (_event, fn) => { handler = fn; },
-                    off: () => {},
-                    has: sinon.stub().returns(true),
-                    stop: sinon.stub()
-                };
-                connectionManager.subscribeToHealthChecks(healthCheckService);
-
-                const cases = [
-                    { label: 'publicKey', publicKey: 123, requestId: 'abc' },
-                    { label: 'requestId', publicKey: testKeyPair5.publicKey, requestId: 456 },
-                    { label: 'undefined', publicKey: undefined, requestId: undefined },
-                ];
-
-                for (const testCase of cases) {
-                    await handler(testCase.publicKey, testCase.requestId);
-                    t.pass(`ignored malformed payload: ${testCase.label}`);
-                }
-            } finally {
-                sinon.restore();
-            }
-        });
-    })
-
-    test('edge branches', async t => {
-        test('pickRandomValidator returns null for empty array', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.is(connectionManager.pickRandomValidator([]), null)
-        })
-
-        test('pickRandomConnectedValidator returns null when pool is empty', async t => {
-            reset()
-            const connectionManager = makeManager(6, [])
-            t.is(connectionManager.pickRandomConnectedValidator(), null)
-        })
-
-        test('remove missing validator keeps state unchanged', async t => {
-            reset()
-            const connectionManager = makeManager()
-            const before = connectionManager.connectionCount()
-            connectionManager.remove(testKeyPair8.publicKey)
-            t.is(connectionManager.connectionCount(), before)
-        })
-
-        test('remove handles connection.end throwing and still deletes validator', async t => {
-            reset()
-            const data = createConnection(testKeyPair7.publicKey)
-            data.connection.end = sinon.stub().throws(new Error('end boom'))
-            const connectionManager = makeManager(6, [data])
-
-            t.ok(connectionManager.connected(data.key))
-            connectionManager.remove(data.key)
-            t.absent(connectionManager.connected(data.key))
-        })
-
-        test('sent counters handle missing validators safely', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.is(connectionManager.getSentCount(testKeyPair8.publicKey), 0)
-            connectionManager.incrementSentCount(testKeyPair8.publicKey)
-            t.is(connectionManager.getSentCount(testKeyPair8.publicKey), 0)
-        })
-
-        test('subscribeToHealthChecks validates service interface', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            await t.exception(
-                () => connectionManager.subscribeToHealthChecks({ on() {} }),
-                /must implement on\/off/
-            )
-        })
-
-        test('health check removes validator when protocolSession is missing', async t => {
-            reset()
-            const emitter = new EventEmitter()
-            emitter.connected = true
-            emitter.remotePublicKey = b4a.from(testKeyPair6.publicKey, 'hex')
-            emitter.end = sinon.stub()
-            const data = {
-                key: b4a.from(testKeyPair6.publicKey, 'hex'),
-                connection: emitter
-            }
-
-            const connectionManager = makeManager(6, [data])
-            const healthCheckService = {
-                on: (_event, fn) => { healthCheckService.handler = fn; },
-                off: () => {},
-                has: sinon.stub().returns(true),
-                stop: sinon.stub(),
-                handler: null,
-            }
-
-            connectionManager.subscribeToHealthChecks(healthCheckService)
-            await healthCheckService.handler(testKeyPair6.publicKey, 'hc-1')
-
-            t.absent(connectionManager.connected(data.key))
-            t.ok(healthCheckService.stop.called)
-        })
-
-        test('remove tolerates health check service errors', async t => {
-            reset()
-            const data = createConnection(testKeyPair5.publicKey)
-            const connectionManager = makeManager(6, [data])
-            const healthCheckService = {
-                on: (_event, fn) => { healthCheckService.handler = fn; },
-                off: () => {},
-                has: sinon.stub().throws(new Error('has boom')),
-                stop: sinon.stub(),
-                handler: null,
-            }
-            connectionManager.subscribeToHealthChecks(healthCheckService)
-
-            connectionManager.remove(data.key)
-
-            t.absent(connectionManager.connected(data.key))
-        })
-    })
-})