trac-msb 0.2.12 → 0.2.13

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

@@ -0,0 +1,445 @@
+import { hook, test } from 'brittle';
+import sinon from 'sinon';
+import b4a from 'b4a';
+
+import { createConfig, ENV } from '../../../../src/config/env.js';
+import MessageOrchestrator from '../../../../src/core/network/services/MessageOrchestrator.js';
+import { OperationType, ResultCode } from '../../../../src/utils/constants.js';
+import NetworkWalletFactory from '../../../../src/core/network/identity/NetworkWalletFactory.js';
+import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
+import { publicKeyToAddress } from '../../../../src/utils/helpers.js';
+import { ConnectionManagerError } from '../../../../src/core/network/services/ConnectionManager.js';
+import { V1TimeoutError } from '../../../../src/core/network/protocols/v1/V1ProtocolError.js';
+
+const VALIDATOR_KEY = testKeyPair2.publicKey;
+
+const createWallet = (config) => {
+    const keyPair = {
+        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
+        secretKey: b4a.from(testKeyPair1.secretKey, 'hex'),
+    };
+    return NetworkWalletFactory.provide({
+        enableWallet: false,
+        keyPair,
+        networkPrefix: config.addressPrefix,
+    });
+};
+
+const createTransferMessage = (config, wallet) => ({
+    type: OperationType.TRANSFER,
+    address: wallet.address,
+    tro: {
+        tx: 'aa'.repeat(32),
+        txv: 'bb'.repeat(32),
+        in: 'cc'.repeat(32),
+        to: publicKeyToAddress(testKeyPair2.publicKey, config),
+        am: '00'.repeat(16),
+        is: 'dd'.repeat(64),
+    },
+});
+
+const createConnectionManager = ({
+    preferredProtocol = 'v1',
+    sendSingleMessage = sinon.stub().resolves(ResultCode.OK),
+    sentCount = 0,
+    connectedValidators = [VALIDATOR_KEY],
+} = {}) => ({
+    pickRandomConnectedValidator: sinon.stub().returns(VALIDATOR_KEY),
+    pickRandomValidator: sinon.stub().callsFake((validators) => validators[0] ?? null),
+    connectedValidators: sinon.stub().returns(connectedValidators),
+    getConnection: sinon.stub().returns({
+        protocolSession: {
+            preferredProtocol,
+            supportedProtocols: {
+                LEGACY: 'legacy',
+                V1: 'v1',
+            }
+        }
+    }),
+    sendSingleMessage,
+    remove: sinon.stub(),
+    incrementSentCount: sinon.stub(),
+    getSentCount: sinon.stub().returns(sentCount),
+});
+
+hook('setup', () => {
+    sinon.stub(console, 'log');
+    sinon.stub(console, 'warn');
+});
+
+hook('teardown', () => {
+    sinon.restore();
+});
+
+test('MessageOrchestrator.send returns false for unsupported protocol', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({ preferredProtocol: 'unknown' });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message, 0);
+
+    t.is(result, false);
+    t.is(connectionManager.sendSingleMessage.callCount, 0);
+});
+
+test('MessageOrchestrator.send V1 matrix: OK -> SUCCESS', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(ResultCode.OK),
+        sentCount: 0,
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(connectionManager.incrementSentCount.callCount, 1);
+    t.is(connectionManager.remove.callCount, 0);
+});
+
+test('MessageOrchestrator.send V1 matrix: TIMEOUT -> ROTATE', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(ResultCode.TIMEOUT),
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, false);
+    t.is(connectionManager.sendSingleMessage.callCount, 1);
+    t.is(connectionManager.remove.callCount, 1);
+    t.is(connectionManager.incrementSentCount.callCount, 0);
+});
+
+test('MessageOrchestrator.send V1 matrix: TX_ALREADY_PENDING -> NO_ROTATE', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(ResultCode.TX_ALREADY_PENDING),
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, false);
+    t.is(connectionManager.sendSingleMessage.callCount, 1);
+    t.is(connectionManager.remove.callCount, 0);
+    t.is(connectionManager.incrementSentCount.callCount, 0);
+});
+
+test('MessageOrchestrator.send V1 matrix: unknown code -> UNDEFINED', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(99999),
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, false);
+    t.is(connectionManager.sendSingleMessage.callCount, 1);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send removes validator when threshold reached on success', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(ResultCode.OK),
+        sentCount: config.messageThreshold,
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(connectionManager.incrementSentCount.callCount, 1);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send retries on ConnectionManagerError without removing validator', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub();
+    sendSingleMessage.onFirstCall().rejects(new ConnectionManagerError('disconnected'));
+    sendSingleMessage.onSecondCall().resolves(ResultCode.OK);
+
+    const connectionManager = createConnectionManager({ sendSingleMessage, sentCount: 0 });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 0);
+    t.is(connectionManager.incrementSentCount.callCount, 1);
+});
+
+test('MessageOrchestrator.send retries on generic catch error with remove + retry', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub();
+    sendSingleMessage.onFirstCall().rejects(new Error('response validation failed'));
+    sendSingleMessage.onSecondCall().resolves(ResultCode.OK);
+
+    const connectionManager = createConnectionManager({ sendSingleMessage, sentCount: 0 });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 1);
+    t.is(connectionManager.incrementSentCount.callCount, 1);
+});
+
+test('MessageOrchestrator.send max retries guard returns false immediately', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 1 });
+    const connectionManager = createConnectionManager({
+        sendSingleMessage: sinon.stub().resolves(ResultCode.OK),
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message, 2);
+
+    t.is(result, false);
+    t.is(connectionManager.pickRandomConnectedValidator.callCount, 0);
+    t.is(connectionManager.sendSingleMessage.callCount, 0);
+});
+
+test('MessageOrchestrator.send timeout split: pending timeout rejection goes through catch and retries', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub();
+    sendSingleMessage.onFirstCall().rejects(new V1TimeoutError('pending request timeout', false));
+    sendSingleMessage.onSecondCall().resolves(ResultCode.OK);
+
+    const connectionManager = createConnectionManager({ sendSingleMessage });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send timeout split: TIMEOUT result code stays in then path and does not retry', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub().resolves(ResultCode.TIMEOUT);
+    const connectionManager = createConnectionManager({ sendSingleMessage });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, false);
+    t.is(sendSingleMessage.callCount, 1);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send validation split: thrown validation error goes through catch', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub();
+    sendSingleMessage.onFirstCall().rejects(new Error('validator response validation failed'));
+    sendSingleMessage.onSecondCall().resolves(ResultCode.OK);
+
+    const connectionManager = createConnectionManager({ sendSingleMessage });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send validation split: non-OK result code stays in then and uses policy', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 2 });
+    const sendSingleMessage = sinon.stub().resolves(ResultCode.SCHEMA_VALIDATION_FAILED);
+    const connectionManager = createConnectionManager({ sendSingleMessage });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, false);
+    t.is(sendSingleMessage.callCount, 1);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send legacy path succeeds and increments sent count', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 0 });
+    const sendSingleMessage = sinon.stub().resolves(true);
+    const connectionManager = createConnectionManager({
+        preferredProtocol: 'legacy',
+        sendSingleMessage,
+        sentCount: 0,
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+    sinon.stub(orchestrator, 'waitForUnsignedState').resolves(true);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 1);
+    t.is(connectionManager.incrementSentCount.callCount, 1);
+    t.is(connectionManager.remove.callCount, 0);
+});
+
+test('MessageOrchestrator.send legacy path false result removes validator and retries', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 1 });
+    const sendSingleMessage = sinon.stub().resolves(true);
+    const connectionManager = createConnectionManager({
+        preferredProtocol: 'legacy',
+        sendSingleMessage,
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+    const waitStub = sinon.stub(orchestrator, 'waitForUnsignedState');
+    waitStub.onFirstCall().resolves(false);
+    waitStub.onSecondCall().resolves(true);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 1);
+});
+
+test('MessageOrchestrator.send legacy path catches send error and retries', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, { maxRetries: 1 });
+    const sendSingleMessage = sinon.stub();
+    sendSingleMessage.onFirstCall().rejects(new Error('legacy send failed'));
+    sendSingleMessage.onSecondCall().resolves(true);
+
+    const connectionManager = createConnectionManager({
+        preferredProtocol: 'legacy',
+        sendSingleMessage,
+    });
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const wallet = createWallet(config);
+    const message = createTransferMessage(config, wallet);
+    sinon.stub(orchestrator, 'waitForUnsignedState').resolves(true);
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 2);
+    t.is(connectionManager.remove.callCount, 0);
+});
+
+test('MessageOrchestrator.waitForUnsignedState returns true when state entry appears', async t => {
+    const clock = sinon.useFakeTimers({ now: 1 });
+    try {
+        const config = createConfig(ENV.DEVELOPMENT, {});
+        const state = {
+            get: sinon.stub()
+                .onFirstCall().resolves(null)
+                .onSecondCall().resolves({ tx: 'found' }),
+        };
+        const orchestrator = new MessageOrchestrator(createConnectionManager(), state, config);
+
+        const pending = orchestrator.waitForUnsignedState('tx-hash', 500);
+        await clock.tickAsync(450);
+        const result = await pending;
+
+        t.is(result, true);
+        t.ok(state.get.callCount >= 2);
+    } finally {
+        clock.restore();
+    }
+});
+
+test('MessageOrchestrator.waitForUnsignedState returns false on timeout', async t => {
+    const clock = sinon.useFakeTimers({ now: 1 });
+    try {
+        const config = createConfig(ENV.DEVELOPMENT, {});
+        const state = { get: sinon.stub().resolves(null) };
+        const orchestrator = new MessageOrchestrator(createConnectionManager(), state, config);
+
+        const pending = orchestrator.waitForUnsignedState('tx-hash', 400);
+        await clock.tickAsync(1000);
+        const result = await pending;
+
+        t.is(result, false);
+        t.ok(state.get.callCount >= 1);
+    } finally {
+        clock.restore();
+    }
+});
+
+test('MessageOrchestrator.send V1 avoids selecting validator with requester address when possible', async t => {
+    const config = createConfig(ENV.DEVELOPMENT, {});
+    const requesterValidatorKey = testKeyPair1.publicKey;
+    const otherValidatorKey = testKeyPair2.publicKey;
+    const sendSingleMessage = sinon.stub().resolves(ResultCode.OK);
+
+    const connectionManager = createConnectionManager({
+        sendSingleMessage,
+        connectedValidators: [requesterValidatorKey, otherValidatorKey],
+    });
+    connectionManager.getConnection = sinon.stub().returns({
+        protocolSession: {
+            preferredProtocol: 'v1',
+            supportedProtocols: {
+                LEGACY: 'legacy',
+                V1: 'v1',
+            }
+        }
+    });
+
+    const orchestrator = new MessageOrchestrator(connectionManager, { get: async () => null }, config);
+    const requesterAddress = publicKeyToAddress(requesterValidatorKey, config);
+    const wallet = createWallet(config);
+    const message = {
+        ...createTransferMessage(config, wallet),
+        address: requesterAddress,
+    };
+
+    orchestrator.setWallet(wallet);
+    const result = await orchestrator.send(message);
+
+    t.is(result, true);
+    t.is(sendSingleMessage.callCount, 1);
+    t.is(sendSingleMessage.firstCall.args[1], otherValidatorKey);
+});