prebid.js 6.4.0 → 6.8.0

package/src/prebid.js

@@ -19,6 +19,7 @@ import { adunitCounter } from './adUnits.js';
 import { executeRenderer, isRendererRequired } from './Renderer.js';
 import { createBid } from './bidfactory.js';
 import { storageCallbacks } from './storageManager.js';
+import { emitAdRenderSucceeded, emitAdRenderFail } from './adRendering.js';
 
 const $$PREBID_GLOBAL$$ = getGlobal();
 const CONSTANTS = require('./constants.json');
@@ -27,7 +28,7 @@ const events = require('./events.js');
 const { triggerUserSyncs } = userSync;
 
 /* private variables */
-const { ADD_AD_UNITS, BID_WON, REQUEST_BIDS, SET_TARGETING, AD_RENDER_FAILED, AD_RENDER_SUCCEEDED, STALE_RENDER } = CONSTANTS.EVENTS;
+const { ADD_AD_UNITS, BID_WON, REQUEST_BIDS, SET_TARGETING, STALE_RENDER } = CONSTANTS.EVENTS;
 const { PREVENT_WRITING_ON_MAIN_DOCUMENT, NO_AD, EXCEPTION, CANNOT_FIND_AD, MISSING_DOC_OR_ADID } = CONSTANTS.AD_RENDER_FAILED_REASON;
 
 const eventValidators = {
@@ -146,7 +147,7 @@ function validateNativeMediaType(adUnit) {
 function validateAdUnitPos(adUnit, mediaType) {
   let pos = deepAccess(adUnit, `mediaTypes.${mediaType}.pos`);
 
-  if (!pos || !isNumber(pos) || !isFinite(pos)) {
+  if (!isNumber(pos) || isNaN(pos) || !isFinite(pos)) {
     let warning = `Value of property 'pos' on ad unit ${adUnit.code} should be of type: Number`;
 
     logWarn(warning);
@@ -385,27 +386,23 @@ $$PREBID_GLOBAL$$.setTargetingForAst = function (adUnitCodes) {
   events.emit(SET_TARGETING, targeting.getAllTargeting());
 };
 
-function emitAdRenderFail({ reason, message, bid, id }) {
-  const data = { reason, message };
-  if (bid) data.bid = bid;
-  if (id) data.adId = id;
-
-  logError(message);
-  events.emit(AD_RENDER_FAILED, data);
-}
-
-function emitAdRenderSucceeded({ doc, bid, id }) {
-  const data = { doc };
-  if (bid) data.bid = bid;
-  if (id) data.adId = id;
-
-  events.emit(AD_RENDER_SUCCEEDED, data);
+/**
+ * This function will check for presence of given node in given parent. If not present - will inject it.
+ * @param {Node} node node, whose existance is in question
+ * @param {Document} doc document element do look in
+ * @param {string} tagName tag name to look in
+ */
+function reinjectNodeIfRemoved(node, doc, tagName) {
+  const injectionNode = doc.querySelector(tagName);
+  if (!node.parentNode || node.parentNode !== injectionNode) {
+    insertElement(node, doc, tagName);
+  }
 }
 
 /**
  * This function will render the ad (based on params) in the given iframe document passed through.
  * Note that doc SHOULD NOT be the parent document page as we can't doc.write() asynchronously
- * @param  {HTMLDocument} doc document
+ * @param  {Document} doc document
  * @param  {string} id bid id to locate the ad
  * @alias module:pbjs.renderAd
  */
@@ -449,10 +446,11 @@ $$PREBID_GLOBAL$$.renderAd = hook('async', function (doc, id, options) {
           const {height, width, ad, mediaType, adUrl, renderer} = bid;
 
           const creativeComment = document.createComment(`Creative ${bid.creativeId} served by ${bid.bidder} Prebid.js Header Bidding`);
+          insertElement(creativeComment, doc, 'html');
 
           if (isRendererRequired(renderer)) {
             executeRenderer(renderer, bid);
-            insertElement(creativeComment, doc, 'html');
+            reinjectNodeIfRemoved(creativeComment, doc, 'html');
             emitAdRenderSucceeded({ doc, bid, id });
           } else if ((doc === document && !inIframe()) || mediaType === 'video') {
             const message = `Error trying to write ad. Ad render call ad id ${id} was prevented from writing to the main document.`;
@@ -471,7 +469,7 @@ $$PREBID_GLOBAL$$.renderAd = hook('async', function (doc, id, options) {
             doc.write(ad);
             doc.close();
             setRenderSize(doc, width, height);
-            insertElement(creativeComment, doc, 'html');
+            reinjectNodeIfRemoved(creativeComment, doc, 'html');
             callBurl(bid);
             emitAdRenderSucceeded({ doc, bid, id });
           } else if (adUrl) {
@@ -484,7 +482,7 @@ $$PREBID_GLOBAL$$.renderAd = hook('async', function (doc, id, options) {
 
             insertElement(iframe, doc, 'body');
             setRenderSize(doc, width, height);
-            insertElement(creativeComment, doc, 'html');
+            reinjectNodeIfRemoved(creativeComment, doc, 'html');
             callBurl(bid);
             emitAdRenderSucceeded({ doc, bid, id });
           } else {
@@ -901,6 +899,8 @@ $$PREBID_GLOBAL$$.markWinningBidAsUsed = function (markBidRequest) {
  */
 $$PREBID_GLOBAL$$.getConfig = config.getConfig;
 $$PREBID_GLOBAL$$.readConfig = config.readConfig;
+$$PREBID_GLOBAL$$.mergeConfig = config.mergeConfig;
+$$PREBID_GLOBAL$$.mergeBidderConfig = config.mergeBidderConfig;
 
 /**
  * Set Prebid config options.

package/src/secureCreatives.js

@@ -4,18 +4,25 @@
  */
 
 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);
 }
@@ -29,52 +36,114 @@ 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](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(ev, 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;
+    }
+  }
 
-      _sendAdToCreative(adObject, ev);
+  try {
+    _sendAdToCreative(adObject, ev);
+  } catch (e) {
+    emitAdRenderFail({
+      reason: constants.AD_RENDER_FAILED_REASON.EXCEPTION,
+      message: e.message,
+      id: data.adId,
+      bid: adObject
+    });
+    return;
+  }
 
-      // save winning bids
-      auctionManager.addWinningBid(adObject);
+  // save winning bids
+  auctionManager.addWinningBid(adObject);
 
-      events.emit(BID_WON, 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 handleNativeRequest(ev, 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);
+  }
+
+  function reply(message) {
+    ev.source.postMessage(JSON.stringify(message), ev.origin);
+  }
+}
+
+function handleEventRequest(ev, 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}')`)
   }
 }
 
@@ -127,11 +196,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/utils.js

@@ -22,7 +22,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 +275,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) {
@@ -1272,7 +1282,18 @@ export function mergeDeep(target, ...sources) {
         if (!target[key]) {
           Object.assign(target, { [key]: source[key] });
         } else if (isArray(target[key])) {
-          target[key] = target[key].concat(source[key]);
+          source[key].forEach(obj => {
+            let addItFlag = 1;
+            for (let i = 0; i < target[key].length; i++) {
+              if (deepEqual(target[key][i], obj)) {
+                addItFlag = 0;
+                break;
+              }
+            }
+            if (addItFlag) {
+              target[key].push(obj);
+            }
+          });
         }
       } else {
         Object.assign(target, { [key]: source[key] });

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

@@ -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(() => {