@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0

package/test/unit/spec/interceptors/locusRetry.ts

@@ -0,0 +1,131 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+/* eslint-disable camelcase */
+import {assert} from '@webex/test-helper-chai';
+import { expect } from "@webex/test-helper-chai";
+import MockWebex from '@webex/test-helper-mock-webex';
+import {LocusRetryStatusInterceptor} from "@webex/plugin-meetings/src/interceptors";
+import {WebexHttpError} from '@webex/webex-core';
+import Meetings from '@webex/plugin-meetings';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+    describe('Interceptors', () => {
+      describe('LocusRetryStatusInterceptor', () => { 
+        let interceptor, webex;
+        beforeEach(() => {
+            webex = new MockWebex({
+                children: {
+                    meeting: Meetings,
+                  },
+            });
+            interceptor = Reflect.apply(LocusRetryStatusInterceptor.create, {
+                sessionId: 'mock-webex_uuid',
+              }, []);
+          });  
+        describe('#onResponseError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                    'retry-after': 1000,
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const reason1 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 403,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'POST not allwed',
+                },
+                });
+            const reason2 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 503,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'Service Unavailable',
+                    },
+                });
+
+            it('rejects when not locus service unavailable error', () => {
+                return assert.isRejected(interceptor.onResponseError(options, reason1));
+            });
+
+            it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
+                handleRetryStub.returns(Promise.resolve());
+
+                return interceptor.onResponseError(options, reason2).then(() => {
+                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+                    
+                });
+            });
+        });
+
+        describe('#handleRetryRequestLocusServiceError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const retryAfterTime = 2000;
+
+            it('returns the correct resolved value when the request is successful', () => {
+                const mockResponse = 'mock response'
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+          
+                return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                  .then((response) => {
+                    expect(response).to.equal(mockResponse);
+                  });
+              });
+
+            it('rejects the promise when the request is unsuccessful', () => {
+              const rejectionReason = 'Service Unavaialble after retry';
+    
+              interceptor.webex.request = sinon.stub().returns(Promise.reject(rejectionReason));
+        
+              return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                .catch((error) => {
+                  expect(error).to.equal(rejectionReason);
+                });
+            });
+
+            it('retries the request after the specified time', () => {
+                let clock;
+                clock = sinon.useFakeTimers();
+                const mockResponse = 'mock response'
+      
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+                const promise = interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime);
+      
+                clock.tick(retryAfterTime);
+
+                return promise.then(() => {
+                    expect(interceptor.webex.request.calledOnce).to.be.true;
+                    });
+            });
+        });
+    });
+    });
+});
+

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

