node-datachannel 0.6.0 → 0.7.0

package/test/jest-tests/streams.test.js

@@ -0,0 +1,48 @@
+import * as nodeDataChannel from '../../lib';
+
+function waitForGathering(peer) {
+    return new Promise((resolve) => {
+        peer.onGatheringStateChange((state) => {
+            if (state === 'complete') resolve();
+        });
+        // Handle race conditions where gathering has already completed
+        if (peer.gatheringState() === 'complete') resolve();
+
+        resolve();
+    });
+}
+
+describe('DataChannel streams', () => {
+    test('can build an echo pipeline', async () => {
+        let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
+        let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
+
+        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
+        echoStream.pipe(echoStream); // Echo all received data back to the client
+
+        await waitForGathering(echoPeer);
+
+        const { sdp: echoDescSdp, type: echoDescType } = echoPeer.localDescription();
+        clientPeer.setRemoteDescription(echoDescSdp, echoDescType);
+        await waitForGathering(clientPeer);
+
+        const { sdp: clientDescSdp, type: clientDescType } = clientPeer.localDescription();
+        echoPeer.setRemoteDescription(clientDescSdp, clientDescType);
+
+        const clientChannel = await new Promise((resolve) => clientPeer.onDataChannel(resolve));
+
+        const clientResponsePromise = new Promise((resolve) => clientChannel.onMessage(resolve));
+        clientChannel.sendMessage('test message');
+
+        expect(await clientResponsePromise).toBe('test message');
+
+        clientChannel.close();
+        clientPeer.close();
+        echoPeer.close();
+    });
+});
+
+afterAll(() => {
+    // Properly cleanup so Jest does not complain about asynchronous operations that weren't stopped.
+    nodeDataChannel.cleanup();
+});

package/test/jest-tests/websocket.test.js

@@ -0,0 +1,69 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('Websocket', () => {
+    const webSocketServer = new nodeDataChannel.WebSocketServer({ bindAddress: '127.0.0.1', port: 1987 });
+    const clientSocket = new nodeDataChannel.WebSocket();
+
+    // Mocks
+    const clientOnOpenMock = jest.fn();
+    const clientOnMessageMock = jest.fn();
+    const clientOnCLosedMock = jest.fn();
+
+    const webServerOnClientMock = jest.fn();
+    const webServerOnOpenMock = jest.fn();
+    const webServerOnMessageMock = jest.fn();
+    const webServerOnClosedMock = jest.fn();
+
+    webSocketServer.onClient((serverSocket) => {
+        webServerOnClientMock();
+
+        serverSocket.onOpen(() => {
+            webServerOnOpenMock();
+        });
+
+        serverSocket.onMessage((message) => {
+            webServerOnMessageMock(message);
+            serverSocket.sendMessage('reply to ' + message);
+            serverSocket.close();
+        });
+
+        serverSocket.onClosed(() => {
+            webServerOnClosedMock();
+            serverSocket.close();
+        });
+    });
+
+    test('can create a websocket client and connect to a server', (done) => {
+        clientSocket.open('ws://127.0.0.1:1987');
+        clientSocket.onOpen(() => {
+            clientOnOpenMock();
+            clientSocket.sendMessage('Hello');
+        });
+
+        clientSocket.onMessage((message) => {
+            clientOnMessageMock(message);
+        });
+
+        clientSocket.onClosed(() => {
+            clientOnCLosedMock();
+        });
+
+        setTimeout(() => {
+            expect(clientOnMessageMock.mock.calls[0][0]).toEqual('reply to Hello');
+            expect(clientOnOpenMock.mock.calls.length).toBe(1);
+            expect(clientOnMessageMock.mock.calls.length).toBe(1);
+            expect(clientOnCLosedMock.mock.calls.length).toBe(1);
+
+            expect(webServerOnMessageMock.mock.calls[0][0]).toEqual('Hello');
+            expect(webServerOnOpenMock.mock.calls.length).toBe(1);
+            expect(webServerOnMessageMock.mock.calls.length).toBe(1);
+            expect(webServerOnClosedMock.mock.calls.length).toBe(1);
+
+            clientSocket.close();
+            webSocketServer.stop();
+
+            done();
+        }, 3000);
+    });
+});

package/test/test.js

