@webex/plugin-meetings 3.8.0-next.8 → 3.8.0-next.81

package/test/unit/spec/members/request.js

@@ -9,7 +9,7 @@ import Meetings from '@webex/plugin-meetings';
 import MembersRequest from '@webex/plugin-meetings/src/members/request';
 import membersUtil from '@webex/plugin-meetings/src/members/util';
 import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
-import { merge } from 'lodash';
+import {merge} from 'lodash';
 
 const {assert} = chai;
 
@@ -65,10 +65,7 @@ describe('plugin-meetings', () => {
 
   const checkRequest = (expectedParams) => {
     assert.calledOnceWithExactly(locusDeltaRequestSpy, expectedParams);
-    assert.calledOnceWithExactly(
-      membersRequest.request,
-      merge(expectedParams, {body: {sequence}})
-    );
+    assert.calledOnceWithExactly(membersRequest.request, merge(expectedParams, {body: {sequence}}));
   };
 
   describe('members request library', () => {
@@ -98,8 +95,8 @@ describe('plugin-meetings', () => {
             },
             device: {
               url,
-            }
-          }
+            },
+          },
         });
       });
     });
@@ -120,9 +117,9 @@ describe('plugin-meetings', () => {
           uri: url1,
           body: {
             alertIfActive: undefined,
-            invitees: [{address: '+18578675309'}]
-          }
-        })
+            invitees: [{address: '+18578675309'}],
+          },
+        });
       });
     });
 
@@ -133,16 +130,16 @@ describe('plugin-meetings', () => {
           memberIds: ['1', '2'],
         };
 
-        await membersRequest.admitMember(options)
+        await membersRequest.admitMember(options);
 
         checkRequest({
           method: 'PUT',
           uri: 'https://example.com/12345/controls',
           body: {
             admit: {
-              participantIds: options.memberIds
-            }
-          }
+              participantIds: options.memberIds,
+            },
+          },
         });
       });
     });
@@ -160,7 +157,7 @@ describe('plugin-meetings', () => {
           method: 'PUT',
           uri: 'https://example.com/12345/participant/member1/leave',
           body: {
-            reason: undefined
+            reason: undefined,
           },
         });
       });
@@ -224,6 +221,29 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#cancelSIPInvite', () => {
+      const memberId = uuid.v4();
+      it('sends a PUT to the locus endpoint', async () => {
+        const options = {
+          invitee: {
+            memberId,
+          },
+          locusUrl: url1,
+        };
+
+        await membersRequest.cancelSIPInvite(options);
+
+        checkRequest({
+          method: 'PUT',
+          uri: url1,
+          body: {
+            actionType: 'REMOVE',
+            invitees: [{address: memberId}],
+          },
+        });
+      });
+    });
+
     describe('#assignRolesMember', () => {
       it('sends a assignRolesMember PATCH to the locus endpoint', async () => {
         const locusUrl = url1;
@@ -247,9 +267,9 @@ describe('plugin-meetings', () => {
           uri: `${locusUrl}/participant/${memberId}/controls`,
           body: {
             role: {
-              roles
-            }
-          }
+              roles,
+            },
+          },
         });
       });
     });
@@ -272,9 +292,9 @@ describe('plugin-meetings', () => {
           uri: `${locusUrl}/participant/${memberId}/controls`,
           body: {
             hand: {
-              raised: true
-            }
-          }
+              raised: true,
+            },
+          },
         });
       });
     });