@@ -10,6 +10,7 @@ import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import EmbeddedAppsUtils from '@webex/plugin-meetings/src/locus-info/embeddedAppsUtils';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {
   LOCUSINFO,
@@ -23,8 +24,7 @@ import {
   _MEETING_,
 } from '../../../../src/constants';
 
-import {self, selfWithInactivity} from './selfConstant';
-import uuid from 'uuid';
+import {self, selfWithInactivity} from './lib/selfConstant';
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -39,6 +39,7 @@ describe('plugin-meetings', () => {
     const locus = {};
     const meetingId = 'meetingId';
     let locusInfo;
+    let sendBehavioralMetricStub;
 
     const webex = new MockWebex({
       children: {
@@ -65,6 +66,12 @@ describe('plugin-meetings', () => {
           },
         },
       };
+
+      sendBehavioralMetricStub = sinon.stub(Metrics, 'sendBehavioralMetric');
+    });
+
+    afterEach(() => {
+      sinon.restore();
     });
 
     describe('#updateControls', () => {
@@ -1370,7 +1377,7 @@ describe('plugin-meetings', () => {
         );
       });
 
-      const checkMeetingInfoUpdatedCalled = (expected) => {
+      const checkMeetingInfoUpdatedCalled = (expected, payload) => {
         const expectedArgs = [
           locusInfo.emitScoped,
           {
@@ -1378,6 +1385,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+          payload
         ];
 
         if (expected) {
@@ -1388,7 +1396,7 @@ describe('plugin-meetings', () => {
         locusInfo.emitScoped.resetHistory();
       };
 
-      const checkMeetingInfoUpdatedCalledForRoles = (expected) => {
+      const checkMeetingInfoUpdatedCalledForRoles = (expected, payload) => {
         const expectedArgs = [
           locusInfo.emitScoped,
           {
@@ -1396,6 +1404,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+          payload
         ];
 
         if (expected) {
@@ -1440,7 +1449,7 @@ describe('plugin-meetings', () => {
 
         // since it was initially undefined, this should trigger the event
 
-        checkMeetingInfoUpdatedCalled(true);
+        checkMeetingInfoUpdatedCalled(true, {isInitializing: false});
 
         const newInfo = cloneDeep(meetingInfo);
 
@@ -1465,7 +1474,7 @@ describe('plugin-meetings', () => {
         };
         locusInfo.updateMeetingInfo(newInfo, self);
 
-        checkMeetingInfoUpdatedCalled(true);
+        checkMeetingInfoUpdatedCalled(true, {isInitializing: false});
 
         // update it with the same info
         expectedMeeting = {
@@ -1487,7 +1496,7 @@ describe('plugin-meetings', () => {
         locusInfo.updateMeetingInfo(newInfo, self);
 
         // since the info is the same it should not call trigger the event
-        checkMeetingInfoUpdatedCalled(false);
+        checkMeetingInfoUpdatedCalled(false, {isInitializing: false});
 
         // update it with the same info, but roles changed
         const updateSelf = cloneDeep(self);
@@ -1518,7 +1527,7 @@ describe('plugin-meetings', () => {
         };
         locusInfo.updateMeetingInfo(newInfo, updateSelf);
         // since the info is the same but roles changed, it should call trigger the event
-        checkMeetingInfoUpdatedCalledForRoles(true);
+        checkMeetingInfoUpdatedCalledForRoles(true, {isInitializing: false});
       });
 
       it('gets roles from self if available', () => {
@@ -1539,12 +1548,17 @@ describe('plugin-meetings', () => {
           roles: ['MODERATOR', 'COHOST'],
         };
 
+        sinon.stub(locusInfo, 'emitScoped');
+
         const parsedLocusInfo = cloneDeep(locusInfo.parsedLocus.info);
 
         locusInfo.updateMeetingInfo(initialInfo);
         assert.calledWith(isJoinedSpy, locusInfo.parsedLocus.self);
         assert.neverCalledWith(getRolesSpy, self);
         assert.calledWith(getInfosSpy, parsedLocusInfo, initialInfo, ['MODERATOR', 'COHOST']);
+
+        // since self is not passed to updateMeetingInfo, MEETING_INFO_UPDATED should be triggered with isIntializing: true
+        checkMeetingInfoUpdatedCalledForRoles(true, {isInitializing: true});
       });
     });
 
@@ -1877,6 +1891,135 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('applyLocusDeltaData handles LOCUS_URL_CHANGED action correctly', () => {
+        const {LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
+        const fakeDeltaLocus = {id: 'fake delta locus'};
+        const meeting = {
+          meetingRequest: {
+            getLocusDTO: sandbox.stub().resolves({body: fakeDeltaLocus}),
+          },
+          locusInfo: {
+            handleLocusDelta: sandbox.stub(),
+          },
+          locusUrl: 'current locus url',
+        };
+
+        locusInfo.locusParser.workingCopy = {
+          syncUrl: 'current sync url',
+        };
+  
+        locusInfo.applyLocusDeltaData(LOCUS_URL_CHANGED, fakeLocus, meeting);
+        assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'current sync url'});
+      });
+
+      describe('edge cases for sync failing', () => {
+        const {DESYNC} = LocusDeltaParser.loci;
+        const fakeFullLocusDto = {id: 'fake full locus dto'};
+        let meeting;
+
+        beforeEach(() => {
+          sinon.stub(locusInfo.locusParser, 'resume');
+          sinon.stub(webex.meetings, 'destroy');
+
+          meeting = {
+            meetingRequest: {
+              getLocusDTO: sandbox.stub(),
+            },
+            locusInfo: {
+              handleLocusDelta: sandbox.stub(),
+              onFullLocus: sandbox.stub(),
+            },
+            locusUrl: 'fullSyncUrl',
+          };
+
+          locusInfo.locusParser.workingCopy = {
+            syncUrl: 'deltaSyncUrl',
+          };
+        });
+
+        it('applyLocusDeltaData gets full locus on DESYNC action if we do not have a syncUrl and destroys the meeting if that fails', () => {
+          meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
+
+          locusInfo.locusParser.workingCopy = {}; // no syncUrl
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            webex.meetings.destroy.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'fullSyncUrl'});
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.notCalled(meeting.locusInfo.onFullLocus);
+            assert.notCalled(locusInfo.locusParser.resume);
+
+            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
+          });
+        });
+
+        it('applyLocusDeltaData first tries a delta sync on DESYNC action and if that fails, does a full locus sync', () => {
+          meeting.meetingRequest.getLocusDTO.onCall(0).rejects(new Error('fake error'));
+          meeting.meetingRequest.getLocusDTO.onCall(1).resolves({body: fakeFullLocusDto});
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            locusInfo.locusParser.resume.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledTwice(meeting.meetingRequest.getLocusDTO);
+
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+
+            assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+              correlationId: meeting.correlationId,
+              url: 'deltaSyncUrl',
+              reason: 'fake error',
+              errorName: 'Error',
+              stack: sinon.match.any,
+              code: sinon.match.any,
+            });
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+            assert.calledOnce(locusInfo.locusParser.resume);
+          });
+        });
+
+        it('applyLocusDeltaData destroys the meeting if both delta sync and full sync fail', () => {
+          meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
+
+          // Since we have a promise inside a function we want to test that's not returned,
+          // we will wait and stub it's last function to resolve this waiting promise.
+          return new Promise((resolve) => {
+            webex.meetings.destroy.callsFake(() => resolve());
+            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+          }).then(() => {
+            assert.calledTwice(meeting.meetingRequest.getLocusDTO);
+
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+
+            assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+              correlationId: meeting.correlationId,
+              url: 'deltaSyncUrl',
+              reason: 'fake error',
+              errorName: 'Error',
+              stack: sinon.match.any,
+              code: sinon.match.any,
+            });
+
+            assert.notCalled(meeting.locusInfo.handleLocusDelta);
+            assert.notCalled(meeting.locusInfo.onFullLocus);
+            assert.notCalled(locusInfo.locusParser.resume);
+
+            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
+          });
+        });
+      });
+
       it('onDeltaLocus handle delta data', () => {
         fakeLocus.participants = {};
         const fakeBreakout = {
@@ -1922,7 +2065,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#getTheLocusToUpdate', () => {
-      it('return the cache locus if return to main session', () => {
+      it('return the cache locus if return to main session and do not clear main session cache', () => {
         locusInfo.mainSessionLocusCache = {url: 'url'};
         locusInfo.controls = {
           breakout: {
@@ -1938,9 +2081,13 @@ describe('plugin-meetings', () => {
         };
 
         assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), {url: 'url'});
+
+        locusInfo.clearMainSessionLocusCache = sinon.stub();
+        locusInfo.getTheLocusToUpdate(newLocus);
+        assert.notCalled(locusInfo.clearMainSessionLocusCache)
       });
 
-      it('return the new locus if return to main session but no cache', () => {
+      it('return the new locus if return to main session but no cache and do not clear main session cache', () => {
         locusInfo.mainSessionLocusCache = null;
         locusInfo.controls = {
           breakout: {
@@ -1956,10 +2103,22 @@ describe('plugin-meetings', () => {
         };
 
         assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), newLocus);
+
+        locusInfo.clearMainSessionLocusCache = sinon.stub();
+        locusInfo.getTheLocusToUpdate(newLocus);
+        assert.notCalled(locusInfo.clearMainSessionLocusCache)
       });
 
-      it('return the new locus if not return to main session', () => {
-        locusInfo.mainSessionLocusCache = {url: 'url'};
+      it('return the new locus if not return to main session and clear main session cache', () => {
+        locusInfo.mainSessionLocusCache = {
+          controls: {
+            breakout: {
+              sessionType: 'MAIN',
+            },
+          },
+          self: {removed: true}
+        };
+        locusInfo.fullState = {state: 'ACTIVE'}
         locusInfo.controls = {
           breakout: {
             sessionType: 'MAIN',
@@ -1973,7 +2132,39 @@ describe('plugin-meetings', () => {
           },
         };
 
-        assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), newLocus);
+        locusInfo.clearMainSessionLocusCache = sinon.stub();
+        const result = locusInfo.getTheLocusToUpdate(newLocus);
+        assert.calledOnce(locusInfo.clearMainSessionLocusCache)
+
+        assert.deepEqual(result, newLocus);
+      });
+
+      it('do not clear main session cache when "mainSessionLocusCache?.self?.removed" is not true', () => {
+        locusInfo.mainSessionLocusCache = {
+          controls: {
+            breakout: {
+              sessionType: 'MAIN',
+            },
+          },
+          self: {removed: undefined}
+        };
+        locusInfo.fullState = {state: 'ACTIVE'}
+        locusInfo.controls = {
+          breakout: {
+            sessionType: 'MAIN',
+          },
+        };
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'BREAKOUT',
+            },
+          },
+        };
+
+        locusInfo.clearMainSessionLocusCache = sinon.stub();
+        locusInfo.getTheLocusToUpdate(newLocus);
+        assert.notCalled(locusInfo.clearMainSessionLocusCache)
       });
     });
 
@@ -2420,6 +2611,8 @@ describe('plugin-meetings', () => {
         // send an out-of-order delta
         locusInfo.handleLocusDelta(oooDelta, mockMeeting);
 
+        assert.calledOnceWithExactly(sendBehavioralMetricStub, 'js_sdk_locus_delta_ooo', { stack: sinon.match.any})
+
         await clock.tickAsync(12499);
         await testUtils.flushPromises();
         assert.notCalled(syncRequestStub);

package/test/unit/spec/locus-info/lib/SeqCmp.json

@@ -517,6 +517,22 @@
       "new": "seq4g",
       "result": "DESYNC",
       "description": "New seq is greater than current, but both current and new base have some unique entries."
+    },
+    "updt25": {
+      "current": "seq4",
+      "newbase": "seq5c",
+      "new": "seq5b",
+      "result": "WAIT",
+      "description": "Both new seq and new base are newer than current but are not equal"
+    },
+    "updt26": {
+      "current": "seq4",
+      "currentUrl": "locus url 1",
+      "newbase": "seq5c",
+      "new": "seq5b",
+      "newUrl": "locus url 2",
+      "result": "LOCUS_URL_CHANGED",
+      "description": "Locus url changes in incoming"
     }
   }
 }

package/test/unit/spec/locus-info/mediaSharesUtils.ts

@@ -20,3 +20,13 @@ describe('getContentUrl', () => {
   });
 });
 
+describe('getContentBeneficiaryDeviceUrl', () => {
+  it('getContentBeneficiaryDeviceUrl return correct deviceUrl value', () => {
+    const mockContentBeneficiaryDeviceUrl = "https://wdm-a.wbx2.com/wdm/api/v1/devices/e9ffd8a1-1fae-42d1-afbe-013e951f93ab"
+    const stub = Sinon.stub(MediaSharesUtils, 'extractContentFloor').returns({ beneficiary: {deviceUrl : mockContentBeneficiaryDeviceUrl}});
+    const contentBeneficiaryDeviceUrl = MediaSharesUtils.getContentBeneficiaryDeviceUrl();
+    assert.equal(contentBeneficiaryDeviceUrl, mockContentBeneficiaryDeviceUrl);
+    stub.restore();
+  });
+});
+