NATSBridge/test/test_js_text_receiver.js

/**
 * JavaScript Text Receiver Test
 * Tests the smartreceive function with text payloads
 */

const NATSBridge = require('../src/natsbridge.js');
const crypto = require('crypto');

const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';

async function runTest() {
    console.log('=== JavaScript Text Receiver Test ===\n');
    
    // Create a mock NATS message with text payload
    const testData = {
        correlation_id: 'test-receiver-' + crypto.randomUUID(),
        msg_id: 'msg-' + crypto.randomUUID(),
        timestamp: new Date().toISOString(),
        send_to: '/test/text',
        msg_purpose: 'test',
        sender_name: 'js-text-test',
        sender_id: 'sender-' + crypto.randomUUID(),
        receiver_name: 'js-receiver',
        receiver_id: 'receiver-' + crypto.randomUUID(),
        reply_to: '',
        reply_to_msg_id: '',
        broker_url: TEST_BROKER_URL,
        metadata: {},
        payloads: [
            {
                id: 'payload-' + crypto.randomUUID(),
                dataname: 'message',
                payload_type: 'text',
                transport: 'direct',
                encoding: 'base64',
                size: 38,
                data: Buffer.from('Hello, NATSBridge! This is a test message.').toString('base64'),
                metadata: { payload_bytes: 38 }
            }
        ]
    };
    
    const mockMsg = {
        payload: JSON.stringify(testData)
    };
    
    console.log('Mock Message Created:');
    console.log(`  Correlation ID: ${testData.correlation_id}`);
    console.log(`  Payloads: ${testData.payloads.length}`);
    console.log(`  Payload dataname: ${testData.payloads[0].dataname}`);
    console.log(`  Payload type: ${testData.payloads[0].payload_type}`);
    console.log(`  Transport: ${testData.payloads[0].transport}\n`);
    
    try {
        // Receive and process the message
        console.log('Receiving and processing message...');
        const env = await NATSBridge.smartreceive(
            mockMsg,
            {
                max_retries: 3,
                base_delay: 100,
                max_delay: 1000
            }
        );
        
        console.log('\n=== Received Envelope ===');
        console.log(`Correlation ID: ${env.correlation_id}`);
        console.log(`Message ID: ${env.msg_id}`);
        console.log(`Timestamp: ${env.timestamp}`);
        console.log(`Subject: ${env.send_to}`);
        console.log(`Payloads: ${env.payloads.length}\n`);
        
        // Validate received data
        console.log('=== Validation ===');
        let passed = true;
        
        if (!env.correlation_id) {
            console.log('❌ correlation_id is missing');
            passed = false;
        } else {
            console.log('✅ correlation_id present');
        }
        
        if (env.payloads.length !== 1) {
            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
            passed = false;
        } else {
            console.log('✅ Correct number of payloads');
        }
        
        const payload = env.payloads[0];
        if (payload[0] !== 'message') {
            console.log(`❌ Expected dataname 'message', got '${payload[0]}'`);
            passed = false;
        } else {
            console.log('✅ Correct dataname');
        }
        
        if (payload[2] !== 'text') {
            console.log(`❌ Expected type 'text', got '${payload[2]}'`);
            passed = false;
        } else {
            console.log('✅ Correct type');
        }
        
        if (payload[1] !== 'Hello, NATSBridge! This is a test message.') {
            console.log(`❌ Data mismatch`);
            console.log(`   Expected: Hello, NATSBridge! This is a test message.`);
            console.log(`   Got: ${payload[1]}`);
            passed = false;
        } else {
            console.log('✅ Data correctly deserialized');
        }
        
        // Test with multiple text payloads
        console.log('\n=== Multiple Text Payloads Test ===');
        const multiTestData = {
            correlation_id: 'multi-receiver-' + crypto.randomUUID(),
            msg_id: 'msg-' + crypto.randomUUID(),
            timestamp: new Date().toISOString(),
            send_to: '/test/text',
            msg_purpose: 'test',
            sender_name: 'js-text-test',
            sender_id: 'sender-' + crypto.randomUUID(),
            receiver_name: 'js-receiver',
            receiver_id: 'receiver-' + crypto.randomUUID(),
            reply_to: '',
            reply_to_msg_id: '',
            broker_url: TEST_BROKER_URL,
            metadata: {},
            payloads: [
                {
                    id: 'payload-1',
                    dataname: 'msg1',
                    payload_type: 'text',
                    transport: 'direct',
                    encoding: 'base64',
                    size: 16,
                    data: Buffer.from('First message').toString('base64'),
                    metadata: { payload_bytes: 16 }
                },
                {
                    id: 'payload-2',
                    dataname: 'msg2',
                    payload_type: 'text',
                    transport: 'direct',
                    encoding: 'base64',
                    size: 16,
                    data: Buffer.from('Second message').toString('base64'),
                    metadata: { payload_bytes: 16 }
                },
                {
                    id: 'payload-3',
                    dataname: 'msg3',
                    payload_type: 'text',
                    transport: 'direct',
                    encoding: 'base64',
                    size: 16,
                    data: Buffer.from('Third message').toString('base64'),
                    metadata: { payload_bytes: 16 }
                }
            ]
        };
        
        const mockMultiMsg = {
            payload: JSON.stringify(multiTestData)
        };
        
        const multiEnv = await NATSBridge.smartreceive(mockMultiMsg);
        
        if (multiEnv.payloads.length === 3) {
            console.log('✅ Multiple payloads handled correctly');
            
            // Verify each payload
            const expectedMessages = ['First message', 'Second message', 'Third message'];
            for (let i = 0; i < 3; i++) {
                if (multiEnv.payloads[i][1] === expectedMessages[i]) {
                    console.log(`✅ Payload ${i + 1} correctly deserialized`);
                } else {
                    console.log(`❌ Payload ${i + 1} mismatch`);
                    passed = false;
                }
            }
        } else {
            console.log(`❌ Expected 3 payloads, got ${multiEnv.payloads.length}`);
            passed = false;
        }
        
        // Final result
        console.log('\n=== Test Result ===');
        if (passed) {
            console.log('✅ ALL TESTS PASSED');
            process.exit(0);
        } else {
            console.log('❌ SOME TESTS FAILED');
            process.exit(1);
        }
        
    } catch (error) {
        console.error('❌ Test failed with error:', error.message);
        console.error(error.stack);
        process.exit(1);
    }
}

runTest();