@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

package/test/unit/spec/roap/index.ts

@@ -1,37 +1,96 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
+import MockWebex from '@webex/test-helper-mock-webex';
 
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import Roap from '@webex/plugin-meetings/src/roap/';
+import Meeting from '@webex/plugin-meetings/src/meeting';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
+
+import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
+  let webex;
+
+  const RESULT = {something: 'some value'};
+  const meeting = {id: 'some meeting id'} as Meeting;
+
+  beforeEach(() => {
+    webex = new MockWebex({});
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
   describe('doTurnDiscovery', () => {
-    it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
-      const RESULT = {something: 'some value'};
-      const meeting = {id: 'some meeting id'};
+    [false, true].forEach(function (isReconnecting) {
+      [false, true, undefined].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments when isReconnecting = ${isReconnecting} and isForced = ${isForced}`, async () => {
+          const doTurnDiscoveryStub = sinon
+            .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
+            .resolves(RESULT);
+
+          const roap = new Roap({}, {parent: webex});
+
+          const result = await roap.doTurnDiscovery(meeting, isReconnecting, isForced);
 
-      const doTurnDiscoveryStub = sinon
-        .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
-        .resolves(RESULT);
+          assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
+          assert.deepEqual(result, RESULT);
+        });
+      });
+    });
 
-      const roap = new Roap({}, {parent: 'fake'});
+    describe('generateTurnDiscoveryRequestMessage', () => {
+      [false, true].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.generateTurnDiscoveryRequestMessage with isForced=${isForced}`, async () => {
+          const generateTurnDiscoveryRequestMessageStub = sinon
+            .stub(TurnDiscovery.prototype, 'generateTurnDiscoveryRequestMessage')
+            .resolves(RESULT);
 
-      // call with isReconnecting: true
-      const result = await roap.doTurnDiscovery(meeting, true);
+          const roap = new Roap({}, {parent: webex});
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
-      assert.deepEqual(result, RESULT);
+          const result = await roap.generateTurnDiscoveryRequestMessage(meeting, isForced);
 
-      doTurnDiscoveryStub.resetHistory();
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, isForced);
+          assert.deepEqual(result, RESULT);
+        });
+      });
+    });
 
-      // and with isReconnecting: false
-      const result2 = await roap.doTurnDiscovery(meeting, false);
+    describe('handleTurnDiscoveryHttpResponse', () => {
+      it('calls this.turnDiscovery.handleTurnDiscoveryHttpResponse', async () => {
+        const handleTurnDiscoveryHttpResponseStub = sinon
+          .stub(TurnDiscovery.prototype, 'handleTurnDiscoveryHttpResponse')
+          .resolves(RESULT);
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
-      assert.deepEqual(result2, RESULT);
+        const httpReponse = {some: 'http response'};
 
-      sinon.restore();
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.handleTurnDiscoveryHttpResponse(meeting, httpReponse);
+
+        assert.calledOnceWithExactly(handleTurnDiscoveryHttpResponseStub, meeting, httpReponse);
+        assert.deepEqual(result, RESULT);
+      });
+    });
+
+    describe('abortTurnDiscovery', () => {
+      it('calls this.turnDiscovery.abort', async () => {
+        const abortStub = sinon
+          .stub(TurnDiscovery.prototype, 'abort')
+          .returns(RESULT);
+
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.abortTurnDiscovery();
+
+        assert.calledOnceWithExactly(abortStub);
+        assert.deepEqual(result, RESULT);
+      });
     });
   });
 
