@webex/plugin-meetings 3.12.0-next.84 → 3.12.0-next.86

package/dist/types/reachability/reachability.types.d.ts

@@ -1,5 +1,12 @@
 import { IP_VERSION, Enum } from '../constants';
 export type Protocol = 'udp' | 'tcp' | 'xtls';
+export type ResolvedReachabilityProtocols = {
+    udp: boolean;
+    tcp: boolean;
+    tls: boolean;
+};
+export type ReachabilityProtocolConfig = Partial<Omit<ResolvedReachabilityProtocols, 'udp'>>;
+export type EnableReachabilityChecksConfig = boolean | ReachabilityProtocolConfig;
 /**
  * Events emitted by ReachabilityPeerConnection
  */

package/dist/types/reachability/util.d.ts

@@ -1,3 +1,20 @@
+import { EnableReachabilityChecksConfig, ResolvedReachabilityProtocols } from './reachability.types';
+/**
+ * Resolves `enableReachabilityChecks` into explicit per-protocol flags.
+ * Defaults to all protocols enabled when not configured.
+ * UDP is always tested unless reachability is disabled entirely (`false`).
+ *
+ * @param {EnableReachabilityChecksConfig} enabled value of config.meetings.enableReachabilityChecks
+ * @returns {ResolvedReachabilityProtocols} resolved per-protocol flags
+ */
+export declare function resolveReachabilityProtocols(enabled?: EnableReachabilityChecksConfig): ResolvedReachabilityProtocols;
+/**
+ * Whether any reachability protocol is enabled.
+ *
+ * @param {EnableReachabilityChecksConfig} config value of config.meetings.enableReachabilityChecks
+ * @returns {boolean} true if any protocol is enabled
+ */
+export declare function isReachabilityEnabled(config?: EnableReachabilityChecksConfig): boolean;
 /**
  * Converts a stun url to a turn url
  *

package/dist/webinar/index.js

@@ -869,7 +869,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
       }, _callee1);
     }))();
   },
-  version: "3.12.0-next.84"
+  version: "3.12.0-next.86"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -94,5 +94,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.12.0-next.84"
+  "version": "3.12.0-next.86"
 }

package/src/config.ts

@@ -87,8 +87,6 @@ export default {
       enableMediaNegotiatedEvent: false,
       enableUnifiedMeetings: true,
       enableAdhocMeetings: true,
-      enableTcpReachability: false,
-      enableTlsReachability: false,
       storeLocusHashTreeEventsForDebugging: false,
     },
     degradationPreferences: {

package/src/constants.ts

@@ -1108,7 +1108,10 @@ export const DISPLAY_HINTS = {
   ANONYMOUS_DISPLAY_NAMES_ENABLED: 'ANONYMOUS_DISPLAY_NAMES_ENABLED',
 };
 
-export const INTERSTITIAL_DISPLAY_HINTS = [DISPLAY_HINTS.VOIP_IS_ENABLED];
+export const INTERSTITIAL_DISPLAY_HINTS = [
+  DISPLAY_HINTS.VOIP_IS_ENABLED,
+  DISPLAY_HINTS.ANONYMOUS_DISPLAY_NAMES_ENABLED,
+];
 
 export const SELF_ROLES = {
   COHOST: 'COHOST',

package/src/meetings/index.ts

@@ -840,42 +840,6 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
-  /**
-   * API to toggle TCP reachability, needs to be called before webex.meetings.register()
-   * @param {Boolean} newValue
-   * @private
-   * @memberof Meetings
-   * @returns {undefined}
-   */
-  private _toggleTcpReachability(newValue: boolean) {
-    if (typeof newValue !== 'boolean') {
-      return;
-    }
-    // @ts-ignore
-    if (this.config.experimental.enableTcpReachability !== newValue) {
-      // @ts-ignore
-      this.config.experimental.enableTcpReachability = newValue;
-    }
-  }
-
-  /**
-   * API to toggle TLS reachability, needs to be called before webex.meetings.register()
-   * @param {Boolean} newValue
-   * @private
-   * @memberof Meetings
-   * @returns {undefined}
-   */
-  private _toggleTlsReachability(newValue: boolean) {
-    if (typeof newValue !== 'boolean') {
-      return;
-    }
-    // @ts-ignore
-    if (this.config.experimental.enableTlsReachability !== newValue) {
-      // @ts-ignore
-      this.config.experimental.enableTlsReachability = newValue;
-    }
-  }
-
   /**
    * API to toggle backend ipv6 native support config, needs to be called before webex.meetings.register()
    *

package/src/reachability/index.ts

@@ -33,6 +33,7 @@ import {
   NatTypeUpdatedEventData,
   ResultEventData,
 } from './clusterReachability';
+import {isReachabilityEnabled, resolveReachabilityProtocols} from './util';
 import EventsScope from '../common/events/events-scope';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import Metrics from '../metrics';
@@ -194,7 +195,7 @@ export default class Reachability extends EventsScope {
    */
   public async gatherReachability(trigger: string): Promise<ReachabilityResults> {
     // @ts-ignore
-    if (!this.webex.config.meetings.enableReachabilityChecks) {
+    if (!isReachabilityEnabled(this.webex.config.meetings.enableReachabilityChecks)) {
       throw new Error('enableReachabilityChecks is disabled in config');
     }
 
@@ -515,7 +516,7 @@ export default class Reachability extends EventsScope {
    * Returns true only if ALL protocols (UDP, TCP and TLS) have been tested and none
    * of the media clusters where reachable with any of the protocols. This is done
    * irrespective of the config, so for example:
-   * if config.meetings.experimental.enableTlsReachability === false,
+   * if config.meetings.enableReachabilityChecks disables TLS,
    * it will return false, because TLS reachability won't be tested,
    * so we can't say for sure that media backend is unreachable over TLS.
    *
@@ -888,14 +889,21 @@ export default class Reachability extends EventsScope {
 
     this.startTime = performance.now();
 
+    const protocols = resolveReachabilityProtocols(
+      // @ts-ignore
+      this.webex.config.meetings.enableReachabilityChecks
+    );
+
+    const enabledProtocols = [
+      protocols.udp && 'UDP',
+      protocols.tcp && 'TCP',
+      protocols.tls && 'TLS',
+    ].filter(Boolean);
+
     LoggerProxy.logger.log(
-      `Reachability:index#performReachabilityChecks --> doing UDP${
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability ? ',TCP' : ''
-      }${
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTlsReachability ? ',TLS' : ''
-      } reachability checks`
+      `Reachability:index#performReachabilityChecks --> doing ${enabledProtocols.join(
+        ','
+      )} reachability checks`
     );
 
     this.resetResultCounters();
@@ -905,18 +913,14 @@ export default class Reachability extends EventsScope {
       const cluster = clusterList[key];
 
       // Linus doesn't support TCP reachability checks on video mesh nodes
-      const includeTcpReachability =
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTcpReachability && !cluster.isVideoMesh;
+      const includeTcpReachability = protocols.tcp && !cluster.isVideoMesh;
 
       if (!includeTcpReachability) {
         cluster.tcp = [];
       }
 
       // Linus doesn't support xTLS reachability checks on video mesh nodes
-      const includeTlsReachability =
-        // @ts-ignore
-        this.webex.config.meetings.experimental.enableTlsReachability && !cluster.isVideoMesh;
+      const includeTlsReachability = protocols.tls && !cluster.isVideoMesh;
 
       if (!includeTlsReachability) {
         cluster.xtls = [];

package/src/reachability/reachability.types.ts

@@ -2,6 +2,17 @@ import {IP_VERSION, Enum} from '../constants';
 
 export type Protocol = 'udp' | 'tcp' | 'xtls';
 
+// Per-protocol reachability flags, fully resolved.
+export type ResolvedReachabilityProtocols = {
+  udp: boolean;
+  tcp: boolean;
+  tls: boolean;
+};
+
+export type ReachabilityProtocolConfig = Partial<Omit<ResolvedReachabilityProtocols, 'udp'>>;
+
+export type EnableReachabilityChecksConfig = boolean | ReachabilityProtocolConfig;
+
 /**
  * Events emitted by ReachabilityPeerConnection
  */

package/src/reachability/util.ts

@@ -1,4 +1,40 @@
 /* eslint-disable import/prefer-default-export */
+import {EnableReachabilityChecksConfig, ResolvedReachabilityProtocols} from './reachability.types';
+
+/**
+ * Resolves `enableReachabilityChecks` into explicit per-protocol flags.
+ * Defaults to all protocols enabled when not configured.
+ * UDP is always tested unless reachability is disabled entirely (`false`).
+ *
+ * @param {EnableReachabilityChecksConfig} enabled value of config.meetings.enableReachabilityChecks
+ * @returns {ResolvedReachabilityProtocols} resolved per-protocol flags
+ */
+export function resolveReachabilityProtocols(
+  enabled: EnableReachabilityChecksConfig = true
+): ResolvedReachabilityProtocols {
+  if (typeof enabled === 'object') {
+    return {
+      udp: true,
+      tcp: enabled.tcp ?? true,
+      tls: enabled.tls ?? true,
+    };
+  }
+
+  return {udp: enabled, tcp: enabled, tls: enabled};
+}
+
+/**
+ * Whether any reachability protocol is enabled.
+ *
+ * @param {EnableReachabilityChecksConfig} config value of config.meetings.enableReachabilityChecks
+ * @returns {boolean} true if any protocol is enabled
+ */
+export function isReachabilityEnabled(config: EnableReachabilityChecksConfig = true): boolean {
+  const {udp, tcp, tls} = resolveReachabilityProtocols(config);
+
+  return udp || tcp || tls;
+}
+
 /**
  * Converts a stun url to a turn url
  *

package/test/unit/spec/locus-info/infoUtils.js

@@ -83,7 +83,7 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('only includes interstitial display hints when user has not joined the meeting', () => {
+      it('only includes interstitial display (VOIP_IS_ENABLED) hints when user has not joined the meeting', () => {
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR'], false), {
           policy: {HINT_3: true, VOIP_IS_ENABLED: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
@@ -111,6 +111,102 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('only includes interstitial display (ANONYMOUS_DISPLAY_NAMES_ENABLED) hints when user has not joined the meeting', () => {
+        const interstitialInfo = {
+          displayHints: {
+            moderator: ['HINT_1', 'HINT_2'],
+            joined: [
+              'HINT_3',
+              'ANONYMOUS_DISPLAY_NAMES_ENABLED',
+            ],
+            coHost: ['HINT_4'],
+            presenter: ['HINT_5'],
+            panelist: ['HINT_6'],
+            attendee: ['HINT_7'],
+          },
+        };
+
+        assert.deepEqual(InfoUtils.parse(interstitialInfo, ['MODERATOR'], false), {
+          policy: {HINT_3: true, ANONYMOUS_DISPLAY_NAMES_ENABLED: true},
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          presenter: {HINT_5: true},
+          panelist: {HINT_6: true},
+          attendee: {HINT_7: true},
+          userDisplayHints: ['ANONYMOUS_DISPLAY_NAMES_ENABLED', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND'],
+        });
+
+        assert.deepEqual(InfoUtils.parse(interstitialInfo, ['MODERATOR'], true), {
+          policy: {HINT_3: true, ANONYMOUS_DISPLAY_NAMES_ENABLED: true},
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          presenter: {HINT_5: true},
+          panelist: {HINT_6: true},
+          attendee: {HINT_7: true},
+          userDisplayHints: [
+            'HINT_3',
+            'ANONYMOUS_DISPLAY_NAMES_ENABLED',
+            'HINT_1',
+            'HINT_2',
+            'LOWER_SOMEONE_ELSES_HAND',
+          ],
+        });
+      });
+
+      it('includes all interstitial display hints (VOIP_IS_ENABLED and ANONYMOUS_DISPLAY_NAMES_ENABLED) when user has not joined the meeting', () => {
+        const interstitialInfo = {
+          displayHints: {
+            moderator: ['HINT_1', 'HINT_2'],
+            joined: [
+              'HINT_3',
+              'VOIP_IS_ENABLED',
+              'ANONYMOUS_DISPLAY_NAMES_ENABLED',
+              'HINT_NON_INTERSTITIAL',
+            ],
+            coHost: ['HINT_4'],
+            presenter: ['HINT_5'],
+            panelist: ['HINT_6'],
+            attendee: ['HINT_7'],
+          },
+        };
+
+        assert.deepEqual(InfoUtils.parse(interstitialInfo, [], false), {
+          policy: {
+            HINT_3: true,
+            VOIP_IS_ENABLED: true,
+            ANONYMOUS_DISPLAY_NAMES_ENABLED: true,
+            HINT_NON_INTERSTITIAL: true,
+          },
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          presenter: {HINT_5: true},
+          panelist: {HINT_6: true},
+          attendee: {HINT_7: true},
+          userDisplayHints: ['VOIP_IS_ENABLED', 'ANONYMOUS_DISPLAY_NAMES_ENABLED'],
+        });
+
+        assert.deepEqual(InfoUtils.parse(interstitialInfo, ['MODERATOR'], false), {
+          policy: {
+            HINT_3: true,
+            VOIP_IS_ENABLED: true,
+            ANONYMOUS_DISPLAY_NAMES_ENABLED: true,
+            HINT_NON_INTERSTITIAL: true,
+          },
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          presenter: {HINT_5: true},
+          panelist: {HINT_6: true},
+          attendee: {HINT_7: true},
+          userDisplayHints: [
+            'VOIP_IS_ENABLED',
+            'ANONYMOUS_DISPLAY_NAMES_ENABLED',
+            'HINT_1',
+            'HINT_2',
+            'LOWER_SOMEONE_ELSES_HAND',
+          ],
+        });
+      });
+
       it('merges presenter hints when user has PRESENTER role', () => {
         assert.deepEqual(InfoUtils.parse(info, ['PRESENTER']), {
           policy: {HINT_3: true, VOIP_IS_ENABLED: true},

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

@@ -358,32 +358,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#_toggleTcpReachability', () => {
-      it('should have _toggleTcpReachability', () => {
-        assert.equal(typeof webex.meetings._toggleTcpReachability, 'function');
-      });
-
-      describe('success', () => {
-        it('should update meetings to do TCP reachability', () => {
-          webex.meetings._toggleTcpReachability(true);
-          assert.equal(webex.meetings.config.experimental.enableTcpReachability, true);
-        });
-      });
-    });
-
-    describe('#_toggleTlsReachability', () => {
-      it('should have _toggleTlsReachability', () => {
-        assert.equal(typeof webex.meetings._toggleTlsReachability, 'function');
-      });
-
-      describe('success', () => {
-        it('should update meetings to do TLS reachability', () => {
-          webex.meetings._toggleTlsReachability(true);
-          assert.equal(webex.meetings.config.experimental.enableTlsReachability, true);
-        });
-      });
-    });
-
     describe('#_toggleIpv6BackendNativeSupport', () => {
       it('should have _toggleIpv6BackendNativeSupport', () => {
         assert.equal(typeof webex.meetings._toggleIpv6BackendNativeSupport, 'function');

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

@@ -1,3 +1,4 @@
+import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import { CapabilityState, WebCapabilities } from '@webex/web-capabilities';
@@ -63,6 +64,13 @@ describe('isAnyPublicClusterReachable', () => {
     );
   });
 
+  it('returns false when only xtls is reachable', async () => {
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}, xtls: {result: 'reachable'}}},
+      false
+    );
+  });
+
   it('returns false when both tcp and udp are unreachable', async () => {
     await checkIsClusterReachable(
       {x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}}},
@@ -70,6 +78,13 @@ describe('isAnyPublicClusterReachable', () => {
     );
   });
 
+  it('returns false when udp, tcp and xtls are all unreachable', async () => {
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}, xtls: {result: 'unreachable'}}},
+      false
+    );
+  });
+
   it('returns false when reachability result is empty', async () => {
     await checkIsClusterReachable({x: {}}, false);
   });
@@ -510,10 +525,7 @@ describe('gatherReachability', () => {
         return mockInstance;
       });
 
-    webex.config.meetings.experimental = {
-      enableTcpReachability: false,
-      enableTlsReachability: false,
-    };
+    webex.config.meetings.enableReachabilityChecks = {tcp: false, tls: false};
   });
 
   afterEach(() => {
@@ -1229,10 +1241,7 @@ describe('gatherReachability', () => {
       expectedMetrics,
     }) =>
       it(`works correctly for the case: ${title}`, async () => {
-        webex.config.meetings.experimental = {
-          enableTcpReachability: true,
-          enableTlsReachability: true,
-        };
+        webex.config.meetings.enableReachabilityChecks = true;
 
         // the metrics related to ipver and trigger are not tested in these tests and are all the same, so setting them up here
         const expectedMetricsFull = {
@@ -1367,10 +1376,7 @@ describe('gatherReachability', () => {
   });
 
   it(`starts ip network version detection and includes the results in the metrics`, async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: true,
-    };
+    webex.config.meetings.enableReachabilityChecks = true;
     webex.internal.device.ipNetworkDetector = {
       supportsIpV4: true,
       supportsIpV6: true,
@@ -1447,10 +1453,7 @@ describe('gatherReachability', () => {
   });
 
   it('keeps updating reachability results after the 3s public cloud timeout expires', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: true,
-    };
+    webex.config.meetings.enableReachabilityChecks = true;
 
     const reachability = new Reachability(webex);
 
@@ -1546,10 +1549,7 @@ describe('gatherReachability', () => {
   });
 
   it('handles clientMediaIpsUpdated event by updating clientMediaIps in results', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: true,
-    };
+    webex.config.meetings.enableReachabilityChecks = true;
 
     const reachability = new Reachability(webex);
 
@@ -1634,10 +1634,7 @@ describe('gatherReachability', () => {
   });
 
   it('starts ClusterReachability on each media cluster', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: true,
-    };
+    webex.config.meetings.enableReachabilityChecks = true;
 
     const getClustersResult = {
       clusters: {
@@ -1686,10 +1683,7 @@ describe('gatherReachability', () => {
   });
 
   it('does not do TCP reachability if it is disabled in config', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: false,
-      enableTlsReachability: true,
-    };
+    webex.config.meetings.enableReachabilityChecks = {tcp: false, tls: true};
 
     const getClustersResult = {
       clusters: {
@@ -1720,10 +1714,7 @@ describe('gatherReachability', () => {
   });
 
   it('does not do TLS reachability if it is disabled in config', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: false,
-    };
+    webex.config.meetings.enableReachabilityChecks = {tcp: true, tls: false};
 
     const getClustersResult = {
       clusters: {
@@ -1755,10 +1746,7 @@ describe('gatherReachability', () => {
   });
 
   it('does not do TCP or TLS reachability if it is disabled in config', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: false,
-      enableTlsReachability: false,
-    };
+    webex.config.meetings.enableReachabilityChecks = {tcp: false, tls: false};
 
     const getClustersResult = {
       clusters: {
@@ -1789,12 +1777,40 @@ describe('gatherReachability', () => {
     }, undefined);
   });
 
-  it('retry of getClusters is succesfull', async () => {
-    webex.config.meetings.experimental = {
-      enableTcpReachability: true,
-      enableTlsReachability: false,
+  it('does UDP, TCP and TLS reachability by default (enableReachabilityChecks=true)', async () => {
+    webex.config.meetings.enableReachabilityChecks = true;
+
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
     };
 
+    const reachability = new Reachability(webex);
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+
+    const promise = reachability.gatherReachability('test');
+    await simulateTimeout();
+    await promise;
+
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: ['testTCP1', 'testTCP2'],
+      xtls: ['testXTLS1', 'testXTLS2'],
+    }, undefined);
+  });
+
+  it('retry of getClusters is succesfull', async () => {
+    webex.config.meetings.enableReachabilityChecks = {tcp: true, tls: false};
+
     const getClustersResult = {
       clusters: {
         'cluster name': {
@@ -1866,10 +1882,7 @@ describe('gatherReachability', () => {
     };
 
     beforeEach(() => {
-      webex.config.meetings.experimental = {
-        enableTcpReachability: true,
-        enableTlsReachability: true,
-      };
+      webex.config.meetings.enableReachabilityChecks = true;
 
       receivedEvents = {
         done: 0,
@@ -2133,7 +2146,7 @@ describe('gatherReachability', () => {
         receivedEvents[event] = receivedEvents[event] + 1 || 1;
       });
     };
-    
+
     it('works as expected', async () => {
       setListener('reachability:stopped');
       setListener('reachability:done');
@@ -2948,4 +2961,4 @@ describe('isSubnetReachable', () => {
   it(`returns false if the subnet is unreachable`, () => {
     assert(!reachability.isSubnetReachable('11'));
   });
-});
+});

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

@@ -3,9 +3,40 @@ import {assert} from '@webex/test-helper-chai';
 import {
   convertStunUrlToTurn,
   convertStunUrlToTurnTls,
+  isReachabilityEnabled,
+  resolveReachabilityProtocols,
 } from '@webex/plugin-meetings/src/reachability/util';
 
 describe('plugin-meetings/src/reachability/util', () => {
+  describe('#resolveReachabilityProtocols()', () => {
+    [
+      {title: 'undefined defaults to all enabled', config: undefined, expected: {udp: true, tcp: true, tls: true}},
+      {title: 'true enables all protocols', config: true, expected: {udp: true, tcp: true, tls: true}},
+      {title: 'false disables all protocols', config: false, expected: {udp: false, tcp: false, tls: false}},
+      {title: 'empty object keeps udp on and defaults tcp/tls to enabled', config: {}, expected: {udp: true, tcp: true, tls: true}},
+      {title: 'object can disable tcp', config: {tcp: false}, expected: {udp: true, tcp: false, tls: true}},
+      {title: 'object can disable tls', config: {tls: false}, expected: {udp: true, tcp: true, tls: false}},
+      {title: 'object can disable both tcp and tls but udp stays on', config: {tcp: false, tls: false}, expected: {udp: true, tcp: false, tls: false}},
+    ].forEach(({title, config, expected}) => {
+      it(`resolves: ${title}`, () => {
+        assert.deepEqual(resolveReachabilityProtocols(config as any), expected);
+      });
+    });
+  });
+
+  describe('#isReachabilityEnabled()', () => {
+    [
+      {title: 'undefined', config: undefined, expected: true},
+      {title: 'true', config: true, expected: true},
+      {title: 'false', config: false, expected: false},
+      {title: 'object disabling tcp and tls (udp still on)', config: {tcp: false, tls: false}, expected: true},
+    ].forEach(({title, config, expected}) => {
+      it(`returns ${expected} for ${title}`, () => {
+        assert.equal(isReachabilityEnabled(config as any), expected);
+      });
+    });
+  });
+
   describe('#convertStunUrlToTurn()', () => {
     [
       {