@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0-test.1

package/src/webinar/index.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+import {MEETINGS} from '../constants';
+
+import WebinarCollection from './collection';
+
+/**
+ * @class Webinar
+ */
+const Webinar = WebexPlugin.extend({
+  namespace: MEETINGS,
+  collections: {
+    webinar: WebinarCollection,
+  },
+
+  props: {
+    locusUrl: 'string', // appears current webinar's locus url
+    webcastUrl: 'string', // current webinar's webcast url
+    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url
+    canManageWebcast: 'boolean', // appears the ability to manage webcast
+  },
+
+  /**
+   * Update the current locus url of the webinar
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  locusUrlUpdate(locusUrl) {
+    this.set('locusUrl', locusUrl);
+  },
+
+  /**
+   * Update the current webcast url of the meeting
+   * @param {string} webcastUrl // webcast url
+   * @returns {void}
+   */
+  webcastUrlUpdate(webcastUrl) {
+    this.set('webcastUrl', webcastUrl);
+  },
+
+  /**
+   * Update the current webinarAttendeesSearching url of the meeting
+   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url
+   * @returns {void}
+   */
+  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {
+    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);
+  },
+
+  /**
+   * Update whether self has capability to manage start/stop webcast (only host can manage it)
+   * @param {boolean} canManageWebcast
+   * @returns {void}
+   */
+  updateCanManageWebcast(canManageWebcast) {
+    this.set('canManageWebcast', canManageWebcast);
+  },
+});
+
+export default Webinar;

package/test/integration/spec/journey.js

@@ -44,14 +44,14 @@ const localStreams = {
   },
 };
 
-
+// Updated expectedPublished from a boolean value to an object containing the stream and status properties
 const waitForPublished = (meeting, expectedPublished, description) => {
   return testUtils.waitForEvents([{
     scope: meeting,
     event: EVENT_TRIGGERS.MEETING_STREAM_PUBLISH_STATE_CHANGED,
     match: (event) => {
       console.log(`${description} is now ${event.isPublished ? 'published': 'not published'}`);
-      return (event.isPublished === expectedPublished);
+      return (event.isPublished === expectedPublished.status && event.stream.id === expectedPublished.stream.id) ;
     }
   }]);
 };
