prebid.js 6.7.0 → 6.8.0

package/test/spec/auctionmanager_spec.js

@@ -3,7 +3,7 @@ import {
   auctionCallbacks,
   AUCTION_COMPLETED,
   adjustBids,
-  getMediaTypeGranularity,
+  getMediaTypeGranularity, addBidResponse,
 } from 'src/auction.js';
 import CONSTANTS from 'src/constants.json';
 import * as auctionModule from 'src/auction.js';
@@ -14,6 +14,10 @@ import * as store from 'src/videoCache.js';
 import * as ajaxLib from 'src/ajax.js';
 import find from 'core-js-pure/features/array/find.js';
 import { server } from 'test/mocks/xhr.js';
+import {expect} from 'chai';
+import {hook} from '../../src/hook.js';
+import 'src/debugging.js'
+import {synchronizePromise} from '../helpers/syncPromise.js'; // some of these tests require debugging hooks to be loaded
 
 var assert = require('assert');
 
@@ -124,6 +128,27 @@ function mockAjaxBuilder() {
 }
 
 describe('auctionmanager.js', function () {
+  let promiseSandbox;
+
+  before(() => {
+    // hooks are global and their side effects depend on what has been loaded... not ideal for unit tests
+    [
+      auctionModule.addBidResponse,
+      auctionModule.addBidderRequests,
+      auctionModule.bidsBackCallback
+    ].forEach((h) => h.getHooks().remove())
+    hook.ready();
+  });
+
+  beforeEach(() => {
+    promiseSandbox = sinon.createSandbox();
+    synchronizePromise(promiseSandbox);
+  });
+
+  afterEach(() => {
+    promiseSandbox.restore();
+  })
+
   describe('getKeyValueTargetingPairs', function () {
     const DEFAULT_BID = {
       cpm: 5.578,
@@ -1259,12 +1284,7 @@ describe('auctionmanager.js', function () {
     let bids = TEST_BIDS;
     let bidRequests;
     let doneSpy;
-    let auction = {
-      getBidRequests: () => bidRequests,
-      getAuctionId: () => '1',
-      addBidReceived: () => true,
-      getTimeout: () => 1000
-    }
+    let auction;
 
     beforeEach(() => {
       doneSpy = sinon.spy();
@@ -1272,12 +1292,21 @@ describe('auctionmanager.js', function () {
         cache: {
           url: 'https://prebid.adnxs.com/pbc/v1/cache'
         }
-      })
+      });
+      const start = Date.now();
+      auction = {
+        getBidRequests: () => bidRequests,
+        getAuctionId: () => '1',
+        addBidReceived: () => true,
+        getTimeout: () => 1000,
+        getAuctionStart: () => start,
+      }
     });
 
     afterEach(() => {
       doneSpy.resetHistory();
       config.resetConfig();
+      bidRequests = null;
     });
 
     it('should call auction done after bid is added to auction for mediaType banner', function () {
@@ -1328,19 +1357,114 @@ describe('auctionmanager.js', function () {
       const responseBody = `{"responses":[{"uuid":"${uuid}"}]}`;
       server.requests[0].respond(200, { 'Content-Type': 'application/json' }, responseBody);
       assert.equal(doneSpy.callCount, 1);
-    })
+    });
+
+    describe('when addBidResponse hook returns promises', () => {
+      let resolvers, callbacks, bids;
+
+      function hook(next, ...args) {
+        next.bail(new Promise((resolve, reject) => {
+          resolvers.resolve.push(resolve);
+          resolvers.reject.push(reject);
+        }).finally(() => next(...args)));
+      }
+
+      function invokeCallbacks() {
+        bids.forEach((bid, i) => callbacks.addBidResponse.call(bidRequests[i], ADUNIT_CODE, bid));
+        bidRequests.forEach(bidRequest => callbacks.adapterDone.call(bidRequest));
+      }
+
+      function delay(ms = 0) {
+        return new Promise((resolve) => {
+          setTimeout(resolve, ms)
+        });
+      }
+
+      beforeEach(() => {
+        promiseSandbox.restore();
+        bids = [
+          mockBid({bidderCode: BIDDER_CODE1}),
+          mockBid({bidderCode: BIDDER_CODE})
+        ]
+        bidRequests = bids.map((b) => mockBidRequest(b));
+        resolvers = {resolve: [], reject: []};
+        addBidResponse.before(hook);
+        callbacks = auctionCallbacks(doneSpy, auction);
+        Object.assign(auction, {
+          addNoBid: sinon.spy()
+        });
+      });
+
+      afterEach(() => {
+        addBidResponse.getHooks({hook: hook}).remove();
+      });
+
+      Object.entries({
+        'all succeed': ['resolve', 'resolve'],
+        'some fail': ['resolve', 'reject'],
+        'all fail': ['reject', 'reject']
+      }).forEach(([test, results]) => {
+        describe(`(and ${test})`, () => {
+          it('should wait for them to complete before calling auctionDone', () => {
+            invokeCallbacks();
+            return delay().then(() => {
+              expect(doneSpy.called).to.be.false;
+              expect(auction.addNoBid.called).to.be.false;
+              resolvers[results[0]][0]();
+              return delay();
+            }).then(() => {
+              expect(doneSpy.called).to.be.false;
+              expect(auction.addNoBid.called).to.be.false;
+              resolvers[results[1]][1]();
+              return delay();
+            }).then(() => {
+              expect(doneSpy.called).to.be.true;
+            });
+          });
+        });
+      });
+
+      Object.entries({
+        bidder: (timeout) => {
+          bidRequests.forEach((r) => r.timeout = timeout);
+          auction.getTimeout = () => timeout + 10000
+        },
+        auction: (timeout) => {
+          auction.getTimeout = () => timeout;
+          bidRequests.forEach((r) => r.timeout = timeout + 10000)
+        }
+      }).forEach(([test, setTimeout]) => {
+        it(`should respect ${test} timeout if they never complete`, () => {
+          const start = Date.now() - 2900;
+          auction.getAuctionStart = () => start;
+          setTimeout(3000);
+          invokeCallbacks();
+          return delay().then(() => {
+            expect(doneSpy.called).to.be.false;
+            return delay(100);
+          }).then(() => {
+            expect(doneSpy.called).to.be.true;
+          });
+        });
+
+        it(`should not wait if ${test} has already timed out`, () => {
+          const start = Date.now() - 2000;
+          auction.getAuctionStart = () => start;
+          setTimeout(1000);
+          invokeCallbacks();
+          return delay().then(() => {
+            expect(doneSpy.called).to.be.true;
+          });
+        });
+      })
+    });
   });
 
   describe('auctionOptions', function() {
     let bidRequests;
     let doneSpy;
     let clock;
-    let auction = {
-      getBidRequests: () => bidRequests,
-      getAuctionId: () => '1',
-      addBidReceived: () => true,
-      getTimeout: () => 1000
-    }
+    let auction;
     let requiredBidder = BIDDER_CODE;
     let requiredBidder1 = BIDDER_CODE1;
     let secondaryBidder = 'doNotWaitForMe';
@@ -1352,7 +1476,15 @@ describe('auctionmanager.js', function () {
         'auctionOptions': {
           secondaryBidders: [ secondaryBidder ]
         }
-      })
+      });
+      const start = Date.now();
+      auction = {
+        getBidRequests: () => bidRequests,
+        getAuctionId: () => '1',
+        addBidReceived: () => true,
+        getTimeout: () => 1000,
+        getAuctionStart: () => start,
+      }
     });
 
     afterEach(() => {

package/test/spec/modules/adagioBidAdapter_spec.js

@@ -244,16 +244,6 @@ describe('Adagio bid adapter', () => {
       expect(spec.isBidRequestValid(bid03)).to.equal(false);
       expect(spec.isBidRequestValid(bid04)).to.equal(false);
     });
-
-    it('should return false when refererInfo.reachedTop is false', function() {
-      sandbox.spy(utils, 'logWarn');
-      sandbox.stub(adagio, 'getRefererInfo').returns({ reachedTop: false });
-      const bid = new BidRequestBuilder().withParams().build();
-
-      expect(spec.isBidRequestValid(bid)).to.equal(false);
-      sinon.assert.callCount(utils.logWarn, 1);
-      sinon.assert.calledWith(utils.logWarn, 'Adagio: the main page url is unreachabled.');
-    });
   });
 
   describe('buildRequests()', function() {

package/test/spec/modules/appnexusBidAdapter_spec.js

@@ -556,6 +556,33 @@ describe('AppNexusAdapter', function () {
       config.getConfig.restore();
     });
 
+    it('adds auction level keywords to request when set', function() {
+      let bidRequest = Object.assign({}, bidRequests[0]);
+      sinon
+        .stub(config, 'getConfig')
+        .withArgs('appnexusAuctionKeywords')
+        .returns({
+          gender: 'm',
+          music: ['rock', 'pop'],
+          test: ''
+        });
+
+      const request = spec.buildRequests([bidRequest]);
+      const payload = JSON.parse(request.data);
+
+      expect(payload.keywords).to.deep.equal([{
+        'key': 'gender',
+        'value': ['m']
+      }, {
+        'key': 'music',
+        'value': ['rock', 'pop']
+      }, {
+        'key': 'test'
+      }]);
+
+      config.getConfig.restore();
+    });
+
     it('should attach native params to the request', function () {
       let bidRequest = Object.assign({},
         bidRequests[0],

package/test/spec/modules/brandmetricsRtdProvider_spec.js

@@ -0,0 +1,191 @@
+import * as brandmetricsRTD from '../../../modules/brandmetricsRtdProvider.js';
+import {config} from 'src/config.js';
+
+const VALID_CONFIG = {
+  name: 'brandmetrics',
+  waitForIt: true,
+  params: {
+    scriptId: '00000000-0000-0000-0000-000000000000',
+    bidders: ['ozone']
+  }
+};
+
+const NO_BIDDERS_CONFIG = {
+  name: 'brandmetrics',
+  waitForIt: true,
+  params: {
+    scriptId: '00000000-0000-0000-0000-000000000000'
+  }
+};
+
+const NO_SCRIPTID_CONFIG = {
+  name: 'brandmetrics',
+  waitForIt: true
+};
+
+const USER_CONSENT = {
+  gdpr: {
+    vendorData: {
+      vendor: {
+        consents: {
+          422: true
+        }
+      },
+      purpose: {
+        consents: {
+          1: true,
+          7: true
+        }
+      }
+    },
+    gdprApplies: true
+  }
+};
+
+const NO_TCF_CONSENT = {
+  gdpr: {
+    vendorData: {
+      vendor: {
+        consents: {
+          422: false
+        }
+      },
+      purpose: {
+        consents: {
+          1: false,
+          7: false
+        }
+      }
+    },
+    gdprApplies: true
+  }
+};
+
+const NO_USP_CONSENT = {
+  usp: '1NYY'
+};
+
+function mockSurveyLoaded(surveyConf) {
+  const commands = window._brandmetrics || [];
+  commands.forEach(command => {
+    if (command.cmd === '_addeventlistener') {
+      const conf = command.val;
+      if (conf.event === 'surveyloaded') {
+        conf.handler(surveyConf);
+      }
+    }
+  });
+}
+
+function scriptTagExists(url) {
+  const tags = document.getElementsByTagName('script');
+  for (let i = 0; i < tags.length; i++) {
+    if (tags[i].src === url) {
+      return true;
+    }
+  }
+  return false;
+}
+
+describe('BrandmetricsRTD module', () => {
+  beforeEach(function () {
+    const scriptTags = document.getElementsByTagName('script');
+    for (let i = 0; i < scriptTags.length; i++) {
+      if (scriptTags[i].src.indexOf('brandmetrics') !== -1) {
+        scriptTags[i].remove();
+      }
+    }
+  });
+
+  it('should init and return true', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(VALID_CONFIG, USER_CONSENT)).to.equal(true);
+  });
+
+  it('should init and return true even if bidders is not included', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(NO_BIDDERS_CONFIG, USER_CONSENT)).to.equal(true);
+  });
+
+  it('should init even if script- id is not configured', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(NO_SCRIPTID_CONFIG, USER_CONSENT)).to.equal(true);
+  });
+
+  it('should not init when there is no TCF- consent', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(VALID_CONFIG, NO_TCF_CONSENT)).to.equal(false);
+  });
+
+  it('should not init when there is no usp- consent', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(VALID_CONFIG, NO_USP_CONSENT)).to.equal(false);
+  });
+});
+
+describe('getBidRequestData', () => {
+  beforeEach(function () {
+    config.resetConfig()
+  })
+
+  it('should set targeting keys for specified bidders', () => {
+    brandmetricsRTD.brandmetricsSubmodule.getBidRequestData({}, () => {
+      const bidderConfig = config.getBidderConfig()
+      const expected = VALID_CONFIG.params.bidders
+
+      expected.forEach(exp => {
+        expect(bidderConfig[exp].ortb2.user.ext.data.mockTargetKey).to.equal('mockMeasurementId')
+      })
+    }, VALID_CONFIG);
+
+    mockSurveyLoaded({
+      available: true,
+      conf: {
+        displayOption: {
+          type: 'pbjs',
+          targetKey: 'mockTargetKey'
+        }
+      },
+      survey: {
+        measurementId: 'mockMeasurementId'
+      }
+    });
+  });
+
+  it('should only set targeting keys when the brandmetrics survey- type is "pbjs"', () => {
+    mockSurveyLoaded({
+      available: true,
+      conf: {
+        displayOption: {
+          type: 'dfp',
+          targetKey: 'mockTargetKey'
+        }
+      },
+      survey: {
+        measurementId: 'mockMeasurementId'
+      }
+    });
+
+    brandmetricsRTD.brandmetricsSubmodule.getBidRequestData({}, () => {}, VALID_CONFIG);
+    const bidderConfig = config.getBidderConfig()
+    expect(Object.keys(bidderConfig).length).to.equal(0)
+  });
+
+  it('should use a default targeting key name if the brandmetrics- configuration does not include one', () => {
+    mockSurveyLoaded({
+      available: true,
+      conf: {
+        displayOption: {
+          type: 'pbjs',
+        }
+      },
+      survey: {
+        measurementId: 'mockMeasurementId'
+      }
+    });
+
+    brandmetricsRTD.brandmetricsSubmodule.getBidRequestData({}, () => {}, VALID_CONFIG);
+
+    const bidderConfig = config.getBidderConfig()
+    const expected = VALID_CONFIG.params.bidders
+
+    expected.forEach(exp => {
+      expect(bidderConfig[exp].ortb2.user.ext.data.brandmetrics_survey).to.equal('mockMeasurementId')
+    })
+  });
+});

