prebid.js 7.22.0 → 7.24.0

package/test/spec/modules/userId_spec.js

@@ -9,7 +9,7 @@ import {
   setSubmoduleRegistry,
   syncDelay,
   PBJS_USER_ID_OPTOUT_NAME,
-  findRootDomain,
+  findRootDomain, requestDataDeletion,
 } from 'modules/userId/index.js';
 import {createEidsArray} from 'modules/userId/eids.js';
 import {config} from 'src/config.js';
@@ -2703,6 +2703,72 @@ describe('User ID', function () {
       });
     });
 
+    describe('requestDataDeletion', () => {
+      function idMod(name, value) {
+        return {
+          name,
+          getId() {
+            return {id: value}
+          },
+          decode(d) {
+            return {[name]: d}
+          },
+          onDataDeletionRequest: sinon.stub()
+        }
+      }
+      let mod1, mod2, mod3, cfg1, cfg2, cfg3;
+
+      beforeEach(() => {
+        init(config);
+        mod1 = idMod('id1', 'val1');
+        mod2 = idMod('id2', 'val2');
+        mod3 = idMod('id3', 'val3');
+        cfg1 = getStorageMock('id1', 'id1', 'cookie');
+        cfg2 = getStorageMock('id2', 'id2', 'html5');
+        cfg3 = {name: 'id3', value: {id3: 'val3'}};
+        setSubmoduleRegistry([mod1, mod2, mod3]);
+        config.setConfig({
+          auctionDelay: 1,
+          userSync: {
+            userIds: [cfg1, cfg2, cfg3]
+          }
+        });
+        return getGlobal().refreshUserIds();
+      });
+
+      it('deletes stored IDs', () => {
+        expect(coreStorage.getCookie('id1')).to.exist;
+        expect(coreStorage.getDataFromLocalStorage('id2')).to.exist;
+        requestDataDeletion(sinon.stub());
+        expect(coreStorage.getCookie('id1')).to.not.exist;
+        expect(coreStorage.getDataFromLocalStorage('id2')).to.not.exist;
+      });
+
+      it('invokes onDataDeletionRequest', () => {
+        requestDataDeletion(sinon.stub());
+        sinon.assert.calledWith(mod1.onDataDeletionRequest, cfg1, {id1: 'val1'});
+        sinon.assert.calledWith(mod2.onDataDeletionRequest, cfg2, {id2: 'val2'})
+        sinon.assert.calledWith(mod3.onDataDeletionRequest, cfg3, {id3: 'val3'})
+      });
+
+      describe('does not choke when onDataDeletionRequest', () => {
+        Object.entries({
+          'is missing': () => { delete mod1.onDataDeletionRequest },
+          'throws': () => { mod1.onDataDeletionRequest.throws(new Error()) }
+        }).forEach(([t, setup]) => {
+          it(t, () => {
+            setup();
+            const next = sinon.stub();
+            const arg = {random: 'value'};
+            requestDataDeletion(next, arg);
+            sinon.assert.calledOnce(mod2.onDataDeletionRequest);
+            sinon.assert.calledOnce(mod3.onDataDeletionRequest);
+            sinon.assert.calledWith(next, arg);
+          })
+        })
+      })
+    });
+
     describe('findRootDomain', function () {
       let sandbox;
 

package/test/spec/modules/videoModule/coreVideo_spec.js

@@ -0,0 +1,98 @@
+import { expect } from 'chai';
+import { VideoCore } from 'modules/videoModule/coreVideo.js';
+
+describe('Video Core', function () {
+  const mockSubmodule = {
+    getOrtbVideo: sinon.spy(),
+    getOrtbContent: sinon.spy(),
+    setAdTagUrl: sinon.spy(),
+    onEvent: sinon.spy(),
+    offEvent: sinon.spy(),
+  };
+
+  const otherSubmodule = {
+    getOrtbVideo: () => {},
+    getOrtbContent: () => {},
+    setAdTagUrl: () => {},
+    onEvent: () => {},
+    offEvent: () => {},
+  };
+
+  const testId = 'test_id';
+  const testVendorCode = 0;
+  const otherId = 'other_id';
+  const otherVendorCode = 1;
+
+  const parentModuleMock = {
+    registerSubmodule: sinon.spy(),
+    getSubmodule: sinon.spy(id => {
+      if (id === testId) {
+        return mockSubmodule;
+      } else if (id === otherId) {
+        return otherSubmodule;
+      }
+    })
+  };
+
+  const videoCore = VideoCore(parentModuleMock);
+
+  videoCore.registerProvider({
+    vendorCode: testVendorCode,
+    divId: testId
+  });
+
+  videoCore.registerProvider({
+    vendorCode: otherVendorCode,
+    divId: otherId
+  });
+
+  describe('registerProvider', function () {
+    it('should delegate the registration to the Parent Module', function () {
+      expect(parentModuleMock.registerSubmodule.calledTwice).to.be.true;
+      expect(parentModuleMock.registerSubmodule.args[0][0]).to.be.equal(testId);
+      expect(parentModuleMock.registerSubmodule.args[1][0]).to.be.equal(otherId);
+      expect(parentModuleMock.registerSubmodule.args[0][1]).to.be.equal(testVendorCode);
+      expect(parentModuleMock.registerSubmodule.args[1][1]).to.be.equal(otherVendorCode);
+    });
+  });
+
+  describe('getOrtbVideo', function () {
+    it('delegates to the submodule of the right divId', function () {
+      videoCore.getOrtbVideo(testId);
+      videoCore.getOrtbVideo(otherId);
+      expect(mockSubmodule.getOrtbVideo.calledOnce).to.be.true;
+    });
+  });
+
+  describe('getOrtbContent', function () {
+    it('delegates to the submodule of the right divId', function () {
+      videoCore.getOrtbContent(testId);
+      videoCore.getOrtbContent(otherId);
+      expect(mockSubmodule.getOrtbContent.calledOnce).to.be.true;
+    });
+  });
+
+  describe('setAdTagUrl', function () {
+    it('delegates to the submodule of the right divId', function () {
+      videoCore.setAdTagUrl('', testId);
+      videoCore.setAdTagUrl('', otherId);
+      expect(mockSubmodule.setAdTagUrl.calledOnce).to.be.true;
+    });
+  });
+
+  describe('onEvents', function () {
+    it('delegates to the submodule of the right divId', function () {
+      videoCore.onEvents(['event'], () => {}, testId);
+      videoCore.onEvents(['event'], () => {}, otherId);
+      expect(mockSubmodule.onEvent.calledOnce).to.be.true;
+    });
+  });
+
+  describe('offEvents', function () {
+    it('delegates to the submodule of the right divId', function () {
+      videoCore.offEvents(['event'], () => {}, testId);
+      videoCore.offEvents(['event'], () => {}, otherId);
+      expect(mockSubmodule.offEvent.calledOnce).to.be.true;
+    });
+  });
+});

package/test/spec/modules/videoModule/pbVideo_spec.js

@@ -0,0 +1,362 @@
+import { expect } from 'chai';
+import { PbVideo } from 'modules/videoModule';
+import CONSTANTS from 'src/constants.json';
+
+let ortbVideoMock;
+let ortbContentMock;
+let videoCoreMock;
+let getConfigMock;
+let requestBidsMock;
+let pbGlobalMock;
+let pbEventsMock;
+let videoEventsMock;
+let gamSubmoduleMock;
+let gamSubmoduleFactoryMock;
+let videoImpressionVerifierFactoryMock;
+let videoImpressionVerifierMock;
+
+function resetTestVars() {
+  ortbVideoMock = {};
+  ortbContentMock = {};
+  videoCoreMock = {
+    registerProvider: sinon.spy(),
+    onEvents: sinon.spy(),
+    getOrtbVideo: () => ortbVideoMock,
+    getOrtbContent: () => ortbContentMock,
+    setAdTagUrl: sinon.spy()
+  };
+  getConfigMock = () => {};
+  requestBidsMock = {
+    before: sinon.spy()
+  };
+  pbGlobalMock = {
+    requestBids: requestBidsMock,
+    getHighestCpmBids: sinon.spy(),
+    getBidResponsesForAdUnitCode: sinon.spy(),
+    setConfig: sinon.spy(),
+    getConfig: () => ({}),
+    markWinningBidAsUsed: sinon.spy()
+  };
+  pbEventsMock = {
+    emit: sinon.spy(),
+    on: sinon.spy()
+  };
+  videoEventsMock = [];
+  gamSubmoduleMock = {
+    getAdTagUrl: sinon.spy()
+  };
+
+  gamSubmoduleFactoryMock = sinon.spy(() => gamSubmoduleMock);
+
+  videoImpressionVerifierMock = {
+    trackBid: sinon.spy(),
+    getBidIdentifiers: sinon.spy()
+  };
+
+  videoImpressionVerifierFactoryMock = () => videoImpressionVerifierMock;
+}
+
+let pbVideoFactory = (videoCore, getConfig, pbGlobal, pbEvents, videoEvents, gamSubmoduleFactory, videoImpressionVerifierFactory) => {
+  const pbVideo = PbVideo(
+    videoCore || videoCoreMock,
+    getConfig || getConfigMock,
+    pbGlobal || pbGlobalMock,
+    pbEvents || pbEventsMock,
+    videoEvents || videoEventsMock,
+    gamSubmoduleFactory || gamSubmoduleFactoryMock,
+    videoImpressionVerifierFactory || videoImpressionVerifierFactoryMock
+  );
+  pbVideo.init();
+  return pbVideo;
+}
+
+describe('Prebid Video', function () {
+  beforeEach(() => resetTestVars());
+
+  describe('Setting video to config', function () {
+    let providers = [{ divId: 'div1' }, { divId: 'div2' }];
+    let getConfigCallback;
+    let getConfig = (propertyName, callback) => {
+      if (propertyName === 'video') {
+        getConfigCallback = callback;
+      }
+    };
+
+    beforeEach(() => {
+      pbVideoFactory(null, getConfig);
+      getConfigCallback({ video: { providers } });
+    });
+
+    it('Should register providers', function () {
+      expect(videoCoreMock.registerProvider.calledTwice).to.be.true;
+    });
+
+    it('Should register events', function () {
+      expect(videoCoreMock.onEvents.calledTwice).to.be.true;
+      const onEventsSpy = videoCoreMock.onEvents;
+      expect(onEventsSpy.getCall(0).args[2]).to.be.equal('div1');
+      expect(onEventsSpy.getCall(1).args[2]).to.be.equal('div2');
+    });
+
+    describe('Event triggering', function () {
+      it('Should emit events off of Prebid\'s Events', function () {
+        let eventHandler;
+        const videoCore = Object.assign({}, videoCoreMock, {
+          onEvents: (events, eventHandler_) => eventHandler = eventHandler_
+        });
+        pbVideoFactory(videoCore, getConfig);
+        getConfigCallback({ video: { providers } });
+        const expectedType = 'test_event';
+        const expectedPayload = {'test': 'data'};
+        eventHandler(expectedType, expectedPayload);
+        expect(pbEventsMock.emit.calledOnce).to.be.true;
+        expect(pbEventsMock.emit.getCall(0).args[0]).to.be.equal('video' + expectedType.replace(/^./, expectedType[0].toUpperCase()));
+        expect(pbEventsMock.emit.getCall(0).args[1]).to.be.equal(expectedPayload);
+      });
+    });
+
+    describe('Ad Server configuration', function() {
+      const test_vendor_code = 5;
+      const test_params = { test: 'params' };
+      providers[0].adServer = { vendorCode: test_vendor_code, params: test_params };
+
+      it('should instantiate the GAM Submodule', function () {
+        expect(gamSubmoduleFactoryMock.calledOnce).to.be.true;
+      });
+    });
+  });
+
+  describe('Ad unit Enrichment', function () {
+    it('registers before:bidRequest hook', function () {
+      pbVideoFactory();
+      expect(requestBidsMock.before.calledOnce).to.be.true;
+    });
+
+    it('requests oRtb params and writes them to ad unit and config', function() {
+      const getOrtbVideoSpy = videoCoreMock.getOrtbVideo = sinon.spy(() => ({
+        test: 'videoTestValue'
+      }));
+      const getOrtbContentSpy = videoCoreMock.getOrtbContent = sinon.spy(() => ({
+        test: 'contentTestValue'
+      }));
+
+      let beforeBidRequestCallback;
+      const requestBids = {
+        before: callback_ => beforeBidRequestCallback = callback_
+      };
+
+      pbVideoFactory(null, null, Object.assign({}, pbGlobalMock, { requestBids }));
+      expect(beforeBidRequestCallback).to.not.be.undefined;
+      const nextFn = sinon.spy();
+      const adUnits = [{
+        code: 'ad1',
+        mediaTypes: {
+          video: {}
+        },
+        video: { divId: 'divId' }
+      }];
+      beforeBidRequestCallback(nextFn, { adUnits });
+      expect(getOrtbVideoSpy.calledOnce).to.be.true;
+      expect(getOrtbContentSpy.calledOnce).to.be.true;
+      const adUnit = adUnits[0];
+      expect(adUnit.mediaTypes.video).to.have.property('test', 'videoTestValue');
+      expect(nextFn.calledOnce).to.be.true;
+      expect(nextFn.getCall(0).args[0].ortb2).to.be.deep.equal({ site: { content: { test: 'contentTestValue' } } });
+    });
+  });
+
+  describe('Ad tag injection', function () {
+    let auctionEndCallback;
+    let providers = [{ divId: 'div1', adServer: {} }, { divId: 'div2' }];
+    let getConfig = (propertyName, callbackFn) => {
+      if (propertyName === 'video') {
+        if (callbackFn) {
+          callbackFn({ video: { providers } });
+        } else {
+          return { providers };
+        }
+      }
+    };
+
+    const pbEvents = {
+      emit: () => {},
+      on: (event, callback) => {
+        if (event === CONSTANTS.EVENTS.AUCTION_END) {
+          auctionEndCallback = callback
+        }
+      },
+      off: () => {}
+    };
+
+    const expectedVendorCode = 5;
+    const expectedAdTag = 'test_tag';
+    const expectedAdUnitCode = 'expectedAdUnitcode';
+    const expectedDivId = 'expectedDivId';
+    const expectedAdUnit = {
+      code: expectedAdUnitCode,
+      video: {
+        divId: expectedDivId,
+        adServer: {
+          vendorCode: expectedVendorCode,
+          baseAdTagUrl: expectedAdTag
+        }
+      }
+    };
+    const auctionResults = { adUnits: [ expectedAdUnit, {} ] };
+
+    beforeEach(() => {
+      gamSubmoduleMock.getAdTagUrl.resetHistory();
+      videoCoreMock.setAdTagUrl.resetHistory();
+    });
+
+    let beforeBidRequestCallback;
+    const requestBids = {
+      before: callback_ => beforeBidRequestCallback = callback_
+    };
+
+    it('should request ad tag url from adServer when configured to use adServer', function () {
+      const expectedVastUrl = 'expectedVastUrl';
+      const expectedVastXml = 'expectedVastXml';
+      const pbGlobal = Object.assign({}, pbGlobalMock, {
+        requestBids,
+        getHighestCpmBids: () => [{
+          vastUrl: expectedVastUrl,
+          vastXml: expectedVastXml
+        }, {}, {}, {}]
+      });
+      pbVideoFactory(null, getConfig, pbGlobal, pbEvents);
+
+      beforeBidRequestCallback(() => {}, {});
+      auctionEndCallback(auctionResults);
+      expect(gamSubmoduleMock.getAdTagUrl.calledOnce).to.be.true;
+      expect(gamSubmoduleMock.getAdTagUrl.getCall(0).args[0]).is.equal(expectedAdUnit);
+      expect(gamSubmoduleMock.getAdTagUrl.getCall(0).args[1]).is.equal(expectedAdTag);
+    });
+
+    it('should load ad tag when ad server returns ad tag', function () {
+      const expectedAdTag = 'resulting ad tag';
+      const gamSubmoduleFactory = () => ({
+        getAdTagUrl: () => expectedAdTag
+      });
+      const expectedVastUrl = 'expectedVastUrl';
+      const expectedVastXml = 'expectedVastXml';
+      const pbGlobal = Object.assign({}, pbGlobalMock, {
+        requestBids,
+        getHighestCpmBids: () => [{
+          vastUrl: expectedVastUrl,
+          vastXml: expectedVastXml
+        }, {}, {}, {}]
+      });
+      pbVideoFactory(null, getConfig, pbGlobal, pbEvents, null, gamSubmoduleFactory);
+      beforeBidRequestCallback(() => {}, {});
+      auctionEndCallback(auctionResults);
+      expect(videoCoreMock.setAdTagUrl.calledOnce).to.be.true;
+      expect(videoCoreMock.setAdTagUrl.args[0][0]).to.be.equal(expectedAdTag);
+      expect(videoCoreMock.setAdTagUrl.args[0][1]).to.be.equal(expectedDivId);
+      expect(videoCoreMock.setAdTagUrl.args[0][2]).to.have.property('adUnitCode', expectedAdUnitCode);
+    });
+
+    it('should load ad tag from highest bid when ad server is not configured', function () {
+      const expectedVastUrl = 'expectedVastUrl';
+      const expectedVastXml = 'expectedVastXml';
+      const pbGlobal = Object.assign({}, pbGlobalMock, {
+        requestBids,
+        getHighestCpmBids: () => [{
+          vastUrl: expectedVastUrl,
+          vastXml: expectedVastXml
+        }, {}, {}, {}]
+      });
+      const expectedAdUnit = {
+        code: expectedAdUnitCode,
+        video: { divId: expectedDivId }
+      };
+      const auctionResults = { adUnits: [ expectedAdUnit, {} ] };
+
+      pbVideoFactory(null, () => ({ providers: [] }), pbGlobal, pbEvents);
+      beforeBidRequestCallback(() => {}, {});
+      auctionEndCallback(auctionResults);
+      expect(videoCoreMock.setAdTagUrl.calledOnce).to.be.true;
+      expect(videoCoreMock.setAdTagUrl.args[0][0]).to.be.equal(expectedVastUrl);
+      expect(videoCoreMock.setAdTagUrl.args[0][1]).to.be.equal(expectedDivId);
+      expect(videoCoreMock.setAdTagUrl.args[0][2]).to.have.property('adUnitCode', expectedAdUnitCode);
+      expect(videoCoreMock.setAdTagUrl.args[0][2]).to.have.property('adXml', expectedVastXml);
+    });
+  });
+
+  describe('Ad tracking', function () {
+    const expectedAdEventPayload = { adEventPayloadMarker: 'marker' };
+    const expectedBid = { bidMarker: 'marker' };
+    let bidAdjustmentCb;
+    let adImpressionCb;
+    let adErrorCb;
+
+    const pbEvents = {
+      on: (event, callback) => {
+        if (event === CONSTANTS.EVENTS.BID_ADJUSTMENT) {
+          bidAdjustmentCb = callback;
+        } else if (event === 'videoAdImpression') {
+          adImpressionCb = callback;
+        } else if (event === 'videoAdError') {
+          adErrorCb = callback;
+        }
+      },
+      emit: sinon.spy()
+    };
+
+    it('should ask Impression Verifier to track bid on Bid Adjustment', function () {
+      pbVideoFactory(null, null, null, pbEvents);
+      bidAdjustmentCb();
+      expect(videoImpressionVerifierMock.trackBid.calledOnce).to.be.true;
+    });
+
+    it('should trigger video bid impression when the bid matched', function () {
+      pbEvents.emit.resetHistory();
+      const pbGlobal = Object.assign({}, pbGlobalMock, { getBidResponsesForAdUnitCode: () => ({ bids: [expectedBid] }) });
+      const videoImpressionVerifier = Object.assign({}, videoImpressionVerifierMock, { getBidIdentifiers: () => ({}) });
+      pbVideoFactory(null, null, pbGlobal, pbEvents, null, null, () => videoImpressionVerifier);
+      adImpressionCb(expectedAdEventPayload);
+
+      expect(pbEvents.emit.calledOnce).to.be.true;
+      expect(pbEvents.emit.getCall(0).args[0]).to.be.equal('videoBidImpression');
+      const payload = pbEvents.emit.getCall(0).args[1];
+      expect(payload.bid).to.be.equal(expectedBid);
+      expect(payload.adEvent).to.be.equal(expectedAdEventPayload);
+      expect(pbGlobal.markWinningBidAsUsed.calledOnce).to.be.true;
+    });
+
+    it('should trigger video bid error when the bid matched', function () {
+      pbEvents.emit.resetHistory();
+      const pbGlobal = Object.assign({}, pbGlobalMock, { getBidResponsesForAdUnitCode: () => ({ bids: [expectedBid] }) });
+      const videoImpressionVerifier = Object.assign({}, videoImpressionVerifierMock, { getBidIdentifiers: () => ({}) });
+      pbVideoFactory(null, null, pbGlobal, pbEvents, null, null, () => videoImpressionVerifier);
+      adErrorCb(expectedAdEventPayload);
+
+      expect(pbEvents.emit.calledOnce).to.be.true;
+      expect(pbEvents.emit.getCall(0).args[0]).to.be.equal('videoBidError');
+      const payload = pbEvents.emit.getCall(0).args[1];
+      expect(payload.bid).to.be.equal(expectedBid);
+      expect(payload.adEvent).to.be.equal(expectedAdEventPayload);
+      expect(pbGlobal.markWinningBidAsUsed.calledOnce).to.be.true;
+    });
+
+    it('should not trigger a bid impression when the bid did not match', function () {
+      pbEvents.emit.resetHistory();
+      const pbGlobal = Object.assign({}, pbGlobalMock, { getBidResponsesForAdUnitCode: () => ({ bids: [expectedBid] }) });
+      const videoImpressionVerifier = Object.assign({}, videoImpressionVerifierMock, { getBidIdentifiers: () => ({ auctionId: 'id' }) });
+      pbVideoFactory(null, null, pbGlobal, pbEvents, null, null, () => videoImpressionVerifier);
+      adImpressionCb(expectedAdEventPayload);
+
+      expect(pbEvents.emit.called).to.be.false;
+    });
+
+    it('should not trigger a bid error when the bid did not match', function () {
+      pbEvents.emit.resetHistory();
+      const pbGlobal = Object.assign({}, pbGlobalMock, { getBidResponsesForAdUnitCode: () => ({ bids: [expectedBid] }) });
+      const videoImpressionVerifier = Object.assign({}, videoImpressionVerifierMock, { getBidIdentifiers: () => ({ auctionId: 'id' }) });
+      pbVideoFactory(null, null, pbGlobal, pbEvents, null, null, () => videoImpressionVerifier);
+      adErrorCb(expectedAdEventPayload);
+
+      expect(pbEvents.emit.called).to.be.false;
+    });
+  });
+});

package/test/spec/modules/videoModule/shared/parentModule_spec.js

@@ -0,0 +1,73 @@
+import { SubmoduleBuilder, ParentModule } from 'libraries/video/shared/parentModule.js';
+import { expect } from 'chai';
+
+describe('Parent Module', function() {
+  const idForMock = 0;
+  const vendorCodeForMock = 'a';
+  const unrecognizedId = 999;
+  const unrecognizedVendorCode = 'zzz';
+  const mockSubmodule = { test: 'test' };
+  const mockSubmoduleBuilder = {
+    build: vendorCode => {
+      if (vendorCode === vendorCodeForMock) {
+        return mockSubmodule;
+      } else {
+        throw new Error('flawed');
+      }
+    }
+  };
+  const parentModule = ParentModule(mockSubmoduleBuilder);
+
+  describe('Register Submodule', function () {
+    it('should throw when the builder fails to build', function () {
+      expect(() => parentModule.registerSubmodule(unrecognizedId, unrecognizedVendorCode)).to.throw('flawed');
+    });
+  });
+
+  describe('Get Submodule', function () {
+    it('should return registered submodules', function () {
+      parentModule.registerSubmodule(idForMock, vendorCodeForMock);
+      const submodule = parentModule.getSubmodule(idForMock);
+      expect(submodule).to.be.equal(mockSubmodule);
+    });
+
+    it('should return undefined when submodule is not registered', function () {
+      const submodule = parentModule.getSubmodule(unrecognizedId);
+      expect(submodule).to.be.undefined;
+    });
+  })
+});
+
+describe('Submodule Builder', function () {
+  const vendorCode1 = 1;
+  const vendorCode2 = 2;
+  const submodule1 = {};
+  const initSpy = sinon.spy();
+  const submodule2 = { init: initSpy };
+  const submoduleFactory1 = () => submodule1;
+  const submoduleFactory2 = () => submodule2;
+  const submoduleFactory1Spy = sinon.spy(submoduleFactory1);
+
+  const vendorDirectory = {};
+  vendorDirectory[vendorCode1] = submoduleFactory1Spy;
+  vendorDirectory[vendorCode2] = submoduleFactory2;
+
+  const submoduleBuilder = SubmoduleBuilder(vendorDirectory);
+
+  it('should call submodule factory when vendor code is supported', function () {
+    const submodule = submoduleBuilder.build(vendorCode1);
+    expect(submoduleFactory1Spy.calledOnce).to.be.true;
+    expect(submodule).to.be.equal(submodule1);
+  });
+
+  it('should instantiate the submodule, when supported', function () {
+    const submodule = submoduleBuilder.build(vendorCode2);
+    expect(initSpy.calledOnce).to.be.true;
+    expect(submodule).to.be.equal(submodule2);
+  });
+
+  it('should throw when vendor code is not recognized', function () {
+    const unrecognizedVendorCode = 999;
+    expect(() => submoduleBuilder.build(unrecognizedVendorCode)).to.throw('Unrecognized submodule vendor code: ' + unrecognizedVendorCode);
+  });
+});

package/test/spec/modules/videoModule/shared/state_spec.js

@@ -0,0 +1,26 @@
+import stateFactory from 'libraries/video/shared/state.js';
+import { expect } from 'chai';
+
+describe('State', function () {
+  let state = stateFactory();
+  beforeEach(() => {
+    state.clearState();
+  });
+
+  it('should update state', function () {
+    state.updateState({ 'test': 'a' });
+    expect(state.getState()).to.have.property('test', 'a');
+    state.updateState({ 'test': 'b' });
+    expect(state.getState()).to.have.property('test', 'b');
+    state.updateState({ 'test_2': 'c' });
+    expect(state.getState()).to.have.property('test', 'b');
+    expect(state.getState()).to.have.property('test_2', 'c');
+  });
+
+  it('should clear state', function () {
+    state.updateState({ 'test': 'a' });
+    state.clearState();
+    expect(state.getState()).to.not.have.property('test', 'a');
+    expect(state.getState()).to.be.empty;
+  });
+});