prebid.js 10.2.0 → 10.4.0

package/dist/src/test/spec/modules/videoModule/submodules/jwplayerVideoProvider_spec.js

@@ -1,6 +1,7 @@
 import { JWPlayerProvider, adStateFactory, timeStateFactory, callbackStorageFactory, utils } from 'modules/jwplayerVideoProvider';
-import { PROTOCOLS, API_FRAMEWORKS, VIDEO_MIME_TYPE, PLAYBACK_METHODS, PLACEMENT, VPAID_MIME_TYPE } from 'libraries/video/constants/ortb.js';
-import { SETUP_COMPLETE, SETUP_FAILED, PLAY, AD_IMPRESSION, AD_STARTED, SEEK_END, videoEvents } from 'libraries/video/constants/events.js';
+import { PROTOCOLS, API_FRAMEWORKS, VIDEO_MIME_TYPE, PLAYBACK_METHODS, PLACEMENT, VPAID_MIME_TYPE, AD_POSITION } from 'libraries/video/constants/ortb.js';
+import { JWPLAYER_VENDOR } from 'libraries/video/constants/vendorCodes.js';
+import { SETUP_COMPLETE, SETUP_FAILED, DESTROYED, AD_REQUEST, AD_BREAK_START, AD_LOADED, AD_STARTED, AD_IMPRESSION, AD_PLAY, AD_TIME, AD_PAUSE, AD_CLICK, AD_SKIPPED, AD_ERROR, AD_COMPLETE, AD_BREAK_END, PLAYLIST, PLAYBACK_REQUEST, AUTOSTART_BLOCKED, PLAY_ATTEMPT_FAILED, CONTENT_LOADED, PLAY, PAUSE, BUFFER, TIME, SEEK_START, SEEK_END, MUTE, VOLUME, RENDITION_UPDATE, ERROR, COMPLETE, PLAYLIST_COMPLETE, FULLSCREEN, PLAYER_RESIZE, VIEWABLE, CAST, videoEvents } from 'libraries/video/constants/events.js';
 import { PLAYBACK_MODE } from 'libraries/video/constants/constants.js';
 function getPlayerMock() {
   return makePlayerFactoryMock({
@@ -18,8 +19,10 @@ function getPlayerMock() {
     getWidth: function () {},
     getFullscreen: function () {},
     getPlaylistItem: function () {},
+    getDuration: function () {},
     playAd: function () {},
-    on: function () {
+    loadAdXml: function () {},
+    on: function (eventName, handler) {
       return this;
     },
     off: function () {
@@ -51,7 +54,7 @@ function getUtilsMock() {
     getPlaybackMethod: function () {},
     isOmidSupported: function () {},
     getSkipParams: function () {},
-    getJwEvent: event => event,
+    getJwEvent: utils.getJwEvent,
     getIsoLanguageCode: function () {},
     getSegments: function () {},
     getContentDatum: function () {}
@@ -344,6 +347,858 @@ describe('JWPlayerProvider', function () {
       const eventName = offSpy.args[0][0];
       expect(eventName).to.be.equal('adViewableImpression');
     });
+    it('should handle setup complete callbacks', function () {
+      const player = getPlayerMock();
+      player.getState = () => 'idle';
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      const setupComplete = sinon.spy();
+      provider.onEvent(SETUP_COMPLETE, setupComplete, {});
+      provider.init();
+      expect(setupComplete.calledOnce).to.be.true;
+      const payload = setupComplete.args[0][1];
+      expect(payload.type).to.be.equal(SETUP_COMPLETE);
+      expect(payload.divId).to.be.equal('test');
+    });
+    it('should handle setup failed callbacks', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      const setupFailed = sinon.spy();
+      provider.onEvent(SETUP_FAILED, setupFailed, {});
+      provider.init();
+      expect(setupFailed.calledOnce).to.be.true;
+      const payload = setupFailed.args[0][1];
+      expect(payload.type).to.be.equal(SETUP_FAILED);
+      expect(payload.divId).to.be.equal('test');
+    });
+    it('should not throw when onEvent is called and player is null', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      const callback = () => {};
+      provider.onEvent(PLAY, callback, {});
+    });
+    it('should handle AD_REQUEST event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(AD_REQUEST, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_REQUEST); // event name
+
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        tag: 'test-ad-tag'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.adTagUrl).to.be.equal('test-ad-tag');
+    });
+    it('should handle AD_BREAK_START event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const timeState = {
+        clearState: sinon.spy(),
+        getState: () => ({})
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(AD_BREAK_START, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_BREAK_START);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        adPosition: 'pre'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.offset).to.be.equal('pre');
+    });
+    it('should handle AD_LOADED event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const expectedAdState = {
+        adTagUrl: 'test-ad-tag',
+        vastAdId: 'ad-123',
+        skip: 1,
+        skipmin: 7,
+        skipafter: 5
+      };
+      const adState = {
+        updateForEvent: sinon.spy(),
+        updateState: sinon.spy(),
+        getState: () => expectedAdState
+      };
+      player.getConfig = () => ({
+        advertising: {
+          skipoffset: 5
+        }
+      });
+      const utils = getUtilsMock();
+      utils.getSkipParams = () => ({
+        skip: 1,
+        skipmin: 7,
+        skipafter: 5
+      });
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeStateFactory(), callbackStorageFactory(), utils, sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(AD_LOADED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_LOADED);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        tag: 'test-ad-tag',
+        id: 'ad-123'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload).to.deep.equal(expectedAdState);
+    });
+    it('should handle AD_STARTED event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const expectedAdState = {
+        adTagUrl: 'test-ad-tag',
+        vastAdId: 'ad-123'
+      };
+      const adState = {
+        getState: () => expectedAdState
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(AD_STARTED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_IMPRESSION); // AD_STARTED maps to AD_IMPRESSION
+
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      eventHandler({});
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload).to.deep.equal(expectedAdState);
+    });
+    it('should handle AD_IMPRESSION event payload', function () {
+      const player = getPlayerMock();
+      const expectedAdState = {
+        adTagUrl: 'test-ad-tag',
+        vastAdId: 'ad-123'
+      };
+      const expectedTimeState = {
+        time: 15,
+        duration: 30
+      };
+      const adState = {
+        getState: () => expectedAdState
+      };
+      const timeState = {
+        getState: () => expectedTimeState
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_IMPRESSION, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('adViewableImpression'); // AD_IMPRESSION maps to 'adViewableImpression'
+
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      eventHandler({});
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload).to.deep.equal({
+        ...expectedAdState,
+        ...expectedTimeState
+      });
+    });
+    it('should handle AD_TIME event payload', function () {
+      const player = getPlayerMock();
+      const timeState = {
+        updateForEvent: sinon.spy(),
+        getState: () => ({})
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_TIME, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_TIME);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        tag: 'test-ad-tag',
+        position: 10,
+        duration: 30
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.adTagUrl).to.be.equal('test-ad-tag');
+      expect(payload.time).to.be.equal(10);
+      expect(payload.duration).to.be.equal(30);
+    });
+    it('should handle AD_SKIPPED event payload', function () {
+      const player = getPlayerMock();
+      const adState = {
+        clearState: sinon.spy()
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_SKIPPED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_SKIPPED);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        position: 15,
+        duration: 30
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.time).to.be.equal(15);
+      expect(payload.duration).to.be.equal(30);
+    });
+    it('should handle AD_ERROR event payload', function () {
+      const player = getPlayerMock();
+      const expectedAdState = {
+        adTagUrl: 'test-ad-tag',
+        vastAdId: 'ad-123'
+      };
+      const expectedTimeState = {
+        time: 15,
+        duration: 30
+      };
+      const adState = {
+        clearState: sinon.spy(),
+        getState: () => expectedAdState
+      };
+      const timeState = {
+        getState: () => expectedTimeState
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_ERROR, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_ERROR);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        sourceError: new Error('Player Ad error'),
+        adErrorCode: 2001,
+        code: 3001,
+        message: 'Ad playback error occurred'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.sourceError).to.be.equal(mockEvent.sourceError);
+      expect(payload.playerErrorCode).to.be.equal(2001);
+      expect(payload.vastErrorCode).to.be.equal(3001);
+      expect(payload.errorMessage).to.be.equal('Ad playback error occurred');
+      expect(payload.adTagUrl).to.be.equal('test-ad-tag');
+      expect(payload.vastAdId).to.be.equal('ad-123');
+      expect(payload.time).to.be.equal(15);
+      expect(payload.duration).to.be.equal(30);
+    });
+    it('should handle AD_COMPLETE event payload', function () {
+      const player = getPlayerMock();
+      const adState = {
+        clearState: sinon.spy()
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adState, timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_COMPLETE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_COMPLETE);
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        tag: 'test-ad-tag'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.adTagUrl).to.be.equal('test-ad-tag');
+    });
+    it('should handle AD_BREAK_END event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(AD_BREAK_END, callback, {});
+
+      // Verify player.on was called
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(AD_BREAK_END);
+
+      // Get the event handler that was passed to player.on
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        adPosition: 'post'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.offset).to.be.equal('post');
+    });
+    it('should handle PLAYLIST event payload', function () {
+      const player = getPlayerMock();
+      player.getConfig = () => ({
+        autostart: true
+      });
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(PLAYLIST, callback, {});
+
+      // Verify player.on was called
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(PLAYLIST);
+
+      // Get the event handler that was passed to player.on
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        playlist: [{}, {}, {}]
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.playlistItemCount).to.be.equal(3);
+      expect(payload.autostart).to.be.true;
+    });
+    it('should handle PLAYBACK_REQUEST event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(PLAYBACK_REQUEST, callback, {});
+
+      // Verify player.on was called
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('playAttempt'); // PLAYBACK_REQUEST maps to 'playAttempt'
+
+      // Get the event handler that was passed to player.on
+      const eventHandler = onSpy.args[0][1];
+
+      // Simulate the player calling the event handler
+      const mockEvent = {
+        playReason: 'user-interaction'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.playReason).to.be.equal('user-interaction');
+    });
+    it('should handle AUTOSTART_BLOCKED event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(AUTOSTART_BLOCKED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('autostartNotAllowed'); // AUTOSTART_BLOCKED maps to 'autostartNotAllowed'
+
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        error: new Error('Autostart blocked'),
+        code: 1001,
+        message: 'User interaction required'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.sourceError).to.be.equal(mockEvent.error);
+      expect(payload.errorCode).to.be.equal(1001);
+      expect(payload.errorMessage).to.be.equal('User interaction required');
+    });
+    it('should handle PLAY_ATTEMPT_FAILED event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(PLAY_ATTEMPT_FAILED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(PLAY_ATTEMPT_FAILED);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        playReason: 'autoplay',
+        sourceError: new Error('Play failed'),
+        code: 2001,
+        message: 'Media not supported'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.playReason).to.be.equal('autoplay');
+      expect(payload.sourceError).to.be.equal(mockEvent.sourceError);
+      expect(payload.errorCode).to.be.equal(2001);
+      expect(payload.errorMessage).to.be.equal('Media not supported');
+    });
+    it('should handle CONTENT_LOADED event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(CONTENT_LOADED, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('playlistItem'); // CONTENT_LOADED maps to 'playlistItem'
+
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        item: {
+          mediaid: 'content-123',
+          file: 'video.mp4',
+          title: 'Test Video',
+          description: 'Test Description',
+          tags: ['tag1', 'tag2']
+        },
+        index: 0
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.contentId).to.be.equal('content-123');
+      expect(payload.contentUrl).to.be.equal('video.mp4');
+      expect(payload.title).to.be.equal('Test Video');
+      expect(payload.description).to.be.equal('Test Description');
+      expect(payload.playlistIndex).to.be.equal(0);
+      expect(payload.contentTags).to.deep.equal(['tag1', 'tag2']);
+    });
+    it('should handle BUFFER event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const expectedTimeState = {
+        time: 15,
+        duration: 30
+      };
+      const timeState = {
+        getState: () => expectedTimeState
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(BUFFER, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(BUFFER);
+      const eventHandler = onSpy.args[0][1];
+      eventHandler({});
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload).to.deep.equal(expectedTimeState);
+    });
+    it('should handle TIME event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const timeState = {
+        updateForEvent: sinon.spy(),
+        getState: () => ({})
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(TIME, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(TIME);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        position: 25,
+        duration: 120
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.position).to.be.equal(25);
+      expect(payload.duration).to.be.equal(120);
+    });
+    it('should handle SEEK_START event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(SEEK_START, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('seek'); // SEEK_START maps to 'seek'
+
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        position: 10,
+        offset: 30,
+        duration: 120
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.position).to.be.equal(10);
+      expect(payload.destination).to.be.equal(30);
+      expect(payload.duration).to.be.equal(120);
+    });
+    it('should handle SEEK_END event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(SEEK_END, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('seeked'); // SEEK_END maps to 'seeked'
+
+      const eventHandler = onSpy.args[0][1];
+
+      // First trigger a seek start to set pendingSeek
+      const seekStartCallback = sinon.spy();
+      const seekStartOnSpy = sinon.spy();
+      player.on = seekStartOnSpy;
+      provider.onEvent(SEEK_START, seekStartCallback, {});
+      const seekStartHandler = seekStartOnSpy.args[0][1];
+      seekStartHandler({
+        position: 10,
+        offset: 30,
+        duration: 120
+      });
+
+      // Now trigger seek end
+      eventHandler({});
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.position).to.be.equal(30);
+      expect(payload.duration).to.be.equal(120);
+    });
+    it('should handle MUTE event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(MUTE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(MUTE);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        mute: true
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.mute).to.be.true;
+    });
+    it('should handle VOLUME event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(VOLUME, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(VOLUME);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        volume: 75
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.volumePercentage).to.be.equal(75);
+    });
+    it('should handle RENDITION_UPDATE event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(RENDITION_UPDATE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('visualQuality'); // RENDITION_UPDATE maps to 'visualQuality'
+
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        bitrate: 2000000,
+        level: {
+          width: 1920,
+          height: 1080
+        },
+        frameRate: 30
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.videoReportedBitrate).to.be.equal(2000000);
+      expect(payload.audioReportedBitrate).to.be.equal(2000000);
+      expect(payload.encodedVideoWidth).to.be.equal(1920);
+      expect(payload.encodedVideoHeight).to.be.equal(1080);
+      expect(payload.videoFramerate).to.be.equal(30);
+    });
+    it('should handle ERROR event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(ERROR, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(ERROR);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        sourceError: new Error('Player error'),
+        code: 3001,
+        message: 'Media error occurred'
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.sourceError).to.be.equal(mockEvent.sourceError);
+      expect(payload.errorCode).to.be.equal(3001);
+      expect(payload.errorMessage).to.be.equal('Media error occurred');
+    });
+    it('should handle COMPLETE event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      const timeState = {
+        clearState: sinon.spy()
+      };
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent(COMPLETE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(COMPLETE);
+      const eventHandler = onSpy.args[0][1];
+      eventHandler({});
+      expect(callback.calledOnce).to.be.true;
+    });
+    it('should handle FULLSCREEN event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(FULLSCREEN, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(FULLSCREEN);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        fullscreen: true
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.fullscreen).to.be.true;
+    });
+    it('should handle PLAYER_RESIZE event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(PLAYER_RESIZE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal('resize'); // PLAYER_RESIZE maps to 'resize'
+
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        height: 480,
+        width: 640
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.height).to.be.equal(480);
+      expect(payload.width).to.be.equal(640);
+    });
+    it('should handle VIEWABLE event payload', function () {
+      const player = getPlayerMock();
+      player.getPercentViewable = () => 0.75;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(VIEWABLE, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(VIEWABLE);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        viewable: true
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.viewable).to.be.true;
+      expect(payload.viewabilityPercentage).to.be.equal(75);
+    });
+    it('should handle CAST event payload', function () {
+      const player = getPlayerMock();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
+      provider.onEvent(CAST, callback, {});
+      expect(onSpy.calledOnce).to.be.true;
+      expect(onSpy.args[0][0]).to.equal(CAST);
+      const eventHandler = onSpy.args[0][1];
+      const mockEvent = {
+        active: true
+      };
+      eventHandler(mockEvent);
+      expect(callback.calledOnce).to.be.true;
+      const payload = callback.args[0][1];
+      expect(payload.casting).to.be.true;
+    });
+    it('should handle unknown events', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy(player, 'on');
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
+      provider.onEvent('UNKNOWN_EVENT', callback, {});
+      expect(onSpy.called).to.be.false;
+    });
+    it('should handle offEvent without callback', function () {
+      const player = getPlayerMock();
+      const offSpy = player.off = sinon.spy();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      provider.offEvent(AD_IMPRESSION);
+      expect(offSpy.calledOnce).to.be.true;
+    });
+    it('should handle offEvent with non-existent callback', function () {
+      const player = getPlayerMock();
+      const offSpy = player.off = sinon.spy();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = () => {};
+      provider.offEvent(AD_IMPRESSION, callback);
+      expect(offSpy.called).to.be.false;
+    });
   });
   describe('destroy', function () {
     it('should remove and null the player', function () {
@@ -358,10 +1213,270 @@ describe('JWPlayerProvider', function () {
       provider.destroy();
       expect(removeSpy.calledOnce).to.be.true;
     });
+    it('should not throw when destroy is called and player is null', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.destroy();
+    });
+  });
+  describe('setupPlayer', function () {
+    it('should setup player with config', function () {
+      const player = getPlayerMock();
+      const setupSpy = player.setup = sinon.spy(() => player);
+      const onSpy = player.on = sinon.spy(() => player);
+      const config = {
+        divId: 'test',
+        playerConfig: {
+          file: 'video.mp4'
+        }
+      };
+      const utils = getUtilsMock();
+      utils.getJwConfig = () => ({
+        file: 'video.mp4',
+        autostart: false
+      });
+      const provider = JWPlayerProvider(config, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), utils, sharedUtils);
+      provider.init();
+      expect(setupSpy.calledOnce).to.be.true;
+      expect(setupSpy.args[0][0]).to.deep.equal({
+        file: 'video.mp4',
+        autostart: false
+      });
+      expect(onSpy.calledTwice).to.be.true;
+      expect(onSpy.args[0][0]).to.be.equal('ready');
+      expect(onSpy.args[1][0]).to.be.equal('setupError');
+    });
+    it('should handle setup without config', function () {
+      const player = getPlayerMock();
+      const setupSpy = player.setup = sinon.spy();
+      const config = {
+        divId: 'test'
+      };
+      const provider = JWPlayerProvider(config, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      expect(setupSpy.called).to.be.false;
+    });
+  });
+  describe('getOrtbVideo edge cases', function () {
+    it('should handle missing player', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      const result = provider.getOrtbVideo();
+      expect(result).to.be.undefined;
+    });
+    it('should not throw when missing config', function () {
+      const player = getPlayerMock();
+      player.getConfig = () => null;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const result = provider.getOrtbVideo();
+      expect(result).to.be.an('object');
+    });
+    it('should not throw when missing advertising config', function () {
+      const player = getPlayerMock();
+      player.getConfig = () => ({});
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const result = provider.getOrtbVideo();
+      expect(result).to.be.an('object');
+    });
+    it('should calculate size from aspect ratio when height and width are null', function () {
+      const player = getPlayerMock();
+      player.getConfig = () => ({
+        advertising: {
+          battr: 'test'
+        },
+        aspectratio: '16:9',
+        width: '100%'
+      });
+      player.getContainer = () => ({
+        clientWidth: 800,
+        clientHeight: 600
+      });
+      const utils = getUtilsMock();
+      utils.getPlayerHeight = () => null;
+      utils.getPlayerWidth = () => null;
+      utils.getPlayerSizeFromAspectRatio = () => ({
+        height: 450,
+        width: 800
+      });
+      utils.getSupportedMediaTypes = () => [VIDEO_MIME_TYPE.MP4];
+      utils.getStartDelay = () => 0;
+      utils.getPlacement = () => PLACEMENT.INSTREAM;
+      utils.getPlaybackMethod = () => PLAYBACK_METHODS.CLICK_TO_PLAY;
+      utils.isOmidSupported = () => false;
+      utils.getSkipParams = () => ({});
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), utils, sharedUtils);
+      provider.init();
+      const result = provider.getOrtbVideo();
+      expect(result.h).to.be.equal(450);
+      expect(result.w).to.be.equal(800);
+    });
+  });
+  describe('getOrtbContent edge cases', function () {
+    it('should handle missing player', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      const result = provider.getOrtbContent();
+      expect(result).to.be.undefined;
+    });
+    it('should handle missing playlist item', function () {
+      const player = getPlayerMock();
+      player.getPlaylistItem = () => null;
+      player.getDuration = () => 120;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const result = provider.getOrtbContent();
+      expect(result).to.be.an('object');
+      expect(result.url).to.be.undefined;
+      expect(result.len).to.be.equal(120);
+    });
+    it('should handle missing duration in timeState', function () {
+      const player = getPlayerMock();
+      player.getPlaylistItem = () => ({
+        mediaid: 'test'
+      });
+      player.getDuration = () => 120;
+      const timeState = timeStateFactory();
+      timeState.getState = () => ({
+        duration: undefined
+      });
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const result = provider.getOrtbContent();
+      expect(result.len).to.be.equal(120);
+    });
+    it('should handle missing mediaId', function () {
+      const player = getPlayerMock();
+      player.getPlaylistItem = () => ({
+        file: 'video.mp4'
+      });
+      const timeState = timeStateFactory();
+      timeState.getState = () => ({
+        duration: 120
+      });
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const result = provider.getOrtbContent();
+      expect(result).to.not.have.property('id');
+    });
+    it('should handle missing jwpseg', function () {
+      const player = getPlayerMock();
+      player.getPlaylistItem = () => ({
+        mediaid: 'test',
+        file: 'video.mp4'
+      });
+      const timeState = timeStateFactory();
+      timeState.getState = () => ({
+        duration: 120
+      });
+      const utils = getUtilsMock();
+      utils.getSegments = () => undefined;
+      utils.getContentDatum = () => undefined;
+      utils.getIsoLanguageCode = () => undefined;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), utils, sharedUtils);
+      provider.init();
+      const result = provider.getOrtbContent();
+      expect(result).to.not.have.property('data');
+    });
+    it('should handle missing language', function () {
+      const player = getPlayerMock();
+      player.getPlaylistItem = () => ({
+        mediaid: 'test',
+        file: 'video.mp4'
+      });
+      const timeState = timeStateFactory();
+      timeState.getState = () => ({
+        duration: 120
+      });
+      const utils = getUtilsMock();
+      utils.getSegments = () => undefined;
+      utils.getContentDatum = () => undefined;
+      utils.getIsoLanguageCode = () => undefined;
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeState, callbackStorageFactory(), utils, sharedUtils);
+      provider.init();
+      const result = provider.getOrtbContent();
+      expect(result).to.not.have.property('language');
+    });
+  });
+  describe('setAdTagUrl edge cases', function () {
+    it('should not throw when setAdTagUrl is called and player is null', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.setAdTagUrl('test-url');
+    });
+    it('should handle missing adTagUrl', function () {
+      const player = getPlayerMock();
+      const playAdSpy = player.playAd = sinon.spy();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      provider.setAdTagUrl(null, {
+        adXml: 'test-vast'
+      });
+      expect(playAdSpy.calledOnce).to.be.true;
+      expect(playAdSpy.args[0][0]).to.be.equal('test-vast');
+    });
+    it('should pass options to playAd', function () {
+      const player = getPlayerMock();
+      const playAdSpy = player.playAd = sinon.spy();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const options = {
+        adXml: '<VAST></VAST>'
+      };
+      provider.setAdTagUrl('test-url', options);
+      expect(playAdSpy.calledOnce).to.be.true;
+      expect(playAdSpy.args[0][0]).to.be.equal('test-url');
+      expect(playAdSpy.args[0][1]).to.be.equal(options);
+    });
+  });
+  describe('setAdXml edge cases', function () {
+    it('should not throw when setAdXml is called and player is null', function () {
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, null, adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.setAdXml('<VAST></VAST>');
+    });
+    it('should handle missing options', function () {
+      const player = getPlayerMock();
+      const loadSpy = player.loadAdXml = sinon.spy();
+      const provider = JWPlayerProvider({
+        divId: 'test'
+      }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      provider.setAdXml('<VAST></VAST>');
+      expect(loadSpy.calledOnce).to.be.true;
+      expect(loadSpy.args[0][0]).to.be.equal('<VAST></VAST>');
+      expect(loadSpy.args[0][1]).to.be.undefined;
+    });
   });
 });
 describe('adStateFactory', function () {
-  const adState = adStateFactory();
+  let adState = adStateFactory();
   beforeEach(() => {
     adState.clearState();
   });
@@ -469,14 +1584,119 @@ describe('adStateFactory', function () {
     state = adState.getState();
     expect(state.adPlacementType).to.be.equal(PLACEMENT.SLIDER);
     adState.updateForEvent({
-      placement: 'floating'
+      placement: 'floating'
+    });
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.FLOATING);
+  });
+  it('should handle unknown placement values', function () {
+    adState.updateForEvent({
+      placement: 'unknown'
+    });
+    const state = adState.getState();
+    expect(state.adPlacementType).to.be.undefined;
+  });
+  it('should handle missing placement', function () {
+    adState.updateForEvent({});
+    const state = adState.getState();
+    expect(state.adPlacementType).to.be.undefined;
+  });
+  it('should handle partial event data', function () {
+    adState.updateForEvent({
+      tag: 'test-tag',
+      id: 'test-id'
+    });
+    const state = adState.getState();
+    expect(state.adTagUrl).to.equal('test-tag');
+    expect(state.vastAdId).to.equal('test-id');
+    expect(state.adDescription).to.be.undefined;
+    expect(state.adServer).to.be.undefined;
+  });
+  it('should handle null and undefined values', function () {
+    adState.updateForEvent({
+      tag: null,
+      id: undefined,
+      description: null,
+      adsystem: undefined
+    });
+    const state = adState.getState();
+    expect(state.adTagUrl).to.be.null;
+    expect(state.vastAdId).to.be.undefined;
+    expect(state.adDescription).to.be.null;
+    expect(state.adServer).to.be.undefined;
+  });
+  it('should handle googima client wrapper ad ids', function () {
+    const mockImaAd = {
+      ad: {
+        a: {
+          adWrapperIds: ['wrapper1', 'wrapper2']
+        }
+      }
+    };
+    adState.updateForEvent({
+      client: 'googima',
+      ima: mockImaAd
+    });
+    const state = adState.getState();
+    expect(state.wrapperAdIds).to.deep.equal(['wrapper1', 'wrapper2']);
+  });
+  it('should handle googima client without wrapper ad ids', function () {
+    const mockImaAd = {
+      ad: {}
+    };
+    adState.updateForEvent({
+      client: 'googima',
+      ima: mockImaAd
+    });
+    const state = adState.getState();
+    expect(state.wrapperAdIds).to.be.undefined;
+  });
+  it('should handle googima client without ima object', function () {
+    adState.updateForEvent({
+      client: 'googima'
+    });
+    const state = adState.getState();
+    expect(state.wrapperAdIds).to.be.undefined;
+  });
+  it('should support wrapper ad ids for non-googima clients', function () {
+    adState.updateForEvent({
+      client: 'vast',
+      wrapperAdIds: ['existing']
+    });
+    const state = adState.getState();
+    expect(state.wrapperAdIds).to.deep.equal(['existing']);
+  });
+  it('should clear state when clearState is called', function () {
+    adState.updateForEvent({
+      tag: 'test-tag',
+      id: 'test-id'
+    });
+    let state = adState.getState();
+    expect(state.adTagUrl).to.equal('test-tag');
+    expect(state.vastAdId).to.equal('test-id');
+    adState.clearState();
+    state = adState.getState();
+    expect(state.adTagUrl).to.be.undefined;
+    expect(state.vastAdId).to.be.undefined;
+  });
+  it('should update state with additional properties', function () {
+    adState.updateForEvent({
+      tag: 'test-tag'
     });
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.FLOATING);
+    adState.updateState({
+      skip: 1,
+      skipmin: 5,
+      skipafter: 3
+    });
+    const state = adState.getState();
+    expect(state.adTagUrl).to.equal('test-tag');
+    expect(state.skip).to.equal(1);
+    expect(state.skipmin).to.equal(5);
+    expect(state.skipafter).to.equal(3);
   });
 });
 describe('timeStateFactory', function () {
-  const timeState = timeStateFactory();
+  let timeState = timeStateFactory();
   beforeEach(() => {
     timeState.clearState();
   });
@@ -528,6 +1748,89 @@ describe('timeStateFactory', function () {
     expect(duration).to.be.equal(test_duration);
     expect(playbackMode).to.be.equal(PLAYBACK_MODE.DVR);
   });
+  it('should handle partial event data', function () {
+    timeState.updateForEvent({
+      position: 10
+    });
+    const {
+      time,
+      duration,
+      playbackMode
+    } = timeState.getState();
+    expect(time).to.be.equal(10);
+    expect(duration).to.be.undefined;
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.LIVE);
+  });
+  it('should handle null and undefined values', function () {
+    timeState.updateForEvent({
+      position: null,
+      duration: undefined
+    });
+    const {
+      time,
+      duration,
+      playbackMode
+    } = timeState.getState();
+    expect(time).to.be.null;
+    expect(duration).to.be.undefined;
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.LIVE);
+  });
+  it('should clear state when clearState is called', function () {
+    timeState.updateForEvent({
+      position: 15,
+      duration: 60
+    });
+    let state = timeState.getState();
+    expect(state.time).to.be.equal(15);
+    expect(state.duration).to.be.equal(60);
+    timeState.clearState();
+    state = timeState.getState();
+    expect(state.time).to.be.undefined;
+    expect(state.duration).to.be.undefined;
+  });
+  it('should update state with additional properties', function () {
+    timeState.updateForEvent({
+      position: 20,
+      duration: 120
+    });
+    timeState.updateState({
+      playbackMode: PLAYBACK_MODE.VOD
+    });
+    const state = timeState.getState();
+    expect(state.time).to.be.equal(20);
+    expect(state.duration).to.be.equal(120);
+    expect(state.playbackMode).to.be.equal(PLAYBACK_MODE.VOD);
+  });
+  it('should handle zero duration as LIVE mode', function () {
+    timeState.updateForEvent({
+      position: 0,
+      duration: 0
+    });
+    const {
+      playbackMode
+    } = timeState.getState();
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.LIVE);
+  });
+  it('should handle negative duration as DVR mode', function () {
+    timeState.updateForEvent({
+      position: -10,
+      duration: -60
+    });
+    const {
+      playbackMode
+    } = timeState.getState();
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.DVR);
+  });
+  it('should handle positive duration as VOD mode', function () {
+    timeState.updateForEvent({
+      position: 30,
+      duration: 180
+    });
+    const {
+      playbackMode
+    } = timeState.getState();
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.VOD);
+  });
 });
 describe('callbackStorageFactory', function () {
   const callbackStorage = callbackStorageFactory();
@@ -560,6 +1863,116 @@ describe('callbackStorageFactory', function () {
     callbackStorage.clearStorage();
     expect(callbackStorage.getCallback('event', callback1)).to.be.undefined;
   });
+  it('should handle multiple events', function () {
+    const callback1 = () => 'callback1';
+    const eventHandler1 = () => 'eventHandler1';
+    const callback2 = () => 'callback2';
+    const eventHandler2 = () => 'eventHandler2';
+    callbackStorage.storeCallback('event1', eventHandler1, callback1);
+    callbackStorage.storeCallback('event2', eventHandler2, callback2);
+    expect(callbackStorage.getCallback('event1', callback1)).to.be.equal(eventHandler1);
+    expect(callbackStorage.getCallback('event2', callback2)).to.be.equal(eventHandler2);
+  });
+  it('should handle non-existent events', function () {
+    const callback = () => 'callback';
+    expect(callbackStorage.getCallback('nonexistent', callback)).to.be.undefined;
+  });
+  it('should handle null and undefined callbacks', function () {
+    const eventHandler = () => 'eventHandler';
+    callbackStorage.storeCallback('event', eventHandler, null);
+    callbackStorage.storeCallback('event2', eventHandler, undefined);
+    expect(callbackStorage.getCallback('event', null)).to.be.equal(eventHandler);
+    expect(callbackStorage.getCallback('event2', undefined)).to.be.equal(eventHandler);
+  });
+  it('should handle multiple callbacks for same event', function () {
+    const callback1 = () => 'callback1';
+    const callback2 = () => 'callback2';
+    const eventHandler1 = () => 'eventHandler1';
+    const eventHandler2 = () => 'eventHandler2';
+    callbackStorage.storeCallback('event', eventHandler1, callback1);
+    callbackStorage.storeCallback('event', eventHandler2, callback2);
+    expect(callbackStorage.getCallback('event', callback1)).to.be.equal(eventHandler1);
+    expect(callbackStorage.getCallback('event', callback2)).to.be.equal(eventHandler2);
+  });
+  it('should handle overwriting callbacks', function () {
+    const callback = () => 'callback';
+    const eventHandler1 = () => 'eventHandler1';
+    const eventHandler2 = () => 'eventHandler2';
+    callbackStorage.storeCallback('event', eventHandler1, callback);
+    callbackStorage.storeCallback('event', eventHandler2, callback);
+    expect(callbackStorage.getCallback('event', callback)).to.be.equal(eventHandler2);
+  });
+});
+describe('jwplayerSubmoduleFactory', function () {
+  const jwplayerSubmoduleFactory = require('modules/jwplayerVideoProvider').default;
+  it('should create a provider with correct vendor code', function () {
+    const config = {
+      divId: 'test'
+    };
+    const provider = jwplayerSubmoduleFactory(config, sharedUtils);
+    expect(provider).to.be.an('object');
+    expect(provider.init).to.be.a('function');
+    expect(provider.getId).to.be.a('function');
+    expect(provider.getOrtbVideo).to.be.a('function');
+    expect(provider.getOrtbContent).to.be.a('function');
+    expect(provider.setAdTagUrl).to.be.a('function');
+    expect(provider.setAdXml).to.be.a('function');
+    expect(provider.onEvent).to.be.a('function');
+    expect(provider.offEvent).to.be.a('function');
+    expect(provider.destroy).to.be.a('function');
+  });
+  it('should have correct vendor code', function () {
+    expect(jwplayerSubmoduleFactory.vendorCode).to.be.equal(JWPLAYER_VENDOR);
+  });
+  it('should create independent state instances', function () {
+    const config1 = {
+      divId: 'test1'
+    };
+    const config2 = {
+      divId: 'test2'
+    };
+    const provider1 = jwplayerSubmoduleFactory(config1, sharedUtils);
+    const provider2 = jwplayerSubmoduleFactory(config2, sharedUtils);
+    expect(provider1).to.not.equal(provider2);
+    expect(provider1.getId()).to.equal('test1');
+    expect(provider2.getId()).to.equal('test2');
+  });
+  it('should handle missing jwplayer global', function () {
+    const originalJwplayer = window.jwplayer;
+    window.jwplayer = undefined;
+    const config = {
+      divId: 'test'
+    };
+    const provider = jwplayerSubmoduleFactory(config, sharedUtils);
+    const setupFailed = sinon.spy();
+    provider.onEvent(SETUP_FAILED, setupFailed, {});
+    provider.init();
+    expect(setupFailed.calledOnce).to.be.true;
+    const payload = setupFailed.args[0][1];
+    expect(payload.errorCode).to.be.equal(-1);
+
+    // Restore original jwplayer
+    window.jwplayer = originalJwplayer;
+  });
+  it('should handle jwplayer with unsupported version', function () {
+    const originalJwplayer = window.jwplayer;
+    const mockJwplayer = () => {};
+    mockJwplayer.version = '8.20.0';
+    window.jwplayer = mockJwplayer;
+    const config = {
+      divId: 'test'
+    };
+    const provider = jwplayerSubmoduleFactory(config, sharedUtils);
+    const setupFailed = sinon.spy();
+    provider.onEvent(SETUP_FAILED, setupFailed, {});
+    provider.init();
+    expect(setupFailed.calledOnce).to.be.true;
+    const payload = setupFailed.args[0][1];
+    expect(payload.errorCode).to.be.equal(-2);
+
+    // Restore original jwplayer
+    window.jwplayer = originalJwplayer;
+  });
 });
 describe('utils', function () {
   describe('getJwConfig', function () {
@@ -648,6 +2061,69 @@ describe('utils', function () {
       expect(jwConfig).to.have.property('advertising');
       expect(jwConfig.advertising).to.have.property('client', 'vast');
     });
+    it('should set outstream to true when no file, playlist, or source is provided', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {}
+        }
+      });
+      expect(jwConfig.advertising.outstream).to.be.true;
+    });
+    it('should not set outstream when file is provided', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {
+            file: 'video.mp4'
+          }
+        }
+      });
+      expect(jwConfig.advertising.outstream).to.be.undefined;
+    });
+    it('should not set outstream when playlist is provided', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {
+            playlist: [{
+              file: 'video.mp4'
+            }]
+          }
+        }
+      });
+      expect(jwConfig.advertising.outstream).to.be.undefined;
+    });
+    it('should not set outstream when source is provided', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {
+            source: 'video.mp4'
+          }
+        }
+      });
+      expect(jwConfig.advertising.outstream).to.be.undefined;
+    });
+    it('should set prebid bids to true', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {}
+        }
+      });
+      expect(jwConfig.advertising.bids.prebid).to.be.true;
+    });
+    it('should preserve existing bids configuration', function () {
+      let jwConfig = getJwConfig({
+        params: {
+          vendorConfig: {
+            advertising: {
+              bids: {
+                existing: 'bid'
+              }
+            }
+          }
+        }
+      });
+      expect(jwConfig.advertising.bids.existing).to.be.equal('bid');
+      expect(jwConfig.advertising.bids.prebid).to.be.true;
+    });
   });
   describe('getPlayerHeight', function () {
     const getPlayerHeight = utils.getPlayerHeight;
@@ -667,6 +2143,20 @@ describe('utils', function () {
         height: 500
       })).to.equal(expectedHeight);
     });
