@webex/plugin-meetings 3.3.0 → 3.3.1-next.10

package/src/statsAnalyzer/mqaUtil.ts

@@ -2,7 +2,7 @@
 
 import {mean, max} from 'lodash';
 
-import {STATS} from '../constants';
+import {MQA_INTERVAL, STATS} from '../constants';
 
 /**
  * Get the totals of a certain value from a certain media type.
@@ -28,6 +28,7 @@ export const getAudioReceiverMqa = ({
   statsResults,
   lastMqaDataSent,
   baseMediaType,
+  isMultistream,
 }) => {
   const sendrecvType = STATS.RECEIVE_DIRECTION;
 
@@ -52,6 +53,7 @@ export const getAudioReceiverMqa = ({
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
       ?.direction || 'inactive';
   audioReceiver.common.common.isMain = !baseMediaType.includes('-share');
+  audioReceiver.common.common.multistreamEnabled = isMultistream;
   audioReceiver.common.transportType = statsResults.connectionType.local.transport;
 
   // add rtpPacket info inside common as also for call analyzer
@@ -127,7 +129,13 @@ export const getAudioReceiverStreamMqa = ({
     ((statsResults[mediaType][sendrecvType].totalBytesReceived - lastBytesReceived) * 8) / 60 || 0;
 };
 
-export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, baseMediaType}) => {
+export const getAudioSenderMqa = ({
+  audioSender,
+  statsResults,
+  lastMqaDataSent,
+  baseMediaType,
+  isMultistream,
+}) => {
   const sendrecvType = STATS.SEND_DIRECTION;
 
   const getLastTotalValue = (value: string) =>
@@ -152,6 +160,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, b
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
       ?.direction || 'inactive';
   audioSender.common.common.isMain = !baseMediaType.includes('-share');
+  audioSender.common.common.multistreamEnabled = isMultistream;
   audioSender.common.transportType = statsResults.connectionType.local.transport;
 
   audioSender.common.maxRemoteJitter = max(meanRemoteJitter) * 1000 || 0;
@@ -166,8 +175,8 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, b
     baseMediaType,
     'availableOutgoingBitrate'
   );
-  // Calculate based on how much packets lost of received compated to how to the client sent
 
+  // Calculate based on how much packets lost of received compated to how to the client sent
   const totalPacketsLostForaMin = totalPacketsLostOnReceiver - lastPacketsLostTotal;
   audioSender.common.remoteLossRate =
     totalPacketsSent - lastPacketsSent > 0
@@ -225,6 +234,7 @@ export const getVideoReceiverMqa = ({
   statsResults,
   lastMqaDataSent,
   baseMediaType,
+  isMultistream,
 }) => {
   const sendrecvType = STATS.RECEIVE_DIRECTION;
 
@@ -237,10 +247,16 @@ 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), []);
@@ -248,6 +264,7 @@ export const getVideoReceiverMqa = ({
   videoReceiver.common.common.direction =
     statsResults[Object.keys(statsResults).find((mediaType) => mediaType.includes(baseMediaType))]
       ?.direction || 'inactive';
+  videoReceiver.common.common.multistreamEnabled = isMultistream;
   videoReceiver.common.common.isMain = !baseMediaType.includes('-share');
   videoReceiver.common.transportType = statsResults.connectionType.local.transport;
 
@@ -266,10 +283,15 @@ 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 = ({
@@ -336,9 +358,23 @@ export const getVideoReceiverStreamMqa = ({
     statsResults[mediaType][sendrecvType].keyFramesDecoded - lastKeyFramesDecoded || 0;
   videoReceiverStream.requestedKeyFrames =
     statsResults[mediaType][sendrecvType].totalPliCount - lastPliCount || 0;
+
+  videoReceiverStream.isActiveSpeaker =
+    statsResults[mediaType][sendrecvType].isActiveSpeaker ||
+    ((statsResults[mediaType][sendrecvType].lastActiveSpeakerTimestamp ?? 0) > 0 &&
+      performance.now() +
+        performance.timeOrigin -
+        (statsResults[mediaType][sendrecvType].lastActiveSpeakerTimestamp ?? 0) <
+        MQA_INTERVAL);
 };
 
-export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, baseMediaType}) => {
+export const getVideoSenderMqa = ({
+  videoSender,
+  statsResults,
+  lastMqaDataSent,
+  baseMediaType,
+  isMultistream,
+}) => {
   const sendrecvType = STATS.SEND_DIRECTION;
 
   const getLastTotalValue = (value: string) =>
@@ -349,15 +385,20 @@ 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))]
       ?.direction || 'inactive';
+  videoSender.common.common.multistreamEnabled = isMultistream;
   videoSender.common.common.isMain = !baseMediaType.includes('-share');
   videoSender.common.transportType = statsResults.connectionType.local.transport;
 
@@ -389,8 +430,11 @@ 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 = ({
@@ -443,3 +487,23 @@ export const getVideoSenderStreamMqa = ({
   videoSenderStream.requestedFrameSize =
     statsResults[mediaType][sendrecvType].requestedFrameSize || 0;
 };
+
+/**
+ * Checks if stream stats should be updated based on request status and elapsed time.
+ *
+ * @param {Object} statsResults - Stats results object.
+ * @param {string} mediaType - Media type (e.g., 'audio', 'video').
+ * @param {string} direction - Stats direction (e.g., 'send', 'receive').
+ * @returns {boolean} Whether stats should be updated.
+ */
+export const isStreamRequested = (
+  statsResults: any,
+  mediaType: string,
+  direction: string
+): boolean => {
+  const now = performance.timeOrigin + performance.now();
+  const lastUpdateTimestamp = statsResults[mediaType][direction]?.lastRequestedUpdateTimestamp;
+  const isRequested = statsResults[mediaType][direction]?.isRequested;
+
+  return isRequested || (lastUpdateTimestamp && now - lastUpdateTimestamp < MQA_INTERVAL);
+};

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

@@ -1302,6 +1302,31 @@ 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;
@@ -1351,15 +1376,10 @@ describe('plugin-meetings', () => {
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(meeting.setLocus);
             assert.equal(result, joinMeetingResult);
-
             assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {
-                file: 'meeting/index',
-                function: 'join',
-              },
-              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
+              webex.internal.llm.on,
+              'online',
+              meeting.handleLLMOnline
             );
           });
 

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: {
@@ -1917,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, '');
           });
@@ -1952,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 () => {
@@ -1968,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);
         });
 
@@ -1989,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(), ['']);
             });
           }
         );
@@ -2005,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 () => {
@@ -2022,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(
@@ -2042,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(), ['']);
             });
           }
         );
@@ -2058,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(), ['']);
         });
       });
     });
@@ -2344,12 +2365,14 @@ 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,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;