@@ -406,7 +426,33 @@ describe('plugin-meetings', () => {
           body: {
             aliasValue,
             requestingParticipantId,
-          }
+          },
+        });
+      });
+    });
+
+    describe('#moveToLobby', () => {
+      it('sends a moveToLobbyMember PATCH to the locus endpoint', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+        };
+        const body = {
+          moveToLobby: {participantIds: [memberId]},
+        };
+
+        const getRequestParamsSpy = sandbox.spy(membersUtil, 'getMoveMemberToLobbyRequestParams');
+
+        await membersRequest.moveToLobbyMember(options, body);
+
+        assert.calledOnceWithExactly(getRequestParamsSpy, options, body);
+
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/participant/${memberId}/controls`,
+          body: {moveToLobby: {participantIds: [memberId]}},
         });
       });
     });

package/test/unit/spec/members/utils.js

@@ -357,5 +357,80 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#getMoveMemberToLobbyRequestBody', () => {
+      it('returns the correct options', () => {
+        const memberId = 'test1';
+        assert.deepEqual(MembersUtil.getMoveMemberToLobbyRequestBody(memberId), {
+          moveToLobby: {
+            participantIds: [memberId],
+          },
+        });
+      });
+    });
+
+    describe('#getMoveMemberToLobbyRequestParams', () => {
+      it('returns the correct params', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test1';
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+        };
+        const body = {
+          moveToLobby: {participantIds: [memberId]},
+        };
+
+        const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+        assert.deepEqual(MembersUtil.getMoveMemberToLobbyRequestParams(options, body), {
+          method: HTTP_VERBS.PATCH,
+          uri,
+          body,
+        });
+      });
+    });
+
+    describe('#cancelSIPInviteOptions', () => {
+      it('returns the correct options', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test';
+        const invitee = {memberId};
+
+        assert.deepEqual(
+          MembersUtil.cancelSIPInviteOptions(
+            invitee,
+            locusUrl
+          ),
+          {
+            invitee,
+            locusUrl,
+          }
+        );
+      });
+    });
+
+    describe('#generateCancelSIPInviteRequestParams', () => {
+      it('returns the correct params', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test';
+        const options = {
+          locusUrl,
+          invitee: {memberId}
+        };
+        const body = {
+          actionType: 'REMOVE',
+          invitees: [{address: options.invitee.memberId}],
+        };
+
+        const uri = options.locusUrl;
+
+        assert.deepEqual(MembersUtil.generateCancelSIPInviteRequestParams(options), {
+          method: HTTP_VERBS.PUT,
+          uri,
+          body,
+        });
+      });
+    });
   });
 });

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

@@ -9,7 +9,9 @@ import {
   ResultEventData,
   Events,
   ClientMediaIpsUpdatedEventData,
+  NatTypeUpdatedEventData,
 } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import { NatType } from 'packages/@webex/plugin-meetings/dist/reachability/reachability.types';
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -17,15 +19,17 @@ describe('ClusterReachability', () => {
   let fakePeerConnection;
   let gatherIceCandidatesSpy;
 
-  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
+  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData | NatTypeUpdatedEventData)[]> = {
     [Events.resultReady]: [],
     [Events.clientMediaIpsUpdated]: [],
+    [Events.natTypeUpdated]: [],
   };
   const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
 
   const resetEmittedEvents = () => {
     emittedEvents[Events.resultReady].length = 0;
     emittedEvents[Events.clientMediaIpsUpdated].length = 0;
+    emittedEvents[Events.natTypeUpdated].length = 0;
   };
   beforeEach(() => {
     fakePeerConnection = {
@@ -56,6 +60,10 @@ describe('ClusterReachability', () => {
     clusterReachability.on(Events.clientMediaIpsUpdated, (data: ClientMediaIpsUpdatedEventData) => {
       emittedEvents[Events.clientMediaIpsUpdated].push(data);
     });
+
+    clusterReachability.on(Events.natTypeUpdated, (data: NatTypeUpdatedEventData) => {
+      emittedEvents[Events.natTypeUpdated].push(data);
+    });
   });
 
   afterEach(() => {
@@ -166,59 +174,6 @@ describe('ClusterReachability', () => {
       assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
-    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
-
-      // check the right events were emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 1);
-      assert.deepEqual(emittedEvents[Events.resultReady][0], {
-        protocol: 'udp',
-        result: 'reachable',
-        latencyInMilliseconds: 100,
-        clientMediaIPs: ['somePublicIp'],
-      });
-
-      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 2);
-      assert.deepEqual(emittedEvents[Events.resultReady][1], {
-        protocol: 'tcp',
-        result: 'reachable',
-        latencyInMilliseconds: 200,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
-      });
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 3);
-      assert.deepEqual(emittedEvents[Events.resultReady][2], {
-        protocol: 'xtls',
-        result: 'reachable',
-        latencyInMilliseconds: 300,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'reachable', latencyInMilliseconds: 300},
-      });
-    });
-
     it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
@@ -267,7 +222,7 @@ describe('ClusterReachability', () => {
 
       await testUtils.flushPromises();
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -285,7 +240,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(30);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -428,6 +383,9 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -440,5 +398,79 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
+
+    it('determines correctly if symmetric-nat is detected', async () => {
+      const promise = clusterReachability.start();
+
+      // generate candidates with duplicate addresses
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 1000}});
+
+      // check events emitted: there shouldn't be any natTypeUpdated emitted
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 0);
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 2000}});
+
+      // should emit natTypeUpdated event
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.natTypeUpdated][0], {
+        natType: 'symmetric-nat',
+      });
+
+      // send also a relay candidate so that the reachability check finishes
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
+
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await clock.tickAsync(10);
+
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1'],
+        },
+        tcp: {result: 'reachable', latencyInMilliseconds: 20},
+        xtls: {result: 'reachable', latencyInMilliseconds: 20},
+      });
+    });
+
+    it('should gather correctly reached subnets', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:4.3.2.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), [
+        '1.2.3.4',
+        '4.3.2.1',
+        'someTurnRelayIp'
+      ]);
+    });
+
+    it('should store only unique subnet address', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:9000'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '1.2.3.4'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['1.2.3.4']);
+    });
   });
 });

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

@@ -538,6 +538,14 @@ describe('gatherReachability', () => {
     assert.equal(storedResultForJoinCookie, JSON.stringify(expectedJoinCookie));
   };
 
+  it('rejects if reachability is disabled in config', async () => {
+    webex.config.meetings.enableReachabilityChecks = false;
+
+    const reachability = new Reachability(webex);
+
+    await assert.isRejected(reachability.gatherReachability('test'), 'enableReachabilityChecks is disabled in config');
+  });
+
   [
     // ========================================================================
     {
@@ -1947,6 +1955,7 @@ describe('gatherReachability', () => {
         receivedEvents[event] = receivedEvents[event] + 1 || 1;
       });
     };
+    
     it('works as expected', async () => {
       setListener('reachability:stopped');
       setListener('reachability:done');
@@ -2008,6 +2017,59 @@ describe('gatherReachability', () => {
       assert.equal(receivedEvents['reachability:done'], undefined);
       assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
     });
+
+    it('does not fallback when no clusters were reached and min clusters were specified', async () => {
+      setListener('reachability:stopped');
+      setListener('reachability:done');
+      setListener('reachability:firstResultAvailable');
+
+      const mockGetClustersResult = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 1,
+        },
+        clusters: {
+          clusterA: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+          clusterB: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'id'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+      const gatherReachabilityFallbackSpy = sinon.spy(reachability, 'gatherReachabilityFallback');
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      reachability.stopReachability();
+
+      await resultPromise;
+
+      // simulate a lot of time passing to check that all timers were stopped and nothing else happens
+      clock.tick(99000);
+
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterA'].abort);
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterB'].abort);
+
+      assert.calledOnceWithExactly(sendMetricSpy, true);
+
+      assert.equal(receivedEvents['reachability:stopped'], 1);
+      assert.equal(receivedEvents['reachability:done'], undefined);
+      assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
+
+      assert.notCalled(gatherReachabilityFallbackSpy);
+    });
   });
 });
 
@@ -2148,6 +2210,7 @@ describe('getReachabilityMetrics', () => {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: 'unknown'
     });
   });
 
@@ -2215,6 +2278,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 1,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2276,6 +2340,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 0,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2337,6 +2402,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 3,
         reachability_vmn_xtls_success: 1,
         reachability_vmn_xtls_failed: 1,
+        natType: 'unknown'
       }
     );
   });
@@ -2674,3 +2740,38 @@ describe('sendMetric', () => {
     });
   });
 });
+
+describe('isSubnetReachable', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+
+    reachability.setFakeClusterReachability({
+      cluster1: {
+        reachedSubnets: new Set(['1.2.3.4', '2.3.4.5']),
+      },
+      cluster2: {
+        reachedSubnets: new Set(['3.4.5.6', '4.5.6.7']),
+      },
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('returns true if the subnet is reachable', () => {
+    assert(reachability.isSubnetReachable('1.2.3.4'));
+  });
+
+  it(`returns false if the subnet is unreachable`, () => {
+    assert(!reachability.isSubnetReachable('11.2.3.4'));
+  });
+
+  it('returns null if the subnet is not provided', () => {
+    assert.isNull(reachability.isSubnetReachable(undefined));
+  });
+});

package/test/unit/spec/reachability/request.js

@@ -12,6 +12,9 @@ describe('plugin-meetings/reachability', () => {
   let reachabilityRequest;
   let webex;
 
+  let appType;
+  let appVersion;
+
   beforeEach(() => {
     webex = new MockWebex({
       children: {
@@ -20,6 +23,14 @@ describe('plugin-meetings/reachability', () => {
       },
     });
 
+    webex.config.support = {
+      'appType': 'NetworkChecker',
+      'appVersion': '43.3.0.1',
+    }
+
+    appType = webex?.config?.support?.appType;
+    appVersion = webex?.config?.support?.appVersion;
+
     webex.meetings.clientRegion = {
       countryCode: 'US',
       regionCode: 'WEST-COAST',
@@ -56,7 +67,9 @@ describe('plugin-meetings/reachability', () => {
 
       previousReport = {
         id: 'fake previous report',
-      }
+      };
+
+
     });
 
     afterEach(() => {
@@ -79,6 +92,7 @@ describe('plugin-meetings/reachability', () => {
             'report-version': 1,
             'early-call-min-clusters': true,
           },
+          'client-environment': { components: { [appType]: appVersion } },
           'previous-report': previousReport,
           trigger: 'startup',
         },
@@ -105,6 +119,7 @@ describe('plugin-meetings/reachability', () => {
             'report-version': 1,
             'early-call-min-clusters': true,
           },
+          'client-environment': { components: { [appType]: appVersion } },
           'previous-report': previousReport,
           trigger: 'early-call/no-min-reached',
         },
@@ -114,5 +129,35 @@ describe('plugin-meetings/reachability', () => {
       assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
       assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency);
     });
+
+    it('sends a POST request with the correct params when appVersion is undefined', async () => {
+      // Setting appType & appVersion to undefined
+      webex.config.support.appType = undefined;
+      webex.config.support.appVersion = undefined;
+    
+      const res = await reachabilityRequest.getClusters('startup', IP_VERSION.only_ipv4, previousReport);
+      const requestParams = webex.request.getCall(0).args[0];
+    
+      assert.deepEqual(requestParams, {
+        method: 'POST',
+        resource: `clusters`,
+        api: 'calliopeDiscovery',
+        shouldRefreshAccessToken: false,
+        timeout: 3000,
+        body: {
+          ipver: IP_VERSION.only_ipv4,
+          'supported-options': {
+            'report-version': 1,
+            'early-call-min-clusters': true,
+          },
+          'previous-report': previousReport,
+          trigger: 'startup',
+        },
+      });
+    
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true});
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"});
+      assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.cluster.time');
+    });
   });
-});
+});