prebid.js 5.19.0 → 5.20.0

package/modules/yahoosspBidAdapter.js

@@ -144,9 +144,9 @@ function getAdapterMode() {
 
 function getResponseFormat(bid) {
   const adm = bid.adm;
-  if (adm.includes('o2playerSettings') || adm.includes('YAHOO.VideoPlatform.VideoPlayer') || adm.includes('AdPlacement')) {
+  if (adm.indexOf('o2playerSettings') !== -1 || adm.indexOf('YAHOO.VideoPlatform.VideoPlayer') !== -1 || adm.indexOf('AdPlacement') !== -1) {
     return BANNER;
-  } else if (adm.includes('VAST')) {
+  } else if (adm.indexOf('VAST') !== -1) {
     return VIDEO;
   }
 };
@@ -188,23 +188,23 @@ function validateAppendObject(validationType, allowedKeys, inputObject, appendTo
   for (const objectKey in inputObject) {
     switch (validationType) {
       case 'string':
-        if (allowedKeys.includes(objectKey) && isStr(inputObject[objectKey])) {
+        if (allowedKeys.indexOf(objectKey) !== -1 && isStr(inputObject[objectKey])) {
           outputObject[objectKey] = inputObject[objectKey];
         };
         break;
       case 'number':
-        if (allowedKeys.includes(objectKey) && isNumber(inputObject[objectKey])) {
+        if (allowedKeys.indexOf(objectKey) !== -1 && isNumber(inputObject[objectKey])) {
           outputObject[objectKey] = inputObject[objectKey];
         };
         break;
 
       case 'array':
-        if (allowedKeys.includes(objectKey) && isArray(inputObject[objectKey])) {
+        if (allowedKeys.indexOf(objectKey) !== -1 && isArray(inputObject[objectKey])) {
           outputObject[objectKey] = inputObject[objectKey];
         };
         break;
       case 'object':
-        if (allowedKeys.includes(objectKey) && isPlainObject(inputObject[objectKey])) {
+        if (allowedKeys.indexOf(objectKey) !== -1 && isPlainObject(inputObject[objectKey])) {
           outputObject[objectKey] = inputObject[objectKey];
         };
         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "5.19.0",
+  "version": "5.20.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

package/src/auction.js

@@ -613,7 +613,8 @@ export const getPriceGranularity = (mediaType, bidReq) => {
  * @returns {function}
  */
 export const getPriceByGranularity = (granularity) => {
-  return (bid) => {
+  return (bid, bidReq) => {
+    granularity = granularity || getPriceGranularity(bid.mediaType, bidReq);
     if (granularity === CONSTANTS.GRANULARITY_OPTIONS.AUTO) {
       return bid.pbAg;
     } else if (granularity === CONSTANTS.GRANULARITY_OPTIONS.DENSE) {
@@ -646,14 +647,14 @@ export const getAdvertiserDomain = () => {
  * @param {BidRequest} bidReq
  * @returns {*}
  */
-export function getStandardBidderSettings(mediaType, bidderCode, bidReq) {
+export function getStandardBidderSettings(mediaType, bidderCode) {
   // factory for key value objs
   function createKeyVal(key, value) {
     return {
       key,
       val: (typeof value === 'function')
-        ? function (bidResponse) {
-          return value(bidResponse);
+        ? function (bidResponse, bidReq) {
+          return value(bidResponse, bidReq);
         }
         : function (bidResponse) {
           return getValue(bidResponse, value);
@@ -661,7 +662,6 @@ export function getStandardBidderSettings(mediaType, bidderCode, bidReq) {
     };
   }
   const TARGETING_KEYS = CONSTANTS.TARGETING_KEYS;
-  const granularity = getPriceGranularity(mediaType, bidReq);
 
   let bidderSettings = $$PREBID_GLOBAL$$.bidderSettings;
   if (!bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD]) {
@@ -671,7 +671,7 @@ export function getStandardBidderSettings(mediaType, bidderCode, bidReq) {
     bidderSettings[CONSTANTS.JSON_MAPPING.BD_SETTING_STANDARD][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING] = [
       createKeyVal(TARGETING_KEYS.BIDDER, 'bidderCode'),
       createKeyVal(TARGETING_KEYS.AD_ID, 'adId'),
-      createKeyVal(TARGETING_KEYS.PRICE_BUCKET, getPriceByGranularity(granularity)),
+      createKeyVal(TARGETING_KEYS.PRICE_BUCKET, getPriceByGranularity()),
       createKeyVal(TARGETING_KEYS.SIZE, 'size'),
       createKeyVal(TARGETING_KEYS.DEAL, 'dealId'),
       createKeyVal(TARGETING_KEYS.SOURCE, 'source'),
@@ -716,12 +716,12 @@ export function getKeyValueTargetingPairs(bidderCode, custBidObj, bidReq) {
   // 1) set the keys from "standard" setting or from prebid defaults
   if (bidderSettings) {
     // initialize default if not set
-    const standardSettings = getStandardBidderSettings(custBidObj.mediaType, bidderCode, bidReq);
-    setKeys(keyValues, standardSettings, custBidObj);
+    const standardSettings = getStandardBidderSettings(custBidObj.mediaType, bidderCode);
+    setKeys(keyValues, standardSettings, custBidObj, bidReq);
 
     // 2) set keys from specific bidder setting override if they exist
     if (bidderCode && bidderSettings[bidderCode] && bidderSettings[bidderCode][CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING]) {
-      setKeys(keyValues, bidderSettings[bidderCode], custBidObj);
+      setKeys(keyValues, bidderSettings[bidderCode], custBidObj, bidReq);
       custBidObj.sendStandardTargeting = bidderSettings[bidderCode].sendStandardTargeting;
     }
   }
@@ -734,7 +734,7 @@ export function getKeyValueTargetingPairs(bidderCode, custBidObj, bidReq) {
   return keyValues;
 }
 
-function setKeys(keyValues, bidderSettings, custBidObj) {
+function setKeys(keyValues, bidderSettings, custBidObj, bidReq) {
   var targeting = bidderSettings[CONSTANTS.JSON_MAPPING.ADSERVER_TARGETING];
   custBidObj.size = custBidObj.getSize();
 
@@ -748,7 +748,7 @@ function setKeys(keyValues, bidderSettings, custBidObj) {
 
     if (isFn(value)) {
       try {
-        value = value(custBidObj);
+        value = value(custBidObj, bidReq);
       } catch (e) {
         logError('bidmanager', 'ERROR', e);
       }

package/test/spec/modules/appnexusBidAdapter_spec.js

@@ -1047,7 +1047,8 @@ describe('AppNexusAdapter', function () {
                 'trackers': [
                   {
                     'impression_urls': [
-                      'https://lax1-ib.adnxs.com/impression'
+                      'https://lax1-ib.adnxs.com/impression',
+                      'https://www.test.com/tracker'
                     ],
                     'video_events': {}
                   }

package/test/spec/modules/atsAnalyticsAdapter_spec.js

@@ -12,11 +12,15 @@ let constants = require('src/constants.json');
 
 export const storage = getStorageManager();
 let sandbox;
+let clock;
+let now = new Date();
+
 describe('ats analytics adapter', function () {
   beforeEach(function () {
     sinon.stub(events, 'getEvents').returns([]);
     storage.setCookie('_lr_env_src_ats', 'true', 'Thu, 01 Jan 1970 00:00:01 GMT');
     sandbox = sinon.sandbox.create();
+    clock = sandbox.useFakeTimers(now.getTime());
   });
 
   afterEach(function () {
@@ -25,18 +29,20 @@ describe('ats analytics adapter', function () {
     atsAnalyticsAdapter.disableAnalytics();
     Math.random.restore();
     sandbox.restore();
+    clock.restore();
   });
 
   describe('track', function () {
     it('builds and sends request and response data', function () {
       sinon.stub(Math, 'random').returns(0.99);
-      sinon.stub(atsAnalyticsAdapter, 'shouldFireRequest').returns(true);
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
-      let now = new Date();
+
       now.setTime(now.getTime() + 3600000);
       storage.setCookie('_lr_env_src_ats', 'true', now.toUTCString());
       storage.setCookie('_lr_sampling_rate', '10', now.toUTCString());
 
+      this.timeout(2100);
+
       let initOptions = {
         pid: '10433394'
       };
@@ -62,7 +68,7 @@ describe('ats analytics adapter', function () {
         'refererInfo': {
           'referer': 'https://example.com/dev'
         },
-        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
+        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7'
       };
       // prepare general auction - response
       let bidResponse = {
@@ -90,7 +96,7 @@ describe('ats analytics adapter', function () {
       let expectedAfterBid = {
         'Data': [{
           'has_envelope': true,
-          'adapter_version': 2,
+          'adapter_version': 3,
           'bidder': 'appnexus',
           'bid_id': '30c77d079cdf17',
           'auction_id': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
@@ -103,10 +109,30 @@ describe('ats analytics adapter', function () {
           'response_time_stamp': '2020-02-03T14:23:11.978Z',
           'currency': 'USD',
           'cpm': 0.5,
-          'net_revenue': true
+          'net_revenue': true,
+          'bid_won': true
         }]
       };
 
+      let wonRequest = {
+        'adId': '2eddfdc0c791dc',
+        'mediaType': 'banner',
+        'requestId': '30c77d079cdf17',
+        'cpm': 0.5,
+        'creativeId': 29681110,
+        'currency': 'USD',
+        'netRevenue': true,
+        'ttl': 300,
+        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
+        'statusMessage': 'Bid available',
+        'responseTimestamp': 1633525319061,
+        'requestTimestamp': 1633525319258,
+        'bidder': 'appnexus',
+        'adUnitCode': 'div-gpt-ad-1438287399331-0',
+        'size': '300x250',
+        'status': 'rendered'
+      };
+
       // lets simulate that some bidders timeout
       let bidTimeoutArgsV1 = [
         {
@@ -148,6 +174,14 @@ describe('ats analytics adapter', function () {
 
       // Step 5: Send auction end event
       events.emit(constants.EVENTS.AUCTION_END, {});
+      // Step 6: Send bid won event
+      events.emit(constants.EVENTS.BID_WON, wonRequest);
+
+      sandbox.stub($$PREBID_GLOBAL$$, 'getAllWinningBids').callsFake((key) => {
+        return [wonRequest]
+      });
+
+      clock.tick(2000);
 
       let requests = server.requests.filter(req => {
         return req.url.indexOf(analyticsUrl) > -1;
@@ -156,13 +190,12 @@ describe('ats analytics adapter', function () {
       expect(requests.length).to.equal(1);
 
       let realAfterBid = JSON.parse(requests[0].requestBody);
-      // Step 6: assert real data after bid and expected data
+
+      // Step 7: assert real data after bid and expected data
       expect(realAfterBid['Data']).to.deep.equal(expectedAfterBid['Data']);
 
       // check that the publisher ID is configured via options
       expect(atsAnalyticsAdapter.context.pid).to.equal(initOptions.pid);
-
-      atsAnalyticsAdapter.shouldFireRequest.restore();
     })
     it('check browser is safari', function () {
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
@@ -204,7 +237,7 @@ describe('ats analytics adapter', function () {
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
       sinon.stub(Math, 'random').returns(0.99);
       // publisher can try to pass anything they want but we will set sampling rate to 100, which means we will have 1% of requests
-      let result = atsAnalyticsAdapter.shouldFireRequest(10);
+      let result = atsAnalyticsAdapter.shouldFireRequest(8);
       expect(result).to.equal(true);
     })
     it('should not fire analytics request if math random is something other then 0.99', function () {

package/test/spec/modules/browsiRtdProvider_spec.js

@@ -1,5 +1,6 @@
 import * as browsiRTD from '../../../modules/browsiRtdProvider.js';
 import {makeSlot} from '../integration/faker/googletag.js';
+import * as utils from '../../../src/utils'
 
 describe('browsi Real time  data sub module', function () {
   const conf = {
@@ -29,11 +30,11 @@ describe('browsi Real time  data sub module', function () {
   });
 
   it('should match placement with ad unit', function () {
-    const slot = makeSlot({code: '/57778053/Browsi_Demo_300x250', divId: 'browsiAd_1'});
+    const slot = makeSlot({code: '/123/abc', divId: 'browsiAd_1'});
 
-    const test1 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_300x250']); // true
-    const test2 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_300x250', '/57778053/Browsi']); // true
-    const test3 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_Low']); // false
+    const test1 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/abc']); // true
+    const test2 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/abc', '/456/def']); // true
+    const test3 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/def']); // false
     const test4 = browsiRTD.isIdMatchingAdUnit(slot, []); // true
 
     expect(test1).to.equal(true);
@@ -43,12 +44,12 @@ describe('browsi Real time  data sub module', function () {
   });
 
   it('should return correct macro values', function () {
-    const slot = makeSlot({code: '/57778053/Browsi_Demo_300x250', divId: 'browsiAd_1'});
+    const slot = makeSlot({code: '/123/abc', divId: 'browsiAd_1'});
 
     slot.setTargeting('test', ['test', 'value']);
     // slot getTargeting doesn't act like GPT so we can't expect real value
     const macroResult = browsiRTD.getMacroId({p: '<AD_UNIT>/<KEY_test>'}, slot);
-    expect(macroResult).to.equal('/57778053/Browsi_Demo_300x250/NA');
+    expect(macroResult).to.equal('/123/abc/NA');
 
     const macroResultB = browsiRTD.getMacroId({}, slot);
     expect(macroResultB).to.equal('browsiAd_1');
@@ -72,7 +73,7 @@ describe('browsi Real time  data sub module', function () {
     it('should return prediction from server', function () {
       makeSlot({code: 'hasPrediction', divId: 'hasPrediction'});
       const data = {
-        p: {'hasPrediction': {p: 0.234}},
+        p: {'hasPrediction': {ps: {0: 0.234}}},
         kn: 'bv',
         pmd: undefined
       };
@@ -80,4 +81,58 @@ describe('browsi Real time  data sub module', function () {
       expect(browsiRTD.browsiSubmodule.getTargetingData(['hasPrediction'])).to.eql({hasPrediction: {bv: '0.20'}});
     })
   })
+
+  describe('should return matching prediction', function () {
+    const predictions = {
+      0: 0.123,
+      1: 0.254,
+      3: 0,
+      4: 0.8
+    }
+    const singlePrediction = {
+      0: 0.123
+    }
+    it('should return raw value if valid', function () {
+      expect(browsiRTD.getCurrentData(predictions, 0)).to.equal(0.123);
+      expect(browsiRTD.getCurrentData(predictions, 1)).to.equal(0.254);
+    })
+    it('should return 0 for prediction = 0', function () {
+      expect(browsiRTD.getCurrentData(predictions, 3)).to.equal(0);
+    })
+    it('should return -1 for invalid params', function () {
+      expect(browsiRTD.getCurrentData(null, 3)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(predictions, null)).to.equal(-1);
+    })
+    it('should return prediction according to object keys length ', function () {
+      expect(browsiRTD.getCurrentData(singlePrediction, 0)).to.equal(0.123);
+      expect(browsiRTD.getCurrentData(singlePrediction, 1)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(singlePrediction, 2)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(predictions, 4)).to.equal(0.8);
+      expect(browsiRTD.getCurrentData(predictions, 5)).to.equal(0.8);
+      expect(browsiRTD.getCurrentData(predictions, 8)).to.equal(0.8);
+    })
+  })
+  describe('should set bid request data', function () {
+    const data = {
+      p: {
+        'adUnit1': {ps: {0: 0.234}},
+        'adUnit2': {ps: {0: 0.134}}},
+      kn: 'bv',
+      pmd: undefined
+    };
+    browsiRTD.setData(data);
+    const fakeAdUnits = [
+      {
+        code: 'adUnit1'
+      },
+      {
+        code: 'adUnit2'
+      }
+    ]
+    browsiRTD.browsiSubmodule.getBidRequestData({adUnits: fakeAdUnits}, () => {}, {}, null);
+    it('should set ad unit params with prediction values', function () {
+      expect(utils.deepAccess(fakeAdUnits[0], 'ortb2Imp.ext.data.browsi')).to.eql({bv: '0.20'});
+      expect(utils.deepAccess(fakeAdUnits[1], 'ortb2Imp.ext.data.browsi')).to.eql({bv: '0.10'});
+    })
+  })
 });

package/test/spec/modules/cleanioRtdProvider_spec.js

@@ -0,0 +1,188 @@
+import * as utils from '../../../src/utils.js';
+import * as hook from '../../../src/hook.js'
+
+import { __TEST__ } from '../../../modules/cleanioRtdProvider.js';
+
+const {
+  readConfig,
+  ConfigError,
+  pageInitStepPreloadScript,
+  pageInitStepProtectPage,
+  bidWrapStepAugmentHtml,
+  bidWrapStepProtectByWrapping,
+  beforeInit,
+} = __TEST__;
+
+sinon.assert.expose(chai.assert, { prefix: 'sinon' });
+
+const fakeScriptURL = 'https://example.com/script.js';
+
+function makeFakeBidResponse() {
+  return {
+    ad: '<body>hello ad</body>',
+    bidderCode: 'BIDDER',
+    creativeId: 'CREATIVE',
+    cpm: 1.23,
+  };
+}
+
+describe('clean.io RTD module', function () {
+  describe('readConfig()', function() {
+    it('should throw ConfigError on invalid configurations', function() {
+      expect(() => readConfig({})).to.throw(ConfigError);
+      expect(() => readConfig({ params: {} })).to.throw(ConfigError);
+      expect(() => readConfig({ params: { protectionMode: 'bids' } })).to.throw(ConfigError);
+      expect(() => readConfig({ params: { cdnUrl: 'abc' } })).to.throw(ConfigError);
+      expect(() => readConfig({ params: { cdnUrl: 'abc', protectionMode: 'bids' } })).to.throw(ConfigError);
+      expect(() => readConfig({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: '123' } })).to.throw(ConfigError);
+    });
+
+    it('should accept valid configurations', function() {
+      expect(() => readConfig({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'full' } })).to.not.throw();
+      expect(() => readConfig({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'bids' } })).to.not.throw();
+      expect(() => readConfig({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'bids-nowait' } })).to.not.throw();
+    });
+  });
+
+  describe('Module initialization step', function() {
+    let insertElementStub;
+    beforeEach(function() {
+      insertElementStub = sinon.stub(utils, 'insertElement');
+    });
+    afterEach(function() {
+      utils.insertElement.restore();
+    });
+
+    it('pageInitStepPreloadScript() should insert link/preload element', function() {
+      pageInitStepPreloadScript(fakeScriptURL);
+
+      sinon.assert.calledOnce(insertElementStub);
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.tagName === 'LINK'));
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.rel === 'preload'));
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.as === 'script'));
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.href === fakeScriptURL));
+    });
+
+    it('pageInitStepProtectPage() should insert script element', function() {
+      pageInitStepProtectPage(fakeScriptURL);
+
+      sinon.assert.calledOnce(insertElementStub);
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.tagName === 'SCRIPT'));
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.type === 'text/javascript'));
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.src === fakeScriptURL));
+    });
+  });
+
+  function ensurePrependToBidResponse(fakeBidResponse) {
+    expect(fakeBidResponse).to.have.own.property('ad').which.is.a('string');
+    expect(fakeBidResponse.ad).to.contain('<!-- pbad://creativeId=CREATIVE&bidderCode=BIDDER&cpm=1.23 -->');
+  }
+
+  function ensureWrapBidResponse(fakeBidResponse, scriptUrl) {
+    expect(fakeBidResponse).to.have.own.property('ad').which.is.a('string');
+    expect(fakeBidResponse.ad).to.contain(`src="${scriptUrl}"`);
+    expect(fakeBidResponse.ad).to.contain('agent.put(ad)');
+  }
+
+  describe('Bid processing step', function() {
+    it('bidWrapStepAugmentHtml() should prepend bid-specific information in a comment', function() {
+      const fakeBidResponse = makeFakeBidResponse();
+      bidWrapStepAugmentHtml(fakeBidResponse);
+      ensurePrependToBidResponse(fakeBidResponse);
+    });
+
+    it('bidWrapStepProtectByWrapping() should wrap payload into a script tag', function() {
+      const fakeBidResponse = makeFakeBidResponse();
+      bidWrapStepProtectByWrapping(fakeScriptURL, 0, fakeBidResponse);
+      ensureWrapBidResponse(fakeBidResponse, fakeScriptURL);
+    });
+  });
+
+  describe('Sumbodule execution', function() {
+    let submoduleStub;
+    let insertElementStub;
+    beforeEach(function () {
+      submoduleStub = sinon.stub(hook, 'submodule');
+      insertElementStub = sinon.stub(utils, 'insertElement');
+    });
+    afterEach(function () {
+      utils.insertElement.restore();
+      submoduleStub.restore();
+    });
+
+    function getModule() {
+      beforeInit();
+
+      expect(submoduleStub.calledOnceWith('realTimeData')).to.equal(true);
+
+      const registeredSubmoduleDefinition = submoduleStub.getCall(0).args[1];
+      expect(registeredSubmoduleDefinition).to.be.an('object');
+      expect(registeredSubmoduleDefinition).to.have.own.property('name', 'clean.io');
+      expect(registeredSubmoduleDefinition).to.have.own.property('init').that.is.a('function');
+      expect(registeredSubmoduleDefinition).to.have.own.property('onBidResponseEvent').that.is.a('function');
+
+      return registeredSubmoduleDefinition;
+    }
+
+    it('should register clean.io RTD submodule provider', function () {
+      getModule();
+    });
+
+    it('should refuse initialization with incorrect parameters', function () {
+      const { init } = getModule();
+      expect(init({ params: { cdnUrl: 'abc', protectionMode: 'full' } }, {})).to.equal(false); // too short distribution name
+      sinon.assert.notCalled(insertElementStub);
+    });
+
+    it('should iniitalize in full (page) protection mode', function () {
+      const { init, onBidResponseEvent } = getModule();
+      expect(init({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'full' } }, {})).to.equal(true);
+      sinon.assert.calledOnce(insertElementStub);
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.tagName === 'SCRIPT'));
+
+      const fakeBidResponse = makeFakeBidResponse();
+      onBidResponseEvent(fakeBidResponse, {}, {});
+      ensurePrependToBidResponse(fakeBidResponse);
+    });
+
+    it('should iniitalize in bids (frame) protection mode', function () {
+      const { init, onBidResponseEvent } = getModule();
+      expect(init({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'bids' } }, {})).to.equal(true);
+      sinon.assert.calledOnce(insertElementStub);
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.tagName === 'LINK'));
+
+      const fakeBidResponse = makeFakeBidResponse();
+      onBidResponseEvent(fakeBidResponse, {}, {});
+      ensureWrapBidResponse(fakeBidResponse, 'https://abc1234567890.cloudfront.net/script.js');
+    });
+
+    it('should respect preload status in bids-nowait protection mode', function () {
+      const { init, onBidResponseEvent } = getModule();
+      expect(init({ params: { cdnUrl: 'https://abc1234567890.cloudfront.net/script.js', protectionMode: 'bids-nowait' } }, {})).to.equal(true);
+      sinon.assert.calledOnce(insertElementStub);
+      sinon.assert.calledWith(insertElementStub, sinon.match(elem => elem.tagName === 'LINK'));
+      const preloadLink = insertElementStub.getCall(0).args[0];
+      expect(preloadLink).to.have.property('onload').which.is.a('function');
+      expect(preloadLink).to.have.property('onerror').which.is.a('function');
+
+      const fakeBidResponse1 = makeFakeBidResponse();
+      onBidResponseEvent(fakeBidResponse1, {}, {});
+      ensurePrependToBidResponse(fakeBidResponse1);
+
+      // Simulate successful preloading
+      preloadLink.onload();
+
+      const fakeBidResponse2 = makeFakeBidResponse();
+      onBidResponseEvent(fakeBidResponse2, {}, {});
+      ensureWrapBidResponse(fakeBidResponse2, 'https://abc1234567890.cloudfront.net/script.js');
+
+      // Simulate error
+      preloadLink.onerror();
+
+      // Now we should fallback to just prepending
+      const fakeBidResponse3 = makeFakeBidResponse();
+      onBidResponseEvent(fakeBidResponse3, {}, {});
+      ensurePrependToBidResponse(fakeBidResponse3);
+    });
+  });
+});