node-datachannel 0.6.0 → 0.7.0

package/src/data-channel-wrapper.cpp

@@ -13,6 +13,14 @@ void DataChannelWrapper::CloseAll()
         inst->doClose();
 }
 
+void DataChannelWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -78,11 +86,15 @@ void DataChannelWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnBufferedAmountLowCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void DataChannelWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -350,6 +362,8 @@ void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 

package/src/data-channel-wrapper.h

@@ -42,10 +42,14 @@ public:
   // Close all existing DataChannels
   static void CloseAll();
 
+  // Reset all Callbacks for existing DataChannels
+  static void CleanupAll();
+
 private:
-  static std::unordered_set<DataChannelWrapper*> instances;
+  static std::unordered_set<DataChannelWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::string mLabel;
   std::shared_ptr<rtc::DataChannel> mDataChannelPtr = nullptr;

package/src/media-track-wrapper.cpp

@@ -2,6 +2,8 @@
 #include "media-direction.h"
 #include "media-rtcpreceivingsession-wrapper.h"
 
+#include "plog/Log.h"
+
 Napi::FunctionReference TrackWrapper::constructor;
 std::unordered_set<TrackWrapper *> TrackWrapper::instances;
 
@@ -12,6 +14,14 @@ void TrackWrapper::CloseAll()
         inst->doClose();
 }
 
