@webex/plugin-meetings 3.2.0 → 3.3.0

package/src/statsAnalyzer/index.ts

@@ -998,11 +998,12 @@ export class StatsAnalyzer extends EventsScope {
         result.qualityLimitationReason;
       this.statsResults[mediaType][sendrecvType].qualityLimitationResolutionChanges =
         result.qualityLimitationResolutionChanges;
-      this.statsResults[mediaType][sendrecvType].totalRtxPacketsSent =
+      this.statsResults[mediaType][sendrecvType].retransmittedPacketsSent =
         result.retransmittedPacketsSent;
-      this.statsResults[mediaType][sendrecvType].totalRtxBytesSent = result.retransmittedBytesSent;
       this.statsResults[mediaType][sendrecvType].totalBytesSent = result.bytesSent;
       this.statsResults[mediaType][sendrecvType].headerBytesSent = result.headerBytesSent;
+      this.statsResults[mediaType][sendrecvType].retransmittedBytesSent =
+        result.retransmittedBytesSent;
       this.statsResults[mediaType][sendrecvType].requestedBitrate = result.requestedBitrate;
       this.statsResults[mediaType][sendrecvType].requestedFrameSize = result.requestedFrameSize;
     }
@@ -1135,10 +1136,6 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].fecPacketsReceived = result.fecPacketsReceived;
       this.statsResults[mediaType][sendrecvType].totalBytesReceived = result.bytesReceived;
       this.statsResults[mediaType][sendrecvType].headerBytesReceived = result.headerBytesReceived;
-      this.statsResults[mediaType][sendrecvType].totalRtxPacketsReceived =
-        result.retransmittedPacketsReceived;
-      this.statsResults[mediaType][sendrecvType].totalRtxBytesReceived =
-        result.retransmittedBytesReceived;
 
       this.statsResults[mediaType][sendrecvType].meanRtpJitter.push(result.jitter);
 

package/src/statsAnalyzer/mqaUtil.ts

