the-nexus/tests/test_nexus_telegram_bridge.js

/**
 * Tests for Nexus-Telegram Bridge
 * Issue #1537: feat: bridge Nexus chat to Hermes Telegram gateway
 */

const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');

const ROOT = path.resolve(__dirname, '..');

// Mock fetch
global.fetch = async (url, options) => {
    if (url.includes('/getMe')) {
        return {
            ok: true,
            json: async () => ({
                ok: true,
                result: { username: 'test_bot' }
            })
        };
    } else if (url.includes('/getUpdates')) {
        return {
            ok: true,
            json: async () => ({
                ok: true,
                result: []
            })
        };
    } else if (url.includes('/sendMessage')) {
        return {
            ok: true,
            json: async () => ({ ok: true })
        };
    }
    throw new Error(`Unexpected URL: ${url}`);
};

// Mock WebSocket
class MockWebSocket {
    constructor(url) {
        this.url = url;
        this.readyState = 1; // OPEN
        this.onopen = null;
        this.onmessage = null;
        this.onclose = null;
        this.onerror = null;
        
        // Simulate connection
        setTimeout(() => {
            if (this.onopen) this.onopen();
        }, 10);
    }
    
    send(data) {
        // Mock send
    }
    
    close() {
        this.readyState = 3; // CLOSED
        if (this.onclose) this.onclose({ code: 1000, reason: 'Normal closure' });
    }
}

global.WebSocket = MockWebSocket;

// Load nexus-telegram-bridge.js
const bridgePath = path.join(ROOT, 'js', 'nexus-telegram-bridge.js');
const bridgeCode = fs.readFileSync(bridgePath, 'utf8');

// Create VM context
const context = {
    module: { exports: {} },
    exports: {},
    console,
    window: { location: { protocol: 'http:', hostname: 'localhost' } },
    fetch: global.fetch,
    WebSocket: global.WebSocket,
    setInterval: () => {},
    clearInterval: () => {},
    setTimeout: (fn, delay) => setTimeout(fn, delay),
    Date: Date
};

// Execute in context
const vm = require('node:vm');
vm.runInNewContext(bridgeCode, context);

// Get NexusTelegramBridge
const NexusTelegramBridge = context.module.exports;

test('NexusTelegramBridge loads correctly', () => {
    assert.ok(NexusTelegramBridge, 'NexusTelegramBridge should be defined');
    assert.ok(typeof NexusTelegramBridge === 'function', 'NexusTelegramBridge should be a constructor');
});

test('NexusTelegramBridge can be instantiated', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    assert.ok(bridge, 'NexusTelegramBridge instance should be created');
    assert.equal(bridge.telegramToken, 'test_token', 'Should have telegram token');
    assert.equal(bridge.telegramChatId, 'test_chat_id', 'Should have telegram chat ID');
    assert.equal(bridge.pollInterval, 5000, 'Should have default poll interval');
    assert.ok(!bridge.isConnected, 'Should not be connected initially');
});

test('NexusTelegramBridge validates configuration', () => {
    // Should throw without token
    assert.throws(
        () => new NexusTelegramBridge({}),
        { message: /Telegram bot token required/ }
    );
    
    // Should throw without chat ID
    assert.throws(
        () => new NexusTelegramBridge({ telegramToken: 'test' }),
        { message: /Telegram chat ID required/ }
    );
});

test('NexusTelegramBridge can connect to Nexus', async () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id',
        nexusWsUrl: 'ws://localhost:8765'
    });
    
    // Mock WebSocket connection
    let connected = false;
    global.WebSocket = class extends MockWebSocket {
        constructor(url) {
            super(url);
            connected = true;
        }
    };
    
    await bridge.connectToNexus();
    
    assert.ok(connected, 'Should attempt to connect to Nexus');
    assert.ok(bridge.nexusWs, 'Should have WebSocket connection');
});

test('NexusTelegramBridge handles Nexus messages', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    let messageReceived = false;
    bridge.onNexusMessage = (data) => {
        messageReceived = true;
        assert.equal(data.type, 'chat');
        assert.equal(data.text, 'Hello from Nexus');
    };
    
    // Simulate message from Nexus
    bridge.handleNexusMessage({
        type: 'chat',
        text: 'Hello from Nexus',
        agent: 'User'
    });
    
    assert.ok(messageReceived, 'Should call onNexusMessage callback');
});

test('NexusTelegramBridge handles Telegram messages', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    let messageReceived = false;
    bridge.onTelegramMessage = (data) => {
        messageReceived = true;
        assert.equal(data.text, 'Hello from Telegram');
        assert.equal(data.from, 'Test User');
    };
    
    // Simulate update from Telegram
    bridge.handleTelegramUpdate({
        update_id: 123,
        message: {
            text: 'Hello from Telegram',
            from: { first_name: 'Test User' },
            date: Math.floor(Date.now() / 1000)
        }
    });
    
    assert.ok(messageReceived, 'Should call onTelegramMessage callback');
});

test('NexusTelegramBridge queues messages when disconnected', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    // Not connected
    assert.ok(!bridge.isConnected, 'Should not be connected');
    
    // Send message (should queue)
    bridge.sendToNexus('Test message', 'Sender');
    
    assert.equal(bridge.messageQueue.length, 1, 'Should queue message');
    assert.equal(bridge.messageQueue[0].text, 'Test message', 'Should queue correct message');
});

test('NexusTelegramBridge gets status', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    const status = bridge.getStatus();
    
    assert.ok(status, 'Should return status object');
    assert.equal(status.connected, false, 'Should not be connected');
    assert.equal(status.telegramConfigured, true, 'Should be configured');
    assert.equal(status.queuedMessages, 0, 'Should have 0 queued messages');
});

test('NexusTelegramBridge can be disconnected', () => {
    const bridge = new NexusTelegramBridge({
        telegramToken: 'test_token',
        telegramChatId: 'test_chat_id'
    });
    
    // Mock WebSocket
    bridge.nexusWs = { close: () => {} };
    bridge.isConnected = true;
    bridge.telegramPollingInterval = setInterval(() => {}, 1000);
    
    bridge.disconnect();
    
    assert.ok(!bridge.isConnected, 'Should not be connected after disconnect');
    assert.equal(bridge.nexusWs, null, 'Should clear WebSocket');
});

console.log('All NexusTelegramBridge tests passed!');