prebid.js 6.6.0 → 6.10.0

package/src/video.js

@@ -1,8 +1,9 @@
 import adapterManager from './adapterManager.js';
-import { getBidRequest, deepAccess, logError } from './utils.js';
+import { deepAccess, logError } from './utils.js';
 import { config } from '../src/config.js';
-import includes from 'core-js-pure/features/array/includes.js';
+import includes from 'prebidjs-polyfill/includes.js';
 import { hook } from './hook.js';
+import {auctionManager} from './auctionManager.js';
 
 const VIDEO_MEDIA_TYPE = 'video';
 export const OUTSTREAM = 'outstream';
@@ -28,23 +29,21 @@ export const hasNonVideoBidder = adUnit =>
 /**
  * Validate that the assets required for video context are present on the bid
  * @param {VideoBid} bid Video bid to validate
- * @param {BidRequest[]} bidRequests All bid requests for an auction
+ * @param index
  * @return {Boolean} If object is valid
  */
-export function isValidVideoBid(bid, bidRequests) {
-  const bidRequest = getBidRequest(bid.requestId, bidRequests);
-
-  const videoMediaType =
-    bidRequest && deepAccess(bidRequest, 'mediaTypes.video');
+export function isValidVideoBid(bid, {index = auctionManager.index} = {}) {
+  const videoMediaType = deepAccess(index.getMediaTypes(bid), 'video');
   const context = videoMediaType && deepAccess(videoMediaType, 'context');
+  const adUnit = index.getAdUnit(bid);
 
   // if context not defined assume default 'instream' for video bids
   // instream bids require a vast url or vast xml content
-  return checkVideoBidSetup(bid, bidRequest, videoMediaType, context);
+  return checkVideoBidSetup(bid, adUnit, videoMediaType, context);
 }
 
-export const checkVideoBidSetup = hook('sync', function(bid, bidRequest, videoMediaType, context) {
-  if (!bidRequest || (videoMediaType && context !== OUTSTREAM)) {
+export const checkVideoBidSetup = hook('sync', function(bid, adUnit, videoMediaType, context) {
+  if (videoMediaType && context !== OUTSTREAM) {
     // xml-only video bids require a prebid cache url
     if (!config.getConfig('cache.url') && bid.vastXml && !bid.vastUrl) {
       logError(`
@@ -59,7 +58,7 @@ export const checkVideoBidSetup = hook('sync', function(bid, bidRequest, videoMe
 
   // outstream bids require a renderer on the bid or pub-defined on adunit
   if (context === OUTSTREAM) {
-    return !!(bid.renderer || bidRequest.renderer || videoMediaType.renderer);
+    return !!(bid.renderer || (adUnit && adUnit.renderer) || videoMediaType.renderer);
   }
 
   return true;

package/src/videoCache.js

@@ -11,7 +11,7 @@
 
 import { ajax } from './ajax.js';
 import { config } from './config.js';
-import { isPlainObject } from './utils.js';
+import {auctionManager} from './auctionManager.js';
 
 /**
  * @typedef {object} CacheableUrlBid
@@ -58,9 +58,11 @@ function wrapURI(uri, impUrl) {
  * the bid can't be converted cleanly.
  *
  * @param {CacheableBid} bid
+ * @param index
  */
-function toStorageRequest(bid) {
+function toStorageRequest(bid, {index = auctionManager.index} = {}) {
   const vastValue = bid.vastXml ? bid.vastXml : wrapURI(bid.vastUrl, bid.vastImpUrl);
+  const auction = index.getAuction(bid);
 
   let payload = {
     type: 'xml',
@@ -72,10 +74,10 @@ function toStorageRequest(bid) {
     payload.bidder = bid.bidder;
     payload.bidid = bid.requestId;
     payload.aid = bid.auctionId;
-    // function has a thisArg set to bidderRequest for accessing the auctionStart
-    if (isPlainObject(this) && this.hasOwnProperty('auctionStart')) {
-      payload.timestamp = this.auctionStart;
-    }
+  }
+
+  if (auction != null) {
+    payload.timestamp = auction.getAuctionStart();
   }
 
   if (typeof bid.customCacheKey === 'string' && bid.customCacheKey !== '') {
@@ -132,12 +134,11 @@ function shimStorageCallback(done) {
  *
  * @param {CacheableBid[]} bids A list of bid objects which should be cached.
  * @param {videoCacheStoreCallback} [done] An optional callback which should be executed after
- * @param {BidderRequest} [bidderRequest]
  * the data has been stored in the cache.
  */
-export function store(bids, done, bidderRequest) {
+export function store(bids, done) {
   const requestData = {
-    puts: bids.map(toStorageRequest, bidderRequest)
+    puts: bids.map(toStorageRequest)
   };
 
   ajax(config.getConfig('cache.url'), shimStorageCallback(done), JSON.stringify(requestData), {

package/test/fixtures/fixtures.js

@@ -1231,7 +1231,7 @@ export function getCurrencyRates() {
   };
 }
 
-export function createBidReceived({bidder, cpm, auctionId, responseTimestamp, adUnitCode, adId, status, ttl, requestId}) {
+export function createBidReceived({bidder, cpm, auctionId, responseTimestamp, adUnitCode, adId, status, ttl, requestId, mediaType}) {
   let bid = {
     'bidderCode': bidder,
     'width': '300',
@@ -1259,6 +1259,7 @@ export function createBidReceived({bidder, cpm, auctionId, responseTimestamp, ad
       'hb_pb': cpm,
       'foobar': '300x250'
     }),
+    'mediaType': mediaType,
     'netRevenue': true,
     'currency': 'USD',
     'ttl': (!ttl) ? 300 : ttl

package/test/helpers/indexStub.js

@@ -0,0 +1,28 @@
+import {AuctionIndex} from '../../src/auctionIndex.js';
+
+export function stubAuctionIndex({bidRequests, bidderRequests, adUnits}) {
+  if (adUnits == null) {
+    adUnits = []
+  }
+  if (bidderRequests == null) {
+    bidderRequests = []
+  }
+  if (bidRequests != null) {
+    bidderRequests.push({
+      bidderRequestId: 'mock-bidder-request',
+      bids: bidRequests
+    });
+  }
+  const auction = {
+    getAuctionId() {
+      return 'mock-auction'
+    },
+    getBidRequests() {
+      return bidderRequests;
+    },
+    getAdUnits() {
+      return adUnits;
+    }
+  };
+  return new AuctionIndex(() => ([auction]));
+}

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