@webex/plugin-meetings 3.0.0-beta.39 → 3.0.0-beta.391

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

@@ -3,8 +3,7 @@ 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 Metrics from '@webex/plugin-meetings/src/metrics';
-import {REACHABILITY} from '@webex/plugin-meetings/src/constants';
+import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings/roap', () => {
   let roapRequest;
@@ -31,6 +30,9 @@ describe('plugin-meetings/roap', () => {
       device: {
         url: 'url',
       },
+      newMetrics: {
+        submitClientEvent: sinon.stub()
+      },
     };
 
     // @ts-ignore
@@ -51,8 +53,6 @@ describe('plugin-meetings/roap', () => {
       })
     );
 
-    Metrics.postEvent = sinon.stub().returns();
-
     await webex.boundedStorage.put(
       REACHABILITY.namespace,
       REACHABILITY.localStorageJoinCookie,
@@ -65,7 +65,9 @@ describe('plugin-meetings/roap', () => {
       REACHABILITY.localStorageResult,
       JSON.stringify({
         clusterId: {
-          udp: 'test',
+          udp: { result: 'reachable', latencyInMilliseconds: 10 },
+          tcp: { result: 'unreachable' },
+          isVideoMesh: false,
         },
       })
     );
@@ -78,7 +80,16 @@ describe('plugin-meetings/roap', () => {
       assert.deepEqual(res.localSdp, {
         reachability: {
           clusterId: {
-            udp: 'test',
+            udp: {
+              reachable: 'true',
+              latencyInMilliseconds: '10',
+            },
+            tcp: {
+              reachable: 'false',
+            },
+            xtls: {
+              untested: 'true',
+            }
           },
         },
       });
@@ -108,37 +119,95 @@ describe('plugin-meetings/roap', () => {
 
   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,
       });
 
-      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.calledWith(webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.locus.media.request',
+        options: {
+          meetingId: 'meeting-id',
         },
-      ]);
-      assert.deepEqual(requestParams.body.clientMediaPreferences, {
+      });
+
+      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',
         },
-        preferTranscoding: true,
+        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({
@@ -148,70 +217,39 @@ describe('plugin-meetings/roap', () => {
         },
       })
     );
-    webex.request.returns(
-      Promise.resolve({
-        body: {
-          locus: {},
-        },
-      })
-    );
 
-    const result = await roapRequest.sendRoap({
+    await roapRequest.sendRoap({
       roapMessage: {
         seq: 1,
       },
       locusSelfUrl: 'locusSelfUrl',
+      ipVersion,
       mediaId: 'mediaId',
-      correlationId: 'correlationId',
-      audioMuted: true,
-      videoMuted: true,
       meetingId: 'meetingId',
       preferTranscoding: true,
+      locusMediaRequest
     });
 
-    const requestParams = roapRequest.request.getCall(0).args[0];
+    const requestParams = locusMediaRequest.send.getCall(0).args[0];
 
     assert.deepEqual(requestParams, {
-      uri: 'locusSelfUrl/media',
-      method: 'PUT',
-      body: {
-        device: {
-          url: 'url',
-          deviceType: undefined,
-        },
-        correlationId: 'correlationId',
-        localMedias: [
-          {
-            localSdp: JSON.stringify(newSdp),
-            mediaId: 'mediaId',
-          },
-        ],
-        clientMediaPreferences: {
-          joinCookie: {
-            anycastEntryPoint: 'aws-eu-west-1',
-          },
-          preferTranscoding: true,
-        },
+      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,
       },
-      audioMuted: true,
-      videoMuted: true,
-    });
-
-    assert.deepEqual(result, {
-      locus: {
-        fullState: {
-          lastActive: 'lastActive',
-        },
-        id: '',
-        roapSeq: 1,
-        url: 'url/path',
-      }
     });
   });
 });