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

package/src/test/webrtc-channel-names-test.ts

@@ -0,0 +1,266 @@
+/**
+ * WebRTC Named Channels Test
+ *
+ * Tests multiple DataChannels with different names to the same peer.
+ *
+ * Usage (two terminals):
+ *
+ *   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 \
+ *   npx ts-node src/test/webrtc-channel-names-test.ts
+ *   ```
+ *
+ *   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 \
+ *   npx ts-node src/test/webrtc-channel-names-test.ts
+ *   ```
+ */
+
+import { PhyHubClient } from '../index';
+import { PhygridDataChannel } from '../services/webrtc/types';
+
+interface TestResult {
+  channel: string;
+  sent: number;
+  received: number;
+  passed: boolean;
+}
+
+const CHANNEL_NAMES = [undefined, 'control', 'data', 'telemetry'] as const;
+const MESSAGES_PER_CHANNEL = 3;
+
+async function runInitiator(peerTwinId: string): Promise<void> {
+  console.log('\n=== Running as INITIATOR ===\n');
+
+  const client = await PhyHubClient.connect();
+  console.log('Connected to PhyHub!\n');
+
+  const results: TestResult[] = [];
+  const channels: Map<string, PhygridDataChannel> = new Map();
+  const receivedCounts: Map<string, number> = new Map();
+
+  // Test each channel name
+  for (const channelName of CHANNEL_NAMES) {
+    const displayName = channelName ?? 'default';
+    console.log(`\n--- Creating channel: "${displayName}" ---`);
+
+    try {
+      const channel = await client.getDataChannel(peerTwinId, channelName);
+      console.log(`Channel "${displayName}" created. Label: ${channel.getChannelName()}`);
+
+      // Verify channel name
+      const expectedName = channelName ?? 'default';
+      if (channel.getChannelName() !== expectedName) {
+        console.error(`ERROR: Expected channel name "${expectedName}", got "${channel.getChannelName()}"`);
+      }
+
+      channels.set(displayName, channel);
+      receivedCounts.set(displayName, 0);
+
+      // Setup message handler
+      channel.onMessage((data) => {
+        console.log(`[${displayName}] RECEIVED:`, data);
+        receivedCounts.set(displayName, (receivedCounts.get(displayName) || 0) + 1);
+      });
+
+    } catch (error) {
+      console.error(`Failed to create channel "${displayName}":`, error);
+      results.push({ channel: displayName, sent: 0, received: 0, passed: false });
+    }
+  }
+
+  // Wait for responder to set up channels
+  console.log('\nWaiting 3 seconds for responder to set up...');
+  await sleep(3000);
+
+  // Send messages on each channel
+  console.log('\n--- Sending messages ---\n');
+
+  for (const [displayName, channel] of channels) {
+    if (!channel.isOpen()) {
+      console.log(`Channel "${displayName}" not open, skipping...`);
+      continue;
+    }
+
+    for (let i = 1; i <= MESSAGES_PER_CHANNEL; i++) {
+      const msg = {
+        channel: displayName,
+        messageNum: i,
+        from: 'initiator',
+        timestamp: Date.now(),
+      };
+      console.log(`[${displayName}] SENDING:`, msg);
+      channel.send(msg);
+      await sleep(200);
+    }
+  }
+
+  // Wait for responses
+  console.log('\nWaiting 5 seconds for responses...');
+  await sleep(5000);
+
+  // Compile results
+  console.log('\n--- Test Results ---\n');
+
+  for (const [displayName] of channels) {
+    const received = receivedCounts.get(displayName) || 0;
+    const passed = received >= MESSAGES_PER_CHANNEL;
+    results.push({
+      channel: displayName,
+      sent: MESSAGES_PER_CHANNEL,
+      received,
+      passed,
+    });
+  }
+
+  // Print results
+  console.log('Channel'.padEnd(15) + 'Sent'.padEnd(8) + 'Received'.padEnd(10) + 'Status');
+  console.log('-'.repeat(45));
+
+  for (const result of results) {
+    const status = result.passed ? '✅ PASS' : '❌ FAIL';
+    console.log(
+      result.channel.padEnd(15) +
+        result.sent.toString().padEnd(8) +
+        result.received.toString().padEnd(10) +
+        status
+    );
+  }
+
+  // Summary
+  const allPassed = results.every((r) => r.passed);
+  console.log('\n' + '='.repeat(45));
+  console.log(allPassed ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED');
+
+  // Close all channels
+  for (const channel of channels.values()) {
+    channel.close();
+  }
+}
+
+async function runResponder(peerTwinId: string): Promise<void> {
+  console.log('\n=== Running as RESPONDER ===\n');
+
+  const client = await PhyHubClient.connect();
+  console.log('Connected to PhyHub!\n');
+
+  const channels: Map<string, PhygridDataChannel> = new Map();
+  const receivedCounts: Map<string, number> = new Map();
+  let channelsReceived = 0;
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout waiting for channels (60s)'));
+    }, 60000);
+
+    // Accept each channel name
+    for (const channelName of CHANNEL_NAMES) {
+      const displayName = channelName ?? 'default';
+      console.log(`Waiting for channel: "${displayName}"`);
+
+      client.onDataChannel(peerTwinId, (channel: PhygridDataChannel) => {
+        console.log(`\n[${displayName}] Channel received! Label: ${channel.getChannelName()}`);
+        channels.set(displayName, channel);
+        receivedCounts.set(displayName, 0);
+        channelsReceived++;
+
+        channel.onMessage((data) => {
+          console.log(`[${displayName}] RECEIVED:`, data);
+          receivedCounts.set(displayName, (receivedCounts.get(displayName) || 0) + 1);
+
+          // Echo back
+          const response = {
+            channel: displayName,
+            type: 'echo',
+            originalMessage: data.messageNum,
+            from: 'responder',
+            timestamp: Date.now(),
+          };
+          console.log(`[${displayName}] SENDING:`, response);
+          channel.send(response);
+        });
+
+        channel.onClose(() => {
+          console.log(`[${displayName}] Channel closed`);
+
+          // Check if all channels closed
+          const openChannels = Array.from(channels.values()).filter((c) => c.isOpen());
+          if (openChannels.length === 0 && channelsReceived === CHANNEL_NAMES.length) {
+            clearTimeout(timeout);
+
+            // Print summary
+            console.log('\n--- Responder Summary ---\n');
+            console.log('Channel'.padEnd(15) + 'Messages Received');
+            console.log('-'.repeat(35));
+
+            for (const [name, count] of receivedCounts) {
+              console.log(name.padEnd(15) + count.toString());
+            }
+
+            resolve();
+          }
+        });
+      }, channelName);
+    }
+  });
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main(): Promise<void> {
+  console.log('='.repeat(60));
+  console.log('WebRTC Named Channels Test');
+  console.log('='.repeat(60));
+
+  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();
+
+  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);
+  }
+
+  console.log(`\nRole: ${role}`);
+  console.log(`Peer Twin ID: ${peerTwinId}`);
+  console.log(`Channels to test: ${CHANNEL_NAMES.map((n) => n ?? 'default').join(', ')}`);
+
+  try {
+    if (role === 'initiator') {
+      await runInitiator(peerTwinId);
+    } else {
+      await runResponder(peerTwinId);
+    }
+
+    console.log('\n[SUCCESS] Test completed!');
+    process.exit(0);
+  } catch (error) {
+    console.error('\n[FAILED]', error);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}