+void TrackWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -73,10 +83,14 @@ void TrackWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void TrackWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -276,7 +290,8 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onOpen([&]() {
+    mTrackPtr->onOpen([&]()
+                      {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -309,7 +324,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onClosed([&]() {
+    mTrackPtr->onClosed([&]()
+                        {
         if (mOnClosedCallback)
             mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Do not check if the data channel has been closed here
@@ -317,6 +333,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 
@@ -340,7 +358,8 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onError([&](const std::string &error) {
+    mTrackPtr->onError([&](const std::string &error)
+                       {
         if (mOnErrorCallback)
             mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -373,7 +392,8 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
+    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message)
+                         {
         if (mOnMessageCallback)
             mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed

package/src/media-track-wrapper.h

@@ -39,21 +39,25 @@ public:
   void onError(const Napi::CallbackInfo &info);
   void onMessage(const Napi::CallbackInfo &info);
 
-  // Close all existing track
+  // Close all existing tracks
   static void CloseAll();
 
+  // Reset all Callbacks for existing tracks
+  static void CleanupAll();
+
 private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;
 
-    // Callback Ptrs
+  // Callback Ptrs
   std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
 };
 
-#endif // MEDIA_TRACK_WRAPPER_H
+#endif // MEDIA_TRACK_WRAPPER_H

package/src/peer-connection-wrapper.cpp

@@ -20,12 +20,12 @@ void PeerConnectionWrapper::CloseAll()
         inst->doClose();
 }
 
-void PeerConnectionWrapper::ResetCallbacksAll()
+void PeerConnectionWrapper::CleanupAll()
 {
-    PLOG_DEBUG << "ResetCallbacksAll() called";
+    PLOG_DEBUG << "CleanupAll() called";
     auto copy(instances);
     for (auto inst : copy)
-        inst->doResetCallbacks();
+        inst->doCleanup();
 }
 
 Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
@@ -37,7 +37,6 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
         "PeerConnection",
         {
             InstanceMethod("close", &PeerConnectionWrapper::close),
-            InstanceMethod("destroy", &PeerConnectionWrapper::destroy),
             InstanceMethod("setLocalDescription", &PeerConnectionWrapper::setLocalDescription),
             InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
             InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
@@ -253,7 +252,8 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
 PeerConnectionWrapper::~PeerConnectionWrapper()
 {
     PLOG_DEBUG << "Destructor called";
-    doDestroy();
+    doCleanup();
+    doClose();
 }
 
 void PeerConnectionWrapper::doClose()
@@ -273,40 +273,27 @@ void PeerConnectionWrapper::doClose()
             return;
         }
     }
-}
-
-void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
-{
-    PLOG_DEBUG << "close() called";
-    doClose();
-}
-
-void PeerConnectionWrapper::doDestroy()
-{
-    PLOG_DEBUG << "doDestroy() called";
-    doClose();
-    doResetCallbacks();
-}
 
-void PeerConnectionWrapper::doResetCallbacks()
-{
-    PLOG_DEBUG << "doResetCallbacks() called";
     mOnLocalDescriptionCallback.reset();
     mOnLocalCandidateCallback.reset();
-    mOnStateChangeCallback.reset();
     mOnIceStateChangeCallback.reset();
     mOnSignalingStateChangeCallback.reset();
     mOnGatheringStateChangeCallback.reset();
     mOnDataChannelCallback.reset();
     mOnTrackCallback.reset();
+}
 
-    instances.erase(this);
+void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "close() called";
+    doClose();
 }
 
-void PeerConnectionWrapper::destroy(const Napi::CallbackInfo &info)
+void PeerConnectionWrapper::doCleanup()
 {
-    PLOG_DEBUG << "destroy() called";
-    doDestroy();
+    PLOG_DEBUG << "doCleanup() called";
+    mOnStateChangeCallback.reset();
+    instances.erase(this);
 }
 
 void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
@@ -738,6 +725,13 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
                 PLOG_DEBUG << "mOnStateChangeCallback call(2)";
+            },[this,state](){
+                PLOG_DEBUG << "mOnStateChangeCallback cleanup";
+                // Special case for closed state, we need to reset all callbacks
+                if(state == rtc::PeerConnection::State::Closed)
+                {
+                    doCleanup();
+                }
             }); });
 }
 

package/src/peer-connection-wrapper.h

@@ -19,8 +19,6 @@ public:
   PeerConnectionWrapper(const Napi::CallbackInfo &info);
   ~PeerConnectionWrapper();
 
-  void destroy(const Napi::CallbackInfo &info);
-
   // Functions
   void close(const Napi::CallbackInfo &info);
   void setLocalDescription(const Napi::CallbackInfo &info);
@@ -58,15 +56,14 @@ public:
   static void CloseAll();
 
   // Reset all Callbacks for existing Peer Connections
-  static void ResetCallbacksAll();
+  static void CleanupAll();
 
 private:
   static Napi::FunctionReference constructor;
   static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
-  void doDestroy();
-  void doResetCallbacks();
+  void doCleanup();
 
   std::string mPeerName;
   std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;

package/src/rtc-wrapper.cpp

@@ -125,8 +125,11 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
         if (rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
             throw std::runtime_error("cleanup timeout (possible deadlock)");
 
-        // Clear Callbacks
-        PeerConnectionWrapper::ResetCallbacksAll();
+        // Cleanup the instances
+        PeerConnectionWrapper::CleanupAll();
+        DataChannelWrapper::CleanupAll();
+        TrackWrapper::CleanupAll();
+        WebSocketWrapper::CleanupAll();
 
         if (logCallback)
             logCallback.reset();

package/src/thread-safe-callback.cpp

@@ -26,9 +26,9 @@ ThreadSafeCallback::~ThreadSafeCallback()
     tsfn.Abort();
 }
 
-void ThreadSafeCallback::call(arg_func_t argFunc)
+void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 {
-    CallbackData *data = new CallbackData{std::move(argFunc)};
+    CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
     if (tsfn.BlockingCall(data) != napi_ok)
     {
         delete data;
@@ -47,6 +47,7 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
 
     arg_vector_t args;
     arg_func_t argFunc(std::move(data->argFunc));
+    cleanup_func_t cleanup(std::move(data->cleanupFunc));
     delete data;
 
     try
@@ -59,5 +60,8 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
     }
 
     if (env && callback)
+    {
         callback.Call(context->Value(), args);
+        cleanup();
+    }
 }

package/src/thread-safe-callback.h

@@ -11,6 +11,7 @@ class ThreadSafeCallback
 public:
     using arg_vector_t = std::vector<napi_value>;
     using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
+    using cleanup_func_t = std::function<void()>;
 
     ThreadSafeCallback(Napi::Function callback);
     ~ThreadSafeCallback();
@@ -21,7 +22,7 @@ public:
     ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
     ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
 
-    void call(arg_func_t argFunc);
+    void call(arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
 
     class CancelException : public std::exception
     {
@@ -32,6 +33,7 @@ private:
     struct CallbackData
     {
         arg_func_t argFunc;
+        cleanup_func_t cleanupFunc;
     };
 
     static void callbackFunc(Napi::Env env,

package/src/web-socket-wrapper.cpp

@@ -13,6 +13,14 @@ void WebSocketWrapper::CloseAll()
         inst->doClose();
 }
 
+void WebSocketWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object WebSocketWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -255,11 +263,15 @@ void WebSocketWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnBufferedAmountLowCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void WebSocketWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -488,8 +500,7 @@ void WebSocketWrapper::onOpen(const Napi::CallbackInfo &info)
                     // This will run in main thread and needs to construct the
                     // arguments for the call
                     args = {};
-                    PLOG_DEBUG << "mOnOpenCallback call(2)"; });
-                          });
+                    PLOG_DEBUG << "mOnOpenCallback call(2)"; }); });
 }
 
 void WebSocketWrapper::onClosed(const Napi::CallbackInfo &info)
