prebid.js 7.26.0 → 7.27.0

package/modules/yieldliftBidAdapter.js

@@ -2,9 +2,9 @@ import {deepSetValue, logInfo, deepAccess} from '../src/utils.js';
 import {registerBidder} from '../src/adapters/bidderFactory.js';
 import {BANNER} from '../src/mediaTypes.js';
 
-const ENDPOINT_URL = 'https://x.yieldlift.com/auction';
+const ENDPOINT_URL = 'https://x.yieldlift.com/pbjs';
 
-const DEFAULT_BID_TTL = 30;
+const DEFAULT_BID_TTL = 300;
 const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_NET_REVENUE = true;
 
@@ -98,7 +98,7 @@ export const spec = {
           width: bid.w,
           height: bid.h,
           ad: bid.adm,
-          ttl: DEFAULT_BID_TTL,
+          ttl: typeof bid.exp === 'number' ? bid.exp : DEFAULT_BID_TTL,
           creativeId: bid.crid,
           netRevenue: DEFAULT_NET_REVENUE,
           currency: DEFAULT_CURRENCY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "7.26.0",
+  "version": "7.27.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

package/src/auction.js

@@ -76,7 +76,7 @@ import {
   timestamp
 } from './utils.js';
 import {getPriceBucketString} from './cpmBucketManager.js';
-import {getNativeTargeting} from './native.js';
+import {getNativeTargeting, toLegacyResponse} from './native.js';
 import {getCacheUrl, store} from './videoCache.js';
 import {Renderer} from './Renderer.js';
 import {config} from './config.js';
@@ -462,9 +462,14 @@ export function auctionCallbacks(auctionDone, auctionInstance, {index = auctionM
     handleBidResponse(adUnitCode, bid, (done) => {
       let bidResponse = getPreparedBidForAuction(bid);
 
-      if (bidResponse.mediaType === 'video') {
+      if (bidResponse.mediaType === VIDEO) {
         tryAddVideoBid(auctionInstance, bidResponse, done);
       } else {
+        if (FEATURES.NATIVE && bidResponse.native != null && typeof bidResponse.native === 'object') {
+          // NOTE: augment bidResponse.native even if bidResponse.mediaType !== NATIVE; it's possible
+          // to treat banner responses as native
+          addLegacyFieldsIfNeeded(bidResponse);
+        }
         addBidToAuction(auctionInstance, bidResponse);
         done();
       }
@@ -593,6 +598,17 @@ function tryAddVideoBid(auctionInstance, bidResponse, afterBidAdded, {index = au
   }
 }
 
+// Native bid response might be in ortb2 format - adds legacy field for backward compatibility
+const addLegacyFieldsIfNeeded = (bidResponse) => {
+  const nativeOrtbRequest = auctionManager.index.getAdUnit(bidResponse)?.nativeOrtbRequest;
+  const nativeOrtbResponse = bidResponse.native?.ortb
+
+  if (nativeOrtbRequest && nativeOrtbResponse) {
+    const legacyResponse = toLegacyResponse(nativeOrtbResponse, nativeOrtbRequest);
+    Object.assign(bidResponse.native, legacyResponse);
+  }
+}
+
 const storeInCache = (batch) => {
   store(batch.map(entry => entry.bidResponse), function (error, cacheIds) {
     cacheIds.forEach((cacheId, i) => {
@@ -672,7 +688,7 @@ function addCommonResponseProperties(bidResponse, adUnitCode, {index = auctionMa
   Object.assign(bidResponse, {
     responseTimestamp: bidResponse.responseTimestamp || timestamp(),
     requestTimestamp: bidResponse.requestTimestamp || start,
-    cpm: bidResponse.cpm || parseFloat(bidResponse.cpm) || 0,
+    cpm: parseFloat(bidResponse.cpm) || 0,
     bidder: bidResponse.bidder || bidResponse.bidderCode,
     adUnitCode
   });

package/src/consentHandler.js

@@ -1,6 +1,14 @@
 import {isStr, timestamp} from './utils.js';
 import {defer, GreedyPromise} from './utils/promise.js';
 
+/**
+ * Placeholder gvlid for when vendor consent is not required. When this value is used as gvlid, the gdpr
+ * enforcement module will take it to mean "vendor consent was given".
+ *
+ * see https://github.com/prebid/Prebid.js/issues/8161
+ */
+export const VENDORLESS_GVLID = Object.freeze({});
+
 export class ConsentHandler {
   #enabled;
   #data;

package/src/events.js

@@ -157,3 +157,7 @@ const _public = (function () {
 utils._setEventEmitter(_public.emit.bind(_public));
 
 export const {on, off, get, getEvents, emit, addEvents} = _public;
+
+export function clearEvents() {
+  eventsFired.length = 0;
+}

package/src/native.js

@@ -23,7 +23,7 @@ export const NATIVE_TARGETING_KEYS = Object.keys(CONSTANTS.NATIVE_KEYS).map(
   key => CONSTANTS.NATIVE_KEYS[key]
 );
 
-const IMAGE = {
+export const IMAGE = {
   ortb: {
     ver: '1.2',
     assets: [
@@ -385,26 +385,14 @@ export function getNativeTargeting(bid, {index = auctionManager.index} = {}) {
   return keyValues;
 }
 
-const getNativeRequest = (bidResponse) => auctionManager.index.getAdUnit(bidResponse)?.nativeOrtbRequest;
-
-function assetsMessage(data, adObject, keys, {getNativeReq = getNativeRequest} = {}) {
+function assetsMessage(data, adObject, keys) {
   const message = {
     message: 'assetResponse',
     adId: data.adId,
   };
 
-  // Pass to Prebid Universal Creative all assets, the legacy ones + the ortb ones (under ortb property)
-  const ortbRequest = getNativeReq(adObject);
   let nativeResp = adObject.native;
-  const ortbResponse = adObject.native?.ortb;
-  let legacyResponse = {};
-  if (ortbRequest && ortbResponse) {
-    legacyResponse = toLegacyResponse(ortbResponse, ortbRequest);
-    nativeResp = {
-      ...adObject.native,
-      ...legacyResponse
-    };
-  }
+
   if (adObject.native.ortb) {
     message.ortb = adObject.native.ortb;
   }
@@ -435,13 +423,13 @@ function assetsMessage(data, adObject, keys, {getNativeReq = getNativeRequest} =
  * Constructs a message object containing asset values for each of the
  * requested data keys.
  */
-export function getAssetMessage(data, adObject, {getNativeReq = getNativeRequest} = {}) {
+export function getAssetMessage(data, adObject) {
   const keys = data.assets.map((k) => getKeyByValue(CONSTANTS.NATIVE_KEYS, k));
-  return assetsMessage(data, adObject, keys, {getNativeReq});
+  return assetsMessage(data, adObject, keys);
 }
 
-export function getAllAssetsMessage(data, adObject, {getNativeReq = getNativeRequest} = {}) {
-  return assetsMessage(data, adObject, null, {getNativeReq});
+export function getAllAssetsMessage(data, adObject) {
+  return assetsMessage(data, adObject, null);
 }
 
 /**
@@ -749,7 +737,7 @@ export function toOrtbNativeResponse(legacyResponse, ortbRequest) {
  * @param {*} ortbRequest the ortb request, useful to match ids.
  * @returns an object containing the response in legacy native format: { title: "this is a title", image: ... }
  */
-function toLegacyResponse(ortbResponse, ortbRequest) {
+export function toLegacyResponse(ortbResponse, ortbRequest) {
   const legacyResponse = {};
   const requestAssets = ortbRequest?.assets || [];
   legacyResponse.clickUrl = ortbResponse.link.url;
@@ -764,6 +752,29 @@ function toLegacyResponse(ortbResponse, ortbRequest) {
       legacyResponse[PREBID_NATIVE_DATA_KEYS_TO_ORTB_INVERSE[NATIVE_ASSET_TYPES_INVERSE[requestAsset.data.type]]] = asset.data.value;
     }
   }
+
+  // Handle trackers
+  legacyResponse.impressionTrackers = [];
+  let jsTrackers = [];
+
+  if (ortbRequest?.imptrackers) {
+    legacyResponse.impressionTrackers.push(...ortbRequest.imptrackers);
+  }
+  for (const eventTracker of ortbResponse?.eventtrackers || []) {
+    if (eventTracker.event === TRACKER_EVENTS.impression && eventTracker.method === TRACKER_METHODS.img) {
+      legacyResponse.impressionTrackers.push(eventTracker.url);
+    }
+    if (eventTracker.event === TRACKER_EVENTS.impression && eventTracker.method === TRACKER_METHODS.js) {
+      jsTrackers.push(eventTracker.url);
+    }
+  }
+
+  jsTrackers = jsTrackers.map(url => `<script async src="${url}"></script>`);
+  if (ortbResponse?.jstracker) { jsTrackers.push(ortbResponse.jstracker); }
+  if (jsTrackers.length) {
+    legacyResponse.javascriptTrackers = jsTrackers.join('\n');
+  }
+
   return legacyResponse;
 }
 

package/src/refererDetection.js

@@ -120,6 +120,7 @@ export function detectReferer(win) {
     const stack = [];
     const ancestors = getAncestorOrigins(win);
     const maxNestedIframes = config.getConfig('maxNestedIframes');
+
     let currentWindow;
     let bestLocation;
     let bestCanonicalUrl;
@@ -226,7 +227,11 @@ export function detectReferer(win) {
 
     const location = reachedTop || hasTopLocation ? bestLocation : null;
     const canonicalUrl = config.getConfig('pageUrl') || bestCanonicalUrl || null;
-    const page = ensureProtocol(canonicalUrl, win) || location;
+    let page = config.getConfig('pageUrl') || location || ensureProtocol(canonicalUrl, win);
+
+    if (location && location.indexOf('?') > -1 && page.indexOf('?') === -1) {
+      page = `${page}${location.substring(location.indexOf('?'))}`;
+    }
 
     return {
       reachedTop,

package/src/storageManager.js

@@ -1,6 +1,7 @@
 import {hook} from './hook.js';
 import {hasDeviceAccess, checkCookieSupport, logError, logInfo, isPlainObject} from './utils.js';
 import {bidderSettings as defaultBidderSettings} from './bidderSettings.js';
+import {VENDORLESS_GVLID} from './consentHandler.js';
 
 const moduleTypeWhiteList = ['core', 'prebid-module'];
 
@@ -33,7 +34,9 @@ export function newStorageManager({gvlid, moduleName, bidderCode, moduleType} =
     return storageAllowed == null ? false : storageAllowed;
   }
 
-  const isVendorless = moduleTypeWhiteList.includes(moduleType);
+  if (moduleTypeWhiteList.includes(moduleType)) {
+    gvlid = gvlid || VENDORLESS_GVLID;
+  }
 
   function isValid(cb) {
     if (!isBidderAllowed()) {
@@ -45,7 +48,7 @@ export function newStorageManager({gvlid, moduleName, bidderCode, moduleType} =
       let hookDetails = {
         hasEnforcementHook: false
       }
-      validateStorageEnforcement(isVendorless, gvlid, bidderCode || moduleName, hookDetails, function(result) {
+      validateStorageEnforcement(gvlid, bidderCode || moduleName, hookDetails, function(result) {
         if (result && result.hasEnforcementHook) {
           value = cb(result);
         } else {
@@ -296,7 +299,7 @@ export function newStorageManager({gvlid, moduleName, bidderCode, moduleType} =
 /**
  * This hook validates the storage enforcement if gdprEnforcement module is included
  */
-export const validateStorageEnforcement = hook('async', function(isVendorless, gvlid, moduleName, hookDetails, callback) {
+export const validateStorageEnforcement = hook('async', function(gvlid, moduleName, hookDetails, callback) {
   callback(hookDetails);
 }, 'validateStorageEnforcement');
 

package/test/helpers/analytics.js

@@ -0,0 +1,34 @@
+import * as pbEvents from 'src/events.js';
+import constants from '../../src/constants.json';
+
+export function fireEvents(events = [
+  constants.EVENTS.AUCTION_INIT,
+  constants.EVENTS.AUCTION_END,
+  constants.EVENTS.BID_REQUESTED,
+  constants.EVENTS.BID_RESPONSE,
+  constants.EVENTS.BID_WON
+]) {
+  return events.map((ev, i) => {
+    ev = Array.isArray(ev) ? ev : [ev, {i: i}];
+    pbEvents.emit.apply(null, ev)
+    return ev;
+  });
+}
+
+export function expectEvents(events) {
+  events = fireEvents(events);
+  return {
+    to: {
+      beTrackedBy(trackFn) {
+        events.forEach(([eventType, args]) => {
+          sinon.assert.calledWithMatch(trackFn, sinon.match({eventType, args}));
+        });
+      },
+      beBundledTo(bundleFn) {
+        events.forEach(([eventType, args]) => {
+          sinon.assert.calledWithMatch(bundleFn, sinon.match.any, eventType, sinon.match(args))
+        });
+      },
+    },
+  };
+}

package/test/mocks/analyticsStub.js

@@ -1,8 +1,10 @@
-import {_internal} from '../../libraries/analyticsAdapter/AnalyticsAdapter.js';
+import {_internal, setDebounceDelay} from '../../libraries/analyticsAdapter/AnalyticsAdapter.js';
 
 before(() => {
   // stub out analytics networking to avoid random events polluting the global xhr mock
   disableAjaxForAnalytics();
+  // make analytics event handling synchronous
+  setDebounceDelay(0);
 })
 
 export function disableAjaxForAnalytics() {

package/test/spec/AnalyticsAdapter_spec.js

@@ -1,18 +1,17 @@
-import { expect } from 'chai';
+import {expect} from 'chai';
 import * as events from 'src/events.js';
 import CONSTANTS from 'src/constants.json';
-import { server } from 'test/mocks/xhr.js';
+import {server} from 'test/mocks/xhr.js';
 import {disableAjaxForAnalytics, enableAjaxForAnalytics} from '../mocks/analyticsStub.js';
+import {clearEvents} from 'src/events.js';
+import {
+  DEFAULT_EXCLUDE_EVENTS,
+  DEFAULT_INCLUDE_EVENTS,
+  setDebounceDelay
+} from '../../libraries/analyticsAdapter/AnalyticsAdapter.js';
 
-const REQUEST_BIDS = CONSTANTS.EVENTS.REQUEST_BIDS;
-const BID_REQUESTED = CONSTANTS.EVENTS.BID_REQUESTED;
-const BID_RESPONSE = CONSTANTS.EVENTS.BID_RESPONSE;
 const BID_WON = CONSTANTS.EVENTS.BID_WON;
-const BID_TIMEOUT = CONSTANTS.EVENTS.BID_TIMEOUT;
-const AD_RENDER_FAILED = CONSTANTS.EVENTS.AD_RENDER_FAILED;
-const AD_RENDER_SUCCEEDED = CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED;
-const AUCTION_DEBUG = CONSTANTS.EVENTS.AUCTION_DEBUG;
-const ADD_AD_UNITS = CONSTANTS.EVENTS.ADD_AD_UNITS;
+const NO_BID = CONSTANTS.EVENTS.NO_BID;
 
 const AnalyticsAdapter = require('libraries/analyticsAdapter/AnalyticsAdapter.js').default;
 const config = {
@@ -35,6 +34,7 @@ FEATURE: Analytics Adapters API
 
   afterEach(function () {
     adapter.disableAnalytics();
+    clearEvents();
   });
 
   it('should track enable status in `enabled`', () => {
@@ -43,21 +43,21 @@ FEATURE: Analytics Adapters API
     expect(adapter.enabled).to.equal(true);
     adapter.disableAnalytics();
     expect(adapter.enabled).to.equal(false);
-  })
+  });
 
   it(`SHOULD call the endpoint WHEN an event occurs that is to be tracked`, function () {
-    const eventType = BID_REQUESTED;
-    const args = { some: 'data' };
+    const eventType = BID_WON;
+    const args = {some: 'data'};
 
-    adapter.track({ eventType, args });
+    adapter.track({eventType, args});
 
     let result = JSON.parse(server.requests[0].requestBody);
-    expect(result).to.deep.equal({args: {some: 'data'}, eventType: 'bidRequested'});
+    expect(result).to.deep.equal({args: {some: 'data'}, eventType});
   });
 
   it(`SHOULD queue the event first and then track it WHEN an event occurs before tracking library is available`, function () {
-    const eventType = BID_RESPONSE;
-    const args = { wat: 'wot' };
+    const eventType = BID_WON;
+    const args = {wat: 'wot'};
 
     events.emit(eventType, args);
     adapter.enableAnalytics();
@@ -65,9 +65,58 @@ FEATURE: Analytics Adapters API
     // As now AUCTION_DEBUG is triggered for WARNINGS too, the BID_RESPONSE goes last in the array
     const index = server.requests.length - 1;
     let result = JSON.parse(server.requests[index].requestBody);
-    expect(result).to.deep.equal({eventType: 'bidResponse', args: {wat: 'wot'}});
+    expect(result).to.deep.equal({eventType, args: {wat: 'wot'}});
   });
 
+  describe('event filters', () => {
+    function fireEvents() {
+      events.emit(BID_WON, {});
+      events.emit(NO_BID, {});
+    }
+    function getEvents(ev) {
+      return server.requests
+        .map(r => JSON.parse(r.requestBody))
+        .filter(r => r.eventType === ev)
+    }
+
+    Object.entries({
+      'whitelist includeEvents': {
+        includeEvents: [BID_WON]
+      },
+      'blacklist excludeEvents': {
+        excludeEvents: [NO_BID]
+      },
+      'give precedence to exclude over include': {
+        includeEvents: [BID_WON, NO_BID],
+        excludeEvents: [NO_BID]
+      }
+    }).forEach(([t, config]) => {
+      it(`should ${t}`, () => {
+        fireEvents();
+        adapter.enableAnalytics(config);
+        expect(getEvents(BID_WON).length).to.eql(1);
+        expect(getEvents(NO_BID).length).to.eql(0);
+        fireEvents();
+        expect(getEvents(BID_WON).length).to.eql(2);
+        expect(getEvents(NO_BID).length).to.eql(0);
+      })
+    })
+  })
+
+  it('should prevent infinite loops when track triggers other events', () => {
+    let i = 0;
+    adapter.track = ((orig) => {
+      return function (event) {
+        i++;
+        orig.call(this, event);
+        events.emit(BID_WON, {})
+      }
+    })(adapter.track);
+    adapter.enableAnalytics(config);
+    events.emit(BID_WON, {});
+    expect(i >= 100).to.eql(false);
+  })
+
   describe(`WHEN an event occurs after enable analytics\n`, function () {
     beforeEach(function () {
       sinon.stub(events, 'getEvents').returns([]); // these tests shouldn't be affected by previous tests
@@ -77,108 +126,26 @@ FEATURE: Analytics Adapters API
       events.getEvents.restore();
     });
 
-    it('SHOULD call global when a bidWon event occurs', function () {
-      const eventType = BID_WON;
-      const args = { more: 'info' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {more: 'info'}, eventType: 'bidWon'});
-    });
-
-    it('SHOULD call global when a adRenderFailed event occurs', function () {
-      const eventType = AD_RENDER_FAILED;
-      const args = { call: 'adRenderFailed' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'adRenderFailed'}, eventType: 'adRenderFailed'});
-    });
-
-    it('SHOULD call global when a adRenderSucceeded event occurs', function () {
-      const eventType = AD_RENDER_SUCCEEDED;
-      const args = { call: 'adRenderSucceeded' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'adRenderSucceeded'}, eventType: 'adRenderSucceeded'});
-    });
-
-    it('SHOULD call global when an auction debug event occurs', function () {
-      const eventType = AUCTION_DEBUG;
-      const args = { call: 'auctionDebug' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'auctionDebug'}, eventType: 'auctionDebug'});
-    });
-
-    it('SHOULD call global when an addAdUnits event occurs', function () {
-      const eventType = ADD_AD_UNITS;
-      const args = { call: 'addAdUnits' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'addAdUnits'}, eventType: 'addAdUnits'});
-    });
-
-    it('SHOULD call global when a requestBids event occurs', function () {
-      const eventType = REQUEST_BIDS;
-      const args = { call: 'request' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'request'}, eventType: 'requestBids'});
-    });
-
-    it('SHOULD call global when a bidRequest event occurs', function () {
-      const eventType = BID_REQUESTED;
-      const args = { call: 'request' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'request'}, eventType: 'bidRequested'});
-    });
-
-    it('SHOULD call global when a bidResponse event occurs', function () {
-      const eventType = BID_RESPONSE;
-      const args = { call: 'response' };
-
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
-
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'response'}, eventType: 'bidResponse'});
-    });
-
-    it('SHOULD call global when a bidTimeout event occurs', function () {
-      const eventType = BID_TIMEOUT;
-      const args = { call: 'timeout' };
+    Object.values(DEFAULT_INCLUDE_EVENTS).forEach(eventType => {
+      it(`SHOULD call global when a ${eventType} event occurs`, () => {
+        const args = {more: 'info'};
 
-      adapter.enableAnalytics();
-      events.emit(eventType, args);
+        adapter.enableAnalytics();
+        events.emit(eventType, args);
 
-      let result = JSON.parse(server.requests[0].requestBody);
-      expect(result).to.deep.equal({args: {call: 'timeout'}, eventType: 'bidTimeout'});
+        let result = JSON.parse(server.requests[server.requests.length - 1].requestBody);
+        sinon.assert.match(result, {
+          eventType,
+          args: {
+            more: 'info'
+          },
+        });
+      });
     });
 
     it('SHOULD NOT call global again when adapter.enableAnalytics is called with previous timeout', function () {
-      const eventType = BID_TIMEOUT;
-      const args = { call: 'timeout' };
+      const eventType = BID_WON;
+      const args = {call: 'timeout'};
 
       events.emit(eventType, args);
       adapter.enableAnalytics();
@@ -189,7 +156,7 @@ FEATURE: Analytics Adapters API
 
     describe(`AND sampling is enabled\n`, function () {
       const eventType = BID_WON;
-      const args = { more: 'info' };
+      const args = {more: 'info'};
 
       beforeEach(function () {
         sinon.stub(Math, 'random').returns(0.5);
@@ -225,3 +192,39 @@ FEATURE: Analytics Adapters API
     });
   });
 });
+
+describe('Analytics asynchronous event tracking', () => {
+  before(() => {
+    setDebounceDelay(100);
+  });
+  after(() => {
+    setDebounceDelay(0);
+  });
+
+  let adapter, clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+    adapter = new AnalyticsAdapter(config);
+    adapter.track = sinon.stub();
+    adapter.enableAnalytics({});
+  });
+
+  afterEach(() => {
+    clock.restore();
+  })
+
+  it('does not call track as long as events are coming', () => {
+    events.emit(BID_WON, {i: 0});
+    sinon.assert.notCalled(adapter.track);
+    clock.tick(10);
+    events.emit(BID_WON, {i: 1});
+    sinon.assert.notCalled(adapter.track);
+    clock.tick(10);
+    sinon.assert.notCalled(adapter.track);
+    clock.tick(100);
+    sinon.assert.calledTwice(adapter.track);
+    sinon.assert.calledWith(adapter.track.firstCall, {eventType: BID_WON, args: {i: 0}});
+    sinon.assert.calledWith(adapter.track.secondCall, {eventType: BID_WON, args: {i: 1}});
+  });
+})