prebid.js 7.22.0 → 7.23.1

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

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

@@ -0,0 +1,103 @@
+import { buildVastWrapper, getVastNode, getAdNode, getWrapperNode, getAdSystemNode,
+  getAdTagUriNode, getErrorNode, getImpressionNode } from 'libraries/video/shared/vastXmlBuilder.js';
+import { expect } from 'chai';
+
+describe('buildVastWrapper', function () {
+  it('should include impression and error nodes when requested', function () {
+    const vastXml = buildVastWrapper(
+      'adId123',
+      'http://wwww.testUrl.com/redirectUrl.xml',
+      'http://wwww.testUrl.com/impression.jpg',
+      'impressionId123',
+      'http://wwww.testUrl.com/error.jpg'
+    );
+    expect(vastXml).to.be.equal(`<VAST version="4.2"><Ad id="adId123"><Wrapper><AdSystem version="${$$PREBID_GLOBAL$$.version}">Prebid org</AdSystem><VASTAdTagURI><![CDATA[http://wwww.testUrl.com/redirectUrl.xml]]></VASTAdTagURI><Impression id="impressionId123"><![CDATA[http://wwww.testUrl.com/impression.jpg]]></Impression><Error><![CDATA[http://wwww.testUrl.com/error.jpg]]></Error></Wrapper></Ad></VAST>`);
+  });
+
+  it('should omit error nodes when excluded', function () {
+    const vastXml = buildVastWrapper(
+      'adId123',
+      'http://wwww.testUrl.com/redirectUrl.xml',
+      'http://wwww.testUrl.com/impression.jpg',
+      'impressionId123',
+    );
+    expect(vastXml).to.be.equal(`<VAST version="4.2"><Ad id="adId123"><Wrapper><AdSystem version="${$$PREBID_GLOBAL$$.version}">Prebid org</AdSystem><VASTAdTagURI><![CDATA[http://wwww.testUrl.com/redirectUrl.xml]]></VASTAdTagURI><Impression id="impressionId123"><![CDATA[http://wwww.testUrl.com/impression.jpg]]></Impression></Wrapper></Ad></VAST>`);
+  });
+
+  it('should omit impression nodes when excluded', function () {
+    const vastXml = buildVastWrapper(
+      'adId123',
+      'http://wwww.testUrl.com/redirectUrl.xml',
+    );
+    expect(vastXml).to.be.equal(`<VAST version="4.2"><Ad id="adId123"><Wrapper><AdSystem version="${$$PREBID_GLOBAL$$.version}">Prebid org</AdSystem><VASTAdTagURI><![CDATA[http://wwww.testUrl.com/redirectUrl.xml]]></VASTAdTagURI></Wrapper></Ad></VAST>`);
+  });
+});
+
+describe('getVastNode', function () {
+  it('should return well formed Vast node', function () {
+    const vastNode = getVastNode('body', '4.0');
+    expect(vastNode).to.be.equal('<VAST version=\"4.0\">body</VAST>');
+  });
+
+  it('should omit version when missing', function() {
+    const vastNode = getVastNode('body');
+    expect(vastNode).to.be.equal('<VAST>body</VAST>');
+  });
+});
+
+describe('getAdNode', function () {
+  it('should return well formed Ad node', function () {
+    const adNode = getAdNode('body', 'adId123');
+    expect(adNode).to.be.equal('<Ad id=\"adId123\">body</Ad>');
+  });
+
+  it('should omit id when missing', function() {
+    const adNode = getAdNode('body');
+    expect(adNode).to.be.equal('<Ad>body</Ad>');
+  });
+});
+
+describe('getWrapperNode', function () {
+  it('should return well formed Wrapper node', function () {
+    const wrapperNode = getWrapperNode('body');
+    expect(wrapperNode).to.be.equal('<Wrapper>body</Wrapper>');
+  });
+});
+
+describe('getAdSystemNode', function () {
+  it('should return well formed AdSystem node', function () {
+    const adSystemNode = getAdSystemNode('testSysName', '5.0');
+    expect(adSystemNode).to.be.equal('<AdSystem version=\"5.0\">testSysName</AdSystem>');
+  });
+
+  it('should omit version when missing', function() {
+    const adSystemNode = getAdSystemNode('testSysName');
+    expect(adSystemNode).to.be.equal('<AdSystem>testSysName</AdSystem>');
+  });
+});
+
+describe('getAdTagUriNode', function () {
+  it('should return well formed ad tag URI node', function () {
+    const adTagNode = getAdTagUriNode('http://wwww.testUrl.com/ad.xml');
+    expect(adTagNode).to.be.equal('<VASTAdTagURI><![CDATA[http://wwww.testUrl.com/ad.xml]]></VASTAdTagURI>');
+  });
+});
+
+describe('getImpressionNode', function () {
+  it('should return well formed Impression node', function () {
+    const impressionNode = getImpressionNode('http://wwww.testUrl.com/adImpression.jpg', 'impresionId123');
+    expect(impressionNode).to.be.equal('<Impression id=\"impresionId123\"><![CDATA[http://wwww.testUrl.com/adImpression.jpg]]></Impression>');
+  });
+
+  it('should omit id when missing', function() {
+    const impressionNode = getImpressionNode('http://wwww.testUrl.com/adImpression.jpg');
+    expect(impressionNode).to.be.equal('<Impression><![CDATA[http://wwww.testUrl.com/adImpression.jpg]]></Impression>');
+  });
+});
+
+describe('getErrorNode', function () {
+  it('should return well formed Error node', function () {
+    const errorNode = getErrorNode('http://wwww.testUrl.com/adError.jpg');
+    expect(errorNode).to.be.equal('<Error><![CDATA[http://wwww.testUrl.com/adError.jpg]]></Error>');
+  });
+});