prebid.js 6.5.0 → 6.9.0

package/src/secureCreatives.js

@@ -4,22 +4,47 @@
  */
 
 import events from './events.js';
-import { fireNativeTrackers, getAssetMessage, getAllAssetsMessage } from './native.js';
+import {fireNativeTrackers, getAllAssetsMessage, getAssetMessage} from './native.js';
 import constants from './constants.json';
-import { logWarn, replaceAuctionPrice, deepAccess, isGptPubadsDefined, isApnGetTagDefined } from './utils.js';
-import { auctionManager } from './auctionManager.js';
+import {deepAccess, isApnGetTagDefined, isGptPubadsDefined, logError, logWarn, replaceAuctionPrice} from './utils.js';
+import {auctionManager} from './auctionManager.js';
 import find from 'core-js-pure/features/array/find.js';
-import { isRendererRequired, executeRenderer } from './Renderer.js';
+import {executeRenderer, isRendererRequired} from './Renderer.js';
 import includes from 'core-js-pure/features/array/includes.js';
-import { config } from './config.js';
+import {config} from './config.js';
+import {emitAdRenderFail, emitAdRenderSucceeded} from './adRendering.js';
 
 const BID_WON = constants.EVENTS.BID_WON;
 const STALE_RENDER = constants.EVENTS.STALE_RENDER;
 
+const HANDLER_MAP = {
+  'Prebid Request': handleRenderRequest,
+  'Prebid Native': handleNativeRequest,
+  'Prebid Event': handleEventRequest,
+}
+
 export function listenMessagesFromCreative() {
   window.addEventListener('message', receiveMessage, false);
 }
 