@@ -1,252 +0,0 @@
-import { jest } from '@jest/globals';
-import * as nodeDataChannel from '../lib';
-
-describe('Module Definition', () => {
-    test('Module Defined', () => {
-        expect(nodeDataChannel).toBeDefined();
-        expect(nodeDataChannel.initLogger).toBeDefined();
-        expect(nodeDataChannel.PeerConnection).toBeDefined();
-        expect(typeof nodeDataChannel.PeerConnection).toBe('function');
-        expect(nodeDataChannel.DataChannel).toBeDefined();
-        expect(typeof nodeDataChannel.DataChannel).toBe('function');
-    });
-});
-
-describe('PeerConnection Classes', () => {
-    test('Create PeerConnection', () => {
-        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
-        expect(peer).toBeDefined();
-        expect(peer.onStateChange).toBeDefined();
-        expect(peer.createDataChannel).toBeDefined();
-
-        peer.close();
-    });
-
-    test('Create Data Channel', () => {
-        let peer = new nodeDataChannel.PeerConnection('Peer', { iceServers: ['stun:stun.l.google.com:19302'] });
-        let dc = peer.createDataChannel('test', { protocol: 'test-protocol' });
-        expect(dc).toBeDefined();
-        expect(dc.getId()).toBeDefined();
-        expect(dc.getProtocol()).toBe('test-protocol');
-        expect(dc.getLabel()).toBe('test');
-        expect(dc.onOpen).toBeDefined();
-        expect(dc.onMessage).toBeDefined();
-
-        dc.close();
-        peer.close();
-    });
-});
-
-describe('P2P', () => {
-    // Default is 5000 ms but we need more
-    jest.setTimeout(30000);
-
-    let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
-    let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
-    let dc1 = null;
-    let dc2 = null;
-
-    // Mocks
-    const p1StateMock = jest.fn();
-    const p1GatheringStateMock = jest.fn();
-    const p2StateMock = jest.fn();
-    const p2GatheringStateMock = jest.fn();
-    const p1SDPMock = jest.fn();
-    const p1CandidateMock = jest.fn();
-    const p2SDPMock = jest.fn();
-    const p2CandidateMock = jest.fn();
-
-    const p1DCMock = jest.fn();
-    const p1DCMessageMock = jest.fn();
-    const p2DCMock = jest.fn();
-    const p2DCMessageMock = jest.fn();
-
-    // Set Callbacks
-    peer1.onStateChange(p1StateMock);
-    peer1.onGatheringStateChange(p1GatheringStateMock);
-    peer1.onLocalDescription((sdp, type) => {
-        p1SDPMock();
-        peer2.setRemoteDescription(sdp, type);
-    });
-    peer1.onLocalCandidate((candidate, mid) => {
-        p1CandidateMock();
-        peer2.addRemoteCandidate(candidate, mid);
-    });
-
-    // Set Callbacks
-    peer2.onStateChange(p2StateMock);
-    peer2.onGatheringStateChange(p2GatheringStateMock);
-    peer2.onLocalDescription((sdp, type) => {
-        p2SDPMock();
-        peer1.setRemoteDescription(sdp, type);
-    });
-    peer2.onLocalCandidate((candidate, mid) => {
-        p2CandidateMock();
-        peer1.addRemoteCandidate(candidate, mid);
-    });
-    peer2.onDataChannel((dc) => {
-        p2DCMock();
-        dc2 = dc;
-        dc2.onMessage((msg) => {
-            p2DCMessageMock(msg);
-        });
-        dc2.sendMessage('Hello From Peer2');
-    });
-
-    dc1 = peer1.createDataChannel('test-p2p');
-    dc1.onOpen(() => {
-        p1DCMock();
-        dc1.sendMessage('Hello From Peer1');
-    });
-    dc1.onMessage((msg) => {
-        p1DCMessageMock(msg);
-    });
-
-    test('P2P', (done) => {
-        setTimeout(() => {
-            dc1.close();
-            dc2.close();
-            peer1.close();
-            peer2.close();
-        }, 10 * 1000);
-
-        setTimeout(() => {
-            // State Callbacks
-            expect(p1StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p1GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2StateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2GatheringStateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-            // SDP
-            expect(p1SDPMock.mock.calls.length).toBe(1);
-            expect(p2SDPMock.mock.calls.length).toBe(1);
-
-            // Candidates
-            expect(p1CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(p2CandidateMock.mock.calls.length).toBeGreaterThanOrEqual(1);
-
-            // DataChannel
-            expect(p1DCMock.mock.calls.length).toBe(1);
-            expect(p1DCMessageMock.mock.calls.length).toBe(1);
-            expect(p1DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer2');
-            expect(p2DCMock.mock.calls.length).toBe(1);
-
-            expect(p2DCMessageMock.mock.calls.length).toBe(1);
-            expect(p2DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer1');
-
-            done();
-        }, 12 * 1000);
-    });
-});
-
-function waitForGathering(peer) {
-    return new Promise((resolve) => {
-        peer.onGatheringStateChange((state) => {
-            if (state === 'complete') resolve();
-        });
-        // Handle race conditions where gathering has already completed
-        if (peer.gatheringState() === 'complete') resolve();
-    });
-}
-
-describe('DataChannel streams', () => {
-    test('can build an echo pipeline', async () => {
-        let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
-        let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
-
-        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
-        echoStream.pipe(echoStream); // Echo all received data back to the client
-
-        await waitForGathering(echoPeer);
-
-        const { sdp: echoDescSdp, type: echoDescType } = echoPeer.localDescription();
-        clientPeer.setRemoteDescription(echoDescSdp, echoDescType);
-        await waitForGathering(clientPeer);
-
-        const { sdp: clientDescSdp, type: clientDescType } = clientPeer.localDescription();
-        echoPeer.setRemoteDescription(clientDescSdp, clientDescType);
-
-        const clientChannel = await new Promise((resolve) => clientPeer.onDataChannel(resolve));
-
-        const clientResponsePromise = new Promise((resolve) => clientChannel.onMessage(resolve));
-        clientChannel.sendMessage('test message');
-
-        expect(await clientResponsePromise).toBe('test message');
-
-        clientChannel.close();
-        clientPeer.close();
-        echoPeer.close();
-    });
-});
-
-describe('Websocket', () => {
-    const webSocketServer = new nodeDataChannel.WebSocketServer({ bindAddress: '127.0.0.1', port: 1987 });
-    const clientSocket = new nodeDataChannel.WebSocket();
-
-    // Mocks
-    const clientOnOpenMock = jest.fn();
-    const clientOnMessageMock = jest.fn();
-    const clientOnCLosedMock = jest.fn();
-
-    const webServerOnClientMock = jest.fn();
-    const webServerOnOpenMock = jest.fn();
-    const webServerOnMessageMock = jest.fn();
-    const webServerOnClosedMock = jest.fn();
-
-    webSocketServer.onClient((serverSocket) => {
-        webServerOnClientMock();
-
-        serverSocket.onOpen(() => {
-            webServerOnOpenMock();
-        });
-
-        serverSocket.onMessage((message) => {
-            webServerOnMessageMock(message);
-            serverSocket.sendMessage('reply to ' + message);
-            serverSocket.close();
-        });
-
-        serverSocket.onClosed(() => {
-            webServerOnClosedMock();
-            serverSocket.close();
-        });
-    });
-
-    test('can create a websocket client and connect to a server', (done) => {
-        clientSocket.open('ws://127.0.0.1:1987');
-        clientSocket.onOpen(() => {
-            clientOnOpenMock();
-            clientSocket.sendMessage('Hello');
-        });
-
-        clientSocket.onMessage((message) => {
-            clientOnMessageMock(message);
-        });
-
-        clientSocket.onClosed(() => {
-            clientOnCLosedMock();
-        });
-
-        setTimeout(() => {
-            expect(clientOnMessageMock.mock.calls[0][0]).toEqual('reply to Hello');
-            expect(clientOnOpenMock.mock.calls.length).toBe(1);
-            expect(clientOnMessageMock.mock.calls.length).toBe(1);
-            expect(clientOnCLosedMock.mock.calls.length).toBe(1);
-
-            expect(webServerOnMessageMock.mock.calls[0][0]).toEqual('Hello');
-            expect(webServerOnOpenMock.mock.calls.length).toBe(1);
-            expect(webServerOnMessageMock.mock.calls.length).toBe(1);
-            expect(webServerOnClosedMock.mock.calls.length).toBe(0);
-
-            clientSocket.close();
-            webSocketServer.stop();
-
-            done();
-        }, 3000);
-    });
-});
-
-afterAll(() => {
-    // Properly cleanup so Jest does not complain about asynchronous operations that weren't stopped.
-    nodeDataChannel.cleanup();
-});