trac-msb 0.2.12 → 0.2.13

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

@@ -0,0 +1,450 @@
+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))
+        })
+    })
+})