@@ -237,16 +237,10 @@ export const getVideoReceiverMqa = ({
   const lastPacketsLost = getLastTotalValue('totalPacketsLost');
   const lastBytesReceived = getLastTotalValue('totalBytesReceived');
 
-  const lastRtxPacketsReceived = getLastTotalValue('totalRtxPacketsReceived');
-  const lastRtxBytesReceived = getLastTotalValue('totalRtxBytesReceived');
-
   const packetsLost = getTotalValue('totalPacketsLost');
   const totalPacketsReceived = getTotalValue('totalPacketsReceived');
   const totalBytesReceived = getTotalValue('totalBytesReceived');
 
-  const totalRtxPacketsReceived = getTotalValue('totalRtxPacketsReceived');
-  const totalRtxBytesReceived = getTotalValue('totalRtxBytesReceived');
-
   const meanRemoteJitter = Object.keys(statsResults)
     .filter((mt) => mt.includes(baseMediaType))
     .reduce((acc, mt) => acc.concat(statsResults[mt][sendrecvType].meanRemoteJitter), []);
@@ -272,15 +266,10 @@ export const getVideoReceiverMqa = ({
 
   // Calculate the outgoing bitrate
   const totalBytesReceivedInaMin = totalBytesReceived - lastBytesReceived;
-  const totalRtxBytesReceivedInaMin = totalRtxBytesReceived - lastRtxBytesReceived;
 
   videoReceiver.common.rtpBitrate = totalBytesReceivedInaMin
     ? (totalBytesReceivedInaMin * 8) / 60
     : 0;
-  videoReceiver.common.rtxPackets = totalRtxPacketsReceived - lastRtxPacketsReceived;
-  videoReceiver.common.rtxBitrate = totalRtxBytesReceivedInaMin
-    ? (totalRtxBytesReceivedInaMin * 8) / 60
-    : 0;
 };
 
 export const getVideoReceiverStreamMqa = ({
@@ -360,15 +349,11 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
   const lastPacketsSent = getLastTotalValue('totalPacketsSent');
   const lastBytesSent = getLastTotalValue('totalBytesSent');
   const lastPacketsLostTotal = getLastTotalValue('totalPacketsLostOnReceiver');
-  const lastRtxPacketsSent = getLastTotalValue('totalRtxPacketsSent');
-  const lastRtxBytesSent = getLastTotalValue('totalRtxBytesSent');
 
   const totalPacketsLostOnReceiver = getTotalValue('totalPacketsLostOnReceiver');
   const totalPacketsSent = getTotalValue('totalPacketsSent');
   const totalBytesSent = getTotalValue('totalBytesSent');
   const availableOutgoingBitrate = getTotalValue('availableOutgoingBitrate');
-  const totalRtxPacketsSent = getTotalValue('totalRtxPacketsSent');
-  const totalRtxBytesSent = getTotalValue('totalRtxBytesSent');
 
   videoSender.common.common.direction =
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
@@ -404,11 +389,8 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, b
 
   // Calculate the outgoing bitrate
   const totalBytesSentInaMin = totalBytesSent - lastBytesSent;
-  const totalRtxBytesSentInaMin = totalRtxBytesSent - lastRtxBytesSent;
 
   videoSender.common.rtpBitrate = totalBytesSentInaMin ? (totalBytesSentInaMin * 8) / 60 : 0;
-  videoSender.common.rtxPackets = totalRtxPacketsSent - lastRtxPacketsSent;
-  videoSender.common.rtxBitrate = totalRtxBytesSentInaMin ? (totalRtxBytesSentInaMin * 8) / 60 : 0;
 };
 
 export const getVideoSenderStreamMqa = ({

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

@@ -1302,31 +1302,6 @@ describe('plugin-meetings', () => {
           );
         });
       });
-
-      describe('#handleLLMOnline', () => {
-        beforeEach(() => {
-          webex.internal.llm.off = sinon.stub();
-        });
-
-        it('turns off llm online, emits transcription connected events', () => {
-          meeting.handleLLMOnline();
-          assert.calledOnceWithExactly(
-            webex.internal.llm.off,
-            'online',
-            meeting.handleLLMOnline
-          );
-          assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'handleLLMOnline',
-            },
-            EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
-          );
-        });
-      });
-
       describe('#join', () => {
         let sandbox = null;
         let setCorrelationIdSpy;
@@ -1376,10 +1351,15 @@ describe('plugin-meetings', () => {
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(meeting.setLocus);
             assert.equal(result, joinMeetingResult);
+
             assert.calledWith(
-              webex.internal.llm.on,
-              'online',
-              meeting.handleLLMOnline
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'join',
+              },
+              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
             );
           });
 

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

@@ -18,7 +18,6 @@ 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';
@@ -76,8 +75,6 @@ describe('plugin-meetings', () => {
   let test1;
   let test2;
   let locusInfo;
-  let services;
-  let catalog;
 
   describe('meetings index', () => {
     beforeEach(() => {
@@ -96,13 +93,9 @@ describe('plugin-meetings', () => {
           device: Device,
           mercury: Mercury,
           meetings: Meetings,
-          services: Services,
         },
       });
 
-      services = webex.internal.services;
-      catalog = services._getCatalog();
-
       Object.assign(webex, {
         logging: logger,
       });
@@ -168,7 +161,6 @@ describe('plugin-meetings', () => {
               ],
             })
           ),
-          _getCatalog: sinon.stub().returns(catalog),
           fetchClientRegionInfo: sinon.stub().returns(Promise.resolve()),
         },
         metrics: {
@@ -1925,34 +1917,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, '');
           });
@@ -1960,7 +1952,6 @@ 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 () => {
@@ -1977,10 +1968,6 @@ 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);
         });
 
@@ -2002,7 +1989,6 @@ describe('plugin-meetings', () => {
                 loggerProxySpy,
                 'Failed to fetch preferred site from user - no site will be set'
               );
-              assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
             });
           }
         );
@@ -2019,7 +2005,6 @@ 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 () => {
@@ -2037,10 +2022,6 @@ 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(
@@ -2061,7 +2042,6 @@ describe('plugin-meetings', () => {
                 loggerProxySpy,
                 'Failed to fetch preferred site from user - no site will be set'
               );
-              assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
             });
           }
         );
@@ -2078,7 +2058,6 @@ describe('plugin-meetings', () => {
             loggerProxySpy,
             'Failed to fetch preferred site from user - no site will be set'
           );
-          assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), ['']);
         });
       });
     });
@@ -2365,14 +2344,12 @@ describe('plugin-meetings', () => {
           sessionType: 'MAIN',
         };
         newLocus.self.state = 'JOINED';
-        newLocus.self.devices = [
-          {
-            intent: {
-              reason: 'ON_HOLD_LOBBY',
-              type: 'WAIT',
-            },
-          },
-        ];
+        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);

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

@@ -141,272 +141,6 @@ 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;