@phystack/hub-client 4.5.19-dev → 4.5.21-dev

package/src/test/communication-comprehensive-test.ts

@@ -0,0 +1,533 @@
+/**
+ * Communication Comprehensive Test Suite
+ *
+ * Tests ALL communication methods between two twins:
+ *
+ * Hub-based (stateless):
+ *   1. Events - fire-and-forget messaging via instance.emit/on
+ *   2. Actions - request-response with callbacks
+ *
+ * WebRTC P2P (stateful):
+ *   3. DataChannel - default channel
+ *   4. DataChannel - named channels
+ *   5. MediaStream - connection establishment
+ *
+ * Usage (two terminals or two hosts via webrtc-test.sh):
+ *
+ *   Terminal 1 (initiator):
+ *   ```
+ *   PHYHUB_DIRECT=true \
+ *   DEVICE_ID=<device-a-id> \
+ *   ACCESS_KEY=<device-a-key> \
+ *   PEER_TWIN_ID=<device-b-twin-id> \
+ *   ROLE=initiator \
+ *   node dist/test/communication-comprehensive-test.js
+ *   ```
+ *
+ *   Terminal 2 (responder):
+ *   ```
+ *   PHYHUB_DIRECT=true \
+ *   DEVICE_ID=<device-b-id> \
+ *   ACCESS_KEY=<device-b-key> \
+ *   PEER_TWIN_ID=<device-a-twin-id> \
+ *   ROLE=responder \
+ *   node dist/test/communication-comprehensive-test.js
+ *   ```
+ */
+
+import { PhyHubClient, Instance } from '../index';
+import { PhygridDataChannel } from '../services/webrtc/types';
+
+interface TestResult {
+  name: string;
+  passed: boolean;
+  details: string;
+  duration: number;
+}
+
+const MESSAGES_PER_TEST = 3;
+const results: TestResult[] = [];
+
+function log(msg: string): void {
+  console.log(`[${new Date().toISOString().split('T')[1].slice(0, 8)}] ${msg}`);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function addResult(name: string, passed: boolean, details: string, startTime: number): void {
+  const duration = Date.now() - startTime;
+  results.push({ name, passed, details, duration });
+  const status = passed ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+  log(`[${status}] ${name}: ${details} (${duration}ms)`);
+}
+
+// =============================================================================
+// Test 1: Events (Fire-and-Forget via Hub)
+// =============================================================================
+async function testEvents(
+  client: PhyHubClient,
+  instance: Instance,
+  peerTwinId: string,
+  isInitiator: boolean
+): Promise<void> {
+  const testName = 'Events (Hub-based)';
+  const startTime = Date.now();
+  log(`\n=== Test 1: ${testName} ===`);
+
+  try {
+    let receivedCount = 0;
+    const receivedMessages: any[] = [];
+
+    // Subscribe to peer's messages
+    await client.subscribeTwin(peerTwinId);
+    log(`Subscribed to peer twin: ${peerTwinId}`);
+
+    // Register event listener
+    instance.on('test-event', (data: any) => {
+      receivedCount++;
+      receivedMessages.push(data);
+      log(`[EVENT RECEIVED] ${JSON.stringify(data)}`);
+    });
+
+    if (isInitiator) {
+      // Wait for responder to be ready
+      log('Waiting for responder to set up listeners...');
+      await sleep(3000);
+
+      // Send test events to peer
+      log('Sending test events...');
+      for (let i = 0; i < MESSAGES_PER_TEST; i++) {
+        const eventData = { type: 'test', count: i + 1, timestamp: Date.now() };
+        log(`[SENDING EVENT] ${JSON.stringify(eventData)}`);
+        // Fire-and-forget: no response expected, no promise to catch
+        instance.to(peerTwinId).emit('test-event', eventData);
+        await sleep(500);
+      }
+
+      // Wait for responses/echoes
+      await sleep(5000);
+
+      // Check if we received echo events from responder
+      const passed = receivedCount >= MESSAGES_PER_TEST;
+      addResult(testName, passed,
+        `Sent ${MESSAGES_PER_TEST}, received echoes: ${receivedCount}`, startTime);
+    } else {
+      // Responder: Listen for events and echo them back
+      log('Waiting for events from initiator...');
+
+      // Set up echo listener
+      instance.on('test-event', (data: any) => {
+        // Echo back to initiator (fire-and-forget: no promise to catch)
+        const echoData = { ...data, echo: true, echoedAt: Date.now() };
+        log(`[ECHOING EVENT] ${JSON.stringify(echoData)}`);
+        instance.to(peerTwinId).emit('test-event', echoData);
+      });
+
+      // Wait for test to complete
+      await sleep(10000);
+
+      const passed = receivedCount >= MESSAGES_PER_TEST;
+      addResult(testName, passed,
+        `Received ${receivedCount} events from initiator`, startTime);
+    }
+  } catch (error: any) {
+    addResult(testName, false, error.message, startTime);
+  }
+}
+
+// =============================================================================
+// Test 2: Actions (Request-Response via Hub)
+// =============================================================================
+async function testActions(
+  _client: PhyHubClient,
+  instance: Instance,
+  peerTwinId: string,
+  isInitiator: boolean
+): Promise<void> {
+  const testName = 'Actions (Hub-based)';
+  const startTime = Date.now();
+  log(`\n=== Test 2: ${testName} ===`);
+
+  try {
+    let successfulActions = 0;
+    let failedActions = 0;
+
+    if (isInitiator) {
+      // Wait for responder to set up action handlers
+      log('Waiting for responder to set up action handlers...');
+      await sleep(3000);
+
+      // Test: instance.to(peerTwinId).emit() with callback (action pattern)
+      log('Testing instance.to(peerTwinId).emit() with callback (action pattern)...');
+      for (let i = 0; i < MESSAGES_PER_TEST; i++) {
+        const actionType = 'test-action';
+        const actionPayload = {
+          command: 'process',
+          value: i * 10,
+          timestamp: Date.now()
+        };
+
+        log(`[SENDING ACTION ${i + 1}] ${actionType}: ${JSON.stringify(actionPayload)}`);
+
+        try {
+          // emit with callback returns a Promise (action pattern)
+          const result = await instance.to(peerTwinId).emit(actionType, actionPayload, () => {});
+          log(`[ACTION RESPONSE] ${JSON.stringify(result)}`);
+          if (result?.status === 'success') {
+            successfulActions++;
+          } else {
+            failedActions++;
+          }
+        } catch (err: any) {
+          log(`[ACTION ERROR] ${err.message || JSON.stringify(err)}`);
+          failedActions++;
+        }
+
+        await sleep(500);
+      }
+
+      const passed = successfulActions >= MESSAGES_PER_TEST;
+      addResult(testName, passed,
+        `Success: ${successfulActions}, Failed: ${failedActions}`, startTime);
+    } else {
+      // Responder: Handle requests using instance.on()
+      log('Setting up request handlers via instance.on()...');
+
+      // Register request handler - the respond callback allows sending a response
+      instance.on('test-action', (message: any, respond?: (result: any) => void) => {
+        log(`[REQUEST RECEIVED] ${JSON.stringify(message)}`);
+        // Send success response
+        if (respond) {
+          respond({ status: 'success', message: 'Request processed successfully' });
+        }
+      });
+
+      // Wait for test to complete
+      await sleep(15000);
+
+      addResult(testName, true, 'Request handler registered and responded', startTime);
+    }
+  } catch (error: any) {
+    addResult(testName, false, error.message, startTime);
+  }
+}
+
+// =============================================================================
+// Test 3: DataChannel Default (Unnamed)
+// =============================================================================
+async function testDataChannelDefault(
+  client: PhyHubClient,
+  peerTwinId: string,
+  isInitiator: boolean
+): Promise<void> {
+  const testName = 'DataChannel Default (P2P)';
+  const startTime = Date.now();
+  log(`\n=== Test 3: ${testName} ===`);
+
+  try {
+    let channel: PhygridDataChannel;
+    let receivedCount = 0;
+
+    if (isInitiator) {
+      channel = await client.getDataChannel(peerTwinId);
+      log(`Created default channel. Name: ${channel.getChannelName()}`);
+
+      if (channel.getChannelName() !== 'default') {
+        throw new Error(`Expected channel name 'default', got '${channel.getChannelName()}'`);
+      }
+
+      channel.onMessage((data) => {
+        receivedCount++;
+        log(`[DC RECEIVED] ${JSON.stringify(data)}`);
+      });
+
+      await sleep(2000);
+
+      for (let i = 0; i < MESSAGES_PER_TEST; i++) {
+        const msg = { test: 'default', num: i, timestamp: Date.now() };
+        log(`[DC SENDING] ${JSON.stringify(msg)}`);
+        channel.send(msg);
+        await sleep(300);
+      }
+
+      await sleep(3000);
+
+      addResult(testName, receivedCount >= MESSAGES_PER_TEST,
+        `Sent ${MESSAGES_PER_TEST}, received echoes: ${receivedCount}`, startTime);
+
+      channel.close();
+    } else {
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Timeout')), 30000);
+
+        client.onDataChannel(peerTwinId, (ch) => {
+          clearTimeout(timeout);
+          channel = ch;
+          log(`Received default channel. Name: ${ch.getChannelName()}`);
+
+          ch.onMessage((data) => {
+            receivedCount++;
+            log(`[DC RECEIVED] ${JSON.stringify(data)}`);
+            ch.send({ echo: data });
+          });
+
+          setTimeout(() => {
+            addResult(testName, receivedCount >= MESSAGES_PER_TEST,
+              `Received ${receivedCount} messages`, startTime);
+            resolve();
+          }, 8000);
+        });
+      });
+    }
+  } catch (error: any) {
+    addResult(testName, false, error.message, startTime);
+  }
+}
+
+// =============================================================================
+// Test 4: DataChannel Named Channels
+// =============================================================================
+async function testDataChannelNamed(
+  client: PhyHubClient,
+  peerTwinId: string,
+  isInitiator: boolean
+): Promise<void> {
+  const testName = 'DataChannel Named (P2P)';
+  const startTime = Date.now();
+  log(`\n=== Test 4: ${testName} ===`);
+
+  const channelNames = ['control', 'data'];
+  const receivedByChannel: Map<string, number> = new Map();
+
+  try {
+    if (isInitiator) {
+      const channels: PhygridDataChannel[] = [];
+
+      for (const name of channelNames) {
+        const ch = await client.getDataChannel(peerTwinId, name);
+        log(`Created channel '${name}'. Reported name: ${ch.getChannelName()}`);
+
+        if (ch.getChannelName() !== name) {
+          throw new Error(`Expected channel name '${name}', got '${ch.getChannelName()}'`);
+        }
+
+        receivedByChannel.set(name, 0);
+        ch.onMessage(() => {
+          receivedByChannel.set(name, (receivedByChannel.get(name) || 0) + 1);
+        });
+        channels.push(ch);
+      }
+
+      await sleep(3000);
+
+      for (let i = 0; i < channels.length; i++) {
+        const ch = channels[i];
+        for (let j = 0; j < MESSAGES_PER_TEST; j++) {
+          ch.send({ channel: channelNames[i], num: j });
+          await sleep(100);
+        }
+      }
+
+      await sleep(3000);
+
+      let allPassed = true;
+      for (const name of channelNames) {
+        const count = receivedByChannel.get(name) || 0;
+        if (count < MESSAGES_PER_TEST) allPassed = false;
+      }
+
+      const details = channelNames.map(n => `${n}:${receivedByChannel.get(n)}`).join(', ');
+      addResult(testName, allPassed, details, startTime);
+
+      channels.forEach(ch => ch.close());
+    } else {
+      const promises = channelNames.map(name => new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error(`Timeout for ${name}`)), 30000);
+        receivedByChannel.set(name, 0);
+
+        client.onDataChannel(peerTwinId, (ch) => {
+          clearTimeout(timeout);
+          log(`Received channel '${name}'. Reported: ${ch.getChannelName()}`);
+
+          ch.onMessage((data) => {
+            receivedByChannel.set(name, (receivedByChannel.get(name) || 0) + 1);
+            ch.send({ echo: data });
+          });
+
+          setTimeout(resolve, 10000);
+        }, name);
+      }));
+
+      await Promise.all(promises);
+
+      const details = channelNames.map(n => `${n}:${receivedByChannel.get(n)}`).join(', ');
+      const allPassed = channelNames.every(n => (receivedByChannel.get(n) || 0) >= MESSAGES_PER_TEST);
+      addResult(testName, allPassed, details, startTime);
+    }
+  } catch (error: any) {
+    addResult(testName, false, error.message, startTime);
+  }
+}
+
+// =============================================================================
+// Test 5: MediaStream Connection
+// =============================================================================
+async function testMediaStreamConnection(
+  client: PhyHubClient,
+  peerTwinId: string,
+  isInitiator: boolean
+): Promise<void> {
+  const testName = 'MediaStream (P2P)';
+  const startTime = Date.now();
+  log(`\n=== Test 5: ${testName} ===`);
+
+  try {
+    if (isInitiator) {
+      const { stream, close } = await client.getMediaStream(peerTwinId);
+      log(`MediaStream created. Target: ${stream.getTargetTwinId()}, Channel: ${stream.getChannelName()}`);
+
+      if (stream.getChannelName() !== 'default') {
+        throw new Error(`Expected channel name 'default', got '${stream.getChannelName()}'`);
+      }
+
+      stream.onTrack((track) => {
+        log(`Received track: ${track.kind}`);
+      });
+
+      await sleep(5000);
+
+      addResult(testName, true,
+        `Connected to ${stream.getTargetTwinId()}`, startTime);
+
+      close();
+    } else {
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Timeout')), 30000);
+
+        client.onMediaStream(peerTwinId, (stream) => {
+          clearTimeout(timeout);
+          log(`MediaStream received. Channel: ${stream.getChannelName()}`);
+
+          stream.onTrack((track) => {
+            log(`Track received: ${track.kind}`);
+          });
+
+          setTimeout(() => {
+            addResult(testName, true,
+              `Connected from ${stream.getTargetTwinId()}`, startTime);
+            resolve();
+          }, 5000);
+        });
+      });
+    }
+  } catch (error: any) {
+    addResult(testName, false, error.message, startTime);
+  }
+}
+
+// =============================================================================
+// Main
+// =============================================================================
+async function main(): Promise<void> {
+  console.log('='.repeat(65));
+  console.log('  Communication Comprehensive Test Suite');
+  console.log('  Hub-based: Events, Actions | P2P: DataChannels, MediaStreams');
+  console.log('='.repeat(65));
+
+  if (process.env.PHYHUB_DIRECT !== 'true') {
+    console.error('ERROR: Set PHYHUB_DIRECT=true');
+    process.exit(1);
+  }
+
+  const peerTwinId = process.env.PEER_TWIN_ID;
+  const role = process.env.ROLE?.toLowerCase();
+  const testFilter = process.env.TEST;
+
+  if (!peerTwinId) {
+    console.error('ERROR: Set PEER_TWIN_ID');
+    process.exit(1);
+  }
+
+  if (role !== 'initiator' && role !== 'responder') {
+    console.error('ERROR: Set ROLE to initiator or responder');
+    process.exit(1);
+  }
+
+  const isInitiator = role === 'initiator';
+  log(`Role: ${role}`);
+  log(`Peer Twin ID: ${peerTwinId}`);
+  if (testFilter) log(`Running only: ${testFilter}`);
+
+  try {
+    log('\nConnecting to PhyHub...');
+    const client = await PhyHubClient.connect();
+    log('Connected!');
+
+    const instance = await client.getInstance();
+    log(`Instance ID: ${instance.id}\n`);
+
+    // Define tests
+    type TestFunction = (
+      client: PhyHubClient,
+      instanceOrPeer: any,
+      peerOrBool: any,
+      isInitiator?: boolean
+    ) => Promise<void>;
+
+    const tests: Array<{ name: string; fn: TestFunction; needsInstance: boolean }> = [
+      { name: 'events', fn: testEvents as TestFunction, needsInstance: true },
+      { name: 'actions', fn: testActions as TestFunction, needsInstance: true },
+      { name: 'datachannel', fn: testDataChannelDefault as TestFunction, needsInstance: false },
+      { name: 'datachannel-named', fn: testDataChannelNamed as TestFunction, needsInstance: false },
+      { name: 'mediastream', fn: testMediaStreamConnection as TestFunction, needsInstance: false },
+    ];
+
+    for (const test of tests) {
+      if (!testFilter || test.name === testFilter) {
+        if (test.needsInstance) {
+          await test.fn(client, instance, peerTwinId, isInitiator);
+        } else {
+          await test.fn(client, peerTwinId, isInitiator, undefined);
+        }
+        await sleep(2000);
+      }
+    }
+
+    // Print summary
+    console.log('\n' + '='.repeat(65));
+    console.log('TEST SUMMARY');
+    console.log('='.repeat(65));
+    console.log('Test'.padEnd(40) + 'Status'.padEnd(10) + 'Time');
+    console.log('-'.repeat(65));
+
+    let passed = 0;
+    let failed = 0;
+    for (const r of results) {
+      const status = r.passed ? '\x1b[32mPASS\x1b[0m' : '\x1b[31mFAIL\x1b[0m';
+      console.log(r.name.padEnd(40) + status.padEnd(15) + `${r.duration}ms`);
+      if (r.passed) passed++;
+      else failed++;
+    }
+
+    console.log('-'.repeat(65));
+    const totalTime = results.reduce((sum, r) => sum + r.duration, 0);
+    console.log(`Total: ${passed} passed, ${failed} failed (${totalTime}ms)`);
+    console.log('='.repeat(65));
+
+    // Give time for final cleanup
+    await sleep(1000);
+
+    process.exit(failed > 0 ? 1 : 0);
+  } catch (error) {
+    console.error('\n[FATAL]', error);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+export { testEvents, testActions, testDataChannelDefault, testDataChannelNamed, testMediaStreamConnection };