prebid.js 8.43.0 → 8.45.0

package/test/spec/modules/priceFloors_spec.js

@@ -1,8 +1,9 @@
 import {expect} from 'chai';
 import * as utils from 'src/utils.js';
 import { getGlobal } from 'src/prebidGlobal.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS, STATUS } from 'src/constants.js';
 import {
+  FLOOR_SKIPPED_REASON,
   _floorDataForAuction,
   getFloorsDataForAuction,
   getFirstMatchingFloor,
@@ -737,7 +738,7 @@ describe('the price floors module', function () {
       handleSetFloorsConfig(floorConfig);
 
       const floorData = createFloorsDataForAuction(adUnits, 'id');
-      expect(floorData.skippedReason).to.equal(CONSTANTS.FLOOR_SKIPPED_REASON.NOT_FOUND);
+      expect(floorData.skippedReason).to.equal(FLOOR_SKIPPED_REASON.NOT_FOUND);
     });
 
     it('should have skippedReason set to "random" if there is floor data and skipped is true', function() {
@@ -746,7 +747,7 @@ describe('the price floors module', function () {
       handleSetFloorsConfig(floorConfig);
 
       const floorData = createFloorsDataForAuction(adUnits, 'id');
-      expect(floorData.skippedReason).to.equal(CONSTANTS.FLOOR_SKIPPED_REASON.RANDOM);
+      expect(floorData.skippedReason).to.equal(FLOOR_SKIPPED_REASON.RANDOM);
     });
   });
 
@@ -2218,7 +2219,7 @@ describe('the price floors module', function () {
       let next = (adUnitCode, bid) => {
         returnedBidResponse = bid;
       };
-      addBidResponseHook(next, bidResp.adUnitCode, Object.assign(createBid(CONSTANTS.STATUS.GOOD, {auctionId: AUCTION_ID}), bidResp), reject);
+      addBidResponseHook(next, bidResp.adUnitCode, Object.assign(createBid(STATUS.GOOD, { auctionId: AUCTION_ID }), bidResp), reject);
     };
     it('continues with the auction if not floors data is present without any flooring', function () {
       runBidResponse();
@@ -2345,7 +2346,7 @@ describe('the price floors module', function () {
     it('should wait 3 seconds before deleting auction floor data', function () {
       handleSetFloorsConfig({enabled: true});
       _floorDataForAuction[AUCTION_END_EVENT.auctionId] = utils.deepClone(basicFloorConfig);
-      events.emit(CONSTANTS.EVENTS.AUCTION_END, AUCTION_END_EVENT);
+      events.emit(EVENTS.AUCTION_END, AUCTION_END_EVENT);
       // should still be here
       expect(_floorDataForAuction[AUCTION_END_EVENT.auctionId]).to.not.be.undefined;
       // tick for 4 seconds

package/test/spec/modules/pubmaticAnalyticsAdapter_spec.js

@@ -1,6 +1,6 @@
 import pubmaticAnalyticsAdapter, { getMetadata } from 'modules/pubmaticAnalyticsAdapter.js';
 import adapterManager from 'src/adapterManager.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS, REJECTION_REASON } from 'src/constants.js';
 import { config } from 'src/config.js';
 import { setConfig } from 'modules/currency.js';
 import { server } from '../../mocks/xhr.js';
@@ -18,18 +18,16 @@ const setUAMobile = () => { window.navigator.__defineGetter__('userAgent', funct
 const setUANull = () => { window.navigator.__defineGetter__('userAgent', function () { return null }) };
 
 const {
-  EVENTS: {
-    AUCTION_INIT,
-    AUCTION_END,
-    BID_REQUESTED,
-    BID_RESPONSE,
-    BID_REJECTED,
-    BIDDER_DONE,
-    BID_WON,
-    BID_TIMEOUT,
-    SET_TARGETING
-  }
-} = CONSTANTS;
+  AUCTION_INIT,
+  AUCTION_END,
+  BID_REQUESTED,
+  BID_RESPONSE,
+  BID_REJECTED,
+  BIDDER_DONE,
+  BID_WON,
+  BID_TIMEOUT,
+  SET_TARGETING
+} = EVENTS;
 
 const BID = {
   'bidder': 'pubmatic',
@@ -110,7 +108,7 @@ const BID2 = Object.assign({}, BID, {
 });
 
 const BID3 = Object.assign({}, BID2, {
-  rejectionReason: CONSTANTS.REJECTION_REASON.FLOOR_NOT_MET
+  rejectionReason: REJECTION_REASON.FLOOR_NOT_MET
 })
 const MOCK = {
   SET_TARGETING: {

package/test/spec/modules/pubmaticBidAdapter_spec.js

@@ -4,7 +4,7 @@ import * as utils from 'src/utils.js';
 import { config } from 'src/config.js';
 import { createEidsArray } from 'modules/userId/eids.js';
 import { bidderSettings } from 'src/bidderSettings.js';
-const constants = require('src/constants.json');
+const constants = require('src/constants.js');
 
 describe('PubMatic adapter', function () {
   let bidRequests;

package/test/spec/modules/pubstackAnalyticsAdapter_spec.js

@@ -2,7 +2,6 @@ import * as utils from 'src/utils.js';
 import pubstackAnalytics from '../../../modules/pubstackAnalyticsAdapter.js';
 import adapterManager from 'src/adapterManager';
 import * as events from 'src/events';
-import constants from 'src/constants.json'
 import {expectEvents} from '../../helpers/analytics.js';
 
 describe('Pubstack Analytics Adapter', () => {

package/test/spec/modules/pubwiseAnalyticsAdapter_spec.js

@@ -2,10 +2,10 @@ import {expect} from 'chai';
 import pubwiseAnalytics from 'modules/pubwiseAnalyticsAdapter.js';
 import {expectEvents} from '../../helpers/analytics.js';
 import {server} from '../../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');
 
 describe('PubWise Prebid Analytics', function () {
   let requests;
@@ -54,14 +54,14 @@ describe('PubWise Prebid Analytics', function () {
       sandbox.spy(pubwiseAnalytics, 'track');
 
       expectEvents([
-        constants.EVENTS.AUCTION_INIT,
-        constants.EVENTS.BID_REQUESTED,
-        constants.EVENTS.BID_RESPONSE,
-        constants.EVENTS.BID_WON,
-        constants.EVENTS.AD_RENDER_FAILED,
-        constants.EVENTS.TCF2_ENFORCEMENT,
-        constants.EVENTS.BID_TIMEOUT,
-        constants.EVENTS.AUCTION_END,
+        EVENTS.AUCTION_INIT,
+        EVENTS.BID_REQUESTED,
+        EVENTS.BID_RESPONSE,
+        EVENTS.BID_WON,
+        EVENTS.AD_RENDER_FAILED,
+        EVENTS.TCF2_ENFORCEMENT,
+        EVENTS.BID_TIMEOUT,
+        EVENTS.AUCTION_END,
       ]).to.beTrackedBy(pubwiseAnalytics.track);
     });
 
@@ -69,10 +69,10 @@ describe('PubWise Prebid Analytics', function () {
       pubwiseAnalytics.enableAnalytics(mock.DEFAULT_PW_CONFIG);
 
       // sent
-      events.emit(constants.EVENTS.AUCTION_INIT, mock.AUCTION_INIT);
-      events.emit(constants.EVENTS.BID_REQUESTED, {});
-      events.emit(constants.EVENTS.BID_RESPONSE, {});
-      events.emit(constants.EVENTS.BID_WON, {});
+      events.emit(EVENTS.AUCTION_INIT, mock.AUCTION_INIT);
+      events.emit(EVENTS.BID_REQUESTED, {});
+      events.emit(EVENTS.BID_RESPONSE, {});
+      events.emit(EVENTS.BID_WON, {});
       // force flush
       clock.tick(500);
 
@@ -120,7 +120,7 @@ describe('PubWise Prebid Analytics', function () {
       pubwiseAnalytics.enableAnalytics(mock.DEFAULT_PW_CONFIG);
 
       // sent
-      events.emit(constants.EVENTS.AUCTION_INIT, mock.AUCTION_INIT_EXTRAS);
+      events.emit(EVENTS.AUCTION_INIT, mock.AUCTION_INIT_EXTRAS);
       // force flush
       clock.tick(500);
 

package/test/spec/modules/pubxaiAnalyticsAdapter_spec.js

@@ -4,9 +4,9 @@ import adapterManager from 'src/adapterManager.js';
 import * as utils from 'src/utils.js';
 import {server} from 'test/mocks/xhr.js';
 import {getGptSlotInfoForAdUnitCode} from '../../../libraries/gptUtils/gptUtils.js';
+import { EVENTS } from 'src/constants.js';
 
 let events = require('src/events');
-let constants = require('src/constants.json');
 
 describe('pubxai analytics adapter', function() {
   beforeEach(function() {
@@ -671,19 +671,19 @@ describe('pubxai analytics adapter', function() {
 
     it('builds and sends auction data', function() {
       // Step 1: Send auction init event
-      events.emit(constants.EVENTS.AUCTION_INIT, prebidEvent['auctionInit']);
+      events.emit(EVENTS.AUCTION_INIT, prebidEvent['auctionInit']);
 
       // Step 2: Send bid requested event
-      events.emit(constants.EVENTS.BID_REQUESTED, prebidEvent['bidRequested']);
+      events.emit(EVENTS.BID_REQUESTED, prebidEvent['bidRequested']);
 
       // Step 3: Send bid response event
-      events.emit(constants.EVENTS.BID_RESPONSE, prebidEvent['bidResponse']);
+      events.emit(EVENTS.BID_RESPONSE, prebidEvent['bidResponse']);
 
       // Step 4: Send bid time out event
-      events.emit(constants.EVENTS.BID_TIMEOUT, prebidEvent['bidTimeout']);
+      events.emit(EVENTS.BID_TIMEOUT, prebidEvent['bidTimeout']);
 
       // Step 5: Send auction end event
-      events.emit(constants.EVENTS.AUCTION_END, prebidEvent['auctionEnd']);
+      events.emit(EVENTS.AUCTION_END, prebidEvent['auctionEnd']);
 
       expect(server.requests.length).to.equal(1);
 
@@ -692,7 +692,7 @@ describe('pubxai analytics adapter', function() {
       expect(realAfterBid).to.deep.equal(expectedAfterBid);
 
       // Step 6: Send auction bid won event
-      events.emit(constants.EVENTS.BID_WON, prebidEvent['bidWon']);
+      events.emit(EVENTS.BID_WON, prebidEvent['bidWon']);
 
       expect(server.requests.length).to.equal(2);
 

package/test/spec/modules/qortexRtdProvider_spec.js

@@ -1,7 +1,7 @@
 import * as utils from 'src/utils';
 import * as ajax from 'src/ajax.js';
 import * as events from 'src/events.js';
-import CONSTANTS from '../../../src/constants.json';
+import { EVENTS } from '../../../src/constants.js';
 import {loadExternalScript} from 'src/adloader.js';
 import {
   qortexSubmodule as module,
@@ -127,7 +127,7 @@ describe('qortexRtdProvider', () => {
     let config = cloneDeep(validModuleConfig);
     config.params.tagConfig = validTagConfig;
 
-    events.on(CONSTANTS.EVENTS.BILLABLE_EVENT, (e) => {
+    events.on(EVENTS.BILLABLE_EVENT, (e) => {
       billableEvents.push(e);
     })
 

package/test/spec/modules/realTimeDataModule_spec.js

@@ -1,7 +1,7 @@
 import * as rtdModule from 'modules/rtdModule/index.js';
 import {config} from 'src/config.js';
 import * as sinon from 'sinon';
-import {default as CONSTANTS} from '../../../src/constants.json';
+import { EVENTS } from '../../../src/constants.js';
 import * as events from '../../../src/events.js';
 import 'src/prebid.js';
 import {attachRealTimeDataProvider, onDataDeletionRequest} from 'modules/rtdModule/index.js';
@@ -255,11 +255,11 @@ describe('Real time module', function () {
   });
 
   describe('event', () => {
-    const EVENTS = {
-      [CONSTANTS.EVENTS.AUCTION_INIT]: 'onAuctionInitEvent',
-      [CONSTANTS.EVENTS.AUCTION_END]: 'onAuctionEndEvent',
-      [CONSTANTS.EVENTS.BID_RESPONSE]: 'onBidResponseEvent',
-      [CONSTANTS.EVENTS.BID_REQUESTED]: 'onBidRequestEvent'
+    const TEST_EVENTS = {
+      [EVENTS.AUCTION_INIT]: 'onAuctionInitEvent',
+      [EVENTS.AUCTION_END]: 'onAuctionEndEvent',
+      [EVENTS.BID_RESPONSE]: 'onBidResponseEvent',
+      [EVENTS.BID_REQUESTED]: 'onBidRequestEvent'
     }
     const conf = {
       'realTimeData': {
@@ -281,7 +281,7 @@ describe('Real time module', function () {
         name: name,
         init: () => true,
       }
-      Object.values(EVENTS).forEach((ev) => provider[ev] = sinon.spy());
+      Object.values(TEST_EVENTS).forEach((ev) => provider[ev] = sinon.spy());
       return provider;
     }
 
@@ -303,13 +303,13 @@ describe('Real time module', function () {
         adUnitCodes: ['a1'],
         adUnits: [{code: 'a1'}]
       };
-      mockEmitEvent(CONSTANTS.EVENTS.AUCTION_END, auction);
+      mockEmitEvent(EVENTS.AUCTION_END, auction);
       providers.forEach(p => {
         expect(p.getTargetingData.calledWith(auction.adUnitCodes)).to.be.true;
       });
     });
 
-    Object.entries(EVENTS).forEach(([event, hook]) => {
+    Object.entries(TEST_EVENTS).forEach(([event, hook]) => {
       it(`'${event}' should be propagated to providers through '${hook}'`, () => {
         const eventArg = {};
         mockEmitEvent(event, eventArg);

package/test/spec/modules/relevantAnalyticsAdapter_spec.js

@@ -1,7 +1,7 @@
 import relevantAnalytics from '../../../modules/relevantAnalyticsAdapter.js';
 import adapterManager from 'src/adapterManager';
 import * as events from 'src/events';
-import constants from 'src/constants.json'
+import { EVENTS } from 'src/constants.js'
 import { expect } from 'chai';
 
 describe('Relevant Analytics Adapter', () => {
@@ -18,8 +18,8 @@ describe('Relevant Analytics Adapter', () => {
   it('should pass all events to the global array', () => {
     // Given
     const testEvents = [
-      { ev: constants.EVENTS.AUCTION_INIT, args: { test: 1 } },
-      { ev: constants.EVENTS.BID_REQUESTED, args: { test: 2 } },
+      { ev: EVENTS.AUCTION_INIT, args: { test: 1 } },
+      { ev: EVENTS.BID_REQUESTED, args: { test: 2 } },
     ];
 
     // When

package/test/spec/modules/relevantdigitalBidAdapter_spec.js

@@ -1,7 +1,7 @@
 import {spec, resetBidderConfigs} from 'modules/relevantdigitalBidAdapter.js';
 import { parseUrl, deepClone } from 'src/utils.js';
 import { config } from 'src/config.js';
-import CONSTANTS from 'src/constants.json';
+import { S2S } from 'src/constants.js';
 
 import adapterManager, {
 } from 'src/adapterManager.js';
@@ -16,7 +16,7 @@ const TEST_PAGE = `https://${TEST_DOMAIN}/page.html`;
 
 const CONFIG = {
   enabled: true,
-  endpoint: CONSTANTS.S2S.DEFAULT_ENDPOINT,
+  endpoint: S2S.DEFAULT_ENDPOINT,
   timeout: 1000,
   maxBids: 1,
   adapter: 'prebidServer',

package/test/spec/modules/rivrAnalyticsAdapter_spec.js

@@ -19,7 +19,7 @@ import {
 import {expect} from 'chai';
 import adapterManager from 'src/adapterManager.js';
 import * as ajax from 'src/ajax.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS } from 'src/constants.js';
 
 const events = require('../../../src/events');
 
@@ -98,7 +98,7 @@ describe('RIVR Analytics adapter', () => {
 
     expect(rivraddonsTrackPbjsEventStub.callCount).to.be.equal(0);
 
-    events.emit(CONSTANTS.EVENTS.AUCTION_INIT, {auctionId: EMITTED_AUCTION_ID, config: {}, timeout: 3000});
+    events.emit(EVENTS.AUCTION_INIT, { auctionId: EMITTED_AUCTION_ID, config: {}, timeout: 3000 });
 
     expect(rivraddonsTrackPbjsEventStub.callCount).to.be.equal(0);
 
@@ -111,12 +111,12 @@ describe('RIVR Analytics adapter', () => {
 
     expect(rivraddonsTrackPbjsEventStub.callCount).to.be.equal(0);
 
-    events.emit(CONSTANTS.EVENTS.AUCTION_INIT, {auctionId: EMITTED_AUCTION_ID, config: {}, timeout: 3000});
+    events.emit(EVENTS.AUCTION_INIT, { auctionId: EMITTED_AUCTION_ID, config: {}, timeout: 3000 });
 
     expect(rivraddonsTrackPbjsEventStub.callCount).to.be.equal(1);
 
     const firstArgument = rivraddonsTrackPbjsEventStub.getCall(0).args[0];
-    expect(firstArgument.eventType).to.be.equal(CONSTANTS.EVENTS.AUCTION_INIT);
+    expect(firstArgument.eventType).to.be.equal(EVENTS.AUCTION_INIT);
     expect(firstArgument.args.auctionId).to.be.equal(EMITTED_AUCTION_ID);
 
     window.rivraddon.analytics.trackPbjsEvent.restore();

package/test/spec/modules/roxotAnalyticsAdapter_spec.js

@@ -1,9 +1,9 @@
 import roxotAnalytic from 'modules/roxotAnalyticsAdapter.js';
 import {expect} from 'chai';
 import {server} from 'test/mocks/xhr.js';
+import { EVENTS } from 'src/constants.js';
 
 let events = require('src/events');
-let constants = require('src/constants.json');
 
 describe('Roxot Prebid Analytic', function () {
   let roxotConfigServerUrl = 'config-server';
@@ -181,18 +181,18 @@ describe('Roxot Prebid Analytic', function () {
       expect(server.requests[0].url).to.equal('https://' + roxotConfigServerUrl + '/c?publisherId=' + publisherId + '&host=localhost');
       server.requests[0].respond(200, {'Content-Type': 'application/json'}, '{"a": 1, "i": 1, "bat": 1}');
 
-      events.emit(constants.EVENTS.AUCTION_INIT, auctionInit);
-      events.emit(constants.EVENTS.BID_REQUESTED, bidRequested);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentWithBid);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseWithBid);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentNoBid);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseNoBid);
-      events.emit(constants.EVENTS.BID_TIMEOUT, bidTimeout);
-      events.emit(constants.EVENTS.AUCTION_END, auctionEnd);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentAfterTimeout);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseAfterTimeout);
-      events.emit(constants.EVENTS.BIDDER_DONE, bidderDone);
-      events.emit(constants.EVENTS.BID_WON, bidWon);
+      events.emit(EVENTS.AUCTION_INIT, auctionInit);
+      events.emit(EVENTS.BID_REQUESTED, bidRequested);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentWithBid);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseWithBid);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentNoBid);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseNoBid);
+      events.emit(EVENTS.BID_TIMEOUT, bidTimeout);
+      events.emit(EVENTS.AUCTION_END, auctionEnd);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentAfterTimeout);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseAfterTimeout);
+      events.emit(EVENTS.BIDDER_DONE, bidderDone);
+      events.emit(EVENTS.BID_WON, bidWon);
 
       expect(server.requests.length).to.equal(4);
 
@@ -260,18 +260,18 @@ describe('Roxot Prebid Analytic', function () {
       expect(server.requests[0].url).to.equal('https://' + roxotConfigServerUrl + '/c?publisherId=' + publisherId + '&host=localhost');
       server.requests[0].respond(200, {'Content-Type': 'application/json'}, '{"a": 1, "i": 1, "bat": 1}');
 
-      events.emit(constants.EVENTS.AUCTION_INIT, auctionInit);
-      events.emit(constants.EVENTS.BID_REQUESTED, bidRequested);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentWithBid);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseWithBid);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentNoBid);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseNoBid);
-      events.emit(constants.EVENTS.BID_TIMEOUT, bidTimeout);
-      events.emit(constants.EVENTS.AUCTION_END, auctionEnd);
-      events.emit(constants.EVENTS.BID_ADJUSTMENT, bidAdjustmentAfterTimeout);
-      events.emit(constants.EVENTS.BID_RESPONSE, bidResponseAfterTimeout);
-      events.emit(constants.EVENTS.BIDDER_DONE, bidderDone);
-      events.emit(constants.EVENTS.BID_WON, bidWon);
+      events.emit(EVENTS.AUCTION_INIT, auctionInit);
+      events.emit(EVENTS.BID_REQUESTED, bidRequested);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentWithBid);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseWithBid);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentNoBid);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseNoBid);
+      events.emit(EVENTS.BID_TIMEOUT, bidTimeout);
+      events.emit(EVENTS.AUCTION_END, auctionEnd);
+      events.emit(EVENTS.BID_ADJUSTMENT, bidAdjustmentAfterTimeout);
+      events.emit(EVENTS.BID_RESPONSE, bidResponseAfterTimeout);
+      events.emit(EVENTS.BIDDER_DONE, bidderDone);
+      events.emit(EVENTS.BID_WON, bidWon);
 
       expect(server.requests.length).to.equal(3);
 

package/test/spec/modules/scaleableAnalyticsAdapter_spec.js

@@ -1,13 +1,13 @@
 import scaleableAnalytics from 'modules/scaleableAnalyticsAdapter.js';
 import { expect } from 'chai';
 import * as events from 'src/events.js';
-import CONSTANTS from 'src/constants.json';
+import { EVENTS } from 'src/constants.js';
 import { server } from 'test/mocks/xhr.js';
 
-const BID_TIMEOUT = CONSTANTS.EVENTS.BID_TIMEOUT;
-const AUCTION_INIT = CONSTANTS.EVENTS.AUCTION_INIT;
-const BID_WON = CONSTANTS.EVENTS.BID_WON;
-const AUCTION_END = CONSTANTS.EVENTS.AUCTION_END;
+const BID_TIMEOUT = EVENTS.BID_TIMEOUT;
+const AUCTION_INIT = EVENTS.AUCTION_INIT;
+const BID_WON = EVENTS.BID_WON;
+const AUCTION_END = EVENTS.AUCTION_END;
 
 describe('Scaleable Analytics Adapter', function() {
   const bidsReceivedObj = {

package/test/spec/modules/seedtagBidAdapter_spec.js

@@ -1,8 +1,8 @@
 import { expect } from 'chai';
-import { spec, getTimeoutUrl } from 'modules/seedtagBidAdapter.js';
+import { getTimeoutUrl, spec } from 'modules/seedtagBidAdapter.js';
 import * as utils from 'src/utils.js';
-import { config } from '../../../src/config.js';
 import * as mockGpt from 'test/spec/integration/faker/googletag.js';
+import { config } from '../../../src/config.js';
 
 const PUBLISHER_ID = '0000-0000-01';
 const ADUNIT_ID = '000000';
@@ -536,8 +536,61 @@ describe('Seedtag Adapter', function () {
         expect(data.gppConsent).to.be.undefined;
       });
     });
-  });
 
+    describe('User param', function () {
+      it('should be added to payload user data param when bidderRequest has ortb2 user info', function () {
+        var ortb2 = {
+
+          user: {
+
+            data: [
+              {
+                ext: {
+                  segtax: 601,
+                  segclass: '4'
+                },
+                segment: [
+                  {
+                    id: '149'
+                  }
+                ],
+                name: 'randomname'
+              }
+
+            ]
+          }
+        }
+        bidderRequest['ortb2'] = ortb2
+        const request = spec.buildRequests(validBidRequests, bidderRequest);
+        const data = JSON.parse(request.data);
+
+        expect(data.user).to.exist;
+        expect(data.user.topics).to.exist;
+        expect(data.user.topics).to.be.an('array').that.is.not.empty;
+        expect(data.user.topics[0].ext).to.eql(ortb2.user.data[0].ext);
+        expect(data.user.topics[0].segment).to.eql(ortb2.user.data[0].segment);
+        expect(data.user.topics[0].name).to.eql(ortb2.user.data[0].name);
+      })
+
+      it('should be added to payload user eids param when validRequest has userId info', function () {
+        var userIdAsEids = [{
+          source: 'sourceid',
+          uids: [{
+            atype: 1,
+            id: 'randomId'
+          }]
+        }]
+        validBidRequests[0]['userIdAsEids'] = userIdAsEids
+        const request = spec.buildRequests(validBidRequests, bidderRequest);
+        const data = JSON.parse(request.data);
+
+        expect(data.user).to.exist;
+        expect(data.user.eids).to.exist;
+        expect(data.user.eids).to.be.an('array').that.is.not.empty;
+        expect(data.user.eids).to.deep.equal(userIdAsEids);
+      })
+    });
+  })
   describe('interpret response method', function () {
     it('should return a void array, when the server response are not correct.', function () {
       const request = { data: JSON.stringify({}) };

package/test/spec/modules/sigmoidAnalyticsAdapter_spec.js

@@ -4,7 +4,6 @@ import {expectEvents} from '../../helpers/analytics.js';
 
 let events = require('src/events');
 let adapterManager = require('src/adapterManager').default;
-let constants = require('src/constants.json');
 
 describe('sigmoid Prebid Analytic', function () {
   after(function () {

package/test/spec/modules/sonobiAnalyticsAdapter_spec.js

@@ -1,9 +1,10 @@
 import sonobiAnalytics, {DEFAULT_EVENT_URL} from 'modules/sonobiAnalyticsAdapter.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');
 
 describe('Sonobi Prebid Analytic', function () {
   var clock;
@@ -55,25 +56,25 @@ describe('Sonobi Prebid Analytic', function () {
       });
 
       // Step 2: Send init auction event
-      events.emit(constants.EVENTS.AUCTION_INIT, {config: initOptions, auctionId: '13', timestamp: Date.now()});
+      events.emit(EVENTS.AUCTION_INIT, { config: initOptions, auctionId: '13', timestamp: Date.now() });
 
       expect(sonobiAnalytics.initOptions).to.have.property('pubId', 'A3B254F');
       expect(sonobiAnalytics.initOptions).to.have.property('siteId', '1234');
       expect(sonobiAnalytics.initOptions).to.have.property('delay', 100);
       // Step 3: Send bid requested event
-      events.emit(constants.EVENTS.BID_REQUESTED, { bids: [bid], auctionId: '13' });
+      events.emit(EVENTS.BID_REQUESTED, { bids: [bid], auctionId: '13' });
 
       // Step 4: Send bid response event
-      events.emit(constants.EVENTS.BID_RESPONSE, bid);
+      events.emit(EVENTS.BID_RESPONSE, bid);
 
       // Step 5: Send bid won event
-      events.emit(constants.EVENTS.BID_WON, bid);
+      events.emit(EVENTS.BID_WON, bid);
 
       // Step 6: Send bid timeout event
-      events.emit(constants.EVENTS.BID_TIMEOUT, {auctionId: '13'});
+      events.emit(EVENTS.BID_TIMEOUT, { auctionId: '13' });
 
       // Step 7: Send auction end event
-      events.emit(constants.EVENTS.AUCTION_END, {auctionId: '13', bidsReceived: [bid]});
+      events.emit(EVENTS.AUCTION_END, { auctionId: '13', bidsReceived: [bid] });
 
       clock.tick(5000);
       const req = server.requests.find(req => req.url.indexOf(DEFAULT_EVENT_URL) !== -1);

package/test/spec/modules/sonobiBidAdapter_spec.js

@@ -495,13 +495,11 @@ describe('SonobiBidAdapter', function () {
       expect(bidRequests.data.hfa).to.equal('hfakey')
     })
 
-    it('should return a properly formatted request with expData and expKey', function () {
-      bidderRequests.ortb2.experianRtidData = 'IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg==';
-      bidderRequests.ortb2.experianRtidKey = 'sovrn-encryption-key-1';
+    it('should return a properly formatted request with experianRtidData and exexperianRtidKeypKey omitted from fpd', function () {
       const bidRequests = spec.buildRequests(bidRequest, bidderRequests)
-      expect(bidRequests.data.expData).to.equal('IkhlbGxvLCB3b3JsZC4gSGVsbG8sIHdvcmxkLiBIZWxsbywgd29ybGQuIg==');
-      expect(bidRequests.data.expKey).to.equal('sovrn-encryption-key-1');
-    })
+      expect(bidRequests.data.fpd.indexOf('experianRtidData')).to.equal(-1);
+      expect(bidRequests.data.fpd.indexOf('exexperianRtidKeypKey')).to.equal(-1);
+    });
 
     it('should return null if there is nothing to bid on', function () {
       const bidRequests = spec.buildRequests([{ params: {} }], bidderRequests)

package/test/spec/modules/sovrnAnalyticsAdapter_spec.js

@@ -4,11 +4,11 @@ import {config} from 'src/config.js';
 import adaptermanager from 'src/adapterManager.js';
 import {server} from 'test/mocks/xhr.js';
 import {expectEvents, fireEvents} from '../../helpers/analytics.js';
+import { EVENTS } from 'src/constants.js';
 
 var assert = require('assert');
 
 let events = require('src/events');
-let constants = require('src/constants.json');
 
 /**
  * Emit analytics events
@@ -18,7 +18,7 @@ let constants = require('src/constants.json');
  */
 function emitEvent(eventType, event, auctionId) {
   event.auctionId = auctionId;
-  events.emit(constants.EVENTS[eventType], event);
+  events.emit(EVENTS[eventType], event);
 }
 
 let auctionStartTimestamp = Date.now();