+export function getReplier(ev) {
+  if (ev.origin == null && ev.ports.length === 0) {
+    return function () {
+      const msg = 'Cannot post message to a frame with null origin. Please update creatives to use MessageChannel, see https://github.com/prebid/Prebid.js/issues/7870'
+      logError(msg)
+      throw new Error(msg);
+    }
+  } else if (ev.ports.length > 0) {
+    return function (message) {
+      ev.ports[0].postMessage(JSON.stringify(message));
+    }
+  } else {
+    return function (message) {
+      ev.source.postMessage(JSON.stringify(message), ev.origin);
+    }
+  }
+}
+
 export function receiveMessage(ev) {
   var key = ev.message ? 'message' : 'data';
   var data = {};
@@ -29,70 +54,128 @@ export function receiveMessage(ev) {
     return;
   }
 
-  if (data && data.adId) {
+  if (data && data.adId && data.message) {
     const adObject = find(auctionManager.getBidsReceived(), function (bid) {
       return bid.adId === data.adId;
     });
+    if (HANDLER_MAP.hasOwnProperty(data.message)) {
+      HANDLER_MAP[data.message](getReplier(ev), data, adObject);
+    }
+  }
+}
 
-    if (adObject && data.message === 'Prebid Request') {
-      if (adObject.status === constants.BID_STATUS.RENDERED) {
-        logWarn(`Ad id ${adObject.adId} has been rendered before`);
-        events.emit(STALE_RENDER, adObject);
-        if (deepAccess(config.getConfig('auctionOptions'), 'suppressStaleRender')) {
-          return;
-        }
-      }
+function handleRenderRequest(reply, data, adObject) {
+  if (adObject == null) {
+    emitAdRenderFail({
+      reason: constants.AD_RENDER_FAILED_REASON.CANNOT_FIND_AD,
+      message: `Cannot find ad '${data.adId}' for cross-origin render request`,
+      id: data.adId
+    });
+    return;
+  }
+  if (adObject.status === constants.BID_STATUS.RENDERED) {
+    logWarn(`Ad id ${adObject.adId} has been rendered before`);
+    events.emit(STALE_RENDER, adObject);
+    if (deepAccess(config.getConfig('auctionOptions'), 'suppressStaleRender')) {
+      return;
+    }
+  }
+
+  try {
+    _sendAdToCreative(adObject, reply);
+  } catch (e) {
+    emitAdRenderFail({
+      reason: constants.AD_RENDER_FAILED_REASON.EXCEPTION,
+      message: e.message,
+      id: data.adId,
+      bid: adObject
+    });
+    return;
+  }
 
-      _sendAdToCreative(adObject, ev);
+  // save winning bids
+  auctionManager.addWinningBid(adObject);
 
-      // save winning bids
-      auctionManager.addWinningBid(adObject);
+  events.emit(BID_WON, adObject);
+}
 
+function handleNativeRequest(reply, data, adObject) {
+  // handle this script from native template in an ad server
+  // window.parent.postMessage(JSON.stringify({
+  //   message: 'Prebid Native',
+  //   adId: '%%PATTERN:hb_adid%%'
+  // }), '*');
+  if (adObject == null) {
+    logError(`Cannot find ad '${data.adId}' for x-origin event request`);
+    return;
+  }
+  switch (data.action) {
+    case 'assetRequest':
+      reply(getAssetMessage(data, adObject));
+      break;
+    case 'allAssetRequest':
+      reply(getAllAssetsMessage(data, adObject));
+      break;
+    case 'resizeNativeHeight':
+      adObject.height = data.height;
+      adObject.width = data.width;
+      resizeRemoteCreative(adObject);
+      break;
+    default:
+      const trackerType = fireNativeTrackers(data, adObject);
+      if (trackerType === 'click') {
+        return;
+      }
+      auctionManager.addWinningBid(adObject);
       events.emit(BID_WON, adObject);
-    }
+  }
+}
 
-    // handle this script from native template in an ad server
-    // window.parent.postMessage(JSON.stringify({
-    //   message: 'Prebid Native',
-    //   adId: '%%PATTERN:hb_adid%%'
-    // }), '*');
-    if (adObject && data.message === 'Prebid Native') {
-      if (data.action === 'assetRequest') {
-        const message = getAssetMessage(data, adObject);
-        ev.source.postMessage(JSON.stringify(message), ev.origin);
-      } else if (data.action === 'allAssetRequest') {
-        const message = getAllAssetsMessage(data, adObject);
-        ev.source.postMessage(JSON.stringify(message), ev.origin);
-      } else if (data.action === 'resizeNativeHeight') {
-        adObject.height = data.height;
-        adObject.width = data.width;
-        resizeRemoteCreative(adObject);
-      } else {
-        const trackerType = fireNativeTrackers(data, adObject);
-        if (trackerType === 'click') { return; }
-
-        auctionManager.addWinningBid(adObject);
-        events.emit(BID_WON, adObject);
-      }
-    }
+function handleEventRequest(reply, data, adObject) {
+  if (adObject == null) {
+    logError(`Cannot find ad '${data.adId}' for x-origin event request`);
+    return;
+  }
+  if (adObject.status !== constants.BID_STATUS.RENDERED) {
+    logWarn(`Received x-origin event request without corresponding render request for ad '${data.adId}'`);
+    return;
+  }
+  switch (data.event) {
+    case constants.EVENTS.AD_RENDER_FAILED:
+      emitAdRenderFail({
+        bid: adObject,
+        id: data.adId,
+        reason: data.info.reason,
+        message: data.info.message
+      });
+      break;
+    case constants.EVENTS.AD_RENDER_SUCCEEDED:
+      emitAdRenderSucceeded({
+        doc: null,
+        bid: adObject,
+        id: data.adId
+      });
+      break;
+    default:
+      logError(`Received x-origin event request for unsupported event: '${data.event}' (adId: '${data.adId}')`)
   }
 }
 
-export function _sendAdToCreative(adObject, ev) {
+export function _sendAdToCreative(adObject, reply) {
   const { adId, ad, adUrl, width, height, renderer, cpm } = adObject;
   // rendering for outstream safeframe
   if (isRendererRequired(renderer)) {
     executeRenderer(renderer, adObject);
   } else if (adId) {
     resizeRemoteCreative(adObject);
-    ev.source.postMessage(JSON.stringify({
+    reply({
       message: 'Prebid Response',
       ad: replaceAuctionPrice(ad, cpm),
       adUrl: replaceAuctionPrice(adUrl, cpm),
       adId,
       width,
       height
-    }), ev.origin);
+    });
   }
 }
 
@@ -127,11 +210,12 @@ function resizeRemoteCreative({ adId, adUnitCode, width, height }) {
   }
 
   function getDfpElementId(adId) {
-    return find(window.googletag.pubads().getSlots(), slot => {
+    const slot = find(window.googletag.pubads().getSlots(), slot => {
       return find(slot.getTargetingKeys(), key => {
         return includes(slot.getTargeting(key), adId);
       });
-    }).getSlotElementId();
+    });
+    return slot ? slot.getSlotElementId() : null;
   }
 
   function getAstElementId(adUnitCode) {

package/src/targeting.js

@@ -1,6 +1,6 @@
 import {
   uniques, isGptPubadsDefined, getHighestCpm, getOldestHighestCpmBid, groupBy, isAdUnitCodeMatchingSlot, timestamp,
-  deepAccess, deepClone, logError, logWarn, logInfo, isFn, isArray, logMessage, isStr, isAllowZeroCpmBidsEnabled
+  deepAccess, deepClone, logError, logWarn, logInfo, isFn, isArray, logMessage, isStr,
 } from './utils.js';
 import { config } from './config.js';
 import { NATIVE_TARGETING_KEYS } from './native.js';
@@ -8,6 +8,7 @@ import { auctionManager } from './auctionManager.js';
 import { sizeSupported } from './sizeMapping.js';
 import { ADPOD } from './mediaTypes.js';
 import { hook } from './hook.js';
+import { bidderSettings } from './bidderSettings.js';
 import includes from 'core-js-pure/features/array/includes.js';
 import find from 'core-js-pure/features/array/find.js';
 
@@ -459,7 +460,7 @@ export function newTargeting(auctionManager) {
     const adUnitCodes = getAdUnitCodes(adUnitCode);
     return bidsReceived
       .filter(bid => includes(adUnitCodes, bid.adUnitCode))
-      .filter(bid => (isAllowZeroCpmBidsEnabled(bid.bidderCode)) ? bid.cpm >= 0 : bid.cpm > 0)
+      .filter(bid => (bidderSettings.get(bid.bidderCode, 'allowZeroCpmBids') === true) ? bid.cpm >= 0 : bid.cpm > 0)
       .map(bid => bid.adUnitCode)
       .filter(uniques)
       .map(adUnitCode => bidsReceived

package/src/utils.js

@@ -1,6 +1,5 @@
 /* eslint-disable no-console */
 import { config } from './config.js';
-import { getGlobal } from './prebidGlobal.js';
 import clone from 'just-clone';
 import find from 'core-js-pure/features/array/find.js';
 import includes from 'core-js-pure/features/array/includes.js';
@@ -22,7 +21,17 @@ let consoleLogExists = Boolean(consoleExists && window.console.log);
 let consoleInfoExists = Boolean(consoleExists && window.console.info);
 let consoleWarnExists = Boolean(consoleExists && window.console.warn);
 let consoleErrorExists = Boolean(consoleExists && window.console.error);
-var events = require('./events.js');
+
+const emitEvent = (function () {
+  // lazy load events to avoid circular import
+  let ev;
+  return function() {
+    if (ev == null) {
+      ev = require('./events.js');
+    }
+    return ev.emit.apply(ev, arguments);
+  }
+})();
 
 // this allows stubbing of utility functions that are used internally by other utility functions
 export const internal = {
@@ -265,14 +274,14 @@ export function logWarn() {
   if (debugTurnedOn() && consoleWarnExists) {
     console.warn.apply(console, decorateLog(arguments, 'WARNING:'));
   }
-  events.emit(CONSTANTS.EVENTS.AUCTION_DEBUG, {type: 'WARNING', arguments: arguments});
+  emitEvent(CONSTANTS.EVENTS.AUCTION_DEBUG, {type: 'WARNING', arguments: arguments});
 }
 
 export function logError() {
   if (debugTurnedOn() && consoleErrorExists) {
     console.error.apply(console, decorateLog(arguments, 'ERROR:'));
   }
-  events.emit(CONSTANTS.EVENTS.AUCTION_DEBUG, {type: 'ERROR', arguments: arguments});
+  emitEvent(CONSTANTS.EVENTS.AUCTION_DEBUG, {type: 'ERROR', arguments: arguments});
 }
 
 function decorateLog(args, prefix) {
@@ -1333,9 +1342,3 @@ export function cyrb53Hash(str, seed = 0) {
   h2 = imul(h2 ^ (h2 >>> 16), 2246822507) ^ imul(h1 ^ (h1 >>> 13), 3266489909);
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString();
 }
-
-export function isAllowZeroCpmBidsEnabled(bidderCode) {
-  const bidderSettings = getGlobal().bidderSettings;
-  return ((bidderSettings[bidderCode] && bidderSettings[bidderCode].allowZeroCpmBids === true) ||
-   (bidderSettings.standard && bidderSettings.standard.allowZeroCpmBids === true));
-}

package/test/helpers/syncPromise.js

@@ -0,0 +1,71 @@
+const orig = {};
+['resolve', 'reject', 'all', 'race', 'allSettled'].forEach((k) => orig[k] = Promise[k].bind(Promise))
+
+// Callbacks attached through Promise.resolve(value).then(...) will usually
+// not execute immediately even if `value` is immediately available. This
+// breaks tests that were written before promises even though they are semantically still valid.
+// They can be made to work by making promises quasi-synchronous.
+
+export function SyncPromise(value, fail = false) {
+  if (value instanceof SyncPromise) {
+    return value;
+  } else if (typeof value === 'object' && typeof value.then === 'function') {
+    return orig.resolve(value);
+  } else {
+    Object.assign(this, {
+      then: function (cb, err) {
+        const handler = fail ? err : cb;
+        if (handler != null) {
+          return new SyncPromise(handler(value));
+        } else {
+          return this;
+        }
+      },
+      catch: function (cb) {
+        if (fail) {
+          return new SyncPromise(cb(value))
+        } else {
+          return this;
+        }
+      },
+      finally: function (cb) {
+        cb();
+        return this;
+      },
+      __value: fail ? {status: 'rejected', reason: value} : {status: 'fulfilled', value}
+    })
+  }
+}
+
+Object.assign(SyncPromise, {
+  resolve: (val) => new SyncPromise(val),
+  reject: (val) => new SyncPromise(val, true),
+  race: (promises) => promises.find((p) => p instanceof SyncPromise) || orig.race(promises),
+  allSettled: (promises) => {
+    if (promises.every((p) => p instanceof SyncPromise)) {
+      return new SyncPromise(promises.map((p) => p.__value))
+    } else {
+      return orig.allSettled(promises);
+    }
+  },
+  all: (promises) => {
+    if (promises.every((p) => p instanceof SyncPromise)) {
+      return SyncPromise.allSettled(promises).then((result) => {
+        const err = result.find((r) => r.status === 'rejected');
+        if (err != null) {
+          return new SyncPromise(err.reason, true);
+        } else {
+          return new SyncPromise(result.map((r) => r.value))
+        }
+      })
+    } else {
+      return orig.all(promises);
+    }
+  }
+})
+
+export function synchronizePromise(sandbox) {
+  Object.keys(orig).forEach((k) => {
+    sandbox.stub(window.Promise, k).callsFake(SyncPromise[k]);
+  })
+}

package/test/spec/auctionmanager_spec.js

@@ -4,6 +4,8 @@ import {
   AUCTION_COMPLETED,
   adjustBids,
   getMediaTypeGranularity,
+  getPriceByGranularity,
+  addBidResponse
 } from 'src/auction.js';
 import CONSTANTS from 'src/constants.json';
 import * as auctionModule from 'src/auction.js';
@@ -14,6 +16,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 +130,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,
@@ -1255,16 +1282,41 @@ describe('auctionmanager.js', function () {
     });
   });
 
+  describe('getPriceByGranularity', () => {
+    beforeEach(() => {
+      config.setConfig({
+        mediaTypePriceGranularity: {
+          video: 'medium',
+          banner: 'low'
+        }
+      });
+    })
+
+    afterEach(() => {
+      config.resetConfig();
+    })
+
+    it('evaluates undef granularity on each call', () => {
+      const gpbg = getPriceByGranularity();
+      expect(gpbg({
+        mediaType: 'video', pbMg: 'medium'
+      }, {
+        'mediaTypes': {video: {id: '1'}}
+      })).to.equal('medium');
+      expect(gpbg({
+        mediaType: 'banner',
+        pbLg: 'low'
+      }, {
+        'mediaTypes': {banner: {}}
+      })).to.equal('low');
+    });
+  })
+
   describe('auctionCallbacks', 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 +1324,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 +1389,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 +1508,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() {