@@ -432,11 +432,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.microphone.setMuted(true);
+        localStreams.alice.microphone.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.microphone.muted, true);
+        assert.equal(localStreams.alice.microphone.userMuted, true);
       });
 
       it('alice Audio unMute ', async () => {
@@ -451,11 +451,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.microphone.setMuted(false);
+        localStreams.alice.microphone.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.microphone.muted, false);
+        assert.equal(localStreams.alice.microphone.userMuted, false);
       });
 
       it('alice video mute', async () => {
@@ -470,11 +470,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.camera.setMuted(true);
+        localStreams.alice.camera.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.camera.muted, true);
+        assert.equal(localStreams.alice.camera.userMuted, true);
       });
 
       it('alice video unmute', async () => {
@@ -489,16 +489,16 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.camera.setMuted(false);
+        localStreams.alice.camera.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.camera.muted, false);
+        assert.equal(localStreams.alice.camera.userMuted, false);
       });
 
       it('alice update Audio', async () => {
         const newMicrophoneStream = await createMicrophoneStream();
-        const newStreamPublished = waitForPublished(alice.meeting, true, "Alice AUDIO: new microphone stream");
+        const newStreamPublished = waitForPublished(alice.meeting, {stream: newMicrophoneStream, status: true}, "Alice AUDIO: new microphone stream");
 
         await testUtils.delayedPromise(
             alice.meeting
@@ -521,7 +521,7 @@ skipInNode(describe)('plugin-meetings', () => {
 
       it('alice update video', async () => {
         const newCameraStream = await createCameraStream();
-        const newStreamPublished = waitForPublished(alice.meeting, true, "Alice VIDEO: new camera stream");
+        const newStreamPublished = waitForPublished(alice.meeting, {stream: newCameraStream, status:  true}, "Alice VIDEO: new camera stream");
 
         await testUtils.delayedPromise(
             alice.meeting
@@ -574,11 +574,11 @@ skipInNode(describe)('plugin-meetings', () => {
         ]);
 
         // first bob mutes himself
-        localStreams.bob.microphone.setMuted(true);
+        localStreams.bob.microphone.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.bob.microphone.muted, true);
+        assert.equal(localStreams.bob.microphone.userMuted, true);
 
         // now alice tries to unmmute bob
         await testUtils.delayedPromise(alice.meeting.mute(bob.meeting.members.selfId, false))
@@ -593,7 +593,7 @@ skipInNode(describe)('plugin-meetings', () => {
             assert.fail('bob received unexpected meeting:self:unmutedByOthers event');
           })
           .catch(() => {
-            assert.equal(localStreams.bob.microphone.muted, true);
+            assert.equal(localStreams.bob.microphone.userMuted, true);
           });
       });
 
@@ -607,11 +607,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: alice.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.bob.microphone.setMuted(false);
+        localStreams.bob.microphone.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.bob.microphone.muted, false);
+        assert.equal(localStreams.bob.microphone.userMuted, false);
       });
 
       it('alice shares the screen with highFrameRate', async () => {
@@ -630,7 +630,7 @@ skipInNode(describe)('plugin-meetings', () => {
             );
           });
 
-        const screenShareVideoPublished = waitForPublished(alice.meeting, true, "alice's screen share video stream");
+        const screenShareVideoPublished = waitForPublished(alice.meeting, {stream: localStreams.alice.screenShare.video, status: true}, "alice's screen share video stream");
 
         await testUtils.delayedPromise(alice.meeting.publishStreams({screenShare: {video: localStreams.alice.screenShare.video}}));
 
@@ -666,8 +666,8 @@ skipInNode(describe)('plugin-meetings', () => {
               JSON.stringify(response, testUtils.getCircularReplacer())
             );
           });
-        const aliceScreenShareVideoUnpublished = waitForPublished(alice.meeting, false, "alice's screen share video stream");
-        const bobScreenShareVideoPublished = waitForPublished(bob.meeting, true, "bob's screen share video stream");
+        const aliceScreenShareVideoUnpublished = waitForPublished(alice.meeting, {stream: localStreams.alice.screenShare.video, status: false}, "alice's screen share video stream");
+        const bobScreenShareVideoPublished = waitForPublished(bob.meeting, {stream: localStreams.bob.screenShare.video, status: true}, "bob's screen share video stream");
 
         await testUtils.delayedPromise(bob.meeting.publishStreams({screenShare: {video: localStreams.bob.screenShare.video}}));
 
@@ -689,7 +689,7 @@ skipInNode(describe)('plugin-meetings', () => {
       });
 
       it('bob stops sharing', async () => {
-        const screenShareVideoUnpublished = waitForPublished(bob.meeting, false, "bob's screen share video stream");
+        const screenShareVideoUnpublished = waitForPublished(bob.meeting, {stream: localStreams.bob.screenShare.video, status: false}, "bob's screen share video stream");
         const stoppedSharingLocal = testUtils.waitForEvents([{scope: bob.meeting, event: 'meeting:stoppedSharingLocal'}]);
         const stoppedSharingRemote = testUtils.waitForEvents([{scope: alice.meeting, event: 'meeting:stoppedSharingRemote'}]);
 
@@ -826,7 +826,7 @@ skipInNode(describe)('plugin-meetings', () => {
               JSON.stringify(response, testUtils.getCircularReplacer())
             );
           });
-        const bobScreenShareVideoPublished = waitForPublished(bob.meeting, true, "bob's screen share video stream");
+        const bobScreenShareVideoPublished = waitForPublished(bob.meeting, {stream: localStreams.bob.screenShare.video, status: true}, "bob's screen share video stream");
 
         await testUtils.delayedPromise(bob.meeting.publishStreams({screenShare: {video: localStreams.bob.screenShare.video}}));
 

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/interpretation/index.ts

@@ -1,6 +1,7 @@
 import {assert, expect} from '@webex/test-helper-chai';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
+import SILanguage from '@webex/plugin-meetings/src/interpretation/siLanguage';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 
@@ -123,7 +124,7 @@ describe('plugin-meetings', () => {
             receiveLanguage: 'en',
             order: 0,
           }, selfParticipantId: '123'};
-        interpretation.updateSelfInterpretation(sampleData);
+        assert.equal(interpretation.updateSelfInterpretation(sampleData), true);
         assert.equal(interpretation.originalLanguage, 'en');
         assert.equal(interpretation.sourceLanguage, 'en');
         assert.equal(interpretation.targetLanguage, 'zh');
@@ -133,12 +134,44 @@ describe('plugin-meetings', () => {
 
         sampleData.interpretation = {
           originalLanguage: 'en',
+          targetLanguage: 'zh',
           order: 0,
         };
-        interpretation.updateSelfInterpretation(sampleData);
+        assert.equal(interpretation.updateSelfInterpretation(sampleData), false);
         assert.equal(interpretation.sourceLanguage, undefined);
-        assert.equal(interpretation.targetLanguage, undefined);
+        assert.equal(interpretation.targetLanguage, 'zh');
         assert.equal(interpretation.receiveLanguage, undefined);
+
+        sampleData.interpretation = {
+          order: 0,
+        };
+        assert.equal(interpretation.updateSelfInterpretation(sampleData), false);
+        assert.equal(interpretation.originalLanguage, undefined);
+        assert.equal(interpretation.targetLanguage, undefined);
+      });
+    });
+
+    describe('#getTargetLanguageCode', () => {
+      it('get target language id if self is interpreter', () => {
+        interpretation.siLanguages.set([{
+          languageCode: 24,
+          languageName: "fr"
+        },
+          {
+            languageCode: 20,
+            languageName: "en"
+          }]);
+        interpretation.selfIsInterpreter = true;
+        interpretation.targetLanguage = 'fr';
+
+        assert.equal(interpretation.getTargetLanguageCode(), 24);
+
+        interpretation.targetLanguage = 'en';
+        assert.equal(interpretation.getTargetLanguageCode(), 20);
+
+        interpretation.selfIsInterpreter = false;
+        assert.equal(interpretation.getTargetLanguageCode(), 0);
+
       });
     });
 

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

@@ -1377,7 +1377,7 @@ describe('plugin-meetings', () => {
         );
       });
 
