@webex/internal-media-core 0.0.2-beta → 0.0.5-beta

package/dist/transpiled/MediaConnection/roap.test.js

@@ -1,873 +0,0 @@
-import { Roap } from './roap';
-import { Event, ErrorType } from './eventTypes';
-import { createControlledPromise, flushPromises, setupTestLogger, teardownTestLogger, RoapListener, } from './testUtils';
-import { getLogger } from './logger';
-describe('Roap', () => {
-    let roap;
-    const MUNGED_LOCAL_SDP = 'munged local SDP';
-    const FAKE_REMOTE_SDP = 'some remote SDP';
-    let createLocalOffer;
-    let handleRemoteOffer;
-    let handleRemoteAnswer;
-    const log = (action, description) => getLogger().info(`Test: ${action} ${description}`);
-    const resetCallbackMocks = () => {
-        createLocalOffer.mockClear();
-        handleRemoteOffer.mockClear();
-        handleRemoteAnswer.mockClear();
-    };
-    let roapListener;
-    let roapStateMachineState;
-    let waitingForState;
-    beforeAll(() => {
-        setupTestLogger();
-    });
-    afterAll(() => {
-        teardownTestLogger();
-    });
-    beforeEach(() => {
-        roapStateMachineState = '';
-        waitingForState = {};
-        createLocalOffer = jest.fn().mockResolvedValue({ sdp: MUNGED_LOCAL_SDP });
-        handleRemoteOffer = jest.fn().mockResolvedValue({ sdp: MUNGED_LOCAL_SDP });
-        handleRemoteAnswer = jest.fn().mockResolvedValue({});
-        roap = new Roap(() => createLocalOffer(), (sdp) => handleRemoteOffer(sdp), (sdp) => handleRemoteAnswer(sdp));
-        roapListener = new RoapListener(roap, log);
-        roap.getStateMachine().onTransition((state) => {
-            roapStateMachineState = state.value;
-            if (waitingForState.resolve && state.value === waitingForState.state) {
-                waitingForState.resolve();
-                waitingForState.resolve = undefined;
-                waitingForState.state = undefined;
-            }
-        });
-        console.log(`======================== TEST: ${expect.getState().currentTestName}`);
-    });
-    const waitForState = (expectedState) => {
-        if (roapStateMachineState === expectedState) {
-            log('waitForState()', `state already matching expectedState ${expectedState}`);
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            log('waitForState()', `waiting for roap state machine to reach ${expectedState}`);
-            waitingForState.state = expectedState;
-            waitingForState.resolve = resolve;
-        });
-    };
-    const checkRemoteAnswerOkFlow = async (seq) => {
-        roap.roapMessageReceived({
-            messageType: 'ANSWER',
-            seq,
-            sdp: FAKE_REMOTE_SDP,
-        });
-        await roapListener.waitForMessage({
-            messageType: 'OK',
-            seq,
-        });
-        await waitForState('idle');
-    };
-    const checkLocalOfferAnswerOkFlow = async (seq) => {
-        await roapListener.waitForMessage({
-            messageType: 'OFFER',
-            seq,
-            sdp: MUNGED_LOCAL_SDP,
-            tieBreaker: 0xfffffffe,
-        });
-        await checkRemoteAnswerOkFlow(seq);
-    };
-    const expectLocalOfferToBeCreated = () => {
-        expect(createLocalOffer).toBeCalledOnceWith();
-    };
-    const expectLocalAnswerToBeCreated = (remoteOffer) => {
-        expect(handleRemoteOffer).toBeCalledOnceWith(remoteOffer);
-    };
-    const expectRemoteAnswerToBeHandled = (remoteAnswer) => {
-        expect(handleRemoteAnswer).toBeCalledOnceWith(remoteAnswer);
-    };
-    it('handles OFFER_REQUEST correctly', async () => {
-        const FAKE_SEQ = 10;
-        roap.roapMessageReceived({
-            messageType: 'OFFER_REQUEST',
-            seq: FAKE_SEQ,
-        });
-        await roapListener.waitForMessage({
-            messageType: 'OFFER_RESPONSE',
-            seq: FAKE_SEQ,
-            sdp: MUNGED_LOCAL_SDP,
-        });
-        expectLocalOfferToBeCreated();
-        roap.roapMessageReceived({
-            messageType: 'ANSWER',
-            seq: FAKE_SEQ,
-            sdp: FAKE_REMOTE_SDP,
-        });
-        await roapListener.waitForMessage({
-            messageType: 'OK',
-            seq: FAKE_SEQ,
-        });
-        expectRemoteAnswerToBeHandled(FAKE_REMOTE_SDP);
-        await waitForState('idle');
-    });
-    it('works correctly when client initiates the offer', async () => {
-        roap.initiateOffer();
-        await roapListener.waitForMessage({
-            messageType: 'OFFER',
-            seq: 1,
-            sdp: MUNGED_LOCAL_SDP,
-            tieBreaker: 0xfffffffe,
-        });
-        expectLocalOfferToBeCreated();
-        roap.roapMessageReceived({
-            messageType: 'ANSWER',
-            seq: 1,
-            sdp: FAKE_REMOTE_SDP,
-        });
-        await roapListener.waitForMessage({
-            messageType: 'OK',
-            seq: 1,
-        });
-        await waitForState('idle');
-    });
-    it('works correctly when backend initiates the offer', async () => {
-        roap.roapMessageReceived({
-            messageType: 'OFFER',
-            seq: 1,
-            sdp: FAKE_REMOTE_SDP,
-            tieBreaker: 0x100,
-        });
-        await roapListener.waitForMessage({
-            messageType: 'ANSWER',
-            seq: 1,
-            sdp: MUNGED_LOCAL_SDP,
-        });
-        expectLocalAnswerToBeCreated(FAKE_REMOTE_SDP);
-        roap.roapMessageReceived({
-            messageType: 'OK',
-            seq: 1,
-        });
-        await waitForState('idle');
-    });
-    describe('glare handling', () => {
-        const runTest = async (remoteOfferMessageType, remoteOfferBeforeOurs = false) => {
-            const createLocalOfferPromise = createControlledPromise();
-            if (remoteOfferBeforeOurs) {
-                createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            }
-            roap.initiateOffer();
-            if (remoteOfferBeforeOurs) {
-                roap.roapMessageReceived({
-                    messageType: remoteOfferMessageType,
-                    seq: 1,
-                    sdp: remoteOfferMessageType === 'OFFER' ? FAKE_REMOTE_SDP : undefined,
-                    tieBreaker: 0x100,
-                });
-                createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-                await roapListener.waitForMessage({
-                    messageType: 'ERROR',
-                    errorType: ErrorType.CONFLICT,
-                    seq: 1,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-            }
-            else {
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                roap.roapMessageReceived({
-                    messageType: remoteOfferMessageType,
-                    seq: 1,
-                    sdp: remoteOfferMessageType === 'OFFER' ? FAKE_REMOTE_SDP : undefined,
-                    tieBreaker: 0x100,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'ERROR',
-                    errorType: ErrorType.CONFLICT,
-                    seq: 1,
-                });
-            }
-            await checkRemoteAnswerOkFlow(1);
-        };
-        it('works correctly when remote OFFER arrives AFTER our offer got created', async () => runTest('OFFER'));
-        it('works correctly when remote OFFER_REQUEST arrives AFTER our offer got created', async () => runTest('OFFER_REQUEST'));
-        it('works correctly when remote OFFER arrives BEFORE our offer got created', async () => runTest('OFFER', true));
-        it('works correctly when remote OFFER_REQUEST arrives BEFORE our offer got created', async () => runTest('OFFER_REQUEST', true));
-        describe('queueing when initiateOffer() is called', () => {
-            const testInitiateOffer = async (whenToCallInitiateOffer) => {
-                let initiateOfferResolved = false;
-                const remoteOfferMessageType = 'OFFER';
-                const handleRemoteOfferPromise = createControlledPromise();
-                handleRemoteOffer = jest.fn().mockReturnValue(handleRemoteOfferPromise);
-                roap.roapMessageReceived({
-                    messageType: remoteOfferMessageType,
-                    seq: 1,
-                    sdp: remoteOfferMessageType === 'OFFER' ? FAKE_REMOTE_SDP : undefined,
-                    tieBreaker: 0x100,
-                });
-                if (whenToCallInitiateOffer === 'WHILE_PROCESSING_REMOTE_OFFER') {
-                    roap.initiateOffer().then(() => {
-                        initiateOfferResolved = true;
-                    });
-                }
-                handleRemoteOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-                await roapListener.waitForMessage({
-                    messageType: 'ANSWER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                });
-                expectLocalAnswerToBeCreated(FAKE_REMOTE_SDP);
-                if (whenToCallInitiateOffer === 'WHILE_WAITING_FOR_OK') {
-                    roap.initiateOffer().then(() => {
-                        initiateOfferResolved = true;
-                    });
-                }
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual(false);
-                roap.roapMessageReceived({
-                    messageType: 'OK',
-                    seq: 1,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 2,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual(true);
-                await checkRemoteAnswerOkFlow(2);
-            };
-            it('queues another SDP exchange if initiateOffer() is called after receiving remote offer', async () => {
-                await testInitiateOffer('WHILE_PROCESSING_REMOTE_OFFER');
-            });
-            it('queues another SDP exchange if initiateOffer() is when waiting for OK message', async () => {
-                await testInitiateOffer('WHILE_WAITING_FOR_OK');
-            });
-            it('restarts SDP exchange if initiateOffer() is called while creating a local offer', async () => {
-                const createLocalOfferPromise = createControlledPromise();
-                const initiateOfferResolved = [false, false];
-                createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[0] = true;
-                });
-                await flushPromises();
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[1] = true;
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([false, false]);
-                createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, true]);
-                expect(createLocalOffer).toBeCalledTimes(2);
-                await checkRemoteAnswerOkFlow(1);
-            });
-            it('restarts SDP exchange if initiateOffer() is called while handling OFFER_REQUEST message', async () => {
-                const createLocalOfferPromise = createControlledPromise();
-                let initiateOfferResolved = false;
-                createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-                roap.roapMessageReceived({
-                    messageType: 'OFFER_REQUEST',
-                    seq: 1,
-                });
-                await flushPromises();
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved = true;
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual(false);
-                createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER_RESPONSE',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual(true);
-                expect(createLocalOffer).toBeCalledTimes(2);
-                await checkRemoteAnswerOkFlow(1);
-            });
-            it('queues another SDP exchange if initiateOffer() is called while waiting for answer', async () => {
-                const initiateOfferResolved = [false, false];
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[0] = true;
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[1] = true;
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, false]);
-                roap.roapMessageReceived({
-                    messageType: 'ANSWER',
-                    seq: 1,
-                    sdp: FAKE_REMOTE_SDP,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OK',
-                    seq: 1,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 2,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, true]);
-                await checkRemoteAnswerOkFlow(2);
-            });
-            it('queues another SDP exchange if initiateOffer() is called while processing an answer', async () => {
-                const initiateOfferResolved = [false, false];
-                const handleRemoteAnswerPromise = createControlledPromise();
-                handleRemoteAnswer = jest.fn().mockReturnValue(handleRemoteAnswerPromise);
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[0] = true;
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 1,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, false]);
-                roap.roapMessageReceived({
-                    messageType: 'ANSWER',
-                    seq: 1,
-                    sdp: FAKE_REMOTE_SDP,
-                });
-                roap.initiateOffer().then(() => {
-                    initiateOfferResolved[1] = true;
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, false]);
-                handleRemoteAnswerPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-                await roapListener.waitForMessage({
-                    messageType: 'OK',
-                    seq: 1,
-                });
-                await roapListener.waitForMessage({
-                    messageType: 'OFFER',
-                    seq: 2,
-                    sdp: MUNGED_LOCAL_SDP,
-                    tieBreaker: 0xfffffffe,
-                });
-                await flushPromises();
-                expect(initiateOfferResolved).toEqual([true, true]);
-                await checkRemoteAnswerOkFlow(2);
-            });
-        });
-    });
-    describe('Error messages', () => {
-        let roapFailurePromise;
-        beforeEach(() => {
-            roapFailurePromise = createControlledPromise();
-            roap.on(Event.ROAP_FAILURE, () => {
-                log('Event.ROAP_FAILURE', 'got ROAP_FAILURE event');
-                roapFailurePromise.resolve({});
-            });
-        });
-        it('DOUBLECONFLICT handled correctly when received after initiating an offer', async () => {
-            roap.initiateOffer();
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            resetCallbackMocks();
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                errorType: ErrorType.DOUBLECONFLICT,
-                seq: 1,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 2,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            await checkRemoteAnswerOkFlow(2);
-        });
-        const retryableErrors = [
-            ErrorType.DOUBLECONFLICT,
-            ErrorType.INVALID_STATE,
-            ErrorType.OUT_OF_ORDER,
-            ErrorType.RETRY,
-        ];
-        retryableErrors.map((errorType) => it(`${errorType} triggers no more than 2 offer retries`, async () => {
-            roap.initiateOffer();
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            resetCallbackMocks();
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                errorType,
-                seq: 1,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 2,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            resetCallbackMocks();
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                errorType,
-                seq: 2,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 3,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            resetCallbackMocks();
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                errorType,
-                seq: 3,
-            });
-            await waitForState('remoteError');
-            await roapFailurePromise;
-        }));
-        it('fails if unrecoverable error is received while waiting for SDP answer', async () => {
-            roap.initiateOffer();
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                errorType: ErrorType.CONFLICT,
-                seq: 1,
-            });
-            await waitForState('remoteError');
-            await roapFailurePromise;
-        });
-        it('fails if error is received while waiting for OK message', async () => {
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-                tieBreaker: 0x100,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            roap.roapMessageReceived({
-                messageType: 'ERROR',
-                seq: 1,
-            });
-            await waitForState('remoteError');
-            await roapFailurePromise;
-        });
-        it('sends FAILED error if browser rejects the remote SDP offer', async () => {
-            handleRemoteOffer = jest.fn().mockRejectedValue(new Error('fake browser failure'));
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'ERROR',
-                errorType: ErrorType.FAILED,
-                seq: 1,
-            });
-            await waitForState('browserError');
-            await roapFailurePromise;
-        });
-        it('sends FAILED error if browser rejects the remote SDP answer', async () => {
-            handleRemoteAnswer = jest.fn().mockRejectedValue(new Error('fake browser failure'));
-            roap.initiateOffer();
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            roap.roapMessageReceived({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-            });
-            await roapListener.waitForMessage({
-                messageType: 'ERROR',
-                errorType: ErrorType.FAILED,
-                seq: 1,
-            });
-            await waitForState('browserError');
-            await roapFailurePromise;
-        });
-        it('sends FAILED error if browser fails to create a local SDP offer', async () => {
-            const fakeError = new Error('local SDP rejected');
-            createLocalOffer.mockRejectedValue(fakeError);
-            await expect(roap.initiateOffer()).rejects.toEqual(fakeError);
-            await waitForState('browserError');
-            await roapFailurePromise;
-        });
-    });
-    describe('Unexpected messages', () => {
-        const checkInvalidStateError = async (messageType, seq) => {
-            roap.roapMessageReceived({ messageType, seq, sdp: FAKE_REMOTE_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ERROR',
-                errorType: ErrorType.INVALID_STATE,
-                seq,
-            });
-            roap.roapMessageReceived({ messageType, seq: seq + 10, sdp: FAKE_REMOTE_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ERROR',
-                errorType: ErrorType.INVALID_STATE,
-                seq: seq + 10,
-            });
-        };
-        it('sends INVALID_STATE error when receiving messages in wrong state (client initiates the offer)', async () => {
-            const createLocalOfferPromise = createControlledPromise();
-            const handleRemoteAnswerPromise = createControlledPromise();
-            createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            handleRemoteAnswer = jest.fn().mockReturnValue(handleRemoteAnswerPromise);
-            await checkInvalidStateError('ANSWER', 1);
-            await checkInvalidStateError('OK', 1);
-            roap.initiateOffer();
-            await flushPromises();
-            await checkInvalidStateError('ANSWER', 1);
-            await checkInvalidStateError('OK', 1);
-            createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            await checkInvalidStateError('OK', 1);
-            roap.roapMessageReceived({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-            });
-            await checkInvalidStateError('OFFER', 1);
-            await checkInvalidStateError('OFFER_REQUEST', 1);
-            await checkInvalidStateError('OK', 1);
-            handleRemoteAnswerPromise.resolve({});
-            await roapListener.waitForMessage({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await checkInvalidStateError('ANSWER', 2);
-            await checkInvalidStateError('OK', 2);
-            await waitForState('idle');
-        });
-        it('sends INVALID_STATE error when receiving messages in wrong state (server initiates the offer)', async () => {
-            const handleRemoteOfferPromise = createControlledPromise();
-            handleRemoteOffer = jest.fn().mockReturnValue(handleRemoteOfferPromise);
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-                tieBreaker: 0x100,
-            });
-            await checkInvalidStateError('ANSWER', 1);
-            await checkInvalidStateError('OK', 1);
-            await checkInvalidStateError('OFFER_REQUEST', 1);
-            handleRemoteOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            expectLocalAnswerToBeCreated(FAKE_REMOTE_SDP);
-            await checkInvalidStateError('ANSWER', 1);
-            await checkInvalidStateError('OFFER_REQUEST', 1);
-            roap.roapMessageReceived({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await waitForState('idle');
-        });
-    });
-    describe('Duplicate messages from server', () => {
-        const checkDuplicateIgnored = async (messageType, seq) => {
-            const stateBeforeMessageReceived = roapStateMachineState;
-            roap.roapMessageReceived({ messageType, seq, sdp: FAKE_REMOTE_SDP });
-            await flushPromises();
-            expect(roapListener.getReceivedMessages().length).toEqual(0);
-            expect(stateBeforeMessageReceived).toEqual(roapStateMachineState);
-        };
-        it('ignores duplicate ANSWER from the server', async () => {
-            const handleRemoteAnswerPromise = createControlledPromise();
-            handleRemoteAnswer = jest.fn().mockReturnValue(handleRemoteAnswerPromise);
-            roap.initiateOffer();
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            roap.roapMessageReceived({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-            });
-            await checkDuplicateIgnored('ANSWER', 1);
-            handleRemoteAnswerPromise.resolve({});
-            await roapListener.waitForMessage({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await checkDuplicateIgnored('ANSWER', 1);
-            await waitForState('idle');
-            await checkDuplicateIgnored('ANSWER', 1);
-        });
-        it('ignores duplicate OFFER from the server', async () => {
-            const handleRemoteOfferPromise = createControlledPromise();
-            handleRemoteOffer = jest.fn().mockReturnValue(handleRemoteOfferPromise);
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-                tieBreaker: 0x100,
-            });
-            await checkDuplicateIgnored('OFFER', 1);
-            handleRemoteOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            expectLocalAnswerToBeCreated(FAKE_REMOTE_SDP);
-            await checkDuplicateIgnored('OFFER', 1);
-            roap.roapMessageReceived({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await waitForState('idle');
-        });
-        it('ignores duplicate OFFER_REQUEST from the server', async () => {
-            const createLocalOfferPromise = createControlledPromise();
-            createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            roap.roapMessageReceived({
-                messageType: 'OFFER_REQUEST',
-                seq: 1,
-            });
-            await checkDuplicateIgnored('OFFER_REQUEST', 1);
-            createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER_RESPONSE',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            expectLocalOfferToBeCreated();
-            await checkDuplicateIgnored('OFFER_REQUEST', 1);
-            await checkRemoteAnswerOkFlow(1);
-        });
-    });
-    describe('messages with old seq are rejected with OUT_OF_ORDER error or ignored', () => {
-        const checkOutOfOrderError = async (messageType, seq) => {
-            roap.roapMessageReceived({ messageType, seq, sdp: FAKE_REMOTE_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ERROR',
-                errorType: ErrorType.OUT_OF_ORDER,
-                seq,
-            });
-        };
-        const checkOldErrorsAreIgnored = async () => {
-            for (const errorType of Object.values(ErrorType)) {
-                const stateBeforeMessageReceived = roapStateMachineState;
-                roap.roapMessageReceived({
-                    messageType: 'ERROR',
-                    errorType,
-                    seq: 0,
-                });
-                await flushPromises();
-                expect(roapListener.getReceivedMessages().length).toEqual(0);
-                expect(stateBeforeMessageReceived).toEqual(roapStateMachineState);
-            }
-        };
-        it('in idle state', async () => {
-            roap.initiateOffer();
-            await checkLocalOfferAnswerOkFlow(1);
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER', 1);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 1);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-        });
-        it('during the flow where client initiates the offer', async () => {
-            const createLocalOfferPromise = createControlledPromise();
-            const handleRemoteAnswerPromise = createControlledPromise();
-            createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            handleRemoteAnswer = jest.fn().mockReturnValue(handleRemoteAnswerPromise);
-            roap.initiateOffer();
-            await flushPromises();
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-                tieBreaker: 0xfffffffe,
-            });
-            expectLocalOfferToBeCreated();
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            roap.roapMessageReceived({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-            });
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            handleRemoteAnswerPromise.resolve({});
-            await roapListener.waitForMessage({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await waitForState('idle');
-        });
-        it('during the flow where server initiates the offer', async () => {
-            const handleRemoteOfferPromise = createControlledPromise();
-            handleRemoteOffer = jest.fn().mockReturnValue(handleRemoteOfferPromise);
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-                tieBreaker: 0x100,
-            });
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            handleRemoteOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'ANSWER',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            expectLocalAnswerToBeCreated(FAKE_REMOTE_SDP);
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            roap.roapMessageReceived({
-                messageType: 'OK',
-                seq: 1,
-            });
-            await waitForState('idle');
-        });
-        it('during the flow where server sends OFFER_REQUEST', async () => {
-            const createLocalOfferPromise = createControlledPromise();
-            createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            roap.roapMessageReceived({
-                messageType: 'OFFER_REQUEST',
-                seq: 1,
-            });
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            createLocalOfferPromise.resolve({ sdp: MUNGED_LOCAL_SDP });
-            await roapListener.waitForMessage({
-                messageType: 'OFFER_RESPONSE',
-                seq: 1,
-                sdp: MUNGED_LOCAL_SDP,
-            });
-            expectLocalOfferToBeCreated();
-            await checkOutOfOrderError('OFFER', 0);
-            await checkOutOfOrderError('OFFER_REQUEST', 0);
-            await checkOutOfOrderError('ANSWER', 0);
-            await checkOutOfOrderError('OK', 0);
-            await checkOldErrorsAreIgnored();
-            await checkRemoteAnswerOkFlow(1);
-        });
-    });
-    describe('stop() method', () => {
-        it('calls stop() on the state machine interpreter', () => {
-            const stateMachineInterpreter = roap.getStateMachine();
-            const stopSpy = jest.spyOn(stateMachineInterpreter, 'stop');
-            roap.stop();
-            expect(stopSpy).toBeCalledOnceWith();
-        });
-        it('stops events that are sent from service onDone handler from firing', async () => {
-            const createLocalOfferPromise = createControlledPromise();
-            createLocalOffer = jest.fn().mockReturnValue(createLocalOfferPromise);
-            roap.initiateOffer();
-            await flushPromises();
-            roap.stop();
-            createLocalOfferPromise.resolve({ sdp: 'fake sdp' });
-            await flushPromises();
-            expect(roapListener.getReceivedMessages().length).toEqual(0);
-            await new Promise((resolve) => {
-                setTimeout(() => resolve({}), 2000);
-            });
-        });
-        it('stops the state machine from handling any more requests', async () => {
-            roap.stop();
-            roap.initiateOffer();
-            await flushPromises();
-            expect(roapListener.getReceivedMessages().length).toEqual(0);
-        });
-        it('stops handling any more remote messages', async () => {
-            roap.stop();
-            roap.roapMessageReceived({
-                messageType: 'OFFER',
-                seq: 1,
-                sdp: FAKE_REMOTE_SDP,
-                tieBreaker: 0x100,
-            });
-            await flushPromises();
-            expect(handleRemoteOffer).not.toBeCalled();
-            expect(roapListener.getReceivedMessages().length).toEqual(0);
-        });
-    });
-});
-//# sourceMappingURL=roap.test.js.map