package/test/spec/modules/criteoBidAdapter_spec.js

@@ -663,6 +663,27 @@ describe('The Criteo bidding adapter', function () {
       expect(request.data.user.uspIab).to.equal('1YNY');
     });
 
+    it('should properly build a request with schain object', function () {
+      const expectedSchain = {
+        someProperty: 'someValue'
+      };
+      const bidRequests = [
+        {
+          bidder: 'criteo',
+          schain: expectedSchain,
+          adUnitCode: 'bid-123',
+          transactionId: 'transaction-123',
+          sizes: [[728, 90]],
+          params: {
+            zoneId: 123,
+          },
+        },
+      ];
+
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.data.source.ext.schain).to.equal(expectedSchain);
+    });
+
     it('should properly build a request with if ccpa consent field is not provided', function () {
       const bidRequests = [
         {

package/test/spec/modules/currency_spec.js

@@ -9,7 +9,8 @@ import {
   setConfig,
   addBidResponseHook,
   currencySupportEnabled,
-  currencyRates
+  currencyRates,
+  ready
 } from 'modules/currency.js';
 
 var assert = require('chai').assert;
@@ -24,6 +25,7 @@ describe('currency', function () {
 
   beforeEach(function () {
     fakeCurrencyFileServer = sinon.fakeServer.create();
+    ready.reset();
   });
 
   afterEach(function () {
@@ -286,7 +288,7 @@ describe('currency', function () {
   });
 
   describe('currency.addBidResponseDecorator bidResponseQueue', function () {
-    it('not run until currency rates file is loaded', function () {
+    it('not run until currency rates file is loaded', function (done) {
       setConfig({});
 
       fakeCurrencyFileServer.respondWith(JSON.stringify(getCurrencyRates()));
@@ -296,14 +298,27 @@ describe('currency', function () {
       setConfig({ 'adServerCurrency': 'JPY' });
 
       var marker = false;
-      addBidResponseHook(function() {
+      let promiseResolved = false;
+      addBidResponseHook(Object.assign(function() {
         marker = true;
-      }, 'elementId', bid);
+      }, {
+        bail: function (promise) {
+          promise.then(() => promiseResolved = true);
+        }
+      }), 'elementId', bid);
 
       expect(marker).to.equal(false);
 
-      fakeCurrencyFileServer.respond();
-      expect(marker).to.equal(true);
+      setTimeout(() => {
+        expect(promiseResolved).to.be.false;
+        fakeCurrencyFileServer.respond();
+
+        setTimeout(() => {
+          expect(marker).to.equal(true);
+          expect(promiseResolved).to.be.true;
+          done();
+        });
+      });
     });
   });