feat(webrtc-core): create answer on success event

cspell.json

@@ -38,6 +38,7 @@
     "webex",
     "webrtc",
     "createofferonsuccess",
+    "createansweronsuccess",
     "setlocaldescriptiononsuccess",
     "setremotedescriptiononsuccess"
   ],

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

@@ -7,6 +7,9 @@
  * This stub exists to act as a scaffold for creating a mock.
  */
 class RTCPeerConnectionStub {
+  createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit> {
+    return new Promise(() => {});
+  }
   createOffer(options?: RTCOfferOptions): Promise<RTCSessionDescriptionInit> {
     return new Promise(() => {});
   }

src/peer-connection.spec.ts

@@ -247,6 +247,50 @@ describe('PeerConnection', () => {
       connectionStateHandlerListener(ConnectionState.Connecting);
     });
   });
+  describe('createAnswer', () => {
+    let mockPc: MockedObjectDeep<RTCPeerConnectionStub>;
+    let createAnswerSpy: jest.SpyInstance;
+    const callback = jest.fn();
+    let pc: PeerConnection;
+    const mockedReturnedAnswer: RTCSessionDescriptionInit = {
+      sdp: 'blah',
+      type: 'offer',
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockPc = mocked(new RTCPeerConnectionStub(), true);
+      mockPc.createAnswer.mockImplementation(() => {
+        return Promise.resolve(mockedReturnedAnswer);
+      });
+      mockCreateRTCPeerConnection.mockReturnValueOnce(mockPc as unknown as RTCPeerConnection);
+      pc = new PeerConnection();
+      createAnswerSpy = jest.spyOn(pc, 'createAnswer');
+      pc.on(PeerConnection.Events.CreateAnswerOnSuccess, callback);
+    });
+
+    it('should emit event when createAnswer called', async () => {
+      expect.hasAssertions();
+      const options: RTCAnswerOptions = {
+        iceRestart: true,
+      };
+      const answer = await pc.createAnswer(options);
+      expect(answer).toStrictEqual(mockedReturnedAnswer);
+      expect(createAnswerSpy).toHaveBeenCalledWith(options);
+      expect(callback).toHaveBeenCalledWith(mockedReturnedAnswer);
+    });
+
+    it('should not emit event when createAnswer failed', async () => {
+      expect.hasAssertions();
+      mockPc.createAnswer.mockImplementation(() => {
+        return Promise.reject(new Error());
+      });
+      const answerPromise = pc.createAnswer(null as unknown as RTCOfferOptions);
+      await expect(answerPromise).rejects.toThrow(Error);
+      expect(createAnswerSpy).toHaveBeenCalledWith(null);
+      expect(callback).toHaveBeenCalledTimes(0);
+    });
+  });
 
   describe('createOffer', () => {
     let mockPc: MockedObjectDeep<RTCPeerConnectionStub>;

src/peer-connection.ts

@@ -29,6 +29,7 @@ enum PeerConnectionEvents {
   IceGatheringStateChange = 'icegatheringstatechange',
   ConnectionStateChange = 'connectionstatechange',
   CreateOfferOnSuccess = 'createofferonsuccess',
+  CreateAnswerOnSuccess = 'createansweronsuccess',
   SetLocalDescriptionOnSuccess = 'setlocaldescriptiononsuccess',
   SetRemoteDescriptionOnSuccess = 'setremotedescriptiononsuccess',
 }
@@ -37,6 +38,7 @@ interface PeerConnectionEventHandlers extends EventMap {
   [PeerConnectionEvents.IceGatheringStateChange]: (ev: IceGatheringStateChangeEvent) => void;
   [PeerConnectionEvents.ConnectionStateChange]: (state: ConnectionState) => void;
   [PeerConnectionEvents.CreateOfferOnSuccess]: (offer: RTCSessionDescriptionInit) => void;
+  [PeerConnectionEvents.CreateAnswerOnSuccess]: (answer: RTCSessionDescriptionInit) => void;
   [PeerConnectionEvents.SetLocalDescriptionOnSuccess]: (
     description: RTCSessionDescription | RTCSessionDescriptionInit
   ) => void;
@@ -183,7 +185,10 @@ class PeerConnection extends EventEmitter<PeerConnectionEventHandlers> {
    *     other peer.
    */
   async createAnswer(options?: RTCAnswerOptions): Promise<RTCSessionDescriptionInit> {
-    return this.pc.createAnswer(options);
+    return this.pc.createAnswer(options).then((answer) => {
+      this.emit(PeerConnection.Events.CreateAnswerOnSuccess, answer);
+      return answer;
+    });
   }
 
   /**