@webex/plugin-meetings 3.0.0-beta.34 → 3.0.0-beta.35

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

@@ -1,114 +1,217 @@
-import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
-import Metrics from '@webex/plugin-meetings/src/metrics';
-
+import Meetings from '@webex/plugin-meetings';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
-
-
-describe('RoapRequest', () => {
-  describe('attachRechabilityData', () => {
-    let webex;
-
-    beforeEach(() => {
-      webex = new MockWebex();
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import {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,
+      },
     });
-    
-    it('attaches the reachability data when it exists', async () => {
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
 
-      const sdp = {some: 'attribute'};
+    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',
+      },
+    };
+
+    // @ts-ignore
+    roapRequest = new RoapRequest({webex});
+
+    roapRequest.request = sinon.mock().returns(
+      Promise.resolve({
+        body: {
+          locus: {
+            roapSeq: '',
+            id: '',
+            url: 'url/path',
+            fullState: {
+              lastActive: 'lastActive',
+            },
+          },
+        },
+      })
+    );
 
-      const reachabilitData = {reachability: 'data'};
+    Metrics.postEvent = sinon.stub().returns();
 
-      await webex.boundedStorage.put(
-        'Reachability',
-        'reachability.result',
-        JSON.stringify(reachabilitData)
-      );
+    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: 'test',
+        },
+      })
+    );
+  });
 
-      const newSdp = await roapRequest.attachRechabilityData(sdp);
+  describe('#attachReachabilityData', () => {
+    it('returns the correct reachability data', async () => {
+      const res = await roapRequest.attachReachabilityData({});
 
-      assert.deepEqual(newSdp, {
-        some: 'attribute',
-        reachability: reachabilitData
-      })
+      assert.deepEqual(res.localSdp, {
+        reachability: {
+          clusterId: {
+            udp: 'test',
+          },
+        },
+      });
+      assert.deepEqual(res.joinCookie, {
+        anycastEntryPoint: 'aws-eu-west-1',
+      });
     });
-  
-    it('handles the case when realiability data does not exist', async () => {
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
 
-      const sdp = {some: 'attribute'};
+    it('handles the case when reachability data does not exist', async () => {
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
 
-      const newSdp = await roapRequest.attachRechabilityData(sdp);
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
+      const sdp = {
+        some: 'attribute',
+      };
+
+      const result = await roapRequest.attachReachabilityData(sdp);
 
-      assert.deepEqual(newSdp, sdp);
+      assert.deepEqual(result, {
+        joinCookie: undefined,
+        localSdp: {
+          some: 'attribute',
+        },
+      });
     });
   });
 
   describe('sendRoap', () => {
-    let webex;
+    it('includes joinCookie in the request correctly', async () => {
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+      });
 
-    beforeEach(() => {
-      webex = new MockWebex();
+      const requestParams = roapRequest.request.getCall(0).args[0];
+      assert.equal(requestParams.method, 'PUT');
+      assert.equal(requestParams.uri, `${locusUrl}/media`);
+      assert.deepEqual(requestParams.body.localMedias, [
+        {
+          localSdp:
+            '{"roapMessage":{"seq":"seq"},"audioMuted":false,"videoMuted":false,"reachability":{"clusterId":{"udp":"test"}}}',
+          mediaId: 'mediaId',
+        },
+      ]);
+      assert.deepEqual(requestParams.body.clientMediaPreferences, {
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+        preferTranscoding: true,
+      });
     });
+  });
 
-    it('calls attachReliabilityData', async () => {
-      Metrics.postEvent = sinon.stub();
-
-      // @ts-ignore
-      const roapRequest = new RoapRequest({}, {parent: webex});
-
-      const newSdp = {new: 'sdp'}
+  it('calls attachReachabilityData when sendRoap', async () => {
+    const newSdp = {
+      new: 'sdp',
+    };
 
-      roapRequest.attachRechabilityData = sinon.stub().returns(Promise.resolve(newSdp));
-      webex.request.returns(Promise.resolve({
+    roapRequest.attachReachabilityData = sinon.stub().returns(
+      Promise.resolve({
+        localSdp: newSdp,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+      })
+    );
+    webex.request.returns(
+      Promise.resolve({
         body: {
-          locus: {}
-        }
-      }))
+          locus: {},
+        },
+      })
+    );
+
+    const result = await roapRequest.sendRoap({
+      roapMessage: {
+        seq: 1,
+      },
+      locusSelfUrl: 'locusSelfUrl',
+      mediaId: 'mediaId',
+      correlationId: 'correlationId',
+      audioMuted: true,
+      videoMuted: true,
+      meetingId: 'meetingId',
+      preferTranscoding: true,
+    });
 
-      const result = await roapRequest.sendRoap({
-        roapMessage: {seq: 1},
-        locusSelfUrl: 'locusSelfUrl',
-        mediaId: 'mediaId',
-        correlationId: 'correlationId',
-        audioMuted: true,
-        videoMuted: true,
-        meetingId: 'meetingId',
-        preferTranscoding: true
-      });
+    const requestParams = roapRequest.request.getCall(0).args[0];
 
-      assert.calledOnceWithExactly(webex.request, {
-        uri: 'locusSelfUrl/media',
-        method: 'PUT',
-        body: {
-          device: {
-            url: undefined,
-            deviceType: undefined,
-          },
-          correlationId: 'correlationId',
-          localMedias: [{
+    assert.deepEqual(requestParams, {
+      uri: 'locusSelfUrl/media',
+      method: 'PUT',
+      body: {
+        device: {
+          url: 'url',
+          deviceType: undefined,
+        },
+        correlationId: 'correlationId',
+        localMedias: [
+          {
             localSdp: JSON.stringify(newSdp),
-            mediaId: 'mediaId'
-          }],
-          clientMediaPreferences: {preferTranscoding: true}
+            mediaId: 'mediaId',
+          },
+        ],
+        clientMediaPreferences: {
+          joinCookie: {
+            anycastEntryPoint: 'aws-eu-west-1',
+          },
+          preferTranscoding: true,
         },
-      });
+      },
+    });
 
-      assert.calledOnceWithExactly(roapRequest.attachRechabilityData, {
-        roapMessage: {seq: 1},
-        audioMuted: true,
-        videoMuted: true
-      })
+    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
+      roapMessage: {
+        seq: 1,
+      },
+      audioMuted: true,
+      videoMuted: true,
+    });
 
-      assert.deepEqual(result, {
-        locus: {
-          roapSeq: 1
-        }
-      });
+    assert.deepEqual(result, {
+      locus: {
+        fullState: {
+          lastActive: 'lastActive',
+        },
+        id: '',
+        roapSeq: 1,
+        url: 'url/path',
+      }
     });
-  })
+  });
 });