prebid.js 10.2.0 → 10.4.0

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

@@ -7,11 +7,16 @@ import {
 } from 'modules/jwplayerVideoProvider';
 
 import {
-  PROTOCOLS, API_FRAMEWORKS, VIDEO_MIME_TYPE, PLAYBACK_METHODS, PLACEMENT, VPAID_MIME_TYPE
+  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, PLAY, AD_IMPRESSION, AD_STARTED, SEEK_END, videoEvents
+  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';
@@ -30,8 +35,12 @@ function getPlayerMock() {
     getWidth: function () {},
     getFullscreen: function () {},
     getPlaylistItem: function () {},
+    getDuration: function () {},
     playAd: function () {},
-    on: function () { return this; },
+    loadAdXml: function () {},
+    on: function (eventName, handler) {
+      return this;
+    },
     off: function () { return this; },
     remove: function () {},
     getAudioTracks: function () {},
@@ -61,7 +70,7 @@ function getUtilsMock() {
     getPlaybackMethod: function () {},
     isOmidSupported: function () {},
     getSkipParams: function () {},
-    getJwEvent: event => event,
+    getJwEvent: utils.getJwEvent,
     getIsoLanguageCode: function () {},
     getSegments: function () {},
     getContentDatum: function () {}
@@ -370,207 +379,1558 @@ describe('JWPlayerProvider', function () {
       const eventName = offSpy.args[0][0];
       expect(eventName).to.be.equal('adViewableImpression');
     });
-  });
 
-  describe('destroy', function () {
-    it('should remove and null the player', function () {
+    it('should handle setup complete callbacks', function () {
       const player = getPlayerMock();
-      const removeSpy = player.remove = sinon.spy();
-      player.remove = removeSpy;
+      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();
-      provider.destroy();
-      provider.destroy();
-      expect(removeSpy.calledOnce).to.be.true;
+      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');
     });
-  });
-});
 
-describe('adStateFactory', function () {
-  const adState = adStateFactory();
+    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');
+    });
 
-  beforeEach(() => {
-    adState.clearState();
-  });
+    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 update state for ad events', function () {
-    const tag = 'tag';
-    const adPosition = 'adPosition';
-    const timeLoading = 'timeLoading';
-    const id = 'id';
-    const description = 'description';
-    const adsystem = 'adsystem';
-    const adtitle = 'adtitle';
-    const advertiserId = 'advertiserId';
-    const advertiser = 'advertiser';
-    const dealId = 'dealId';
-    const linear = 'linear';
-    const vastversion = 'vastversion';
-    const mediaFile = 'mediaFile';
-    const adId = 'adId';
-    const universalAdId = 'universalAdId';
-    const creativeAdId = 'creativeAdId';
-    const creativetype = 'creativetype';
-    const clickThroughUrl = 'clickThroughUrl';
-    const witem = 'witem';
-    const wcount = 'wcount';
-    const podcount = 'podcount';
-    const sequence = 'sequence';
+    it('should handle AD_REQUEST event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
 
-    adState.updateForEvent({
-      tag,
-      adPosition,
-      timeLoading,
-      id,
-      description,
-      adsystem,
-      adtitle,
-      advertiserId,
-      advertiser,
-      dealId,
-      linear,
-      vastversion,
-      mediaFile,
-      adId,
-      universalAdId,
-      creativeAdId,
-      creativetype,
-      clickThroughUrl,
-      witem,
-      wcount,
-      podcount,
-      sequence
+      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');
     });
 
-    const state = adState.getState();
-    expect(state.adTagUrl).to.equal(tag);
-    expect(state.offset).to.equal(adPosition);
-    expect(state.loadTime).to.equal(timeLoading);
-    expect(state.vastAdId).to.equal(id);
-    expect(state.adDescription).to.equal(description);
-    expect(state.adServer).to.equal(adsystem);
-    expect(state.adTitle).to.equal(adtitle);
-    expect(state.advertiserId).to.equal(advertiserId);
-    expect(state.dealId).to.equal(dealId);
-    expect(state.linear).to.equal(linear);
-    expect(state.vastVersion).to.equal(vastversion);
-    expect(state.creativeUrl).to.equal(mediaFile);
-    expect(state.adId).to.equal(adId);
-    expect(state.universalAdId).to.equal(universalAdId);
-    expect(state.creativeId).to.equal(creativeAdId);
-    expect(state.creativeType).to.equal(creativetype);
-    expect(state.redirectUrl).to.equal(clickThroughUrl);
-    expect(state).to.have.property('adPlacementType');
-    expect(state.adPlacementType).to.be.undefined;
-    expect(state.waterfallIndex).to.equal(witem);
-    expect(state.waterfallCount).to.equal(wcount);
-    expect(state.adPodCount).to.equal(podcount);
-    expect(state.adPodIndex).to.equal(sequence);
-  });
+    it('should handle AD_BREAK_START event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
 
-  it('should convert placement to oRTB value', function () {
-    adState.updateForEvent({
-      placement: 'instream'
+      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');
     });
 
-    let state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.INSTREAM);
+    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
+      };
 
-    adState.updateForEvent({
-      placement: 'banner'
+      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);
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.BANNER);
+    it('should handle AD_STARTED event payload', function () {
+      const player = getPlayerMock();
+      const onSpy = sinon.spy();
+      player.on = onSpy;
 
-    adState.updateForEvent({
-      placement: 'article'
+      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);
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.ARTICLE);
+    it('should handle AD_IMPRESSION event payload', function () {
+      const player = getPlayerMock();
 
-    adState.updateForEvent({
-      placement: 'feed'
+      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 });
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.FEED);
+    it('should handle AD_TIME event payload', function () {
+      const player = getPlayerMock();
 
-    adState.updateForEvent({
-      placement: 'interstitial'
+      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);
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.INTERSTITIAL);
+    it('should handle AD_SKIPPED event payload', function () {
+      const player = getPlayerMock();
 
-    adState.updateForEvent({
-      placement: 'slider'
+      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);
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.SLIDER);
+    it('should handle AD_ERROR event payload', function () {
+      const player = getPlayerMock();
 
-    adState.updateForEvent({
-      placement: 'floating'
+      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);
     });
 
-    state = adState.getState();
-    expect(state.adPlacementType).to.be.equal(PLACEMENT.FLOATING);
-  });
-});
+    it('should handle AD_COMPLETE event payload', function () {
+      const player = getPlayerMock();
 
-describe('timeStateFactory', function () {
-  const timeState = timeStateFactory();
+      const adState = {
+        clearState: sinon.spy()
+      };
 
-  beforeEach(() => {
-    timeState.clearState();
-  });
+      const provider = JWPlayerProvider({ divId: 'test' }, makePlayerFactoryMock(player), adState, timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      const callback = sinon.spy();
 
-  it('should update state for VOD time event', function() {
-    const position = 5;
-    const test_duration = 30;
+      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 () {
+      const player = getPlayerMock();
+      const removeSpy = player.remove = sinon.spy();
+      player.remove = removeSpy;
+      const provider = JWPlayerProvider({ divId: 'test' }, makePlayerFactoryMock(player), adStateFactory(), timeStateFactory(), callbackStorageFactory(), getUtilsMock(), sharedUtils);
+      provider.init();
+      provider.destroy();
+      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 () {
+  let adState = adStateFactory();
+
+  beforeEach(() => {
+    adState.clearState();
+  });
+
+  it('should update state for ad events', function () {
+    const tag = 'tag';
+    const adPosition = 'adPosition';
+    const timeLoading = 'timeLoading';
+    const id = 'id';
+    const description = 'description';
+    const adsystem = 'adsystem';
+    const adtitle = 'adtitle';
+    const advertiserId = 'advertiserId';
+    const advertiser = 'advertiser';
+    const dealId = 'dealId';
+    const linear = 'linear';
+    const vastversion = 'vastversion';
+    const mediaFile = 'mediaFile';
+    const adId = 'adId';
+    const universalAdId = 'universalAdId';
+    const creativeAdId = 'creativeAdId';
+    const creativetype = 'creativetype';
+    const clickThroughUrl = 'clickThroughUrl';
+    const witem = 'witem';
+    const wcount = 'wcount';
+    const podcount = 'podcount';
+    const sequence = 'sequence';
+
+    adState.updateForEvent({
+      tag,
+      adPosition,
+      timeLoading,
+      id,
+      description,
+      adsystem,
+      adtitle,
+      advertiserId,
+      advertiser,
+      dealId,
+      linear,
+      vastversion,
+      mediaFile,
+      adId,
+      universalAdId,
+      creativeAdId,
+      creativetype,
+      clickThroughUrl,
+      witem,
+      wcount,
+      podcount,
+      sequence
+    });
+
+    const state = adState.getState();
+    expect(state.adTagUrl).to.equal(tag);
+    expect(state.offset).to.equal(adPosition);
+    expect(state.loadTime).to.equal(timeLoading);
+    expect(state.vastAdId).to.equal(id);
+    expect(state.adDescription).to.equal(description);
+    expect(state.adServer).to.equal(adsystem);
+    expect(state.adTitle).to.equal(adtitle);
+    expect(state.advertiserId).to.equal(advertiserId);
+    expect(state.dealId).to.equal(dealId);
+    expect(state.linear).to.equal(linear);
+    expect(state.vastVersion).to.equal(vastversion);
+    expect(state.creativeUrl).to.equal(mediaFile);
+    expect(state.adId).to.equal(adId);
+    expect(state.universalAdId).to.equal(universalAdId);
+    expect(state.creativeId).to.equal(creativeAdId);
+    expect(state.creativeType).to.equal(creativetype);
+    expect(state.redirectUrl).to.equal(clickThroughUrl);
+    expect(state).to.have.property('adPlacementType');
+    expect(state.adPlacementType).to.be.undefined;
+    expect(state.waterfallIndex).to.equal(witem);
+    expect(state.waterfallCount).to.equal(wcount);
+    expect(state.adPodCount).to.equal(podcount);
+    expect(state.adPodIndex).to.equal(sequence);
+  });
+
+  it('should convert placement to oRTB value', function () {
+    adState.updateForEvent({
+      placement: 'instream'
+    });
+
+    let state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.INSTREAM);
+
+    adState.updateForEvent({
+      placement: 'banner'
+    });
+
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.BANNER);
+
+    adState.updateForEvent({
+      placement: 'article'
+    });
+
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.ARTICLE);
+
+    adState.updateForEvent({
+      placement: 'feed'
+    });
+
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.FEED);
+
+    adState.updateForEvent({
+      placement: 'interstitial'
+    });
+
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.INTERSTITIAL);
+
+    adState.updateForEvent({
+      placement: 'slider'
+    });
+
+    state = adState.getState();
+    expect(state.adPlacementType).to.be.equal(PLACEMENT.SLIDER);
+
+    adState.updateForEvent({
+      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'
+    });
+
+    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 () {
+  let timeState = timeStateFactory();
+
+  beforeEach(() => {
+    timeState.clearState();
+  });
+
+  it('should update state for VOD time event', function() {
+    const position = 5;
+    const test_duration = 30;
+
+    timeState.updateForEvent({
+      position,
+      duration: test_duration
+    });
+
+    const { time, duration, playbackMode } = timeState.getState();
+    expect(time).to.be.equal(position);
+    expect(duration).to.be.equal(test_duration);
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.VOD);
+  });
+
+  it('should update state for LIVE time events', function() {
+    const position = 0;
+    const test_duration = 0;
+
+    timeState.updateForEvent({
+      position,
+      duration: test_duration
+    });
+
+    const { time, duration, playbackMode } = timeState.getState();
+    expect(time).to.be.equal(position);
+    expect(duration).to.be.equal(test_duration);
+    expect(playbackMode).to.be.equal(PLAYBACK_MODE.LIVE);
+  });
+
+  it('should update state for DVR time events', function() {
+    const position = -5;
+    const test_duration = -30;
+
+    timeState.updateForEvent({
+      position,
+      duration: test_duration
+    });
+
+    const { time, duration, playbackMode } = timeState.getState();
+    expect(time).to.be.equal(position);
+    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.updateForEvent({
-      position,
-      duration: test_duration
+    timeState.updateState({
+      playbackMode: PLAYBACK_MODE.VOD
     });
 
-    const { time, duration, playbackMode } = timeState.getState();
-    expect(time).to.be.equal(position);
-    expect(duration).to.be.equal(test_duration);
-    expect(playbackMode).to.be.equal(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 update state for LIVE time events', function() {
-    const position = 0;
-    const test_duration = 0;
-
+  it('should handle zero duration as LIVE mode', function() {
     timeState.updateForEvent({
-      position,
-      duration: test_duration
+      position: 0,
+      duration: 0
     });
 
-    const { time, duration, playbackMode } = timeState.getState();
-    expect(time).to.be.equal(position);
-    expect(duration).to.be.equal(test_duration);
+    const { playbackMode } = timeState.getState();
     expect(playbackMode).to.be.equal(PLAYBACK_MODE.LIVE);
   });
 
-  it('should update state for DVR time events', function() {
-    const position = -5;
-    const test_duration = -30;
-
+  it('should handle negative duration as DVR mode', function() {
     timeState.updateForEvent({
-      position,
-      duration: test_duration
+      position: -10,
+      duration: -60
     });
 
-    const { time, duration, playbackMode } = timeState.getState();
-    expect(time).to.be.equal(position);
-    expect(duration).to.be.equal(test_duration);
+    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 () {
@@ -613,6 +1973,133 @@ 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 () {
@@ -717,6 +2204,79 @@ 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 () {
@@ -733,6 +2293,16 @@ describe('utils', function () {
       const playerMock = { getHeight: () => undefined };
       expect(getPlayerHeight(playerMock, { 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 () {
@@ -754,6 +2324,16 @@ describe('utils', function () {
       const playerMock = { getWidth: () => undefined };
       expect(getPlayerWidth(playerMock, { 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 () {
@@ -791,6 +2371,19 @@ describe('utils', function () {
     it('should return the container height when smaller than the calculated height', function () {
       expect(getPlayerSizeFromAspectRatio({ getContainer: () => testContainer }, {aspectratio: '1:1', width: '100%'})).to.deep.equal({ height: 480, 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 () {
@@ -819,6 +2412,24 @@ 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 () {
@@ -831,6 +2442,39 @@ 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 () {
@@ -877,6 +2521,25 @@ describe('utils', function () {
       const placement = getPlacement({ outstream: true }, 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() {
@@ -922,6 +2585,29 @@ 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 () {
@@ -949,6 +2635,16 @@ 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 () {
@@ -993,6 +2689,38 @@ 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 () {
@@ -1006,6 +2734,18 @@ 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 () {
@@ -1022,6 +2762,30 @@ 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 () {
@@ -1035,6 +2799,7 @@ describe('utils', function () {
       expect(getContentDatum('id1', segments)).to.deep.equal({
         name: 'jwplayer.com',
         segment: segments,
+        cids: ['id1'],
         ext: { cids: ['id1'], segtax: 502 }
       });
     });
@@ -1042,8 +2807,42 @@ 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;
+    });
   });
 });