@webex/plugin-meetings 3.10.0 → 3.11.0-next.10

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

@@ -1,5 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
+import { CapabilityState, WebCapabilities } from '@webex/web-capabilities';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
@@ -8,6 +9,7 @@ import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import Metrics from '@webex/plugin-meetings/src/metrics';
+import * as InternalMediaCore from '@webex/internal-media-core';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
@@ -466,11 +468,13 @@ describe('gatherReachability', () => {
   let clock;
   let clusterReachabilityCtorStub;
   let mockClusterReachabilityInstances: Record<string, MockClusterReachability>;
+  let supportsRTCPeerConnectionStub;
 
   beforeEach(async () => {
     webex = new MockWebex();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
+    supportsRTCPeerConnectionStub = sinon.stub(WebCapabilities, 'supportsRTCPeerConnection').returns(CapabilityState.CAPABLE);
 
     await webex.boundedStorage.put(
       'Reachability',
@@ -545,6 +549,25 @@ describe('gatherReachability', () => {
     await assert.isRejected(reachability.gatherReachability('test'), 'enableReachabilityChecks is disabled in config');
   });
 
+  [CapabilityState.NOT_CAPABLE, CapabilityState.UNKNOWN].forEach((capabilityState) =>
+    it(`returns empty object if WebRTC API is not available (capabilityState=${capabilityState}`, async () => {
+      supportsRTCPeerConnectionStub.returns(capabilityState);
+
+      const reachability = new Reachability(webex);
+
+      const result = await reachability.gatherReachability('test');
+
+      assert.deepEqual(result, {});
+
+      // Verify that no new reachability result was stored - old results should remain unchanged
+      // This check is mainly to ensure that we don't put any "unreachable" results into storage
+      const storedResults = await webex.boundedStorage.get('Reachability', 'reachability.result');
+      assert.equal(storedResults, JSON.stringify({old: 'results'}));
+
+      assert.equal(await reachability.isWebexMediaBackendUnreachable(), false);
+    })
+  );
+
   [
     // ========================================================================
     {
@@ -1693,7 +1716,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: ['testXTLS1', 'testXTLS2'],
-    });
+    }, undefined);
   });
 
   it('does not do TLS reachability if it is disabled in config', async () => {
@@ -1728,7 +1751,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: ['testTCP1', 'testTCP2'],
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('does not do TCP or TLS reachability if it is disabled in config', async () => {
@@ -1763,7 +1786,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('retry of getClusters is succesfull', async () => {

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

@@ -631,5 +631,111 @@ describe('plugin-meetings', () => {
           }
         });
       });
+
+      describe("#searchLargeScaleWebinarAttendees", () => {
+        const attendeeSearchUrl = 'https://locusUrl/attendees/search';
+        const params = {
+          queryString: 'queryString',
+          limit: 50,
+          next: null,
+        };
+        beforeEach(() => {
+          // @ts-ignore
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              locusInfo: {
+                links:{
+                  resources: {
+                    attendeeSearch: {
+                      url: attendeeSearchUrl
+                    }
+                  }
+                }
+              }
+            })
+          };
+        });
+
+        it('throws an error if attendeeSearchUrl is not available', async () => {
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              locusInfo: {
+                links:{
+                  resources: {
+                    attendeeSearch: {
+                      url: null
+                    }
+                  }
+                }
+              }
+            })
+          };
+          try {
+            await webinar.searchLargeScaleWebinarAttendees(params);
+            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message,'Meeting:webinar5k#Attendee search url is not available', 'should throw the correct error');
+          }
+        });
+
+        it('sends a GET request to search the large scale webinar attendees', async () => {
+          const result = await webinar.searchLargeScaleWebinarAttendees(params);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: 'GET',
+            uri: `${attendeeSearchUrl}?search_text=${encodeURIComponent(params.queryString)}&limit=50`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(
+            result,
+            'REQUEST_RETURN_VALUE',
+            'should return the resolved value from the request'
+          );
+        });
+
+        it('queryString is empty string', async () => {
+          params.queryString = '';
+          const result = await webinar.searchLargeScaleWebinarAttendees(params);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: 'GET',
+            uri: `${attendeeSearchUrl}?limit=50`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(
+            result,
+            'REQUEST_RETURN_VALUE',
+            'should return the resolved value from the request'
+          );
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.searchLargeScaleWebinarAttendees(params);
+            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(
+              errorLogger,
+              'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed',
+              sinon.match.instanceOf(Error)
+            );
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
     })
 })

package/test/unit/spec/webinar/utils.ts

@@ -0,0 +1,39 @@
+import chai from 'chai';
+import {sanitizeParams} from '@webex/plugin-meetings/src/webinar/utils';
+
+const {assert} = chai;
+
+describe('plugin-meetings', () => {
+  describe('webinar utils', () => {
+    describe('#sanitizeParams', () => {
+      it('sanitizes params by removing undefined, "", or null values', () => {
+        const input = {
+          a: 1,
+          b: undefined,
+          c: null,
+          d: 'test',
+          e: false,
+          f: '',
+        };
+        const expectedOutput = {
+          a: 1,
+          d: 'test',
+          e: false,
+        };
+        const result = sanitizeParams(input);
+        assert.deepEqual(result, expectedOutput);
+      });
+
+      it('returns an empty object when all values are invalid', () => {
+        const input = {
+          a: undefined,
+          b: null,
+          c: '',
+        };
+        const expectedOutput = {};
+        const result = sanitizeParams(input);
+        assert.deepEqual(result, expectedOutput);
+      });
+    });
+  });
+});