+    it('should return undefined when both API and config return undefined', function () {
+      const playerMock = {
+        getHeight: () => undefined
+      };
+      expect(getPlayerHeight(playerMock, {})).to.be.undefined;
+    });
+    it('should return undefined when both API and config return null', function () {
+      const playerMock = {
+        getHeight: () => null
+      };
+      expect(getPlayerHeight(playerMock, {
+        height: null
+      })).to.be.null;
+    });
   });
   describe('getPlayerWidth', function () {
     const getPlayerWidth = utils.getPlayerWidth;
@@ -694,6 +2184,20 @@ describe('utils', function () {
         width: '50%'
       })).to.be.undefined;
     });
+    it('should return undefined when both API and config return undefined', function () {
+      const playerMock = {
+        getWidth: () => undefined
+      };
+      expect(getPlayerWidth(playerMock, {})).to.be.undefined;
+    });
+    it('should return undefined when both API and config return null', function () {
+      const playerMock = {
+        getWidth: () => null
+      };
+      expect(getPlayerWidth(playerMock, {
+        width: null
+      })).to.be.undefined;
+    });
   });
   describe('getPlayerSizeFromAspectRatio', function () {
     const getPlayerSizeFromAspectRatio = utils.getPlayerSizeFromAspectRatio;
@@ -798,6 +2302,36 @@ describe('utils', function () {
         width: 640
       });
     });
