prebid.js 8.43.0 → 8.45.0

package/test/spec/modules/loyalBidAdapter_spec .js

@@ -0,0 +1,375 @@
+import { expect } from 'chai';
+import { spec } from '../../../modules/loyalBidAdapter.js';
+import { BANNER, VIDEO, NATIVE } from '../../../src/mediaTypes.js';
+import { getUniqueIdentifierStr } from '../../../src/utils.js';
+
+const bidder = 'loyal'
+
+describe('LoyalBidAdapter', function () {
+  const bids = [
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [BANNER]: {
+          sizes: [[300, 250]]
+        }
+      },
+      params: {
+        placementId: 'testBanner',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [VIDEO]: {
+          playerSize: [[300, 300]],
+          minduration: 5,
+          maxduration: 60
+        }
+      },
+      params: {
+        placementId: 'testVideo',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [NATIVE]: {
+          native: {
+            title: {
+              required: true
+            },
+            body: {
+              required: true
+            },
+            icon: {
+              required: true,
+              size: [64, 64]
+            }
+          }
+        }
+      },
+      params: {
+        placementId: 'testNative',
+      }
+    }
+  ];
+
+  const invalidBid = {
+    bidId: getUniqueIdentifierStr(),
+    bidder: bidder,
+    mediaTypes: {
+      [BANNER]: {
+        sizes: [[300, 250]]
+      }
+    },
+    params: {
+
+    }
+  }
+
+  const bidderRequest = {
+    uspConsent: '1---',
+    gdprConsent: {
+      consentString: 'COvFyGBOvFyGBAbAAAENAPCAAOAAAAAAAAAAAEEUACCKAAA.IFoEUQQgAIQwgIwQABAEAAAAOIAACAIAAAAQAIAgEAACEAAAAAgAQBAAAAAAAGBAAgAAAAAAAFAAECAAAgAAQARAEQAAAAAJAAIAAgAAAYQEAAAQmAgBC3ZAYzUw'
+    },
+    refererInfo: {
+      referer: 'https://test.com'
+    },
+    timeout: 500
+  };
+
+  describe('isBidRequestValid', function () {
+    it('Should return true if there are bidId, params and key parameters present', function () {
+      expect(spec.isBidRequestValid(bids[0])).to.be.true;
+    });
+    it('Should return false if at least one of parameters is not present', function () {
+      expect(spec.isBidRequestValid(invalidBid)).to.be.false;
+    });
+  });
+
+  describe('buildRequests', function () {
+    let serverRequest = spec.buildRequests(bids, bidderRequest);
+
+    it('Creates a ServerRequest object with method, URL and data', function () {
+      expect(serverRequest).to.exist;
+      expect(serverRequest.method).to.exist;
+      expect(serverRequest.url).to.exist;
+      expect(serverRequest.data).to.exist;
+    });
+
+    it('Returns POST method', function () {
+      expect(serverRequest.method).to.equal('POST');
+    });
+
+    it('Returns valid URL', function () {
+      expect(serverRequest.url).to.equal('https://us-east-1.loyal.app/pbjs');
+    });
+
+    it('Returns general data valid', function () {
+      let data = serverRequest.data;
+      expect(data).to.be.an('object');
+      expect(data).to.have.all.keys('deviceWidth',
+        'deviceHeight',
+        'language',
+        'secure',
+        'host',
+        'page',
+        'placements',
+        'coppa',
+        'ccpa',
+        'gdpr',
+        'tmax'
+      );
+      expect(data.deviceWidth).to.be.a('number');
+      expect(data.deviceHeight).to.be.a('number');
+      expect(data.language).to.be.a('string');
+      expect(data.secure).to.be.within(0, 1);
+      expect(data.host).to.be.a('string');
+      expect(data.page).to.be.a('string');
+      expect(data.coppa).to.be.a('number');
+      expect(data.gdpr).to.be.a('object');
+      expect(data.ccpa).to.be.a('string');
+      expect(data.tmax).to.be.a('number');
+      expect(data.placements).to.have.lengthOf(3);
+    });
+
+    it('Returns valid placements', function () {
+      const { placements } = serverRequest.data;
+      for (let i = 0, len = placements.length; i < len; i++) {
+        const placement = placements[i];
+        expect(placement.placementId).to.be.oneOf(['testBanner', 'testVideo', 'testNative']);
+        expect(placement.adFormat).to.be.oneOf([BANNER, VIDEO, NATIVE]);
+        expect(placement.bidId).to.be.a('string');
+        expect(placement.schain).to.be.an('object');
+        expect(placement.bidfloor).to.exist.and.to.equal(0);
+        expect(placement.type).to.exist.and.to.equal('publisher');
+        expect(placement.eids).to.exist.and.to.be.an('array');
+
+        if (placement.adFormat === BANNER) {
+          expect(placement.sizes).to.be.an('array');
+        }
+        switch (placement.adFormat) {
+          case BANNER:
+            expect(placement.sizes).to.be.an('array');
+            break;
+          case VIDEO:
+            expect(placement.playerSize).to.be.an('array');
+            expect(placement.minduration).to.be.an('number');
+            expect(placement.maxduration).to.be.an('number');
+            break;
+          case NATIVE:
+            expect(placement.native).to.be.an('object');
+            break;
+        }
+      }
+    });
+
+    it('Returns data with gdprConsent and without uspConsent', function () {
+      delete bidderRequest.uspConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.gdpr).to.exist;
+      expect(data.gdpr).to.be.a('object');
+      expect(data.ccpa).to.not.exist;
+      delete bidderRequest.gdprConsent;
+    });
+
+    it('Returns data with uspConsent and without gdprConsent', function () {
+      bidderRequest.uspConsent = '1---';
+      delete bidderRequest.gdprConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.ccpa).to.exist;
+      expect(data.ccpa).to.be.a('string');
+      expect(data.ccpa).to.equal(bidderRequest.uspConsent);
+      expect(data.gdpr).to.not.exist;
+    });
+
+    it('Returns empty data if no valid requests are passed', function () {
+      serverRequest = spec.buildRequests([], bidderRequest);
+      let data = serverRequest.data;
+      expect(data.placements).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('Should interpret banner response', function () {
+      const banner = {
+        body: [{
+          mediaType: 'banner',
+          width: 300,
+          height: 250,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let bannerResponses = spec.interpretResponse(banner);
+      expect(bannerResponses).to.be.an('array').that.is.not.empty;
+      let dataItem = bannerResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'width', 'height', 'ad', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal(banner.body[0].requestId);
+      expect(dataItem.cpm).to.equal(banner.body[0].cpm);
+      expect(dataItem.width).to.equal(banner.body[0].width);
+      expect(dataItem.height).to.equal(banner.body[0].height);
+      expect(dataItem.ad).to.equal(banner.body[0].ad);
+      expect(dataItem.ttl).to.equal(banner.body[0].ttl);
+      expect(dataItem.creativeId).to.equal(banner.body[0].creativeId);
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal(banner.body[0].currency);
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret video response', function () {
+      const video = {
+        body: [{
+          vastUrl: 'test.com',
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let videoResponses = spec.interpretResponse(video);
+      expect(videoResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = videoResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'vastUrl', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.5);
+      expect(dataItem.vastUrl).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret native response', function () {
+      const native = {
+        body: [{
+          mediaType: 'native',
+          native: {
+            clickUrl: 'test.com',
+            title: 'Test',
+            image: 'test.com',
+            impressionTrackers: ['test.com'],
+          },
+          ttl: 120,
+          cpm: 0.4,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let nativeResponses = spec.interpretResponse(native);
+      expect(nativeResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = nativeResponses[0];
+      expect(dataItem).to.have.keys('requestId', 'cpm', 'ttl', 'creativeId', 'netRevenue', 'currency', 'mediaType', 'native', 'meta');
+      expect(dataItem.native).to.have.keys('clickUrl', 'impressionTrackers', 'title', 'image')
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.4);
+      expect(dataItem.native.clickUrl).to.equal('test.com');
+      expect(dataItem.native.title).to.equal('Test');
+      expect(dataItem.native.image).to.equal('test.com');
+      expect(dataItem.native.impressionTrackers).to.be.an('array').that.is.not.empty;
+      expect(dataItem.native.impressionTrackers[0]).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should return an empty array if invalid banner response is passed', function () {
+      const invBanner = {
+        body: [{
+          width: 300,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+
+      let serverResponses = spec.interpretResponse(invBanner);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid video response is passed', function () {
+      const invVideo = {
+        body: [{
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invVideo);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid native response is passed', function () {
+      const invNative = {
+        body: [{
+          mediaType: 'native',
+          clickUrl: 'test.com',
+          title: 'Test',
+          impressionTrackers: ['test.com'],
+          ttl: 120,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invNative);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid response is passed', function () {
+      const invalid = {
+        body: [{
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invalid);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+  });
+});

package/test/spec/modules/magniteAnalyticsAdapter_spec.js

@@ -6,7 +6,7 @@ import magniteAdapter, {
   detectBrowserFromUa,
   callPrebidCacheHook
 } from '../../../modules/magniteAnalyticsAdapter.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS } from 'src/constants.js';
 import { config } from 'src/config.js';
 import { server } from 'test/mocks/xhr.js';
 import * as mockGpt from '../integration/faker/googletag.js';
@@ -17,19 +17,17 @@ let events = require('src/events.js');
 let utils = require('src/utils.js');
 
 const {
-  EVENTS: {
-    AUCTION_INIT,
-    AUCTION_END,
-    BID_REQUESTED,
-    BID_RESPONSE,
-    BIDDER_DONE,
-    BID_WON,
-    BID_TIMEOUT,
-    BILLABLE_EVENT,
-    SEAT_NON_BID,
-    BID_REJECTED
-  }
-} = CONSTANTS;
+  AUCTION_INIT,
+  AUCTION_END,
+  BID_REQUESTED,
+  BID_RESPONSE,
+  BIDDER_DONE,
+  BID_WON,
+  BID_TIMEOUT,
+  BILLABLE_EVENT,
+  SEAT_NON_BID,
+  BID_REJECTED
+} = EVENTS;
 
 const STUBBED_UUID = '12345678-1234-1234-1234-123456789abc';
 
@@ -241,6 +239,7 @@ const ANALYTICS_MESSAGE = {
   },
   'auctions': [
     {
+      'auctionIndex': 1,
       'auctionId': '99785e47-a7c8-4c8a-ae05-ef1c717a4b4d',
       'auctionStart': 1658868383741,
       'samplingFactor': 1,
@@ -603,7 +602,22 @@ describe('magnite analytics adapter', function () {
       it(`should parse browser from ${testData.expected} user agent correctly`, function () {
         expect(detectBrowserFromUa(testData.ua)).to.equal(testData.expected);
       });
-    })
+    });
+
+    it('should increment auctionIndex each auction', function () {
+      // run 3 auctions
+      performStandardAuction();
+      performStandardAuction();
+      performStandardAuction();
+
+      expect(server.requests.length).to.equal(3);
+      server.requests.forEach((request, index) => {
+        let message = JSON.parse(request.requestBody);
+
+        // should be index of array + 1
+        expect(message?.auctions?.[0].auctionIndex).to.equal(index + 1);
+      });
+    });
 
     it('should pass along 1x1 size if no sizes in adUnit', function () {
       const auctionInit = utils.deepClone(MOCK.AUCTION_INIT);
@@ -1522,6 +1536,8 @@ describe('magnite analytics adapter', function () {
 
       // bid source should be 'server'
       expectedMessage.auctions[0].adUnits[0].bids[0].source = 'server';
+      // if one of bids.source === server should add pbsRequest flag to adUnit
+      expectedMessage.auctions[0].adUnits[0].pbsRequest = 1;
       expectedMessage.bidsWon[0].source = 'server';
       expect(message).to.deep.equal(expectedMessage);
     });

package/test/spec/modules/malltvAnalyticsAdapter_spec.js

@@ -5,7 +5,7 @@ import {
 import { expect } from 'chai'
 import { getCpmInEur } from '../../../modules/malltvAnalyticsAdapter'
 import * as events from 'src/events'
-import constants from 'src/constants.json'
+import { EVENTS } from 'src/constants.js'
 
 const auctionId = 'b0b39610-b941-4659-a87c-de9f62d3e13e'
 const propertyId = '123456'
@@ -481,14 +481,14 @@ describe('Malltv Prebid AnalyticsAdapter Testing', function () {
 
     it('should call handleBidTimeout as BID_TIMEOUT trigger event', function() {
       sinon.spy(malltvAnalyticsAdapter, 'handleBidTimeout')
-      events.emit(constants.EVENTS.BID_TIMEOUT, {})
+      events.emit(EVENTS.BID_TIMEOUT, {})
       sinon.assert.callCount(malltvAnalyticsAdapter.handleBidTimeout, 1)
       malltvAnalyticsAdapter.handleBidTimeout.restore()
     })
 
     it('should call handleAuctionEnd as AUCTION_END trigger event', function() {
       sinon.spy(malltvAnalyticsAdapter, 'handleAuctionEnd')
-      events.emit(constants.EVENTS.AUCTION_END, {})
+      events.emit(EVENTS.AUCTION_END, {})
       sinon.assert.callCount(malltvAnalyticsAdapter.handleAuctionEnd, 1)
       malltvAnalyticsAdapter.handleAuctionEnd.restore()
     })

package/test/spec/modules/mediafilterRtdProvider_spec.js

@@ -1,7 +1,7 @@
 import * as utils from '../../../src/utils.js';
 import * as hook from '../../../src/hook.js'
 import * as events from '../../../src/events.js';
-import CONSTANTS from '../../../src/constants.json';
+import { EVENTS } from '../../../src/constants.js';
 
 import {
   MediaFilter,
@@ -121,7 +121,7 @@ describe('The Media Filter RTD module', function () {
 
       eventHandler(mockEvent);
 
-      expect(eventsEmitSpy.calledWith(CONSTANTS.EVENTS.BILLABLE_EVENT, {
+      expect(eventsEmitSpy.calledWith(EVENTS.BILLABLE_EVENT, {
         'billingId': sinon.match.string,
         'configurationHash': configurationHash,
         'type': 'impression',

package/test/spec/modules/medianetAnalyticsAdapter_spec.js

@@ -1,13 +1,13 @@
 import { expect } from 'chai';
 import medianetAnalytics from 'modules/medianetAnalyticsAdapter.js';
 import * as utils from 'src/utils.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS } from 'src/constants.js';
 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 }
-} = CONSTANTS;
+  AUCTION_INIT, BID_REQUESTED, BID_RESPONSE, NO_BID, BID_TIMEOUT, AUCTION_END, SET_TARGETING, BID_WON
+} = EVENTS;
 
 const ERROR_WINNING_BID_ABSENT = 'winning_bid_absent';
 

package/test/spec/modules/nobidAnalyticsAdapter_spec.js

@@ -1,9 +1,9 @@
 import nobidAnalytics from 'modules/nobidAnalyticsAdapter.js';
 import {expect} from 'chai';
 import {server} from 'test/mocks/xhr.js';
+import { EVENTS } from 'src/constants.js';
 let events = require('src/events');
 let adapterManager = require('src/adapterManager').default;
-let constants = require('src/constants.json');
 
 const TOP_LOCATION = 'https://www.somesite.com';
 const SITE_ID = 1234;
@@ -46,7 +46,7 @@ describe('NoBid Prebid Analytic', function () {
       });
 
       // Step 2: Send init auction event
-      events.emit(constants.EVENTS.AUCTION_INIT, {config: initOptions,
+      events.emit(EVENTS.AUCTION_INIT, {config: initOptions,
         auctionId: '13',
         timestamp: Date.now(),
         bidderRequests: [{refererInfo: {topmostLocation: TOP_LOCATION}}]});
@@ -77,27 +77,27 @@ describe('NoBid Prebid Analytic', function () {
       });
 
       // Step 2: Send init auction event
-      events.emit(constants.EVENTS.AUCTION_INIT, {config: initOptions,
+      events.emit(EVENTS.AUCTION_INIT, {config: initOptions,
         auctionId: '13',
         timestamp: Date.now(),
         bidderRequests: [{refererInfo: {topmostLocation: TOP_LOCATION}}]});
-      events.emit(constants.EVENTS.BID_WON, {});
+      events.emit(EVENTS.BID_WON, {});
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
 
-      events.emit(constants.EVENTS.BID_REQUESTED, {});
+      events.emit(EVENTS.BID_REQUESTED, {});
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
 
-      events.emit(constants.EVENTS.BID_RESPONSE, {});
+      events.emit(EVENTS.BID_RESPONSE, {});
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
 
-      events.emit(constants.EVENTS.BID_TIMEOUT, {});
+      events.emit(EVENTS.BID_TIMEOUT, {});
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
 
-      events.emit(constants.EVENTS.AD_RENDER_SUCCEEDED, {});
+      events.emit(EVENTS.AD_RENDER_SUCCEEDED, {});
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
 
@@ -191,13 +191,13 @@ describe('NoBid Prebid Analytic', function () {
       });
 
       // Step 2: Send init auction event
-      events.emit(constants.EVENTS.AUCTION_INIT, {config: initOptions,
+      events.emit(EVENTS.AUCTION_INIT, {config: initOptions,
         auctionId: '13',
         timestamp: Date.now(),
         bidderRequests: [{refererInfo: {topmostLocation: TOP_LOCATION}}]});
 
       // Step 3: Send bid won event
-      events.emit(constants.EVENTS.BID_WON, requestIncoming);
+      events.emit(EVENTS.BID_WON, requestIncoming);
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
       const bidWonRequest = JSON.parse(server.requests[0].requestBody);
@@ -388,13 +388,13 @@ describe('NoBid Prebid Analytic', function () {
       });
 
       // Step 2: Send init auction event
-      events.emit(constants.EVENTS.AUCTION_INIT, {config: initOptions,
+      events.emit(EVENTS.AUCTION_INIT, {config: initOptions,
         auctionId: '13',
         timestamp: Date.now(),
         bidderRequests: [{refererInfo: {topmostLocation: `${TOP_LOCATION}_something`}}]});
 
       // Step 3: Send bid won event
-      events.emit(constants.EVENTS.AUCTION_END, requestIncoming);
+      events.emit(EVENTS.AUCTION_END, requestIncoming);
       clock.tick(5000);
       expect(server.requests).to.have.length(1);
       const auctionEndRequest = JSON.parse(server.requests[0].requestBody);
@@ -428,22 +428,22 @@ describe('NoBid Prebid Analytic', function () {
       nobidAnalytics.processServerResponse(JSON.stringify({disabled: 0}));
       disabled = nobidAnalytics.isAnalyticsDisabled();
       expect(disabled).to.equal(false);
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '1234567890'});
+      events.emit(EVENTS.AUCTION_END, {auctionId: '1234567890'});
       clock.tick(1000);
       expect(server.requests).to.have.length(1);
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '12345678901'});
+      events.emit(EVENTS.AUCTION_END, {auctionId: '12345678901'});
       clock.tick(1000);
       expect(server.requests).to.have.length(2);
 
       nobidAnalytics.processServerResponse('disabled: true');
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '12345678902'});
+      events.emit(EVENTS.AUCTION_END, {auctionId: '12345678902'});
       clock.tick(1000);
       expect(server.requests).to.have.length(3);
 
       nobidAnalytics.processServerResponse(JSON.stringify({disabled: 1}));
       disabled = nobidAnalytics.isAnalyticsDisabled();
       expect(disabled).to.equal(true);
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '12345678902'});
+      events.emit(EVENTS.AUCTION_END, {auctionId: '12345678902'});
       clock.tick(5000);
       expect(server.requests).to.have.length(3);
 
@@ -481,7 +481,7 @@ describe('NoBid Prebid Analytic', function () {
       nobidAnalytics.enableAnalytics(initOptions);
       adapterManager.enableAnalytics({ provider: 'nobid', options: initOptions });
 
-      let eventType = constants.EVENTS.AUCTION_END;
+      let eventType = EVENTS.AUCTION_END;
       let disabled;
       nobidAnalytics.processServerResponse(JSON.stringify({disabled: 0}));
       disabled = nobidAnalytics.isAnalyticsDisabled();
@@ -508,14 +508,14 @@ describe('NoBid Prebid Analytic', function () {
       nobidAnalytics.processServerResponse(JSON.stringify({disabled_auctionEnd: 0}));
       disabled = nobidAnalytics.isAnalyticsDisabled(eventType);
       expect(disabled).to.equal(false);
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '1234567890'});
+      events.emit(EVENTS.AUCTION_END, {auctionId: '1234567890'});
       clock.tick(1000);
       expect(server.requests).to.have.length(1);
 
       server.requests.length = 0;
       expect(server.requests).to.have.length(0);
 
-      eventType = constants.EVENTS.BID_WON;
+      eventType = EVENTS.BID_WON;
       nobidAnalytics.processServerResponse(JSON.stringify({disabled_bidWon: 1}));
       disabled = nobidAnalytics.isAnalyticsDisabled(eventType);
       expect(disabled).to.equal(true);
@@ -526,7 +526,7 @@ describe('NoBid Prebid Analytic', function () {
       server.requests.length = 0;
       expect(server.requests).to.have.length(0);
 
-      eventType = constants.EVENTS.AUCTION_END;
+      eventType = EVENTS.AUCTION_END;
       nobidAnalytics.processServerResponse(JSON.stringify({disabled: 1}));
       disabled = nobidAnalytics.isAnalyticsDisabled(eventType);
       expect(disabled).to.equal(true);
@@ -537,16 +537,16 @@ describe('NoBid Prebid Analytic', function () {
       server.requests.length = 0;
       expect(server.requests).to.have.length(0);
 
-      eventType = constants.EVENTS.AUCTION_END;
+      eventType = EVENTS.AUCTION_END;
       nobidAnalytics.processServerResponse(JSON.stringify({disabled_auctionEnd: 1, disabled_bidWon: 0}));
       disabled = nobidAnalytics.isAnalyticsDisabled(eventType);
       expect(disabled).to.equal(true);
       events.emit(eventType, {auctionId: '1234567890'});
       clock.tick(1000);
       expect(server.requests).to.have.length(0);
-      disabled = nobidAnalytics.isAnalyticsDisabled(constants.EVENTS.BID_WON);
+      disabled = nobidAnalytics.isAnalyticsDisabled(EVENTS.BID_WON);
       expect(disabled).to.equal(false);
-      events.emit(constants.EVENTS.BID_WON, {bidderCode: 'nobid'});
+      events.emit(EVENTS.BID_WON, {bidderCode: 'nobid'});
       clock.tick(1000);
       expect(server.requests).to.have.length(1);