@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -1,442 +0,0 @@
-import sinon from 'sinon';
-import {assert} from '@webex/test-helper-chai';
-import { cloneDeep, defer } from 'lodash';
-
-import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
-import { LocalMuteRequest, LocusMediaRequest, RoapRequest } from "@webex/plugin-meetings/src/meeting/locusMediaRequest";
-import testUtils from '../../../utils/testUtils';
-import { Defer } from '@webex/common';
-import { IP_VERSION } from '../../../../src/constants';
-
-describe('LocusMediaRequest.send()', () => {
-  let locusMediaRequest: LocusMediaRequest;
-  let webexRequestStub;
-  let mockWebex;
-
-  const fakeLocusResponse = {
-    locus: { something: 'whatever'}
-  };
-
-  const exampleRoapRequestBody:RoapRequest = {
-    type: 'RoapMessage',
-    mediaId: 'mediaId',
-    selfUrl: 'fakeMeetingSelfUrl',
-    roapMessage: {
-      messageType: 'OFFER',
-      sdps: ['sdp'],
-      version: '2',
-      seq: 1,
-      tieBreaker: 0xfffffffe,
-    },
-    reachability: {
-      'wjfkm.wjfkm.*': {udp:{reachable: true}, tcp:{reachable:false}},
-      '1eb65fdf-9643-417f-9974-ad72cae0e10f.59268c12-7a04-4b23-a1a1-4c74be03019a.*': {udp:{reachable: false}, tcp:{reachable:true}},
-    },
-    joinCookie: {
-      anycastEntryPoint: 'aws-eu-west-1',
-      clientIpAddress: 'some ip',
-      timeShot: '2023-05-23T08:03:49Z',
-    },
-    ipVersion: IP_VERSION.only_ipv4,
-  };
-
-  const createExpectedRoapBody = (expectedMessageType, expectedMute:{audioMuted: boolean, videoMuted: boolean}) => {
-    return {
-      device: { url: 'deviceUrl', deviceType: 'deviceType', regionCode: 'regionCode' },
-      correlationId: 'correlationId',
-      localMedias: [
-        {
-          localSdp: `{"audioMuted":${expectedMute.audioMuted},"videoMuted":${expectedMute.videoMuted},"roapMessage":{"messageType":"${expectedMessageType}","sdps":["sdp"],"version":"2","seq":1,"tieBreaker":4294967294},"reachability":{"wjfkm.wjfkm.*":{"udp":{"reachable":true},"tcp":{"reachable":false}},"1eb65fdf-9643-417f-9974-ad72cae0e10f.59268c12-7a04-4b23-a1a1-4c74be03019a.*":{"udp":{"reachable":false},"tcp":{"reachable":true}}}}`,
-          mediaId: 'mediaId'
-        }
-      ],
-      clientMediaPreferences: {
-        preferTranscoding: true,
-        ipver: 4,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
-          clientIpAddress: 'some ip',
-          timeShot: '2023-05-23T08:03:49Z'
-        }
-      }
-    };
-  };
-
-  const exampleLocalMuteRequestBody:LocalMuteRequest = {
-    type: 'LocalMute',
-    mediaId: 'mediaId',
-    selfUrl: 'fakeMeetingSelfUrl',
-    muteOptions: {},
-  };
-
-  const createExpectedLocalMuteBody = (expectedMute:{audioMuted: boolean, videoMuted: boolean}, sequence = undefined) => {
-    const body: any = {
-      device: {
-        url: 'deviceUrl',
-        deviceType: 'deviceType',
-        regionCode: 'regionCode',
-      },
-      correlationId: 'correlationId',
-      usingResource: null,
-      respOnlySdp: true,
-      localMedias: [
-        {
-          mediaId: 'mediaId',
-          localSdp: `{"audioMuted":${expectedMute.audioMuted},"videoMuted":${expectedMute.videoMuted}}`,
-        },
-      ],
-      clientMediaPreferences: {
-        preferTranscoding: true,
-        ipver: undefined,
-      },
-    };
-
-    if (sequence) {
-      body.sequence = sequence;
-    }
-
-    return body;
-  };
-
-  beforeEach(() => {
-    mockWebex = new MockWebex({
-      children: {
-        meetings: Meetings,
-      },
-    });
-
-    locusMediaRequest = new LocusMediaRequest({
-      device: {
-        url: 'deviceUrl',
-        deviceType: 'deviceType',
-        regionCode: 'regionCode',
-      },
-      correlationId: 'correlationId',
-      preferTranscoding: true,
-    }, {
-      parent: mockWebex,
-    });
-    webexRequestStub = sinon.stub(locusMediaRequest, 'request').resolves(fakeLocusResponse);
-  })
-
-  const sendLocalMute = (muteOptions, overrides={}) => locusMediaRequest.send({...exampleLocalMuteRequestBody, ...overrides, muteOptions});
-
-  const sendRoapMessage = (messageType) => {
-    const request = cloneDeep(exampleRoapRequestBody);
-
-    request.roapMessage.messageType = messageType;
-    return locusMediaRequest.send(request);
-  }
-
-  /** Helper function that makes sure the LocusMediaRequest.confluenceState is 'created' */
-  const ensureConfluenceCreated = async () => {
-    await sendRoapMessage('OFFER');
-
-    webexRequestStub.resetHistory();
-  }
-
-  it('sends a roap message', async () => {
-    const result = await sendRoapMessage('OFFER');
-
-    assert.equal(result, fakeLocusResponse);
-
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
-    });
-  });
-
-  it('sends a local mute request', async () => {
-    await ensureConfluenceCreated();
-
-    const result = await sendLocalMute({audioMuted: false, videoMuted: false});
-
-    assert.equal(result, fakeLocusResponse);
-
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: false}),
-    });
-  });
-
-  it('sends a local mute request with sequence', async () => {
-    await ensureConfluenceCreated();
-
-    const sequence = {some: 'sequence data'};
-
-    const result = await sendLocalMute({audioMuted: false, videoMuted: false}, {sequence});
-
-    assert.equal(result, fakeLocusResponse);
-
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: false}, sequence),
-    });
-  });
-
-  it('sends a local mute request with the last audio/video mute values when called multiple times in same processing cycle', async () => {
-    await ensureConfluenceCreated();
-
-    let result1;
-    let result2;
-
-    const promise1 = sendLocalMute({audioMuted: true, videoMuted: false})
-      .then((result) => {
-        result1 = result;
-      });
-
-    const promise2 = sendLocalMute({audioMuted: false, videoMuted: true})
-      .then((result) => {
-        result2 = result;
-      });
-
-    await testUtils.flushPromises();
-
-    await promise1;
-    await promise2;
-    assert.equal(result1, fakeLocusResponse);
-    assert.equal(result2, fakeLocusResponse);
-
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
-    });
-
-  });
-
-  it('sends a local mute request with the last audio/video mute values', async () => {
-    await ensureConfluenceCreated();
-
-    await Promise.all([
-      sendLocalMute({audioMuted: undefined, videoMuted: false}),
-      sendLocalMute({audioMuted: true, videoMuted: undefined}),
-      sendLocalMute({audioMuted: false, videoMuted: true}),
-      sendLocalMute({audioMuted: true, videoMuted: false}),
-    ]);
-
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedLocalMuteBody({audioMuted: true, videoMuted: false}),
-    });
-
-  });
-
-  it('sends only roap when roap and local mute are requested', async () => {
-    await Promise.all([
-      sendLocalMute({audioMuted: false, videoMuted: undefined}),
-      sendRoapMessage('OFFER'),
-      sendLocalMute({audioMuted: true, videoMuted: false}),
-    ]);
-
-    /* check that only the roap message was sent and it had the last
-       values for audio and video mute
-    */
-    assert.calledOnceWithExactly(webexRequestStub, {
-      method: 'PUT',
-      uri: 'fakeMeetingSelfUrl/media',
-      body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: false}),
-    });
-  });
-
-  describe('queueing', () => {
-    let clock;
-    let requestsToLocus;
-    let results;
-
-    beforeEach(() => {
-      clock = sinon.useFakeTimers();
-      requestsToLocus = [];
-      results = [];
-
-      // setup the mock so that each new request that we send to Locus,
-      // returns a promise that we control from this test
-      webexRequestStub.callsFake(() => {
-        const defer = new Defer();
-        requestsToLocus.push(defer);
-        return defer.promise;
-      });
-    });
-
-    afterEach(() => {
-      clock.restore();
-    });
-
-    /** LocusMediaRequest.send() uses Lodash.defer(), so it only starts sending any requests
-     * after the processing cycle from which it was called is finished.
-     * This helper function waits for this to happen - it's needed, because we're using
-     * fake timers in these tests
-    */
-    const ensureQueueProcessingIsStarted = () => {
-      clock.tick(1);
-    }
-    it('queues requests if there is one already in progress', async () => {
-      results.push(sendRoapMessage('OFFER'));
-
-      ensureQueueProcessingIsStarted();
-
-      // check that OFFER has been sent out
-      assert.calledWith(webexRequestStub, {
-        method: 'PUT',
-        uri: 'fakeMeetingSelfUrl/media',
-        body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
-      });
-
-      webexRequestStub.resetHistory();
-
-      // at this point the request should be sent out and "in progress",
-      // so any further calls should be queued
-      results.push(sendRoapMessage('OK'));
-
-      // OK should not be sent out yet, only queued
-      assert.notCalled(webexRequestStub);
-
-      // now simulate the first locus request (offer) to resolve,
-      // so that the next request from the queue (ok) can be sent out
-      requestsToLocus[0].resolve();
-      await testUtils.flushPromises();
-      ensureQueueProcessingIsStarted();
-
-      // verify OK was sent out
-      assert.calledWith(webexRequestStub, {
-        method: 'PUT',
-        uri: 'fakeMeetingSelfUrl/media',
-        body: createExpectedRoapBody('OK', {audioMuted: true, videoMuted: true}),
-      });
-
-      // promise returned by the first call to send OFFER should be resolved by now
-      await results[0];
-
-      // simulate Locus sending http response to OK
-      requestsToLocus[1].resolve();
-      await results[1];
-    });
-
-    it('combines local mute requests into a single /media request to Locus when queueing', async () => {
-      results.push(sendRoapMessage('OFFER'));
-      results.push(sendLocalMute({audioMuted: false, videoMuted: false}));
-
-      ensureQueueProcessingIsStarted();
-
-      // check that OFFER and local mute have been combined into
-      // a single OFFER request with the right mute values
-      assert.calledOnceWithExactly(webexRequestStub, {
-        method: 'PUT',
-        uri: 'fakeMeetingSelfUrl/media',
-        body: createExpectedRoapBody('OFFER', {audioMuted: false, videoMuted: false}),
-      });
-
-      webexRequestStub.resetHistory();
-
-      // at this point the request should be sent out and "in progress",
-      // so any further calls should be queued
-      results.push(sendLocalMute({audioMuted: true, videoMuted: false}));
-      results.push(sendRoapMessage('OK'));
-      results.push(sendLocalMute({audioMuted: false, videoMuted: true}));
-
-      // nothing should be sent out yet, only queued
-      assert.notCalled(webexRequestStub);
-
-      // now simulate the first locus request (offer) to resolve,
-      // so that the next request from the queue (ok) can be sent out
-      requestsToLocus[0].resolve();
-      await testUtils.flushPromises();
-      ensureQueueProcessingIsStarted();
-
-      // verify OK was sent out
-      assert.calledOnceWithExactly(webexRequestStub, {
-        method: 'PUT',
-        uri: 'fakeMeetingSelfUrl/media',
-        body: createExpectedRoapBody('OK', {audioMuted: false, videoMuted: true}),
-      });
-
-      // promise returned by the first call to send OFFER should be resolved by now
-      await results[0];
-
-      // simulate Locus sending http response to OK
-      requestsToLocus[1].resolve();
-      await results[1];
-    });
-
-    describe('confluence creation', () => {
-      it('resolves without sending the request if LocalMute is requested before Roap Offer is sent (confluence state is "not created")', async () => {
-        const result = await sendLocalMute({audioMuted: false, videoMuted: true});
-
-        assert.notCalled(webexRequestStub);
-        assert.deepEqual(result, {});
-      });
-
-      it('queues LocalMute if requested after first Roap Offer was sent but before it got http response (confluence state is "creation in progress")', async () => {
-        let result;
-
-        // send roap offer so that confluence state is "creation in progress"
-        sendRoapMessage('OFFER');
-
-        ensureQueueProcessingIsStarted();
-
-        sendLocalMute({audioMuted: false, videoMuted: true})
-          .then((response) => {
-            result = response;
-          });
-
-        // only roap offer should have been sent so far
-        assert.calledOnceWithExactly(webexRequestStub, {
-          method: 'PUT',
-          uri: 'fakeMeetingSelfUrl/media',
-          body: createExpectedRoapBody('OFFER', {audioMuted: true, videoMuted: true}),
-        });
-        assert.equal(result, undefined); // sendLocalMute shouldn't resolve yet, as the request should be queued
-
-        // now let the Offer be completed - so confluence state will be "complete"
-        webexRequestStub.resetHistory();
-        requestsToLocus[0].resolve({});
-        await testUtils.flushPromises();
-
-        // now the queued up local mute request should have been sent out
-        assert.calledOnceWithExactly(webexRequestStub, {
-          method: 'PUT',
-          uri: 'fakeMeetingSelfUrl/media',
-          body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
-        });
-
-        // check also the result once Locus replies to local mute
-        const fakeLocusResponse = { response: 'ok'};
-        requestsToLocus[1].resolve(fakeLocusResponse);
-        await testUtils.flushPromises();
-        assert.deepEqual(result, fakeLocusResponse);
-      });
-    });
-
-    it('sends LocalMute request if Offer was already sent and Locus replied (confluence state is "completed")', async () => {
-      let result;
-
-      // send roap offer and ensure it's completed
-      sendRoapMessage('OFFER');
-      ensureQueueProcessingIsStarted();
-      requestsToLocus[0].resolve({});
-      await testUtils.flushPromises();
-      webexRequestStub.resetHistory();
-
-      // now send local mute
-      sendLocalMute({audioMuted: false, videoMuted: true})
-        .then((response) => {
-          result = response;
-        });
-
-      ensureQueueProcessingIsStarted();
-
-      // it should be sent out
-      assert.calledOnceWithExactly(webexRequestStub, {
-        method: 'PUT',
-        uri: 'fakeMeetingSelfUrl/media',
-        body: createExpectedLocalMuteBody({audioMuted: false, videoMuted: true}),
-      });
-    });
-
-  });
-})