prebid.js 7.51.0 → 7.53.0

package/test/spec/unit/core/adapterManager_spec.js

@@ -4,7 +4,7 @@ import adapterManager, {
   coppaDataHandler,
   _partitionBidders,
   PARTITIONS,
-  getS2SBidderSet, _filterBidsForAdUnit
+  getS2SBidderSet, _filterBidsForAdUnit, dep
 } from 'src/adapterManager.js';
 import {
   getAdUnits,
@@ -23,6 +23,7 @@ import {hook} from '../../../../src/hook.js';
 import {auctionManager} from '../../../../src/auctionManager.js';
 import {GDPR_GVLIDS} from '../../../../src/consentHandler.js';
 import {MODULE_TYPE_ANALYTICS, MODULE_TYPE_BIDDER} from '../../../../src/activities/modules.js';
+import {ACTIVITY_FETCH_BIDS, ACTIVITY_REPORT_ANALYTICS} from '../../../../src/activities/activities.js';
 var events = require('../../../../src/events');
 
 const CONFIG = {
@@ -1721,6 +1722,129 @@ describe('adapterManager tests', function () {
       expect(sizes1).not.to.deep.equal(sizes2);
     });
 
+    describe('and activity controls', () => {
+      let redactOrtb2;
+      let redactBidRequest;
+      const MOCK_BIDDERS = ['1', '2', '3', '4', '5'].map((n) => `mockBidder${n}`);
+
+      beforeEach(() => {
+        sinon.stub(dep, 'isAllowed');
+        redactOrtb2 = sinon.stub().callsFake(ob => ob);
+        redactBidRequest = sinon.stub().callsFake(ob => ob);
+        sinon.stub(dep, 'redact').callsFake(() => ({
+          ortb2: redactOrtb2,
+          bidRequest: redactBidRequest
+        }))
+        MOCK_BIDDERS.forEach((bidder) => adapterManager.bidderRegistry[bidder] = {});
+      });
+      afterEach(() => {
+        dep.isAllowed.restore();
+        dep.redact.restore();
+        MOCK_BIDDERS.forEach(bidder => { delete adapterManager.bidderRegistry[bidder] });
+        config.resetConfig();
+      })
+      it('should not generate requests for bidders that cannot fetchBids', () => {
+        adUnits = [
+          {code: 'one', bids: ['mockBidder1', 'mockBidder2', 'mockBidder3'].map((bidder) => ({bidder}))},
+          {code: 'two', bids: ['mockBidder4', 'mockBidder5', 'mockBidder4'].map((bidder) => ({bidder}))}
+        ];
+        const allowed = ['mockBidder2', 'mockBidder5'];
+        dep.isAllowed.callsFake((activity, {componentType, componentName}) => {
+          return activity === ACTIVITY_FETCH_BIDS &&
+            componentType === MODULE_TYPE_BIDDER &&
+            allowed.includes(componentName);
+        });
+        let reqs = adapterManager.makeBidRequests(
+          adUnits,
+          Date.now(),
+          utils.getUniqueIdentifierStr(),
+          function callback() {},
+          []
+        );
+        const bidders = Array.from(new Set(reqs.flatMap(br => br.bids).map(bid => bid.bidder)).keys());
+        expect(bidders).to.have.members(allowed);
+      });
+
+      it('should redact ortb2 and bid request objects', () => {
+        dep.isAllowed.callsFake(() => true);
+        adUnits = [
+          {code: 'one', bids: [{bidder: 'mockBidder1'}]}
+        ];
+        let reqs = adapterManager.makeBidRequests(
+          adUnits,
+          Date.now(),
+          utils.getUniqueIdentifierStr(),
+          function callback() {},
+          []
+        );
+        sinon.assert.calledWith(redactBidRequest, reqs[0].bids[0]);
+        sinon.assert.calledWith(redactOrtb2, reqs[0].ortb2);
+      })
+
+      describe('with multiple s2s configs', () => {
+        beforeEach(() => {
+          config.setConfig({
+            s2sConfig: [
+              {
+                enabled: true,
+                adapter: 'mockS2SDefault',
+                bidders: ['mockBidder1']
+              },
+              {
+                enabled: true,
+                adapter: 'mockS2S1',
+                configName: 'mock1',
+              },
+              {
+                enabled: true,
+                adapter: 'mockS2S2',
+                configName: 'mock2',
+              }
+            ]
+          });
+        });
+        it('should keep stored impressions, even if everything else is denied', () => {
+          adUnits = [
+            {code: 'one', bids: [{bidder: null}]},
+            {code: 'two', bids: [{module: 'pbsBidAdapter', params: {configName: 'mock1'}}, {module: 'pbsBidAdapter', params: {configName: 'mock2'}}]}
+          ]
+          dep.isAllowed.callsFake(({componentType}) => componentType !== 'bidder');
+          let bidRequests = adapterManager.makeBidRequests(
+            adUnits,
+            Date.now(),
+            utils.getUniqueIdentifierStr(),
+            function callback() {},
+            []
+          );
+          expect(new Set(bidRequests.map(br => br.uniquePbsTid)).size).to.equal(3);
+        });
+
+        it('should check if the s2s adapter itself is allowed to fetch bids', () => {
+          adUnits = [
+            {
+              code: 'au',
+              bids: [
+                {bidder: null},
+                {module: 'pbsBidAdapter', params: {configName: 'mock1'}},
+                {module: 'pbsBidAdapter', params: {configName: 'mock2'}},
+                {bidder: 'mockBidder1'}
+              ]
+            }
+          ];
+          dep.isAllowed.callsFake((_, {configName, componentName}) => !(componentName === 'pbsBidAdapter' && configName === 'mock1'));
+          let bidRequests = adapterManager.makeBidRequests(
+            adUnits,
+            Date.now(),
+            utils.getUniqueIdentifierStr(),
+            function callback() {
+            },
+            []
+          );
+          expect(new Set(bidRequests.map(br => br.uniquePbsTid)).size).to.eql(2)
+        });
+      });
+    });
+
     it('should make FPD available under `ortb2`', () => {
       const global = {
         k1: 'v1',
@@ -2692,12 +2816,29 @@ describe('adapterManager tests', function () {
 
       beforeEach(() => {
         bidderRequests = [];
+        ['mockBidder', 'mockBidder1', 'mockBidder2'].forEach(bidder => {
+          adapterManager.registerBidAdapter({callBids: sinon.stub(), getSpec: () => ({code: bidder})}, bidder);
+        })
         sinon.stub(auctionManager, 'getBidsRequested').callsFake(() => bidderRequests);
       })
       afterEach(() => {
         auctionManager.getBidsRequested.restore();
       })
 
+      it('can resolve aliases', () => {
+        adapterManager.aliasBidAdapter('mockBidder', 'mockBidderAlias');
+        expect(adapterManager.resolveAlias('mockBidderAlias')).to.eql('mockBidder');
+      });
+      it('does not stuck in alias cycles', () => {
+        adapterManager.aliasRegistry['alias1'] = 'alias2';
+        adapterManager.aliasRegistry['alias2'] = 'alias2';
+        expect(adapterManager.resolveAlias('alias2')).to.eql('alias2');
+      })
+      it('returns self when not an alias', () => {
+        delete adapterManager.aliasRegistry['missing'];
+        expect(adapterManager.resolveAlias('missing')).to.eql('missing');
+      })
+
       it('does not invoke onDataDeletionRequest on aliases', () => {
         const del = delMethodForBidder('mockBidder');
         adapterManager.aliasBidAdapter('mockBidder', 'mockBidderAlias');
@@ -2740,6 +2881,45 @@ describe('adapterManager tests', function () {
     })
   });
 
+  describe('reportAnalytics check', () => {
+    beforeEach(() => {
+      sinon.stub(dep, 'isAllowed');
+    });
+    afterEach(() => {
+      dep.isAllowed.restore();
+    });
+
+    it('should check for reportAnalytics before registering analytics adapter', () => {
+      const enabled = {};
+      ['mockAnalytics1', 'mockAnalytics2'].forEach((code) => {
+        adapterManager.registerAnalyticsAdapter({
+          code,
+          adapter: {
+            enableAnalytics: sinon.stub().callsFake(() => { enabled[code] = true })
+          }
+        })
+      })
+
+      const anlCfg = [
+        {
+          provider: 'mockAnalytics1',
+          random: 'values'
+        },
+        {
+          provider: 'mockAnalytics2'
+        }
+      ]
+      dep.isAllowed.callsFake((activity, {component, _config}) => {
+        return activity === ACTIVITY_REPORT_ANALYTICS &&
+          component === `${MODULE_TYPE_ANALYTICS}.${anlCfg[0].provider}` &&
+          _config === anlCfg[0]
+      })
+
+      adapterManager.enableAnalytics(anlCfg);
+      expect(enabled).to.eql({mockAnalytics1: true});
+    });
+  });
+
   describe('registers GVL IDs', () => {
     beforeEach(() => {
       sinon.stub(GDPR_GVLIDS, 'register');

package/test/spec/unit/core/storageManager_spec.js

@@ -1,14 +1,25 @@
 import {
-  getCoreStorageManager, getStorageManager,
+  deviceAccessRule,
+  getCoreStorageManager,
   newStorageManager,
   resetData,
+  STORAGE_TYPE_COOKIES,
+  STORAGE_TYPE_LOCALSTORAGE,
+  storageAllowedRule,
   storageCallbacks,
-  validateStorageEnforcement
 } from 'src/storageManager.js';
+import adapterManager from 'src/adapterManager.js';
 import {config} from 'src/config.js';
 import * as utils from 'src/utils.js';
 import {hook} from '../../../../src/hook.js';
-import {MODULE_TYPE_BIDDER} from '../../../../src/activities/modules.js';
+import {MODULE_TYPE_BIDDER, MODULE_TYPE_PREBID} from '../../../../src/activities/modules.js';
+import {ACTIVITY_ACCESS_DEVICE} from '../../../../src/activities/activities.js';
+import {
+  ACTIVITY_PARAM_COMPONENT_NAME,
+  ACTIVITY_PARAM_COMPONENT_TYPE,
+  ACTIVITY_PARAM_STORAGE_TYPE
+} from '../../../../src/activities/params.js';
+import {activityParams} from '../../../../src/activities/activityParams.js';
 
 describe('storage manager', function() {
   before(() => {
@@ -56,41 +67,42 @@ describe('storage manager', function() {
     deviceAccessSpy.restore();
   });
 
-  describe(`enforcement`, () => {
-    let validateHook;
+  describe(`accessDevice activity check`, () => {
+    let isAllowed;
+
+    function mkManager(moduleType, moduleName) {
+      return newStorageManager({moduleType, moduleName}, {isAllowed});
+    }
 
     beforeEach(() => {
-      validateHook = sinon.stub().callsFake(function (next, ...args) {
-        next.apply(this, args);
-      });
-      validateStorageEnforcement.before(validateHook, 99);
+      isAllowed = sinon.stub();
     });
 
-    afterEach(() => {
-      validateStorageEnforcement.getHooks({hook: validateHook}).remove();
-      config.resetConfig();
-    })
-
-    Object.entries({
-      'core': () => getCoreStorageManager('mock'),
-      'other': () => getStorageManager({moduleType: 'other', moduleName: 'mock'})
-    }).forEach(([moduleType, getMgr]) => {
-      describe(`for ${moduleType} modules`, () => {
-        let storage;
-        beforeEach(() => {
-          storage = getMgr();
-        });
-        it(`should pass '${moduleType}' module type to consent enforcement`, () => {
-          storage.localStorageIsEnabled();
-          expect(validateHook.args[0][1]).to.equal(moduleType);
-        });
+    it('should pass module type and name as activity params', () => {
+      mkManager(MODULE_TYPE_PREBID, 'mockMod').localStorageIsEnabled();
+      sinon.assert.calledWith(isAllowed, ACTIVITY_ACCESS_DEVICE, sinon.match({
+        [ACTIVITY_PARAM_COMPONENT_TYPE]: MODULE_TYPE_PREBID,
+        [ACTIVITY_PARAM_COMPONENT_NAME]: 'mockMod',
+        [ACTIVITY_PARAM_STORAGE_TYPE]: STORAGE_TYPE_LOCALSTORAGE
+      }));
+    });
 
-        it('should respect the deviceAccess flag', () => {
-          config.setConfig({deviceAccess: false});
-          expect(storage.localStorageIsEnabled()).to.be.false
-        });
-      });
+    it('should deny access if activity is denied', () => {
+      isAllowed.returns(false);
+      const mgr = mkManager(MODULE_TYPE_PREBID, 'mockMod');
+      mgr.setDataInLocalStorage('testKey', 'val');
+      expect(mgr.getDataFromLocalStorage('testKey')).to.not.exist;
     });
+
+    it('should use bidder aliases when possible', () => {
+      adapterManager.registerBidAdapter({callBids: sinon.stub(), getSpec: () => ({})}, 'mockBidder');
+      adapterManager.aliasBidAdapter('mockBidder', 'mockAlias');
+      const mgr = mkManager(MODULE_TYPE_BIDDER, 'mockBidder');
+      config.runWithBidder('mockAlias', () => mgr.cookiesAreEnabled());
+      sinon.assert.calledWith(isAllowed, ACTIVITY_ACCESS_DEVICE, sinon.match({
+        [ACTIVITY_PARAM_COMPONENT_NAME]: 'mockAlias'
+      }))
+    })
   })
 
   describe('localstorage forbidden access in 3rd-party context', function() {
@@ -145,13 +157,26 @@ describe('storage manager', function() {
     });
   });
 
-  describe('when bidderSettings.allowStorage is defined', () => {
+  describe('deviceAccess control', () => {
+    afterEach(() => {
+      config.resetConfig()
+    });
+
+    it('should allow by default', () => {
+      config.resetConfig();
+      expect(deviceAccessRule()).to.not.exist;
+    });
+
+    it('should deny access when set', () => {
+      config.setConfig({deviceAccess: false});
+      sinon.assert.match(deviceAccessRule(), {allow: false});
+    })
+  });
+
+  describe('allowStorage access control rule', () => {
     const ALLOWED_BIDDER = 'allowed-bidder';
     const ALLOW_KEY = 'storageAllowed';
 
-    const COOKIE = 'test-cookie';
-    const LS_KEY = 'test-localstorage';
-
     function mockBidderSettings(val) {
       return {
         get(bidder, key) {
@@ -213,39 +238,22 @@ describe('storage manager', function() {
         }).forEach(([t, {configValues, shouldWork: {cookie, html5}}]) => {
           describe(`when ${t} is allowed`, () => {
             configValues.forEach(configValue => describe(`storageAllowed = ${configValue}`, () => {
-              let mgr;
-
-              beforeEach(() => {
-                mgr = newStorageManager({moduleType: MODULE_TYPE_BIDDER, moduleName: bidderCode}, {bidderSettings: mockBidderSettings(configValue)});
-              })
-
-              afterEach(() => {
-                mgr.setCookie(COOKIE, 'delete', new Date().toUTCString());
-                mgr.removeDataFromLocalStorage(LS_KEY);
-              })
-
-              function scenario(type, desc, fn) {
+              Object.entries({
+                [STORAGE_TYPE_LOCALSTORAGE]: 'allow localStorage',
+                [STORAGE_TYPE_COOKIES]: 'allow cookies'
+              }).forEach(([type, desc]) => {
                 const shouldWork = isBidderAllowed && ({html5, cookie})[type];
-                it(`${shouldWork ? '' : 'NOT'} ${desc}`, () => fn(shouldWork));
-              }
-
-              scenario('cookie', 'allow cookies', (shouldWork) => {
-                mgr.setCookie(COOKIE, 'value');
-                expect(mgr.getCookie(COOKIE)).to.equal(shouldWork ? 'value' : null);
-              });
-
-              scenario('html5', 'allow localStorage', (shouldWork) => {
-                mgr.setDataInLocalStorage(LS_KEY, 'value');
-                expect(mgr.getDataFromLocalStorage(LS_KEY)).to.equal(shouldWork ? 'value' : null);
-              });
-
-              scenario('html5', 'report localStorage as available', (shouldWork) => {
-                expect(mgr.hasLocalStorage()).to.equal(shouldWork);
-              });
-
-              scenario('cookie', 'report cookies as available', (shouldWork) => {
-                expect(mgr.cookiesAreEnabled()).to.equal(shouldWork);
-              });
+                it(`${shouldWork ? '' : 'NOT'} ${desc}`, () => {
+                  const res = storageAllowedRule(activityParams(MODULE_TYPE_BIDDER, bidderCode, {
+                    [ACTIVITY_PARAM_STORAGE_TYPE]: type
+                  }), mockBidderSettings(configValue));
+                  if (shouldWork) {
+                    expect(res).to.not.exist;
+                  } else {
+                    sinon.assert.match(res, {allow: false});
+                  }
+                });
+              })
             }));
           });
         });

package/test/spec/unit/pbjs_api_spec.js

@@ -25,6 +25,7 @@ import {stubAuctionIndex} from '../../helpers/indexStub.js';
 import {createBid} from '../../../src/bidfactory.js';
 import {enrichFPD} from '../../../src/fpd/enrichment.js';
 import {mockFpdEnrichments} from '../../helpers/fpd.js';
+
 var assert = require('chai').assert;
 var expect = require('chai').expect;
 
@@ -3349,66 +3350,55 @@ describe('Unit: Prebid Module', function () {
 
   if (FEATURES.VIDEO) {
     describe('markWinningBidAsUsed', function () {
-      it('marks the bid object as used for the given adUnitCode/adId combination', function () {
-        // make sure the auction has "state" and does not reload the fixtures
-        const adUnitCode = '/19968336/header-bid-tag-0';
+      const adUnitCode = '/19968336/header-bid-tag-0';
+      let winningBid;
+
+      beforeEach(() => {
         const bidsReceived = $$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode);
         auction.getBidsReceived = function() { return bidsReceived.bids };
 
         // mark the bid and verify the state has changed to RENDERED
-        const winningBid = targeting.getWinningBids(adUnitCode)[0];
+        winningBid = targeting.getWinningBids(adUnitCode)[0];
+        auction.getAuctionId = function() { return winningBid.auctionId };
+      })
+
+      afterEach(() => {
+        resetAuction();
+      })
+
+      it('marks the bid object as used for the given adUnitCode/adId combination', function () {
+        // make sure the auction has "state" and does not reload the fixtures
         $$PREBID_GLOBAL$$.markWinningBidAsUsed({ adUnitCode, adId: winningBid.adId });
         const markedBid = find($$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode).bids,
           bid => bid.adId === winningBid.adId);
 
         expect(markedBid.status).to.equal(CONSTANTS.BID_STATUS.RENDERED);
-        resetAuction();
       });
 
       it('try and mark the bid object, but fail because we supplied the wrong adId', function () {
-        const adUnitCode = '/19968336/header-bid-tag-0';
-        const bidsReceived = $$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode);
-        auction.getBidsReceived = function() { return bidsReceived.bids };
-
-        const winningBid = targeting.getWinningBids(adUnitCode)[0];
         $$PREBID_GLOBAL$$.markWinningBidAsUsed({ adUnitCode, adId: 'miss' });
         const markedBid = find($$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode).bids,
           bid => bid.adId === winningBid.adId);
 
         expect(markedBid.status).to.not.equal(CONSTANTS.BID_STATUS.RENDERED);
-        resetAuction();
       });
 
       it('marks the winning bid object as used for the given adUnitCode', function () {
         // make sure the auction has "state" and does not reload the fixtures
-        const adUnitCode = '/19968336/header-bid-tag-0';
-        const bidsReceived = $$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode);
-        auction.getBidsReceived = function() { return bidsReceived.bids };
-
-        // mark the bid and verify the state has changed to RENDERED
-        const winningBid = targeting.getWinningBids(adUnitCode)[0];
         $$PREBID_GLOBAL$$.markWinningBidAsUsed({ adUnitCode });
         const markedBid = find($$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode).bids,
           bid => bid.adId === winningBid.adId);
 
         expect(markedBid.status).to.equal(CONSTANTS.BID_STATUS.RENDERED);
-        resetAuction();
       });
 
       it('marks a bid object as used for the given adId', function () {
         // make sure the auction has "state" and does not reload the fixtures
-        const adUnitCode = '/19968336/header-bid-tag-0';
-        const bidsReceived = $$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode);
-        auction.getBidsReceived = function() { return bidsReceived.bids };
-
-        // mark the bid and verify the state has changed to RENDERED
-        const winningBid = targeting.getWinningBids(adUnitCode)[0];
         $$PREBID_GLOBAL$$.markWinningBidAsUsed({ adId: winningBid.adId });
         const markedBid = find($$PREBID_GLOBAL$$.getBidResponsesForAdUnitCode(adUnitCode).bids,
           bid => bid.adId === winningBid.adId);
 
         expect(markedBid.status).to.equal(CONSTANTS.BID_STATUS.RENDERED);
-        resetAuction();
       });
     });
   }

package/test/spec/userSync_spec.js

@@ -1,5 +1,13 @@
 import { expect } from 'chai';
 import { config } from 'src/config.js';
+import {ruleRegistry} from '../../src/activities/rules.js';
+import {ACTIVITY_SYNC_USER} from '../../src/activities/activities.js';
+import {
+  ACTIVITY_PARAM_COMPONENT,
+  ACTIVITY_PARAM_SYNC_TYPE,
+  ACTIVITY_PARAM_SYNC_URL
+} from '../../src/activities/params.js';
+import {MODULE_TYPE_BIDDER} from '../../src/activities/modules.js';
 // Use require since we need to be able to write to these vars
 const utils = require('../../src/utils');
 let { newUserSync, USERSYNC_DEFAULT_CONFIG } = require('../../src/userSync');
@@ -14,12 +22,18 @@ describe('user sync', function () {
   let idPrefix = 'test-generated-id-';
   let lastId = 0;
   let defaultUserSyncConfig = config.getConfig('userSync');
-  function getUserSyncConfig(userSyncConfig) {
-    return Object.assign({}, defaultUserSyncConfig, userSyncConfig);
+  let regRule, isAllowed;
+
+  function mkUserSync(deps) {
+    [regRule, isAllowed] = ruleRegistry();
+    return newUserSync(Object.assign({
+      regRule, isAllowed
+    }, deps))
   }
+
   function newTestUserSync(configOverrides, disableBrowserCookies) {
     const thisConfig = Object.assign({}, defaultUserSyncConfig, configOverrides);
-    return newUserSync({
+    return mkUserSync({
       config: thisConfig,
       browserSupportsCookies: !disableBrowserCookies,
     })
@@ -59,6 +73,22 @@ describe('user sync', function () {
     expect(triggerPixelStub.getCall(0).args[0]).to.exist.and.to.equal('http://example.com');
   });
 
+  it('should NOT fire a sync if a rule blocks syncUser', () => {
+    const userSync = newTestUserSync()
+    regRule(ACTIVITY_SYNC_USER, 'testRule', (params) => {
+      if (
+        params[ACTIVITY_PARAM_COMPONENT] === `${MODULE_TYPE_BIDDER}.testBidder` &&
+        params[ACTIVITY_PARAM_SYNC_TYPE] === 'image' &&
+        params[ACTIVITY_PARAM_SYNC_URL] === 'http://example.com'
+      ) {
+        return {allow: false}
+      }
+    })
+    userSync.registerSync('image', 'testBidder', 'http://example.com');
+    userSync.syncUsers();
+    expect(triggerPixelStub.called).to.be.false;
+  })
+
   it('should clear queue after sync', function () {
     const userSync = newTestUserSync();
     userSync.syncUsers();
@@ -371,14 +401,13 @@ describe('user sync', function () {
     userSync.registerSync('image', 'atestBidder', 'http://example.com/1');
     userSync.registerSync('iframe', 'testBidder', 'http://example.com/iframe');
     userSync.syncUsers();
-    expect(logWarnStub.getCall(0).args[0]).to.exist;
     expect(triggerPixelStub.getCall(0)).to.not.be.null;
     expect(triggerPixelStub.getCall(0).args[0]).to.exist.and.to.equal('http://example.com/1');
     expect(insertUserSyncIframeStub.getCall(0)).to.be.null;
   });
 
   it('should still allow default image syncs if setConfig only defined iframe', function () {
-    const userSync = newUserSync({
+    const userSync = mkUserSync({
       config: config.getConfig('userSync'),
       browserSupportsCookies: true
     });
@@ -403,7 +432,7 @@ describe('user sync', function () {
   });
 
   it('should not fire image pixel for a bidder if iframe pixel is fired for same bidder', function() {
-    const userSync = newUserSync({
+    const userSync = mkUserSync({
       config: config.getConfig('userSync'),
       browserSupportsCookies: true
     });
@@ -430,7 +459,7 @@ describe('user sync', function () {
   });
 
   it('should override default image syncs if setConfig used image filter', function () {
-    const userSync = newUserSync({
+    const userSync = mkUserSync({
       config: config.getConfig('userSync'),
       browserSupportsCookies: true
     });
@@ -455,7 +484,7 @@ describe('user sync', function () {
   });
 
   it('should override default image syncs if setConfig used all filter', function() {
-    const userSync = newUserSync({
+    const userSync = mkUserSync({
       config: config.getConfig('userSync'),
       browserSupportsCookies: true
     });
@@ -488,7 +517,7 @@ describe('user sync', function () {
     describe('canBidderRegisterSync', function () {
       describe('with filterSettings', function () {
         it('should return false if filter settings does not allow it', function () {
-          const userSync = newUserSync({
+          const userSync = mkUserSync({
             config: {
               filterSettings: {
                 image: {
@@ -505,7 +534,7 @@ describe('user sync', function () {
           expect(userSync.canBidderRegisterSync('iframe', 'otherTestBidder')).to.equal(false);
         });
         it('should return false for iframe if there is no iframe filterSettings', function () {
-          const userSync = newUserSync({
+          const userSync = mkUserSync({
             config: {
               syncEnabled: true,
               filterSettings: {
@@ -523,7 +552,7 @@ describe('user sync', function () {
           expect(userSync.canBidderRegisterSync('iframe', 'otherTestBidder')).to.equal(false);
         });
         it('should return true if filter settings does allow it', function () {
-          const userSync = newUserSync({
+          const userSync = mkUserSync({
             config: {
               filterSettings: {
                 image: {
@@ -543,7 +572,7 @@ describe('user sync', function () {
       describe('almost deprecated - without filterSettings', function () {
         describe('enabledBidders contains testBidder', function () {
           it('should return false if type is iframe and iframeEnabled is false', function () {
-            const userSync = newUserSync({
+            const userSync = mkUserSync({
               config: {
                 filterSettings: {
                   iframe: {
@@ -557,7 +586,7 @@ describe('user sync', function () {
           });
 
           it('should return true if type is iframe and iframeEnabled is true', function () {
-            const userSync = newUserSync({
+            const userSync = mkUserSync({
               config: {
                 pixelEnabled: true,
                 iframeEnabled: true,
@@ -568,7 +597,7 @@ describe('user sync', function () {
           });
 
           it('should return false if type is image and pixelEnabled is false', function () {
-            const userSync = newUserSync({
+            const userSync = mkUserSync({
               config: {
                 filterSettings: {
                   image: {
@@ -582,7 +611,7 @@ describe('user sync', function () {
           });
 
           it('should return true if type is image and pixelEnabled is true', function () {
-            const userSync = newUserSync({
+            const userSync = mkUserSync({
               config: {
                 pixelEnabled: true,
                 iframeEnabled: true,
@@ -595,7 +624,7 @@ describe('user sync', function () {
 
         describe('enabledBidders does not container testBidder', function () {
           it('should return false since testBidder is not in enabledBidders', function () {
-            const userSync = newUserSync({
+            const userSync = mkUserSync({
               config: {
                 filterSettings: {
                   image: {