+    it('should handle non-numeric aspect ratio values', function () {
+      expect(getPlayerSizeFromAspectRatio({
+        getContainer: () => testContainer
+      }, {
+        aspectratio: 'abc:def',
+        width: '100%'
+      })).to.deep.equal({});
+    });
+    it('should handle non-numeric width percentage', function () {
+      expect(getPlayerSizeFromAspectRatio({
+        getContainer: () => testContainer
+      }, {
+        aspectratio: '16:9',
+        width: 'abc%'
+      })).to.deep.equal({});
+    });
+    it('should handle zero aspect ratio values', function () {
+      expect(getPlayerSizeFromAspectRatio({
+        getContainer: () => testContainer
+      }, {
+        aspectratio: '0:9',
+        width: '100%'
+      })).to.deep.equal({});
+      expect(getPlayerSizeFromAspectRatio({
+        getContainer: () => testContainer
+      }, {
+        aspectratio: '16:0',
+        width: '100%'
+      })).to.deep.equal({});
+    });
   });
   describe('getSkipParams', function () {
     const getSkipParams = utils.getSkipParams;
@@ -822,6 +2356,22 @@ describe('utils', function () {
       expect(skipParams.skipmin).to.be.equal(skipOffset + 2);
       expect(skipParams.skipafter).to.be.equal(skipOffset);
     });
+    it('should handle zero skip offset', function () {
+      let skipParams = getSkipParams({
+        skipoffset: 0
+      });
+      expect(skipParams.skip).to.be.equal(1);
+      expect(skipParams.skipmin).to.be.equal(2);
+      expect(skipParams.skipafter).to.be.equal(0);
+    });
+    it('should handle large skip offset', function () {
+      let skipParams = getSkipParams({
+        skipoffset: 30
+      });
+      expect(skipParams.skip).to.be.equal(1);
+      expect(skipParams.skipmin).to.be.equal(32);
+      expect(skipParams.skipafter).to.be.equal(30);
+    });
   });
   describe('getSupportedMediaTypes', function () {
     const getSupportedMediaTypes = utils.getSupportedMediaTypes;
@@ -831,6 +2381,32 @@ describe('utils', function () {
       supportedMediaTypes = getSupportedMediaTypes([VIDEO_MIME_TYPE.MP4]);
       expect(supportedMediaTypes).to.include(VPAID_MIME_TYPE);
     });
+    it('should filter supported media types', function () {
+      const mockVideo = document.createElement('video');
+      const originalCanPlayType = mockVideo.canPlayType;
+
+      // Mock canPlayType to simulate browser support
+      mockVideo.canPlayType = function (type) {
+        if (type === VIDEO_MIME_TYPE.MP4) return 'probably';
+        if (type === VIDEO_MIME_TYPE.WEBM) return 'maybe';
+        return '';
+      };
+
+      // Temporarily replace document.createElement
+      const originalCreateElement = document.createElement;
+      document.createElement = function (tagName) {
+        if (tagName === 'video') return mockVideo;
+        return originalCreateElement.call(document, tagName);
+      };
+      const supportedMediaTypes = getSupportedMediaTypes([VIDEO_MIME_TYPE.MP4, VIDEO_MIME_TYPE.WEBM, VIDEO_MIME_TYPE.OGG]);
+      expect(supportedMediaTypes).to.include(VIDEO_MIME_TYPE.MP4);
+      expect(supportedMediaTypes).to.include(VIDEO_MIME_TYPE.WEBM);
+      expect(supportedMediaTypes).to.not.include(VIDEO_MIME_TYPE.OGG);
+      expect(supportedMediaTypes).to.include(VPAID_MIME_TYPE);
+
+      // Restore original function
+      document.createElement = originalCreateElement;
+    });
   });
   describe('getPlacement', function () {
     const getPlacement = utils.getPlacement;
@@ -887,6 +2463,29 @@ describe('utils', function () {
       }, getPlayerMock());
       expect(placement).to.be.undefined;
     });
