Add tests for call answering / candidate sending

spec/test-utils/webrtc.ts

@@ -99,6 +99,7 @@ export class MockRTCPeerConnection {
     private static instances: MockRTCPeerConnection[] = [];
 
     private negotiationNeededListener: () => void;
+    public iceCandidateListener?: (e: RTCPeerConnectionIceEvent) => void;
     private needsNegotiation = false;
     public readyToNegotiate: Promise<void>;
     private onReadyToNegotiate: () => void;
@@ -135,7 +136,11 @@ export class MockRTCPeerConnection {
     }
 
     addEventListener(type: string, listener: () => void) {
-        if (type === 'negotiationneeded') this.negotiationNeededListener = listener;
+        if (type === 'negotiationneeded') {
+            this.negotiationNeededListener = listener;
+        } else if (type == 'icecandidate') {
+            this.iceCandidateListener = listener;
+        }
     }
     createDataChannel(label: string, opts: RTCDataChannelInit) { return { label, ...opts }; }
     createOffer() {

spec/unit/webrtc/call.spec.ts

@@ -887,6 +887,77 @@ describe('Call', function() {
         });
     });
 
+    describe("answering calls", () => {
+        beforeEach(async () => {
+            await fakeIncomingCall(client, call, "1");
+        });
+
+        const untilEventSent = async (...args) => {
+            const maxTries = 20;
+
+            for (let tries = 0; tries < maxTries; ++tries) {
+                if (tries) {
+                    await new Promise(resolve => {
+                        setTimeout(resolve, 100);
+                    });
+                }
+                try {
+                    expect(client.client.sendEvent).toHaveBeenCalledWith(...args);
+                    return;
+                } catch (e) {
+                    if (tries == maxTries - 1) {
+                        throw e;
+                    }
+                }
+            }
+        };
+
+        it("sends an answer event", async () => {
+            await call.answer();
+            await untilEventSent(
+                FAKE_ROOM_ID,
+                EventType.CallAnswer,
+                expect.objectContaining({
+                    call_id: call.callId,
+                    answer: expect.objectContaining({
+                        type: 'offer',
+                    }),
+                }),
+            );
+        });
+
+        it("sends ICE candidates as separate events if they arrive after the answer", async () => {
+            const fakeCandidateString = "here is a fake candidate!";
+
+            await call.answer();
+            await untilEventSent(
+                FAKE_ROOM_ID,
+                EventType.CallAnswer,
+                expect.objectContaining({}),
+            );
+
+            const mockPeerConn = call.peerConn as unknown as MockRTCPeerConnection;
+            mockPeerConn.iceCandidateListener!({
+                candidate: {
+                    candidate: fakeCandidateString,
+                    sdpMLineIndex: 0,
+                    sdpMid: '0',
+                    toJSON: jest.fn().mockReturnValue(fakeCandidateString),
+                },
+            } as unknown as RTCPeerConnectionIceEvent);
+
+            await untilEventSent(
+                FAKE_ROOM_ID,
+                EventType.CallCandidates,
+                expect.objectContaining({
+                    candidates: [
+                        fakeCandidateString,
+                    ],
+                }),
+            );
+        });
+    });
+
     it("times out an incoming call", async () => {
         jest.useFakeTimers();
         await fakeIncomingCall(client, call, "1");