prebid.js 7.26.0 → 7.28.0

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

package/test/spec/auctionmanager_spec.js

@@ -22,6 +22,7 @@ import 'modules/debugging/index.js' // some tests look for debugging side effect
 import {AuctionIndex} from '../../src/auctionIndex.js';
 import {expect} from 'chai';
 import {deepClone} from '../../src/utils.js';
+import { IMAGE as ortbNativeRequest } from 'src/native.js';
 
 var assert = require('assert');
 
@@ -185,7 +186,8 @@ describe('auctionmanager.js', function () {
       source: 'client',
       mediaType: 'banner',
       meta: {
-        advertiserDomains: ['adomain']
+        advertiserDomains: ['adomain'],
+        primaryCatId: 'IAB-test'
       }
     };
 
@@ -199,6 +201,7 @@ describe('auctionmanager.js', function () {
       expected[ CONSTANTS.TARGETING_KEYS.SOURCE ] = bid.source;
       expected[ CONSTANTS.TARGETING_KEYS.FORMAT ] = bid.mediaType;
       expected[ CONSTANTS.TARGETING_KEYS.ADOMAIN ] = bid.meta.advertiserDomains[0];
+      expected[ CONSTANTS.TARGETING_KEYS.ACAT ] = bid.meta.primaryCatId;
       if (bid.mediaType === 'video') {
         expected[ CONSTANTS.TARGETING_KEYS.UUID ] = bid.videoCacheKey;
         expected[ CONSTANTS.TARGETING_KEYS.CACHE_ID ] = bid.videoCacheKey;
@@ -289,6 +292,12 @@ describe('auctionmanager.js', function () {
               val: function (bidResponse) {
                 return bidResponse.meta.advertiserDomains[0];
               }
+            },
+            {
+              key: CONSTANTS.TARGETING_KEYS.ACAT,
+              val: function (bidResponse) {
+                return bidResponse.meta.primaryCatId;
+              }
             }
           ]
 
@@ -366,6 +375,12 @@ describe('auctionmanager.js', function () {
               val: function (bidResponse) {
                 return bidResponse.meta.advertiserDomains[0];
               }
+            },
+            {
+              key: CONSTANTS.TARGETING_KEYS.ACAT,
+              val: function (bidResponse) {
+                return bidResponse.meta.primaryCatId;
+              }
             }
           ]
 
@@ -454,6 +469,24 @@ describe('auctionmanager.js', function () {
       assert.deepEqual(response, expected);
     });
 
+    it('Should set targeting as expecting when pbs is enabled', function () {
+      config.setConfig({
+        s2sConfig: {
+          accountId: '1',
+          enabled: true,
+          defaultVendor: 'appnexus',
+          bidders: ['appnexus'],
+          timeout: 1000,
+          adapter: 'prebidServer'
+        }
+      });
+
+      $$PREBID_GLOBAL$$.bidderSettings = {};
+      let expected = getDefaultExpected(bid);
+      let response = getKeyValueTargetingPairs(bid.bidderCode, bid);
+      assert.deepEqual(response, expected);
+    });
+
     it('Custom bidCpmAdjustment for one bidder and inherit standard but doesn\'t use standard bidCpmAdjustment', function () {
       $$PREBID_GLOBAL$$.bidderSettings =
       {
@@ -1276,6 +1309,81 @@ describe('auctionmanager.js', function () {
     });
   });
 
+  if (FEATURES.NATIVE) {
+    describe('addBidResponse native', function () {
+      let makeRequestsStub;
+      let ajaxStub;
+      let spec;
+      let auction;
+
+      beforeEach(function () {
+        makeRequestsStub = sinon.stub(adapterManager, 'makeBidRequests');
+        ajaxStub = sinon.stub(ajaxLib, 'ajaxBuilder').callsFake(mockAjaxBuilder);
+
+        const adUnits = [{
+          code: ADUNIT_CODE,
+          transactionId: ADUNIT_CODE,
+          bids: [
+            {bidder: BIDDER_CODE, params: {placementId: 'id'}},
+          ],
+          nativeOrtbRequest: ortbNativeRequest.ortb,
+          mediaTypes: { native: { type: 'image' } }
+        }];
+        auction = auctionModule.newAuction({adUnits, adUnitCodes: [ADUNIT_CODE], callback: function() {}, cbTimeout: 3000});
+        indexAuctions = [auction];
+        const createAuctionStub = sinon.stub(auctionModule, 'newAuction');
+        createAuctionStub.returns(auction);
+
+        spec = mockBidder(BIDDER_CODE);
+        registerBidder(spec);
+      });
+
+      afterEach(function () {
+        ajaxStub.restore();
+        auctionModule.newAuction.restore();
+        adapterManager.makeBidRequests.restore();
+      });
+
+      it('should add legacy fields to native response', function () {
+        let nativeBid = mockBid();
+        nativeBid.mediaType = 'native';
+        nativeBid.native = {
+          ortb: {
+            ver: '1.2',
+            assets: [
+              { id: 2, title: { text: 'Sample title' } },
+              { id: 4, data: { value: 'Sample body' } },
+              { id: 3, data: { value: 'Sample sponsoredBy' } },
+              { id: 1, img: { url: 'https://www.example.com/image.png', w: 200, h: 200 } },
+              { id: 5, img: { url: 'https://www.example.com/icon.png', w: 32, h: 32 } }
+            ],
+            link: { url: 'http://www.click.com' },
+            eventtrackers: [
+              { event: 1, method: 1, url: 'http://www.imptracker.com' },
+              { event: 1, method: 2, url: 'http://www.jstracker.com/file.js' }
+            ]
+          }
+        }
+
+        let bidRequest = mockBidRequest(nativeBid, { mediaType: { native: ortbNativeRequest } });
+        makeRequestsStub.returns([bidRequest]);
+
+        spec.interpretResponse.returns(nativeBid);
+        auction.callBids();
+
+        const addedBid = auction.getBidsReceived().pop();
+        assert.equal(addedBid.native.body, 'Sample body')
+        assert.equal(addedBid.native.title, 'Sample title')
+        assert.equal(addedBid.native.sponsoredBy, 'Sample sponsoredBy')
+        assert.equal(addedBid.native.clickUrl, 'http://www.click.com')
+        assert.equal(addedBid.native.image, 'https://www.example.com/image.png')
+        assert.equal(addedBid.native.icon, 'https://www.example.com/icon.png')
+        assert.equal(addedBid.native.impressionTrackers[0], 'http://www.imptracker.com')
+        assert.equal(addedBid.native.javascriptTrackers, '<script async src="http://www.jstracker.com/file.js"></script>')
+      });
+    });
+  }
+
   describe('getMediaTypeGranularity', function () {
     it('video', function () {
       let mediaTypes = { video: {id: '1'} };
@@ -1464,6 +1572,15 @@ describe('auctionmanager.js', function () {
       assert.equal(doneSpy.callCount, 1);
     });
 
+    it('should convert cpm to number', () => {
+      auction.addBidReceived = sinon.spy();
+      const cbs = auctionCallbacks(doneSpy, auction);
+      const bid = {...bids[0], cpm: '1.23'}
+      bidRequests = [mockBidRequest(bid)];
+      cbs.addBidResponse.call(bidRequests[0], ADUNIT_CODE, bid);
+      sinon.assert.calledWith(auction.addBidReceived, sinon.match({cpm: 1.23}));
+    })
+
     describe('when addBidResponse hook returns promises', () => {
       let resolvers, callbacks, bids;
 
@@ -1605,6 +1722,7 @@ describe('auctionmanager.js', function () {
         ];
         cbs = auctionCallbacks(doneSpy, auction);
         expectedRejection = sinon.match(Object.assign({}, bid, {
+          cpm: parseFloat(bid.cpm),
           rejectionReason: REJECTION_REASON,
           adUnitCode: AU_CODE
         }));

package/test/spec/modules/33acrossIdSystem_spec.js

@@ -43,7 +43,10 @@ describe('33acrossIdSystem', () => {
 
       expect(request.method).to.equal('GET');
       expect(request.withCredentials).to.be.true;
-      expect(request.url).to.contain('https://lexicon.33across.com/v1/envelope?pid=12345');
+
+      const regExp = new RegExp('https://lexicon.33across.com/v1/envelope\\?pid=12345&gdpr=\\d&src=pbjs&ver=$prebid.version$');
+
+      expect(request.url).to.match(regExp);
       expect(completeCallback.calledOnceWithExactly('foo')).to.be.true;
     });
 

package/test/spec/modules/adWMGAnalyticsAdapter_spec.js

@@ -1,6 +1,7 @@
 import adWMGAnalyticsAdapter from 'modules/adWMGAnalyticsAdapter.js';
 import { expect } from 'chai';
 import { server } from 'test/mocks/xhr.js';
+import {expectEvents} from '../../helpers/analytics.js';
 let adapterManager = require('src/adapterManager').default;
 let events = require('src/events');
 let constants = require('src/constants.json');
@@ -140,14 +141,15 @@ describe('adWMG Analytics', function () {
         }
       });
 
-      events.emit(constants.EVENTS.AUCTION_INIT, {timestamp, auctionId, timeout, adUnits});
-      events.emit(constants.EVENTS.BID_REQUESTED, {});
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponse);
-      events.emit(constants.EVENTS.NO_BID, {});
-      events.emit(constants.EVENTS.BID_TIMEOUT, bidTimeoutArgs);
-      events.emit(constants.EVENTS.AUCTION_END, {});
-      events.emit(constants.EVENTS.BID_WON, wonRequest);
-      sinon.assert.callCount(adWMGAnalyticsAdapter.track, 7);
+      expectEvents([
+        [constants.EVENTS.AUCTION_INIT, {timestamp, auctionId, timeout, adUnits}],
+        [constants.EVENTS.BID_REQUESTED, {}],
+        [constants.EVENTS.BID_RESPONSE, bidResponse],
+        [constants.EVENTS.NO_BID, {}],
+        [constants.EVENTS.BID_TIMEOUT, bidTimeoutArgs],
+        [constants.EVENTS.AUCTION_END, {}],
+        [constants.EVENTS.BID_WON, wonRequest],
+      ]).to.beTrackedBy(adWMGAnalyticsAdapter.track);
     });
 
     it('should be two xhr requests', function () {

package/test/spec/modules/adagioAnalyticsAdapter_spec.js

@@ -83,34 +83,27 @@ describe('adagio analytics adapter', () => {
         timeToRespond: 132,
       };
 
-      // Step 1: Send bid requested event
-      events.emit(constants.EVENTS.BID_REQUESTED, bidRequest);
+      const testEvents = {
+        [constants.EVENTS.BID_REQUESTED]: bidRequest,
+        [constants.EVENTS.BID_RESPONSE]: bidResponse,
+        [constants.EVENTS.AUCTION_END]: {}
+      };
 
-      // Step 2: Send bid response event
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponse);
+      // Step 1-3: Send events
+      Object.entries(testEvents).forEach(([ev, payload]) => events.emit(ev, payload));
 
-      // Step 3: Send auction end event
-      events.emit(constants.EVENTS.AUCTION_END, {});
+      function eventItem(eventName, args) {
+        return sinon.match({
+          action: 'pb-analytics-event',
+          ts: sinon.match((val) => val !== undefined),
+          data: {
+            eventName,
+            args
+          }
+        })
+      }
 
-      sandbox.assert.callCount(adagioQueuePushSpy, 3);
-
-      const call0 = adagioQueuePushSpy.getCall(0);
-      expect(call0.args[0].action).to.equal('pb-analytics-event');
-      expect(call0.args[0].ts).to.not.be.undefined;
-      expect(call0.args[0].data).to.not.be.undefined;
-      expect(call0.args[0].data).to.deep.equal({eventName: constants.EVENTS.BID_REQUESTED, args: bidRequest});
-
-      const call1 = adagioQueuePushSpy.getCall(1);
-      expect(call1.args[0].action).to.equal('pb-analytics-event');
-      expect(call1.args[0].ts).to.not.be.undefined;
-      expect(call1.args[0].data).to.not.be.undefined;
-      expect(call1.args[0].data).to.deep.equal({eventName: constants.EVENTS.BID_RESPONSE, args: bidResponse});
-
-      const call2 = adagioQueuePushSpy.getCall(2);
-      expect(call2.args[0].action).to.equal('pb-analytics-event');
-      expect(call2.args[0].ts).to.not.be.undefined;
-      expect(call2.args[0].data).to.not.be.undefined;
-      expect(call2.args[0].data).to.deep.equal({eventName: constants.EVENTS.AUCTION_END, args: {}});
+      Object.entries(testEvents).forEach(([ev, payload]) => sinon.assert.calledWith(adagioQueuePushSpy, eventItem(ev, payload)));
     });
   });