-      const checkMeetingInfoUpdatedCalled = (expected) => {
+      const checkMeetingInfoUpdatedCalled = (expected, payload) => {
         const expectedArgs = [
           locusInfo.emitScoped,
           {
@@ -1385,6 +1385,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+          payload
         ];
 
         if (expected) {
@@ -1395,7 +1396,7 @@ describe('plugin-meetings', () => {
         locusInfo.emitScoped.resetHistory();
       };
 
-      const checkMeetingInfoUpdatedCalledForRoles = (expected) => {
+      const checkMeetingInfoUpdatedCalledForRoles = (expected, payload) => {
         const expectedArgs = [
           locusInfo.emitScoped,
           {
@@ -1403,6 +1404,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+          payload
         ];
 
         if (expected) {
@@ -1447,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);
 
@@ -1472,7 +1474,7 @@ describe('plugin-meetings', () => {
         };
         locusInfo.updateMeetingInfo(newInfo, self);
 
-        checkMeetingInfoUpdatedCalled(true);
+        checkMeetingInfoUpdatedCalled(true, {isInitializing: false});
 
         // update it with the same info
         expectedMeeting = {
@@ -1494,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);
@@ -1525,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', () => {
@@ -1546,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});
       });
     });
 
@@ -1884,6 +1891,27 @@ 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'};
@@ -2037,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: {
@@ -2053,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: {
@@ -2071,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',
@@ -2088,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)
       });
     });
 

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();
+  });
+});
+