prebid.js 7.26.0 → 7.28.0

package/test/spec/modules/genericAnalyticsAdapter_spec.js

@@ -0,0 +1,284 @@
+import {defaultHandler, GenericAnalytics} from '../../../modules/genericAnalyticsAdapter.js';
+import * as events from 'src/events.js';
+import * as CONSTANTS from 'src/constants.json';
+
+const {AUCTION_INIT, BID_RESPONSE} = CONSTANTS.EVENTS;
+
+describe('Generic analytics', () => {
+  describe('adapter', () => {
+    let adapter, sandbox, clock;
+    beforeEach(() => {
+      sandbox = sinon.sandbox.create();
+      sandbox.stub(events, 'getEvents').returns([]);
+      clock = sandbox.useFakeTimers();
+      adapter = new GenericAnalytics();
+    });
+
+    afterEach(() => {
+      adapter.disableAnalytics();
+      sandbox.restore();
+    });
+
+    describe('configuration', () => {
+      it('should be accepted if valid', () => {
+        adapter.enableAnalytics({
+          options: {
+            url: 'mock',
+            method: 'GET',
+            batchSize: 123,
+            batchDelay: 321
+          }
+        });
+        expect(adapter.enabled).to.be.true;
+      });
+
+      describe('should not work if', () => {
+        afterEach(function() {
+          expect(adapter.enabled).to.equal(false, this.currentTest.title);
+        });
+
+        it('neither handler nor url are specified', () => {
+          adapter.enableAnalytics({});
+        });
+
+        ['batchSize', 'batchDelay', 'handler'].forEach(option => {
+          it(`${option} is not valid`, () => {
+            adapter.enableAnalytics({
+              options: {
+                url: 'mock',
+                [option]: false
+              }
+            });
+          });
+        });
+
+        it('method is not GET or POST', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              method: 'PATCH'
+            }
+          });
+        });
+
+        it('events is not an object', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              events: null
+            }
+          });
+        });
+
+        it('events\' properties are not functions', () => {
+          adapter.enableAnalytics({
+            options: {
+              url: 'mock',
+              events: {
+                bidResponse: null
+              }
+            }
+          });
+        });
+      });
+    });
+
+    describe('when handler is specified', () => {
+      let handler;
+      beforeEach(() => {
+        handler = sinon.stub();
+      });
+
+      it('should collect events in batches, and call handler', () => {
+        adapter.enableAnalytics({
+          options: {
+            handler,
+            batchSize: 2
+          }
+        });
+        events.emit(AUCTION_INIT, {i: 0});
+        sinon.assert.notCalled(handler);
+        events.emit(BID_RESPONSE, {i: 0});
+        sinon.assert.calledWith(handler, sinon.match((arg) => {
+          return sinon.match({eventType: AUCTION_INIT, args: {i: 0}}).test(arg[0]) &&
+            sinon.match({eventType: BID_RESPONSE, args: {i: 0}}).test(arg[1]);
+        }));
+      });
+
+      it('should not choke if handler throws', () => {
+        adapter.enableAnalytics({
+          options: {
+            handler,
+            batchSize: 1
+          }
+        });
+        handler.throws(new Error());
+        events.emit(AUCTION_INIT, {i: 0});
+        let recv;
+        handler.reset();
+        handler.callsFake((arg) => {
+          recv = arg;
+        });
+        events.emit(BID_RESPONSE, {i: 1});
+        expect(recv).to.eql([{eventType: BID_RESPONSE, args: {i: 1}}]);
+      });
+
+      it('should not cause infinite recursion, if handler triggers more events', () => {
+        let i = 0;
+        handler.callsFake(() => {
+          if (i <= 100) {
+            i++;
+            events.emit(BID_RESPONSE, {});
+          }
+        });
+        adapter.enableAnalytics({
+          options: {
+            handler,
+          }
+        });
+        events.emit(AUCTION_INIT, {});
+        expect(i >= 100).to.be.false;
+      });
+
+      it('should send incomplete batch after batchDelay', () => {
+        adapter.enableAnalytics({
+          options: {
+            batchDelay: 100,
+            batchSize: 2,
+            handler
+          }
+        });
+        [0, 1, 2].forEach(i => events.emit(BID_RESPONSE, {i}));
+        sinon.assert.calledOnce(handler);
+        clock.tick(100);
+        sinon.assert.calledTwice(handler);
+      });
+
+      it('does not send empty batches', () => {
+        adapter.enableAnalytics({
+          options: {
+            batchDelay: 100,
+            batchSize: 2,
+            handler
+          }
+        });
+        [0, 1, 2].forEach(i => events.emit(BID_RESPONSE, {i}));
+        sinon.assert.calledOnce(handler);
+        clock.tick(50);
+        events.emit(BID_RESPONSE, {i: 3});
+        sinon.assert.calledTwice(handler);
+        clock.tick(100);
+        sinon.assert.calledTwice(handler);
+      });
+
+      describe('and options.events is specified', () => {
+        it('filters out other events', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return bid;
+                }
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {});
+          sinon.assert.notCalled(handler);
+        });
+
+        it('transforms event data', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return {
+                    extra: 'data',
+                    prop: bid.prop
+                  }
+                }
+              }
+            }
+          });
+          events.emit(BID_RESPONSE, {prop: 'value', i: 0});
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({extra: 'data', prop: 'value'}).test(data[0])));
+        });
+
+        it('does not choke if an event handler throws', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                bidResponse(bid) {
+                  return bid;
+                },
+                auctionInit(auction) {
+                  throw new Error();
+                }
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {});
+          events.emit(BID_RESPONSE, {i: 0});
+          sinon.assert.calledOnce(handler);
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({i: 0}).test(data[0])));
+        });
+
+        it('filters out events when their handler returns undefined', () => {
+          adapter.enableAnalytics({
+            options: {
+              handler,
+              events: {
+                auctionInit(auction) {
+                  return auction;
+                },
+                bidResponse(bid) {}
+              }
+            }
+          });
+          events.emit(AUCTION_INIT, {i: 0});
+          events.emit(BID_RESPONSE, {i: 1});
+          sinon.assert.calledOnce(handler);
+          sinon.assert.calledWith(handler, sinon.match(data => sinon.match({i: 0}).test(data[0])));
+        });
+      });
+    });
+  });
+
+  describe('default handler', () => {
+    const url = 'mock-url';
+
+    let ajax;
+    beforeEach(() => {
+      ajax = sinon.stub();
+    });
+
+    Object.entries({
+      'GET': (data) => JSON.parse(data.data),
+      'POST': (data) => JSON.parse(data)
+    }).forEach(([method, parse]) => {
+      describe(`when HTTP method is ${method}`, () => {
+        it('should send single event when batchSize is 1', () => {
+          const handler = defaultHandler({url, method, batchSize: 1, ajax});
+          const payload = {i: 0};
+          handler([payload, {}]);
+          sinon.assert.calledWith(ajax, url, sinon.match.any,
+            sinon.match(data => sinon.match(payload).test(parse(data))),
+            {method}
+          );
+        });
+
+        it('should send multiple events when batchSize is greater than 1', () => {
+          const handler = defaultHandler({url, method, batchSize: 10, ajax});
+          const payload = [{i: 0}, {i: 1}];
+          handler(payload);
+          sinon.assert.calledWith(ajax, url, sinon.match.any,
+            sinon.match(data => sinon.match(payload).test(parse(data))),
+            {method}
+          );
+        });
+      });
+    });
+  });
+});