@@ -39,103 +98,200 @@ describe('Roap', () => {
     let sendRoapStub;
     let meeting;
 
+    let webex;
+    let roap;
+
+    const fakeLocus = {id: 'fake locus'};
+
     beforeEach(() => {
+      webex = new MockWebex({});
       meeting = {
         id: 'some meeting id',
         correlationId: 'correlation id',
         selfUrl: 'self url',
         mediaId: 'media id',
-        isMultistream: false,
-        isAudioMuted: () => true,
-        isVideoMuted: () => false,
+        audio: {
+          isLocallyMuted: () => true,
+        },
+        video: {
+          isLocallyMuted: () => false,
+        },
+        isMultistream: true,
         setRoapSeq: sinon.stub(),
-        config: {experimental: {enableTurnDiscovery: false}},
+        locusMediaRequest: {fake: true},
+        webex: {meetings: {reachability: {isAnyPublicClusterReachable: () => true}}},
+        updateMediaConnections: sinon.stub(),
       };
 
+      sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
+
       sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
       meeting.setRoapSeq.resetHistory();
+
+      roap = new Roap({}, {parent: webex});
+      sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(false);
     });
 
     afterEach(() => {
       sinon.restore();
     });
 
-    [
-      {reconnect: true, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: true, enableTurnDiscovery: false, expectEmptyMediaId: true},
-      {reconnect: false, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: false, enableTurnDiscovery: false, expectEmptyMediaId: false},
-    ].forEach(({reconnect, enableTurnDiscovery, expectEmptyMediaId}) =>
-      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
-        reconnect ? '' : 'not '
-      }reconnecting and TURN discovery is ${
-        enableTurnDiscovery ? 'enabled' : 'disabled'
-      }`, async () => {
-        meeting.config.experimental.enableTurnDiscovery = enableTurnDiscovery;
-
-        const roap = new Roap({}, {parent: 'fake'});
-
-        await roap.sendRoapMediaRequest({
-          meeting,
-          sdp: 'sdp',
-          reconnect,
-          seq: 2,
-          tieBreaker: 4294967294,
-        });
+    it(`sends roap OFFER`, async () => {
+      await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        seq: 2,
+        tieBreaker: 4294967294,
+      });
 
-        const expectedRoapMessage = {
-          messageType: 'OFFER',
-          sdps: ['sdp'],
-          version: '2',
-          seq: 2,
-          tieBreaker: 4294967294,
-        };
+      const expectedRoapMessage = {
+        messageType: 'OFFER',
+        sdps: ['sdp'],
+        version: '2',
+        seq: 2,
+        tieBreaker: 4294967294,
+        headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+      };
 
-        assert.calledOnce(sendRoapStub);
-        assert.calledWith(sendRoapStub, {
+      assert.calledOnce(sendRoapStub);
+      assert.calledWith(
+        sendRoapStub,
+        sinon.match({
           roapMessage: expectedRoapMessage,
-          correlationId: meeting.correlationId,
           locusSelfUrl: meeting.selfUrl,
-          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
+          mediaId: meeting.mediaId,
           meetingId: meeting.id,
-          preferTranscoding: true,
-        });
-      })
-    );
-    it('sends roap request with preferTranscoding=false for multistream meetings', async () => {
-      const roap = new Roap({}, {parent: 'fake'});
+          locusMediaRequest: meeting.locusMediaRequest,
+        })
+      );
+    });
 
-      meeting.isMultistream = true;
+    it('reads SDP answer from the http response', async () => {
+      const roapAnswer = {
+        seq: 5,
+        messageType: 'ANSWER',
+        sdps: ['sdp answer'],
+        errorType: 'error type', // normally ANSWER would not have errorType or errorCause (only error messages have these)
+        errorCause: 'error cause', // but we're just testing here that all the fields are forwarded to the caller of sendRoapMediaRequest()
+        headers: ['header1', 'header2'],
+      };
+      const fakeMediaConnections = [
+        {
+          remoteSdp: JSON.stringify({
+            roapMessage: roapAnswer,
+          }),
+        },
+      ];
 
-      await roap.sendRoapMediaRequest({
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
         meeting,
         sdp: 'sdp',
         reconnect: false,
-        seq: 10,
-        tieBreaker: 1,
+        seq: 1,
+        tieBreaker: 4294967294,
       });
 
-      const expectedRoapMessage = {
-        messageType: 'OFFER',
-        sdps: ['sdp'],
-        version: '2',
-        seq: 10,
-        tieBreaker: 1,
-      };
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: {
+          seq: 5,
+          messageType: 'ANSWER',
+          sdp: 'sdp answer',
+          errorType: 'error type',
+          errorCause: 'error cause',
+          headers: ['header1', 'header2'],
+        },
+      });
+    });
+
+    it('handles the case when there is no answer in the http response', async () => {
+      const fakeMediaConnections = [
+        {
+          // this is the actual value Locus returns to us when they don't send Roap ANSWER in the http response
+          remoteSdp:
+            '{"audioMuted":false,"videoMuted":false,"csis":[],"dtmfReceiveSupported":true,"type":"SDP"}',
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
 
       assert.calledOnce(sendRoapStub);
-      assert.calledWith(sendRoapStub, {
-        roapMessage: expectedRoapMessage,
-        correlationId: meeting.correlationId,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id,
-        preferTranscoding: false,
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: undefined,
       });
+      assert.calledOnceWithExactly(
+        Metrics.sendBehavioralMetric,
+        BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+        {
+          correlationId: meeting.correlationId,
+          messageType: 'ANSWER',
+          isMultistream: meeting.isMultistream,
+        }
+      );
+    });
+
+    describe('does not crash when http response is missing things', () => {
+      [
+        {mediaConnections: undefined, title: 'mediaConnections are undefined'},
+        {mediaConnections: [], title: 'mediaConnections are empty array'},
+        {mediaConnections: [{}], title: 'mediaConnections[0] has no remoteSdp'},
+        {
+          mediaConnections: [{remoteSdp: '{}'}],
+          title: 'mediaConnections[0].remoteSdp is an empty json',
+        },
+      ].forEach(({mediaConnections, title}) =>
+        it(title, async () => {
+          sendRoapStub.resolves({
+            mediaConnections,
+            locus: fakeLocus,
+          });
+
+          const result = await roap.sendRoapMediaRequest({
+            meeting,
+            sdp: 'sdp',
+            reconnect: false,
+            seq: 1,
+            tieBreaker: 4294967294,
+          });
+
+          assert.calledOnce(sendRoapStub);
+          assert.deepEqual(result, {
+            locus: fakeLocus,
+            roapAnswer: undefined,
+          });
+
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+            {
+              correlationId: meeting.correlationId,
+              messageType: 'ANSWER',
+              isMultistream: meeting.isMultistream,
+            }
+          );
+        })
+      );
     });
   });
 });

package/test/unit/spec/roap/request.ts

@@ -0,0 +1,255 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings/roap', () => {
+  let roapRequest;
+  let webex;
+  const locusUrl = 'locusUrl';
+
+  beforeEach(async () => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns(locusUrl),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+      device: {
+        url: 'url',
+      },
+      newMetrics: {
+        submitClientEvent: sinon.stub()
+      },
+    };
+
+    // @ts-ignore
+    roapRequest = new RoapRequest({webex});
+
+    roapRequest.request = sinon.mock().returns(
+      Promise.resolve({
+        body: {
+          locus: {
+            roapSeq: '',
+            id: '',
+            url: 'url/path',
+            fullState: {
+              lastActive: 'lastActive',
+            },
+          },
+        },
+      })
+    );
+
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageJoinCookie,
+      JSON.stringify({
+        anycastEntryPoint: 'aws-eu-west-1',
+      })
+    );
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageResult,
+      JSON.stringify({
+        clusterId: {
+          udp: { result: 'reachable', latencyInMilliseconds: 10 },
+          tcp: { result: 'unreachable' },
+          isVideoMesh: false,
+        },
+      })
+    );
+  });
+
+  describe('#attachReachabilityData', () => {
+    it('returns the correct reachability data', async () => {
+      const res = await roapRequest.attachReachabilityData({});
+
+      assert.deepEqual(res.localSdp, {
+        reachability: {
+          clusterId: {
+            udp: {
+              reachable: 'true',
+              latencyInMilliseconds: '10',
+            },
+            tcp: {
+              reachable: 'false',
+            },
+            xtls: {
+              untested: 'true',
+            }
+          },
+        },
+      });
+      assert.deepEqual(res.joinCookie, {
+        anycastEntryPoint: 'aws-eu-west-1',
+      });
+    });
+
+    it('handles the case when reachability data does not exist', async () => {
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
+
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
+      const sdp = {
+        some: 'attribute',
+      };
+
+      const result = await roapRequest.attachReachabilityData(sdp);
+
+      assert.deepEqual(result, {
+        joinCookie: undefined,
+        localSdp: {
+          some: 'attribute',
+        },
+      });
+    });
+  });
+
+  describe('sendRoap', () => {
+    it('includes joinCookie in the request correctly', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
+      const ipVersion = IP_VERSION.unknown;
+
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        ipVersion,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        meetingId: 'meeting-id',
+        locusMediaRequest,
+      });
+
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.request',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
+
+      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.response',
+        options: {
+          meetingId: 'meeting-id',
+        },
+      });
+
+      const requestParams = locusMediaRequest.send.getCall(0).args[0];
+      assert.deepEqual(requestParams, {
+        type: 'RoapMessage',
+        selfUrl: locusUrl,
+        ipVersion,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        reachability: {
+          clusterId: {
+            tcp: {
+              reachable: 'false',
+            },
+            udp: {
+              latencyInMilliseconds: '10',
+              reachable: 'true',
+            },
+            xtls: {
+              untested: 'true',
+            },
+          },
+        },
+      });
+    });
+
+    it('sends correct client event when fails', async () => {
+      const locusMediaRequest = {send: sinon.stub().rejects({code: 300, message: 'error'})};
+      try {
+        await roapRequest.sendRoap({
+          locusSelfUrl: locusUrl,
+          mediaId: 'mediaId',
+          roapMessage: {
+            seq: 'seq',
+          },
+          meetingId: 'meeting-id',
+          locusMediaRequest,
+        });
+      } catch (err) {
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.response',
+          options: {
+            meetingId: 'meeting-id',
+            rawError: {code: 300, message: 'error'},
+          },
+        });
+      }
+    });
+  });
+
+  it('calls attachReachabilityData when sendRoap', async () => {
+    const locusMediaRequest = { send: sinon.stub().resolves({body: {locus: {}}})};
+
+    const newSdp = {
+      new: 'sdp',
+      reachability: { someResult: 'whatever' }
+    };
+    const ipVersion = IP_VERSION.only_ipv6;
+
+    roapRequest.attachReachabilityData = sinon.stub().returns(
+      Promise.resolve({
+        localSdp: newSdp,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+      })
+    );
+
+    await roapRequest.sendRoap({
+      roapMessage: {
+        seq: 1,
+      },
+      locusSelfUrl: 'locusSelfUrl',
+      ipVersion,
+      mediaId: 'mediaId',
+      meetingId: 'meetingId',
+      preferTranscoding: true,
+      locusMediaRequest
+    });
+
+    const requestParams = locusMediaRequest.send.getCall(0).args[0];
+
+    assert.deepEqual(requestParams, {
+      type: 'RoapMessage',
+      selfUrl: 'locusSelfUrl',
+      ipVersion,
+      joinCookie: {
+        anycastEntryPoint: 'aws-eu-west-1',
+      },
+      mediaId: 'mediaId',
+      roapMessage: {
+        seq: 1,
+      },
+      reachability: { someResult: 'whatever' },
+    });
+
+    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
+      roapMessage: {
+        seq: 1,
+      },
+    });
+  });
+});