prebid.js 5.19.0 → 6.2.0

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/beachfrontBidAdapter_spec.js

@@ -1,6 +1,7 @@
 import { expect } from 'chai';
 import { spec, VIDEO_ENDPOINT, BANNER_ENDPOINT, OUTSTREAM_SRC, DEFAULT_MIMES } from 'modules/beachfrontBidAdapter.js';
-import { parseUrl } from 'src/utils.js';
+import { config } from 'src/config.js';
+import { parseUrl, deepAccess } from 'src/utils.js';
 
 describe('BeachfrontAdapter', function () {
   let bidRequests;
@@ -556,6 +557,69 @@ describe('BeachfrontAdapter', function () {
       });
     });
 
+    describe('with first-party data', function () {
+      let sandbox
+
+      beforeEach(function () {
+        sandbox = sinon.sandbox.create();
+      });
+
+      afterEach(function () {
+        sandbox.restore();
+      });
+
+      it('must add first-party data to the video bid request', function () {
+        sandbox.stub(config, 'getConfig').callsFake(key => {
+          const cfg = {
+            ortb2: {
+              site: {
+                keywords: 'test keyword'
+              },
+              user: {
+                data: 'some user data'
+              }
+            }
+          };
+          return deepAccess(cfg, key);
+        });
+        const bidRequest = bidRequests[0];
+        bidRequest.mediaTypes = { video: {} };
+        const bidderRequest = {
+          refererInfo: {
+            referer: 'http://example.com/page.html'
+          }
+        };
+        const requests = spec.buildRequests([ bidRequest ], bidderRequest);
+        const data = requests[0].data;
+        expect(data.user.data).to.equal('some user data');
+        expect(data.site.keywords).to.equal('test keyword');
+        expect(data.site.page).to.equal('http://example.com/page.html');
+        expect(data.site.domain).to.equal('example.com');
+      });
+
+      it('must add first-party data to the banner bid request', function () {
+        sandbox.stub(config, 'getConfig').callsFake(key => {
+          const cfg = {
+            ortb2: {
+              site: {
+                keywords: 'test keyword'
+              },
+              user: {
+                data: 'some user data'
+              }
+            }
+          };
+          return deepAccess(cfg, key);
+        });
+        const bidRequest = bidRequests[0];
+        bidRequest.mediaTypes = { banner: {} };
+        const requests = spec.buildRequests([ bidRequest ]);
+        const data = requests[0].data;
+        expect(data.ortb2.user.data).to.equal('some user data');
+        expect(data.ortb2.site.keywords).to.equal('test keyword');
+      });
+    });
+
     describe('for multi-format bids', function () {
       it('should create a POST request for each bid format', function () {
         const width = 300;

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

package/test/spec/modules/codefuelBidAdapter_spec.js

@@ -183,7 +183,7 @@ describe('Codefuel Adapter', function () {
           tmax: 500
         }
         const res = spec.buildRequests([bidRequest], commonBidderRequest)
-        expect(res.url).to.equal('https://bidder-url.com')
+        expect(res.url).to.equal('https://ai-p-codefuel-ds-rtb-us-east-1-k8s.seccint.com/prebid')
         expect(res.data).to.deep.equal(expectedData)
       })
 

package/test/spec/modules/datablocksBidAdapter_spec.js

@@ -96,8 +96,8 @@ const bidderRequest = {
   refererInfo: {
     numIframes: 0,
     reachedTop: true,
-    referer: 'https://v5demo.datablocks.net/test',
-    stack: ['https://v5demo.datablocks.net/test']
+    referer: 'https://7560.v5demo.datablocks.net/test',
+    stack: ['https://7560.v5demo.datablocks.net/test']
   },
   start: Date.now(),
   timeout: 10000
@@ -452,7 +452,7 @@ describe('DatablocksAdapter', function() {
 
     it('Returns valid URL', function() {
       expect(request.url).to.exist;
-      expect(request.url).to.equal('https://7560.v5demo.datablocks.net/openrtb/?sid=7560');
+      expect(request.url).to.equal('https://v5demo.datablocks.net/openrtb/?sid=7560');
     });
 
     it('Creates an array of request objects', function() {