feat: set/create events

cspell.json

@@ -36,7 +36,10 @@
     "Wcme",
     "WCME",
     "webex",
-    "webrtc"
+    "webrtc",
+    "createofferonsuccess",
+    "setlocaldescriptiononsuccess",
+    "setremotedescriptiononsuccess"
   ],
   "flagWords": [],
   "ignorePaths": [

src/mocks/rtc-peer-connection-stub.ts

@@ -13,7 +13,15 @@ class RTCPeerConnectionStub {
   getStats(): Promise<any> {
     return new Promise(() => {});
   }
-  setLocalDescription(): Promise<any> {
+  setLocalDescription(
+    description?: RTCSessionDescription | RTCSessionDescriptionInit
+  ): Promise<void> {
+    return new Promise(() => {});
+  }
+
+  setRemoteDescription(
+    description?: RTCSessionDescription | RTCSessionDescriptionInit
+  ): Promise<void> {
     return new Promise(() => {});
   }
   onconnectionstatechange: () => void = () => {};

src/peer-connection.spec.ts

@@ -1,4 +1,5 @@
 import { BrowserInfo } from '@webex/web-capabilities';
+import { MockedObjectDeep } from 'ts-jest';
 import { ConnectionState, ConnectionStateHandler } from './connection-state-handler';
 import { mocked } from './mocks/mock';
 import { RTCPeerConnectionStub } from './mocks/rtc-peer-connection-stub';
@@ -247,17 +248,76 @@ describe('PeerConnection', () => {
     });
   });
 
+  describe('createOffer', () => {
+    let mockPc: MockedObjectDeep<RTCPeerConnectionStub>;
+    let createOfferSpy: jest.SpyInstance;
+    const callback = jest.fn();
+    let pc: PeerConnection;
+    const mockedReturnedOffer: RTCSessionDescriptionInit = {
+      sdp: 'blah',
+      type: 'offer',
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockPc = mocked(new RTCPeerConnectionStub(), true);
+      mockPc.createOffer.mockImplementation((description) => {
+        return new Promise((resolve, reject) => {
+          if (!description) {
+            reject(new Error());
+          } else {
+            resolve(mockedReturnedOffer);
+          }
+        });
+      });
+      mockCreateRTCPeerConnection.mockReturnValueOnce(mockPc as unknown as RTCPeerConnection);
+      pc = new PeerConnection();
+      createOfferSpy = jest.spyOn(pc, 'createOffer');
+      pc.on(PeerConnection.Events.CreateOfferOnSuccess, callback);
+    });
+
+    it('should emit event when createOffer called', async () => {
+      expect.hasAssertions();
+      const options: RTCOfferOptions = {
+        iceRestart: true,
+      };
+      const offer = await pc.createOffer(options);
+      expect(offer).toStrictEqual(mockedReturnedOffer);
+      expect(createOfferSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledWith(mockedReturnedOffer);
+    });
+
+    it('should not emit event when createOffer failed', async () => {
+      expect.hasAssertions();
+      const offerPromise = pc.createOffer(null as unknown as RTCOfferOptions);
+      await expect(offerPromise).rejects.toThrow(Error);
+      expect(createOfferSpy).toHaveBeenCalledWith(null);
+      expect(callback).toHaveBeenCalledTimes(0);
+    });
+  });
+
   describe('setLocalDescription', () => {
-    let mockPc: RTCPeerConnectionStub;
+    let mockPc: MockedObjectDeep<RTCPeerConnectionStub>;
     let setLocalDescriptionSpy: jest.SpyInstance;
+    const callback = jest.fn();
     let pc: PeerConnection;
 
     beforeEach(() => {
       jest.clearAllMocks();
       mockPc = mocked(new RTCPeerConnectionStub(), true);
       mockCreateRTCPeerConnection.mockReturnValueOnce(mockPc as unknown as RTCPeerConnection);
+      mockPc.setLocalDescription.mockImplementation((description) => {
+        return new Promise((resolve, reject) => {
+          if (description?.sdp === 'reject') {
+            reject(new Error());
+          } else {
+            resolve();
+          }
+        });
+      });
       setLocalDescriptionSpy = jest.spyOn(mockPc, 'setLocalDescription');
       pc = new PeerConnection();
+      pc.on(PeerConnection.Events.SetLocalDescriptionOnSuccess, callback);
     });
 
     it('sets the local description with an SDP offer', async () => {
@@ -278,5 +338,72 @@ describe('PeerConnection', () => {
         pc.setLocalDescription({ type: 'offer', sdp: 'm=video 9 UDP/TLS/RTP' })
       ).rejects.toThrow(Error);
     });
+
+    it('should emit event when setLocalDescription called', async () => {
+      expect.hasAssertions();
+      const options = {
+        sdp: 'blah',
+      };
+      await pc.setLocalDescription(options as unknown as RTCSessionDescriptionInit);
+      expect(setLocalDescriptionSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledWith(options);
+    });
+
+    it('should not emit event when setLocalDescription failed', async () => {
+      expect.hasAssertions();
+      const options = {
+        sdp: 'reject',
+      };
+      const offerPromise = pc.setLocalDescription(options as unknown as RTCSessionDescriptionInit);
+      await expect(offerPromise).rejects.toThrow(Error);
+      expect(setLocalDescriptionSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('setRemoteDescription', () => {
+    let mockPc: MockedObjectDeep<RTCPeerConnectionStub>;
+    let setRemoteDescriptionSpy: jest.SpyInstance;
+    const callback = jest.fn();
+    let pc: PeerConnection;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockPc = mocked(new RTCPeerConnectionStub(), true);
+      mockPc.setRemoteDescription.mockImplementation((description) => {
+        return new Promise((resolve, reject) => {
+          if (description?.sdp === 'reject') {
+            reject(new Error());
+          } else {
+            resolve();
+          }
+        });
+      });
+      mockCreateRTCPeerConnection.mockReturnValueOnce(mockPc as unknown as RTCPeerConnection);
+      pc = new PeerConnection();
+      setRemoteDescriptionSpy = jest.spyOn(pc, 'setRemoteDescription');
+      pc.on(PeerConnection.Events.SetRemoteDescriptionOnSuccess, callback);
+    });
+
+    it('should emit event when setRemoteDescription called', async () => {
+      expect.hasAssertions();
+      const options = {
+        sdp: 'blah',
+      };
+      await pc.setRemoteDescription(options as unknown as RTCSessionDescriptionInit);
+      expect(setRemoteDescriptionSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledWith(options);
+    });
+
+    it('should not emit event when setRemoteDescription failed', async () => {
+      expect.hasAssertions();
+      const options = {
+        sdp: 'reject',
+      };
+      const offerPromise = pc.setRemoteDescription(options as unknown as RTCSessionDescriptionInit);
+      await expect(offerPromise).rejects.toThrow(Error);
+      expect(setRemoteDescriptionSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledTimes(0);
+    });
   });
 });

src/peer-connection.ts

@@ -3,6 +3,7 @@ import { ConnectionState, ConnectionStateHandler } from './connection-state-hand
 import { EventEmitter, EventMap } from './event-emitter';
 import { createRTCPeerConnection } from './rtc-peer-connection-factory';
 import { logger } from './util/logger';
+
 /**
  * A type-safe form of the DOMString used in the MediaStreamTrack.kind field.
  */
@@ -27,11 +28,21 @@ type IceGatheringStateChangeEvent = {
 enum PeerConnectionEvents {
   IceGatheringStateChange = 'icegatheringstatechange',
   ConnectionStateChange = 'connectionstatechange',
+  CreateOfferOnSuccess = 'createofferonsuccess',
+  SetLocalDescriptionOnSuccess = 'setlocaldescriptiononsuccess',
+  SetRemoteDescriptionOnSuccess = 'setremotedescriptiononsuccess',
 }
 
 interface PeerConnectionEventHandlers extends EventMap {
   [PeerConnectionEvents.IceGatheringStateChange]: (ev: IceGatheringStateChangeEvent) => void;
   [PeerConnectionEvents.ConnectionStateChange]: (state: ConnectionState) => void;
+  [PeerConnectionEvents.CreateOfferOnSuccess]: (offer: RTCSessionDescriptionInit) => void;
+  [PeerConnectionEvents.SetLocalDescriptionOnSuccess]: (
+    description: RTCSessionDescription | RTCSessionDescriptionInit
+  ) => void;
+  [PeerConnectionEvents.SetRemoteDescriptionOnSuccess]: (
+    description: RTCSessionDescription | RTCSessionDescriptionInit
+  ) => void;
 }
 
 type ConnectionType = 'UDP' | 'TCP' | 'TURN-TLS' | 'TURN-TCP' | 'TURN-UDP' | 'unknown';
@@ -186,7 +197,10 @@ class PeerConnection extends EventEmitter<PeerConnectionEventHandlers> {
    *    That received offer should be delivered through the signaling server to a remote peer.
    */
   async createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit> {
-    return this.pc.createOffer(options);
+    return this.pc.createOffer(options).then((offer) => {
+      this.emit(PeerConnection.Events.CreateOfferOnSuccess, offer);
+      return offer;
+    });
   }
 
   /**
@@ -215,7 +229,11 @@ class PeerConnection extends EventEmitter<PeerConnectionEventHandlers> {
         });
     }
 
-    return this.pc.setLocalDescription(description);
+    return this.pc.setLocalDescription(description).then(() => {
+      if (description) {
+        this.emit(PeerConnection.Events.SetLocalDescriptionOnSuccess, description);
+      }
+    });
   }
 
   /**
@@ -230,7 +248,9 @@ class PeerConnection extends EventEmitter<PeerConnectionEventHandlers> {
   async setRemoteDescription(
     description: RTCSessionDescription | RTCSessionDescriptionInit
   ): Promise<void> {
-    return this.pc.setRemoteDescription(description);
+    return this.pc.setRemoteDescription(description).then(() => {
+      this.emit(PeerConnection.Events.SetRemoteDescriptionOnSuccess, description);
+    });
   }
 
   /**