@webex/plugin-meetings 3.1.0-next.9 → 3.2.0

package/test/unit/spec/meetings/index.js

@@ -18,6 +18,7 @@ import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import Meeting, {CallStateForMetrics} from '@webex/plugin-meetings/src/meeting';
+import {Services} from '@webex/webex-core';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Meetings from '@webex/plugin-meetings/src/meetings';
 import MeetingCollection from '@webex/plugin-meetings/src/meetings/collection';
@@ -75,6 +76,8 @@ describe('plugin-meetings', () => {
   let test1;
   let test2;
   let locusInfo;
+  let services;
+  let catalog;
 
   describe('meetings index', () => {
     beforeEach(() => {
@@ -93,9 +96,13 @@ describe('plugin-meetings', () => {
           device: Device,
           mercury: Mercury,
           meetings: Meetings,
+          services: Services,
         },
       });
 
+      services = webex.internal.services;
+      catalog = services._getCatalog();
+
       Object.assign(webex, {
         logging: logger,
       });
@@ -161,6 +168,7 @@ describe('plugin-meetings', () => {
               ],
             })
           ),
+          _getCatalog: sinon.stub().returns(catalog),
           fetchClientRegionInfo: sinon.stub().returns(Promise.resolve()),
         },
         metrics: {
@@ -513,13 +521,8 @@ describe('plugin-meetings', () => {
             });
             describe('#getAllMeetings', () => {
               it('calls MeetingCollection to get all meetings with supplied options', () => {
-                webex.meetings.getAllMeetings({
-                  test: test1,
-                });
+                webex.meetings.getAllMeetings();
                 assert.calledOnce(webex.meetings.meetingCollection.getAll);
-                assert.calledWith(webex.meetings.meetingCollection.getAll, {
-                  test: test1,
-                });
               });
             });
           });
@@ -1011,6 +1014,7 @@ describe('plugin-meetings', () => {
                   callBackInfo: {
                     callbackAddress: uri1,
                   },
+                  devices: [],
                 },
                 info: {
                   webExMeetingId,
@@ -1038,6 +1042,7 @@ describe('plugin-meetings', () => {
                 callBackInfo: {
                   callbackAddress: uri1,
                 },
+                devices: [],
               },
               info: {
                 webExMeetingId,
@@ -1052,6 +1057,7 @@ describe('plugin-meetings', () => {
                   callBackInfo: {
                     callbackAddress: uri1,
                   },
+                  devices: [],
                 },
                 info: {
                   webExMeetingId,
@@ -1074,6 +1080,7 @@ describe('plugin-meetings', () => {
                 callBackInfo: {
                   callbackAddress: uri1,
                 },
+                devices: [],
               },
               info: {
                 webExMeetingId,
@@ -1091,6 +1098,7 @@ describe('plugin-meetings', () => {
                   callBackInfo: {
                     callbackAddress: uri1,
                   },
+                  devices: [],
                 },
                 info: {
                   webExMeetingId,
@@ -1121,6 +1129,7 @@ describe('plugin-meetings', () => {
                   callBackInfo: {
                     callbackAddress: uri1,
                   },
+                  devices: [],
                 },
                 info: {
                   webExMeetingId,
@@ -1143,6 +1152,7 @@ describe('plugin-meetings', () => {
                 callBackInfo: {
                   callbackAddress: uri1,
                 },
+                devices: [],
               },
               info: {
                 webExMeetingId,
@@ -1157,6 +1167,7 @@ describe('plugin-meetings', () => {
                 callbackInfo: {
                   callbackAddress: uri1,
                 },
+                devices: [],
               },
               info: {
                 isUnifiedSpaceMeeting,
@@ -1914,34 +1925,34 @@ describe('plugin-meetings', () => {
         let loggerProxySpy;
 
         it('should call request.getMeetingPreferences to get the preferred webex site ', async () => {
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
           assert.isDefined(webex.meetings.preferredWebexSite);
           await webex.meetings.fetchUserPreferredWebexSite();
 
           assert.equal(webex.meetings.preferredWebexSite, 'go.webex.com');
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), [
+            'go.webex.com',
+          ]);
         });
 
         const setup = ({user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
 
           Object.assign(webex.internal, {
-            services: {
-              getMeetingPreferences: sinon.stub().returns(Promise.resolve({})),
-            },
             user: {
               get: sinon.stub().returns(Promise.resolve(user)),
             },
           });
+
+          Object.assign(webex.internal.services, {
+            getMeetingPreferences: sinon.stub().returns(Promise.resolve({})),
+          });
         };
 
         it('should not fail if UserPreferred info is not fetched ', async () => {
           setup();
 
-          Object.assign(webex.internal, {
-            services: {
-              getMeetingPreferences: sinon.stub().returns(Promise.resolve({})),
-            },
-          });
-
           await webex.meetings.fetchUserPreferredWebexSite().then(() => {
             assert.equal(webex.meetings.preferredWebexSite, '');
           });
@@ -1949,6 +1960,7 @@ describe('plugin-meetings', () => {
             loggerProxySpy,
             'Failed to fetch preferred site from user - no site will be set'
           );
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
         });
 
         it('should fall back to fetching the site from the user', async () => {
@@ -1965,6 +1977,10 @@ describe('plugin-meetings', () => {
           await webex.meetings.fetchUserPreferredWebexSite();
 
           assert.equal(webex.meetings.preferredWebexSite, 'site.webex.com');
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), [
+            '',
+            'site.webex.com',
+          ]);
           assert.notCalled(loggerProxySpy);
         });
 
@@ -1986,6 +2002,7 @@ describe('plugin-meetings', () => {
                 loggerProxySpy,
                 'Failed to fetch preferred site from user - no site will be set'
               );
+              assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
             });
           }
         );
@@ -2002,6 +2019,7 @@ describe('plugin-meetings', () => {
             loggerProxySpy,
             'Failed to fetch preferred site from user - no site will be set'
           );
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
         });
 
         it('should fall back to fetching the site from the user', async () => {
@@ -2019,6 +2037,10 @@ describe('plugin-meetings', () => {
 
           assert.equal(webex.meetings.preferredWebexSite, 'site.webex.com');
           assert.notCalled(loggerProxySpy);
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), [
+            '',
+            'site.webex.com',
+          ]);
         });
 
         forEach(
@@ -2039,6 +2061,7 @@ describe('plugin-meetings', () => {
                 loggerProxySpy,
                 'Failed to fetch preferred site from user - no site will be set'
               );
+              assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
             });
           }
         );
@@ -2055,6 +2078,7 @@ describe('plugin-meetings', () => {
             loggerProxySpy,
             'Failed to fetch preferred site from user - no site will be set'
           );
+          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
         });
       });
     });
@@ -2299,6 +2323,7 @@ describe('plugin-meetings', () => {
           sessionType: 'BREAKOUT',
         };
         newLocus.self.state = 'JOINED';
+        newLocus.self.devices = [];
         newLocus.fullState = {
           active: true,
         };
@@ -2315,7 +2340,7 @@ describe('plugin-meetings', () => {
           sessionType: 'MAIN',
         };
         newLocus.self.state = 'JOINED';
-
+        newLocus.self.devices = [];
         LoggerProxy.logger.log = sinon.stub();
         const result = webex.meetings.isNeedHandleLocusDTO(meeting, newLocus);
         assert.equal(result, true);
@@ -2330,11 +2355,28 @@ describe('plugin-meetings', () => {
         };
         newLocus.self.state = 'LEFT';
         newLocus.self.reason = 'MOVED';
-
+        newLocus.self.devices = [];
         LoggerProxy.logger.log = sinon.stub();
         const result = webex.meetings.isNeedHandleLocusDTO(meeting, newLocus);
         assert.equal(result, false);
       });
+      it('moved to lobby, return true', () => {
+        newLocus.controls.breakout = {
+          sessionType: 'MAIN',
+        };
+        newLocus.self.state = 'JOINED';
+        newLocus.self.devices = [
+          {
+            intent: {
+              reason: 'ON_HOLD_LOBBY',
+              type: 'WAIT',
+            },
+          },
+        ];
+        LoggerProxy.logger.log = sinon.stub();
+        const result = webex.meetings.isNeedHandleLocusDTO(meeting, newLocus);
+        assert.equal(result, true);
+      });
     });
 
     describe('#getCorrespondingMeetingByLocus', () => {

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

@@ -141,6 +141,272 @@ describe('isAnyPublicClusterReachable', () => {
   });
 });
 
+
+describe('isWebexMediaBackendUnreachable', () => {
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const runCheck = async (mockStorage: any, expectedValue: boolean) => {
+    if (mockStorage) {
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
+    }
+    const reachability = new Reachability(webex);
+
+    const result = await reachability.isWebexMediaBackendUnreachable();
+
+    assert.equal(result, expectedValue);
+  };
+
+  [
+    {
+      title: 'no clusters at all',
+      mockStorage: {},
+      expectedResult: false,
+    },
+    {
+      title: 'clusters without results',
+      mockStorage: {a: {}, b: {}},
+      expectedResult: false,
+    },
+    {
+      title: 'all clusters untested',
+      mockStorage: {
+        a: {udp: 'untested'},
+        b: {udp: 'untested', tcp: 'untested'},
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with udp reachable',
+      mockStorage: {x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with tcp reachable',
+      mockStorage: {x: {tcp: {result: 'reachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'one cluster with xtls reachable',
+      mockStorage: {x: {xtls: {result: 'reachable'}}, y: {xtls: {result: 'unreachable'}}},
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with various protocols reachable',
+      mockStorage: {
+        a: {udp: {result: 'reachable'}, tcp: {result: 'reachable'}},
+        b: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}},
+        c: {tcp: {result: 'reachable'}},
+        d: {xtls: {result: 'reachable'}},
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: true,
+    },
+    {
+      title: 'multiple clusters with UDP and TCP protocols unreachable, but TLS not tested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TCP protocols unreachable, but TLS missing',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TLS protocols unreachable, but TCP not tested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with UDP and TLS protocols unreachable, but TCP missing',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, some untested',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {udp: {result: 'unreachable'}, tcp: {result: 'untested'}, xtls: {result: 'unreachable'}},
+        c: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}, xtls: {result: 'untested'}},
+      },
+      expectedResult: true,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on udp',
+      mockStorage: {
+        a: {
+          udp: {result: 'reachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on tcp',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with all protocols unreachable, except for 1 reachable on xtls',
+      mockStorage: {
+        a: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+        b: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'reachable'},
+        },
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with some missing results',
+      mockStorage: {
+        a: {udp: {result: 'unreachable'}},
+        b: {tcp: {result: 'unreachable'}},
+        c: {xtls: {result: 'unreachable'}},
+        d: {},
+      },
+      expectedResult: true,
+    },
+  ].forEach(({mockStorage, expectedResult, title}) => {
+    it(`returns ${expectedResult} when ${title}`, async () => {
+      await runCheck(mockStorage, expectedResult);
+    });
+  });
+});
+
+
 describe('gatherReachability', () => {
   let webex;
 

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

@@ -133,20 +133,6 @@ describe('plugin-meetings/roap', () => {
         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',
@@ -175,29 +161,6 @@ describe('plugin-meetings/roap', () => {
         },
       });
     });
-
-    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 () => {