package/test/spec/modules/geoedgeRtdProvider_spec.js

@@ -2,6 +2,8 @@ import * as utils from '../../../src/utils.js';
 import * as hook from '../../../src/hook.js'
 import { beforeInit, geoedgeSubmodule, setWrapper, wrapper, htmlPlaceholder, WRAPPER_URL, getClientUrl } from '../../../modules/geoedgeRtdProvider.js';
 import { server } from '../../../test/mocks/xhr.js';
+import * as events from '../../../src/events.js';
+import CONSTANTS from '../../../src/constants.json';
 
 let key = '123123123';
 function makeConfig() {
@@ -88,6 +90,19 @@ describe('Geoedge RTD module', function () {
         let isLinkPreloadAsScript = arg => arg.tagName === 'LINK' && arg.rel === 'preload' && arg.as === 'script' && arg.href === getClientUrl(key);
         expect(insertElementStub.calledWith(sinon.match(isLinkPreloadAsScript))).to.equal(true);
       });
+      it('should emit billable events with applicable winning bids', function () {
+        let applicableBid = mockBid('bidderA');
+        let nonApplicableBid = mockBid('bidderB');
+        let counter = 0;
+        events.on(CONSTANTS.EVENTS.BILLABLE_EVENT, function (event) {
+          if (event.vendor === 'geoedge' && event.type === 'impression') {
+            counter += 1;
+          }
+        });
+        events.emit(CONSTANTS.EVENTS.BID_WON, applicableBid);
+        events.emit(CONSTANTS.EVENTS.BID_WON, nonApplicableBid);
+        expect(counter).to.equal(1);
+      });
     });
     describe('onBidResponseEvent', function () {
       let bidFromA = mockBid('bidderA');

package/test/spec/modules/glomexBidAdapter_spec.js

@@ -49,6 +49,10 @@ const RESPONSE = {
 describe('glomexBidAdapter', function () {
   const adapter = newBidder(spec)
 
+  it('should expose gvlid', function() {
+    expect(spec.gvlid).to.equal(967)
+  });
+
   describe('inherited functions', function () {
     it('exists and is a function', function () {
       expect(adapter.callBids).to.exist.and.to.be.a('function')

package/test/spec/modules/gravitoIdSystem_spec.js

@@ -40,7 +40,7 @@ describe('gravitompId module', function () {
   describe('decode()', function () {
     it('should return the gravitompId when it exists in cookie', function () {
       const decoded = gravitoIdSystemSubmodule.decode(GRAVITOID_TEST_OBJ);
-      expect(decoded).to.be.deep.equal({gravitompId: {id: GRAVITOID_TEST_VALUE}});
+      expect(decoded).to.be.deep.equal({gravitompId: GRAVITOID_TEST_VALUE});
     });
 
     it('should return the undefined when decode id is not "string"', function () {

package/test/spec/modules/growthCodeAnalyticsAdapter_spec.js

@@ -0,0 +1,70 @@
+import adapterManager from '../../../src/adapterManager.js';
+import growthCodeAnalyticsAdapter from '../../../modules/growthCodeAnalyticsAdapter.js';
+import { expect } from 'chai';
+import * as events from '../../../src/events.js';
+import constants from '../../../src/constants.json';
+import { generateUUID } from '../../../src/utils.js';
+import { server } from 'test/mocks/xhr.js';
+
+describe('growthCode analytics adapter', () => {
+  beforeEach(() => {
+    growthCodeAnalyticsAdapter.enableAnalytics({
+      provider: 'growthCodeAnalytics',
+      options: {
+        pid: 'TEST01',
+        trackEvents: [
+          'auctionInit',
+          'auctionEnd',
+          'bidAdjustment',
+          'bidTimeout',
+          'bidTimeout',
+          'bidRequested',
+          'bidResponse',
+          'setTargeting',
+          'requestBids',
+          'addAdUnits',
+          'noBid',
+          'bidWon',
+          'bidderDone']
+      }
+    });
+  });
+
+  afterEach(() => {
+    growthCodeAnalyticsAdapter.disableAnalytics();
+  });
+
+  it('registers itself with the adapter manager', () => {
+    const adapter = adapterManager.getAnalyticsAdapter('growthCodeAnalytics');
+    expect(adapter).to.exist;
+    expect(adapter.adapter).to.equal(growthCodeAnalyticsAdapter);
+  });
+
+  it('tolerates undefined or empty config', () => {
+    growthCodeAnalyticsAdapter.enableAnalytics(undefined);
+    growthCodeAnalyticsAdapter.enableAnalytics({});
+  });
+
+  it('sends auction end events to the backend', () => {
+    const auction = {
+      auctionId: generateUUID(),
+      adUnits: [{
+        code: 'usr1234',
+        mediaTypes: {
+          banner: {
+            sizes: [[300, 250], [300, 600], [728, 90]]
+          }
+        },
+        adUnitCodes: ['usr1234']
+      }],
+    };
+    events.emit(constants.EVENTS.AUCTION_END, auction);
+    assert(server.requests.length > 0)
+    const body = JSON.parse(server.requests[0].requestBody);
+    var eventTypes = [];
+    body.events.forEach(e => eventTypes.push(e.eventType));
+    assert(eventTypes.length > 0)
+    assert(eventTypes.indexOf(constants.EVENTS.AUCTION_END) > -1);
+    growthCodeAnalyticsAdapter.disableAnalytics();
+  });
+});

package/test/spec/modules/impactifyBidAdapter_spec.js

@@ -166,6 +166,19 @@ describe('ImpactifyAdapter', function () {
       }
     };
 
+    it('should pass bidfloor', function () {
+      videoBidRequests[0].getFloor = function() {
+        return {
+          currency: 'USD',
+          floor: 1.23,
+        }
+      }
+
+      const res = spec.buildRequests(videoBidRequests, videoBidderRequest)
+      const resData = JSON.parse(res.data)
+      expect(resData.imp[0].bidfloor).to.equal(1.23)
+    });
+
     it('sends video bid request to ENDPOINT via POST', function () {
       const request = spec.buildRequests(videoBidRequests, videoBidderRequest);
       expect(request.url).to.equal(ORIGIN + AUCTIONURI);

package/test/spec/modules/invisiblyAnalyticsAdapter_spec.js

@@ -1,5 +1,6 @@
 import invisiblyAdapter from 'modules/invisiblyAnalyticsAdapter.js';
 import { expect } from 'chai';
+import {expectEvents} from '../../helpers/analytics.js';
 let events = require('src/events');
 let constants = require('src/constants.json');
 
@@ -197,14 +198,8 @@ describe('Invisibly Analytics Adapter test suite', function () {
               account: 'invisibly',
             },
           });
-          events.emit(constants.EVENTS.AUCTION_INIT, MOCK.AUCTION_INIT);
-          events.emit(constants.EVENTS.AUCTION_END, MOCK.AUCTION_END);
-          events.emit(constants.EVENTS.BID_REQUESTED, MOCK.BID_REQUESTED);
-          events.emit(constants.EVENTS.BID_RESPONSE, MOCK.BID_RESPONSE);
-          events.emit(constants.EVENTS.BID_WON, MOCK.BID_WON);
 
-          // 5 Invisibly events + 1 Clean.io event
-          sinon.assert.callCount(invisiblyAdapter.track, 6);
+          expectEvents().to.beTrackedBy(invisiblyAdapter.track);
         });
 
         it('should not catch events triggered without invisibly account config', function () {
@@ -382,9 +377,6 @@ describe('Invisibly Analytics Adapter test suite', function () {
         expect(invisiblyEvents.event_data.pageViewId).to.exist;
         expect(invisiblyEvents.event_data.ver).to.equal(1);
         expect(invisiblyEvents.event_type).to.equal('PREBID_bidWon');
-
-        // 1 Invisibly event + 1 Clean.io event
-        sinon.assert.callCount(invisiblyAdapter.track, 2);
       });
 
       // spec for bidder done event
@@ -522,7 +514,6 @@ describe('Invisibly Analytics Adapter test suite', function () {
         expect(invisiblyEvents.event_data.auctionId).to.equal(
           MOCK.AUCTION_END.auctionId
         );
-        sinon.assert.callCount(invisiblyAdapter.track, 1);
       });
 
       // should not call sendEvent for events not supported by the adapter
@@ -541,22 +532,21 @@ describe('Invisibly Analytics Adapter test suite', function () {
       it('track all event without errors', function () {
         invisiblyAdapter.enableAnalytics(MOCK.config);
 
-        events.emit(constants.EVENTS.AUCTION_INIT, MOCK.AUCTION_INIT);
-        events.emit(constants.EVENTS.AUCTION_END, MOCK.AUCTION_END);
-        events.emit(constants.EVENTS.BID_ADJUSTMENT, MOCK.BID_ADJUSTMENT);
-        events.emit(constants.EVENTS.BID_TIMEOUT, MOCK.BID_TIMEOUT);
-        events.emit(constants.EVENTS.BID_REQUESTED, MOCK.BID_REQUESTED);
-        events.emit(constants.EVENTS.BID_RESPONSE, MOCK.BID_RESPONSE);
-        events.emit(constants.EVENTS.NO_BID, MOCK.NO_BID);
-        events.emit(constants.EVENTS.BID_WON, MOCK.BID_WON);
-        events.emit(constants.EVENTS.BIDDER_DONE, MOCK.BIDDER_DONE);
-        events.emit(constants.EVENTS.SET_TARGETING, MOCK.SET_TARGETING);
-        events.emit(constants.EVENTS.REQUEST_BIDS, MOCK.REQUEST_BIDS);
-        events.emit(constants.EVENTS.ADD_AD_UNITS, MOCK.ADD_AD_UNITS);
-        events.emit(constants.EVENTS.AD_RENDER_FAILED, MOCK.AD_RENDER_FAILED);
-
-        // 13 Invisibly events + 1 Clean.io event
-        sinon.assert.callCount(invisiblyAdapter.track, 14);
+        expectEvents([
+          constants.EVENTS.AUCTION_INIT,
+          constants.EVENTS.AUCTION_END,
+          constants.EVENTS.BID_ADJUSTMENT,
+          constants.EVENTS.BID_TIMEOUT,
+          constants.EVENTS.BID_REQUESTED,
+          constants.EVENTS.BID_RESPONSE,
+          constants.EVENTS.NO_BID,
+          constants.EVENTS.BID_WON,
+          constants.EVENTS.BIDDER_DONE,
+          constants.EVENTS.SET_TARGETING,
+          constants.EVENTS.REQUEST_BIDS,
+          constants.EVENTS.ADD_AD_UNITS,
+          constants.EVENTS.AD_RENDER_FAILED
+        ]).to.beTrackedBy(invisiblyAdapter.track);
       });
     });
 

package/test/spec/modules/jwplayerRtdProvider_spec.js

@@ -659,9 +659,9 @@ describe('jwplayerRtdProvider', function() {
       const segment2 = 'segment2';
       const segment3 = 'segment3';
       const contentSegments = getContentSegments([segment1, segment2, segment3]);
-      expect(contentSegments[0]).to.deep.equal({ id: segment1, value: segment1 });
-      expect(contentSegments[1]).to.deep.equal({ id: segment2, value: segment2 });
-      expect(contentSegments[2]).to.deep.equal({ id: segment3, value: segment3 });
+      expect(contentSegments[0]).to.deep.equal({ id: segment1 });
+      expect(contentSegments[1]).to.deep.equal({ id: segment2 });
+      expect(contentSegments[2]).to.deep.equal({ id: segment3 });
     });
   });
 

package/test/spec/modules/konduitAnalyticsAdapter_spec.js

@@ -121,7 +121,5 @@ describe(`Konduit Analytics Adapter`, () => {
     expect(requestBody.konduitId).to.be.equal(konduitId);
     expect(requestBody.prebidVersion).to.be.equal('$prebid.version$');
     expect(requestBody.environment).to.be.an('object');
-    // 6 Konduit events + 1 Clean.io event
-    sinon.assert.callCount(konduitAnalyticsAdapter.track, 7);
   });
 });

package/test/spec/modules/liveIntentAnalyticsAdapter_spec.js

@@ -2,6 +2,7 @@ import liAnalytics from 'modules/liveIntentAnalyticsAdapter';
 import { expect } from 'chai';
 import { server } from 'test/mocks/xhr.js';
 import { auctionManager } from 'src/auctionManager.js';
+import {expectEvents} from '../../helpers/analytics.js';
 
 let utils = require('src/utils');
 let refererDetection = require('src/refererDetection');
@@ -286,12 +287,8 @@ describe('LiveIntent Analytics Adapter ', () => {
   });
 
   it('track is called', () => {
-    liAnalytics.enableAnalytics(config);
     sandbox.stub(liAnalytics, 'track');
-    events.emit(constants.EVENTS.AUCTION_END, args);
-    events.emit(constants.EVENTS.AUCTION_END, args);
-    events.emit(constants.EVENTS.AUCTION_END, args);
-    clock.tick(6000);
-    sinon.assert.callCount(liAnalytics.track, 3)
+    liAnalytics.enableAnalytics(config);
+    expectEvents().to.beTrackedBy(liAnalytics.track);
   })
 });

package/test/spec/modules/medianetAnalyticsAdapter_spec.js

@@ -3,6 +3,7 @@ import medianetAnalytics from 'modules/medianetAnalyticsAdapter.js';
 import * as utils from 'src/utils.js';
 import CONSTANTS from 'src/constants.json';
 import * as events from 'src/events.js';
+import {clearEvents} from 'src/events.js';
 
 const {
   EVENTS: { AUCTION_INIT, BID_REQUESTED, BID_RESPONSE, NO_BID, BID_TIMEOUT, AUCTION_END, SET_TARGETING, BID_WON }
@@ -127,7 +128,12 @@ describe('Media.net Analytics Adapter', function() {
     options: {
       cid: CUSTOMER_ID
     }
-  };
+  }
+
+  before(() => {
+    clearEvents();
+  });
+
   beforeEach(function () {
     sandbox = sinon.sandbox.create();
   });