+    it('should handle case-insensitive placement values', function () {
+      const player = getPlayerMock();
+      player.getFloating = () => false;
+      let placement = getPlacement({
+        placement: 'BANNER',
+        outstream: true
+      }, player);
+      expect(placement).to.be.equal(PLACEMENT.BANNER);
+      placement = getPlacement({
+        placement: 'Article',
+        outstream: true
+      }, player);
+      expect(placement).to.be.equal(PLACEMENT.ARTICLE);
+    });
+    it('should handle unknown placement values', function () {
+      const player = getPlayerMock();
+      player.getFloating = () => false;
+      const placement = getPlacement({
+        placement: 'unknown',
+        outstream: true
+      }, player);
+      expect(placement).to.be.undefined;
+    });
   });
   describe('getPlaybackMethod', function () {
     const getPlaybackMethod = utils.getPlaybackMethod;
@@ -927,6 +2526,26 @@ describe('utils', function () {
       });
       expect(playbackMethod).to.equal(PLAYBACK_METHODS.CLICK_TO_PLAY);
     });
+    it('should prioritize mute over autoplayAdsMuted', function () {
+      const playbackMethod = getPlaybackMethod({
+        autoplay: true,
+        mute: true,
+        autoplayAdsMuted: false
+      });
+      expect(playbackMethod).to.equal(PLAYBACK_METHODS.AUTOPLAY_MUTED);
+    });
+    it('should handle undefined autoplay', function () {
+      const playbackMethod = getPlaybackMethod({
+        mute: false
+      });
+      expect(playbackMethod).to.equal(PLAYBACK_METHODS.CLICK_TO_PLAY);
+    });
+    it('should handle undefined mute and autoplayAdsMuted', function () {
+      const playbackMethod = getPlaybackMethod({
+        autoplay: true
+      });
+      expect(playbackMethod).to.equal(PLAYBACK_METHODS.AUTOPLAY);
+    });
   });
   describe('isOmidSupported', function () {
     const isOmidSupported = utils.isOmidSupported;
@@ -950,6 +2569,14 @@ describe('utils', function () {
       expect(isOmidSupported(null)).to.be.false;
       expect(isOmidSupported()).to.be.false;
     });
+    it('should be false when OmidSessionClient is null', function () {
+      window.OmidSessionClient = null;
+      expect(isOmidSupported('vast')).to.be.false;
+    });
+    it('should be false when OmidSessionClient is undefined', function () {
+      window.OmidSessionClient = undefined;
+      expect(isOmidSupported('vast')).to.be.false;
+    });
   });
   describe('getIsoLanguageCode', function () {
     const sampleAudioTracks = [{
@@ -996,6 +2623,40 @@ describe('utils', function () {
       const languageCode = utils.getIsoLanguageCode(player);
       expect(languageCode).to.be.equal('es');
     });
+    it('should handle out of bounds track index', function () {
+      const player = getPlayerMock();
+      player.getAudioTracks = () => sampleAudioTracks;
+      player.getCurrentAudioTrack = () => 10;
+      const languageCode = utils.getIsoLanguageCode(player);
+      expect(languageCode).to.be.undefined;
+    });
+    it('should handle negative track index', function () {
+      const player = getPlayerMock();
+      player.getAudioTracks = () => sampleAudioTracks;
+      player.getCurrentAudioTrack = () => -5;
+      const languageCode = utils.getIsoLanguageCode(player);
+      expect(languageCode).to.be.equal('ht');
+    });
+    it('should handle audio tracks with missing language property', function () {
+      const player = getPlayerMock();
+      player.getAudioTracks = () => [{}, {
+        language: 'en'
+      }, {}];
+      player.getCurrentAudioTrack = () => 0;
+      const languageCode = utils.getIsoLanguageCode(player);
+      expect(languageCode).to.be.undefined;
+    });
+    it('should handle audio tracks with null language property', function () {
+      const player = getPlayerMock();
+      player.getAudioTracks = () => [{
+        language: null
+      }, {
+        language: 'en'
+      }, {}];
+      player.getCurrentAudioTrack = () => 0;
+      const languageCode = utils.getIsoLanguageCode(player);
+      expect(languageCode).to.be.null;
+    });
   });
   describe('getJwEvent', function () {
     const getJwEvent = utils.getJwEvent;
@@ -1007,6 +2668,17 @@ describe('utils', function () {
     it('should return event name when not mapped', function () {
       expect(getJwEvent('custom')).to.equal('custom');
     });
+    it('should map all known event mappings', function () {
+      expect(getJwEvent(SETUP_FAILED)).to.equal('setupError');
+      expect(getJwEvent(DESTROYED)).to.equal('remove');
+      expect(getJwEvent(AD_IMPRESSION)).to.equal('adViewableImpression');
+      expect(getJwEvent(PLAYBACK_REQUEST)).to.equal('playAttempt');
+      expect(getJwEvent(AUTOSTART_BLOCKED)).to.equal('autostartNotAllowed');
+      expect(getJwEvent(CONTENT_LOADED)).to.equal('playlistItem');
+      expect(getJwEvent(SEEK_START)).to.equal('seek');
+      expect(getJwEvent(RENDITION_UPDATE)).to.equal('visualQuality');
+      expect(getJwEvent(PLAYER_RESIZE)).to.equal('resize');
+    });
   });
   describe('getSegments', function () {
     const getSegments = utils.getSegments;
@@ -1022,6 +2694,28 @@ describe('utils', function () {
         id: 'b'
       }]);
     });
+    it('should handle single segment', function () {
+      const segs = ['single'];
+      expect(getSegments(segs)).to.deep.equal([{
+        id: 'single'
+      }]);
+    });
+    it('should handle segments with special characters', function () {
+      const segs = ['segment-1', 'segment_2', 'segment 3'];
+      expect(getSegments(segs)).to.deep.equal([{
+        id: 'segment-1'
+      }, {
+        id: 'segment_2'
+      }, {
+        id: 'segment 3'
+      }]);
+    });
+    it('should handle null input', function () {
+      expect(getSegments(null)).to.be.undefined;
+    });
+    it('should handle undefined input', function () {
+      expect(getSegments(undefined)).to.be.undefined;
+    });
   });
   describe('getContentDatum', function () {
     const getContentDatum = utils.getContentDatum;
@@ -1035,6 +2729,7 @@ describe('utils', function () {
       expect(getContentDatum('id1', segments)).to.deep.equal({
         name: 'jwplayer.com',
         segment: segments,
+        cids: ['id1'],
         ext: {
           cids: ['id1'],
           segtax: 502
@@ -1044,11 +2739,45 @@ describe('utils', function () {
     it('should set only media id when segments missing', function () {
       expect(getContentDatum('id2')).to.deep.equal({
         name: 'jwplayer.com',
+        cids: ['id2'],
         ext: {
           cids: ['id2']
         }
       });
     });
+    it('should set only segments when media id missing', function () {
+      const segments = [{
+        id: 'y'
+      }];
+      expect(getContentDatum(null, segments)).to.deep.equal({
+        name: 'jwplayer.com',
+        segment: segments,
+        ext: {
+          segtax: 502
+        }
+      });
+    });
+    it('should handle empty segments array', function () {
+      expect(getContentDatum('id3', [])).to.deep.equal({
+        name: 'jwplayer.com',
+        cids: ['id3'],
+        ext: {
+          cids: ['id3']
+        }
+      });
+    });
+    it('should handle null media id', function () {
+      expect(getContentDatum(null)).to.be.undefined;
+    });
+    it('should handle empty string media id', function () {
+      expect(getContentDatum('')).to.be.undefined;
+    });
+  });
+  describe('getStartDelay', function () {
+    const getStartDelay = utils.getStartDelay;
+    it('should return undefined (not implemented)', function () {
+      expect(getStartDelay()).to.be.undefined;
+    });
   });
 });
 //# sourceMappingURL=jwplayerVideoProvider_spec.js.map