@@ -524,6 +535,8 @@ void WebSocketWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 

package/src/web-socket-wrapper.h

@@ -22,7 +22,7 @@ public:
 
   // Functions
   void open(const Napi::CallbackInfo &info);
-  void close(const Napi::CallbackInfo &info); 
+  void close(const Napi::CallbackInfo &info);
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
   Napi::Value isOpen(const Napi::CallbackInfo &info);
@@ -40,10 +40,14 @@ public:
   // Close all existing WebSockets
   static void CloseAll();
 
+  // Reset all Callbacks for existing WebSockets
+  static void CleanupAll();
+
 private:
-  static std::unordered_set<WebSocketWrapper*> instances;
+  static std::unordered_set<WebSocketWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;
 

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

@@ -0,0 +1,37 @@
+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();
+    });
+});

package/test/jest-tests/multiple-run.test.js

@@ -0,0 +1,73 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('P2P', () => {
+    // Default is 5000 ms but we need more
+    jest.setTimeout(12000);
+
+    test.each(Array(100).fill(0))('P2P Test-%p', (i) => {
+        return new Promise((done) => {
+            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 p1DCMessageMock = jest.fn();
+            const p2DCMessageMock = jest.fn();
+
+            // Set Callbacks
+            peer1.onStateChange(() => {
+                /** */
+            });
+            peer1.onGatheringStateChange(() => {
+                /** */
+            });
+            peer1.onLocalDescription((sdp, type) => {
+                peer2.setRemoteDescription(sdp, type);
+            });
+            peer1.onLocalCandidate((candidate, mid) => {
+                peer2.addRemoteCandidate(candidate, mid);
+            });
+
+            // Set Callbacks
+            peer2.onStateChange(() => {
+                /** */
+            });
+            peer2.onGatheringStateChange(() => {
+                /** */
+            });
+            peer2.onLocalDescription((sdp, type) => {
+                peer1.setRemoteDescription(sdp, type);
+            });
+            peer2.onLocalCandidate((candidate, mid) => {
+                peer1.addRemoteCandidate(candidate, mid);
+            });
+            peer2.onDataChannel((dc) => {
+                dc2 = dc;
+                dc2.onMessage((msg) => {
+                    p2DCMessageMock(msg);
+                    dc2.sendMessage('Hello From Peer2');
+                });
+            });
+
+            dc1 = peer1.createDataChannel('test-p2p');
+            dc1.onOpen(() => {
+                dc1.sendMessage('Hello From Peer1');
+            });
+            dc1.onMessage((msg) => {
+                p1DCMessageMock(msg);
+                peer1.close();
+                peer2.close();
+
+                // DataChannel
+                expect(p1DCMessageMock.mock.calls.length).toBe(1);
+                expect(p1DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer2');
+                expect(p2DCMessageMock.mock.calls.length).toBe(1);
+                expect(p2DCMessageMock.mock.calls[0][0]).toEqual('Hello From Peer1');
+
+                done();
+            });
+        });
+    });
+});

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

@@ -0,0 +1,99 @@
+import { jest } from '@jest/globals';
+import * as nodeDataChannel from '../../lib';
+
+describe('P2P', () => {
+    // Default is 5000 ms but we need more
+    jest.setTimeout(30000);
+
+    test('P2P Test', () => {
+        return new Promise((done) => {
+            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);
+                peer1.close();
+                peer2.close();
+
+                // 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();
+            });
+        });
+    });
+});