prebid.js 7.43.0 → 7.44.0

package/test/spec/modules/zeotapIdPlusIdSystem_spec.js

@@ -4,6 +4,7 @@ import { config } from 'src/config.js';
 import { init, requestBidsHook, setSubmoduleRegistry } from 'modules/userId/index.js';
 import { storage, getStorage, zeotapIdPlusSubmodule } from 'modules/zeotapIdPlusIdSystem.js';
 import * as storageManager from 'src/storageManager.js';
+import {MODULE_TYPE_UID} from '../../../src/activities/modules.js';
 
 const ZEOTAP_COOKIE_NAME = 'IDP';
 const ZEOTAP_COOKIE = 'THIS-IS-A-DUMMY-COOKIE';
@@ -52,9 +53,9 @@ describe('Zeotap ID System', function() {
     });
 
     it('when a stored Zeotap ID exists it is added to bids', function() {
-      let store = getStorage();
+      getStorage();
       expect(getStorageManagerSpy.calledOnce).to.be.true;
-      sinon.assert.calledWith(getStorageManagerSpy, {gvlid: 301, moduleName: 'zeotapIdPlus'});
+      sinon.assert.calledWith(getStorageManagerSpy, {moduleType: MODULE_TYPE_UID, moduleName: 'zeotapIdPlus'});
     });
   });
 

package/test/spec/modules/zeta_global_sspBidAdapter_spec.js

@@ -51,6 +51,7 @@ describe('Zeta Ssp Bid Adapter', function () {
     },
     sid: 'publisherId',
     shortname: 'test_shortname',
+    tagid: 'test_tag_id',
     site: {
       page: 'testPage'
     },
@@ -396,4 +397,11 @@ describe('Zeta Ssp Bid Adapter', function () {
 
     expect(payload.source.ext.schain).to.eql(schain);
   });
+
+  it('Test tagid provided', function () {
+    const request = spec.buildRequests(bannerRequest, bannerRequest[0]);
+    const payload = JSON.parse(request.data);
+
+    expect(payload.imp[0].tagid).to.eql(params.tagid);
+  });
 });

package/test/spec/refererDetection_spec.js

@@ -1,4 +1,4 @@
-import {detectReferer, ensureProtocol, parseDomain} from 'src/refererDetection.js';
+import {cacheWithLocation, detectReferer, ensureProtocol, parseDomain} from 'src/refererDetection.js';
 import {config} from 'src/config.js';
 import {expect} from 'chai';
 
@@ -493,3 +493,58 @@ describe('parseDomain', () => {
     })
   })
 });
+
+describe('cacheWithLocation', () => {
+  let fn, win, cached;
+  const RESULT = 'result';
+  beforeEach(() => {
+    fn = sinon.stub().callsFake(() => RESULT);
+    win = {
+      location: {
+      },
+      document: {
+        querySelector: sinon.stub()
+      }
+    }
+  });
+
+  describe('when window is not on top', () => {
+    beforeEach(() => {
+      win.top = {};
+      cached = cacheWithLocation(fn, win);
+    })
+
+    it('should not cache', () => {
+      win.top = {};
+      cached();
+      expect(cached()).to.eql(RESULT);
+      expect(fn.callCount).to.eql(2);
+    });
+  })
+
+  describe('when window is on top', () => {
+    beforeEach(() => {
+      win.top = win;
+      cached = cacheWithLocation(fn, win);
+    })
+
+    it('should not cache when canonical URL changes', () => {
+      let canonical = 'foo';
+      win.document.querySelector.callsFake(() => ({href: canonical}));
+      cached();
+      expect(cached()).to.eql(RESULT);
+      canonical = 'bar';
+      expect(cached()).to.eql(RESULT);
+      expect(fn.callCount).to.eql(2);
+    });
+
+    it('should not cache when location changes', () => {
+      win.location.href = 'foo';
+      cached();
+      expect(cached()).to.eql(RESULT);
+      win.location.href = 'bar';
+      expect(cached()).to.eql(RESULT);
+      expect(fn.callCount).to.eql(2);
+    })
+  });
+})

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

@@ -21,6 +21,8 @@ import {find, includes} from 'src/polyfill.js';
 import s2sTesting from 'modules/s2sTesting.js';
 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';
 var events = require('../../../../src/events');
 
 const CONFIG = {
@@ -1966,64 +1968,6 @@ describe('adapterManager tests', function () {
       });
     });
 
-    describe('fledgeEnabled', function () {
-      const origRunAdAuction = navigator?.runAdAuction;
-      before(function () {
-        // navigator.runAdAuction doesn't exist, so we can't stub it normally with
-        // sinon.stub(navigator, 'runAdAuction') or something
-        navigator.runAdAuction = sinon.stub();
-      });
-
-      after(function() {
-        navigator.runAdAuction = origRunAdAuction;
-      })
-
-      afterEach(function () {
-        config.resetConfig();
-      });
-
-      it('should set fledgeEnabled correctly per bidder', function () {
-        config.setConfig({bidderSequence: 'fixed'})
-        config.setBidderConfig({
-          bidders: ['appnexus'],
-          config: {
-            fledgeEnabled: true,
-          }
-        });
-
-        const adUnits = [{
-          'code': '/19968336/header-bid-tag1',
-          'mediaTypes': {
-            'banner': {
-              'sizes': [[728, 90]]
-            },
-          },
-          'bids': [
-            {
-              'bidder': 'appnexus',
-            },
-            {
-              'bidder': 'rubicon',
-            },
-          ]
-        }];
-
-        const bidRequests = adapterManager.makeBidRequests(
-          adUnits,
-          Date.now(),
-          utils.getUniqueIdentifierStr(),
-          function callback() {},
-          []
-        );
-
-        expect(bidRequests[0].bids[0].bidder).equals('appnexus');
-        expect(bidRequests[0].fledgeEnabled).to.be.true;
-
-        expect(bidRequests[1].bids[0].bidder).equals('rubicon');
-        expect(bidRequests[1].fledgeEnabled).to.be.undefined;
-      });
-    });
-
     describe('sizeMapping', function () {
       let sandbox;
       beforeEach(function () {
@@ -2795,4 +2739,23 @@ describe('adapterManager tests', function () {
       })
     })
   });
+
+  describe('registers GVL IDs', () => {
+    beforeEach(() => {
+      sinon.stub(GDPR_GVLIDS, 'register');
+    });
+    afterEach(() => {
+      GDPR_GVLIDS.register.restore();
+    });
+
+    it('for bid adapters', () => {
+      adapterManager.registerBidAdapter({getSpec: () => ({gvlid: 123}), callBids: sinon.stub()}, 'mock');
+      sinon.assert.calledWith(GDPR_GVLIDS.register, MODULE_TYPE_BIDDER, 'mock', 123);
+    });
+
+    it('for analytics adapters', () => {
+      adapterManager.registerAnalyticsAdapter({adapter: {enableAnalytics: sinon.stub()}, code: 'mock', gvlid: 123});
+      sinon.assert.calledWith(GDPR_GVLIDS.register, MODULE_TYPE_ANALYTICS, 'mock', 123);
+    });
+  });
 });

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

@@ -1,4 +1,11 @@
-import {newBidder, registerBidder, preloadBidderMappingFile, storage, isValid} from 'src/adapters/bidderFactory.js';
+import {
+  newBidder,
+  registerBidder,
+  preloadBidderMappingFile,
+  storage,
+  isValid,
+  addComponentAuction
+} from 'src/adapters/bidderFactory.js';
 import adapterManager from 'src/adapterManager.js';
 import * as ajax from 'src/ajax.js';
 import { expect } from 'chai';
@@ -1212,16 +1219,27 @@ describe('validate bid response: ', function () {
     };
     const fledgeAuctionConfig = {
       bidId: '1',
+      config: {
+        foo: 'bar'
+      }
     }
     describe('when response has FLEDGE auction config', function() {
-      let logInfoSpy;
+      let fledgeStub;
 
-      beforeEach(function () {
-        logInfoSpy = sinon.spy(utils, 'logInfo');
+      function fledgeHook(next, ...args) {
+        fledgeStub(...args);
+      }
+
+      before(() => {
+        addComponentAuction.before(fledgeHook);
       });
 
-      afterEach(function () {
-        logInfoSpy.restore();
+      after(() => {
+        addComponentAuction.getHooks({hook: fledgeHook}).remove();
+      })
+
+      beforeEach(function () {
+        fledgeStub = sinon.stub();
       });
 
       it('should unwrap bids', function() {
@@ -1243,8 +1261,8 @@ describe('validate bid response: ', function () {
         });
         bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-        expect(logInfoSpy.calledOnce).to.equal(true);
-        expect(logInfoSpy.firstCall.args[1]).to.equal(fledgeAuctionConfig);
+        expect(fledgeStub.calledOnce).to.equal(true);
+        sinon.assert.calledWith(fledgeStub, 'mock/placement', fledgeAuctionConfig.config);
         expect(addBidResponseStub.calledOnce).to.equal(true);
         expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
       })
@@ -1257,8 +1275,8 @@ describe('validate bid response: ', function () {
         });
         bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
 
-        expect(logInfoSpy.calledOnce).to.equal(true);
-        expect(logInfoSpy.firstCall.args[1]).to.equal(fledgeAuctionConfig);
+        expect(fledgeStub.calledOnce).to.be.true;
+        sinon.assert.calledWith(fledgeStub, 'mock/placement', fledgeAuctionConfig.config);
         expect(addBidResponseStub.calledOnce).to.equal(false);
       })
     })

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

@@ -1,4 +1,4 @@
-import {ConsentHandler} from '../../../../src/consentHandler.js';
+import {ConsentHandler, gvlidRegistry} from '../../../../src/consentHandler.js';
 
 describe('Consent data handler', () => {
   let handler;
@@ -57,3 +57,31 @@ describe('Consent data handler', () => {
     })
   });
 })
+
+describe('gvlidRegistry', () => {
+  let registry;
+  beforeEach(() => {
+    registry = gvlidRegistry();
+  });
+
+  it('returns undef when id cannoot be found', () => {
+    expect(registry.get('name')).to.eql({modules: {}})
+  });
+
+  it('does not register null ids', () => {
+    registry.register('type', 'name', null);
+    expect(registry.get('type', 'name')).to.eql({modules: {}});
+  })
+
+  it('can retrieve registered GVL IDs', () => {
+    registry.register('type', 'name', 123);
+    registry.register('otherType', 'name', 123);
+    expect(registry.get('name')).to.eql({gvlid: 123, modules: {type: 123, otherType: 123}});
+  });
+
+  it('does not return `gvlid` if there is more than one', () => {
+    registry.register('type', 'name', 123);
+    registry.register('otherType', 'name', 321);
+    expect(registry.get('name')).to.eql({modules: {type: 123, otherType: 321}})
+  });
+})

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

@@ -1,14 +1,14 @@
 import {
+  getCoreStorageManager, getStorageManager,
+  newStorageManager,
   resetData,
-  getCoreStorageManager,
   storageCallbacks,
-  getStorageManager,
-  newStorageManager, validateStorageEnforcement
+  validateStorageEnforcement
 } from 'src/storageManager.js';
-import { config } from 'src/config.js';
+import {config} from 'src/config.js';
 import * as utils from 'src/utils.js';
 import {hook} from '../../../../src/hook.js';
-import {VENDORLESS_GVLID} from '../../../../src/consentHandler.js';
+import {MODULE_TYPE_BIDDER} from '../../../../src/activities/modules.js';
 
 describe('storage manager', function() {
   before(() => {
@@ -34,7 +34,7 @@ describe('storage manager', function() {
 
   it('should add done callbacks to storageCallbacks array', function() {
     let noop = sinon.spy();
-    const coreStorage = getStorageManager();
+    const coreStorage = newStorageManager();
 
     coreStorage.setCookie('foo', 'bar', null, null, null, noop);
     coreStorage.getCookie('foo', noop);
@@ -50,17 +50,16 @@ describe('storage manager', function() {
 
   it('should allow bidder to access device if gdpr enforcement module is not included', function() {
     let deviceAccessSpy = sinon.spy(utils, 'hasDeviceAccess');
-    const storage = getStorageManager();
+    const storage = newStorageManager();
     storage.setCookie('foo1', 'baz1');
     expect(deviceAccessSpy.calledOnce).to.equal(true);
     deviceAccessSpy.restore();
   });
 
-  describe(`core storage`, () => {
-    let storage, validateHook;
+  describe(`enforcement`, () => {
+    let validateHook;
 
     beforeEach(() => {
-      storage = getCoreStorageManager();
       validateHook = sinon.stub().callsFake(function (next, ...args) {
         next.apply(this, args);
       });
@@ -72,15 +71,26 @@ describe('storage manager', function() {
       config.resetConfig();
     })
 
-    it('should respect (vendorless) consent enforcement', () => {
-      storage.localStorageIsEnabled();
-      expect(validateHook.args[0][1]).to.equal(VENDORLESS_GVLID); // gvlid should be set to VENDORLESS_GVLID
-    });
+    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 respect the deviceAccess flag', () => {
-      config.setConfig({deviceAccess: false});
-      expect(storage.localStorageIsEnabled()).to.be.false
-    })
+        it('should respect the deviceAccess flag', () => {
+          config.setConfig({deviceAccess: false});
+          expect(storage.localStorageIsEnabled()).to.be.false
+        });
+      });
+    });
   })
 
   describe('localstorage forbidden access in 3rd-party context', function() {
@@ -100,7 +110,7 @@ describe('storage manager', function() {
     })
 
     it('should not throw if the localstorage is not accessible when setting/getting/removing from localstorage', function() {
-      const coreStorage = getStorageManager();
+      const coreStorage = newStorageManager();
 
       coreStorage.setDataInLocalStorage('key', 'value');
       const val = coreStorage.getDataFromLocalStorage('key');
@@ -124,7 +134,7 @@ describe('storage manager', function() {
     })
 
     it('should remove side-effect after checking', function () {
-      const storage = getStorageManager();
+      const storage = newStorageManager();
 
       localStorage.setItem('unrelated', 'dummy');
       const val = storage.localStorageIsEnabled();
@@ -206,7 +216,7 @@ describe('storage manager', function() {
               let mgr;
 
               beforeEach(() => {
-                mgr = newStorageManager({bidderCode: bidderCode}, {bidderSettings: mockBidderSettings(configValue)});
+                mgr = newStorageManager({moduleType: MODULE_TYPE_BIDDER, moduleName: bidderCode}, {bidderSettings: mockBidderSettings(configValue)});
               })
 
               afterEach(() => {

package/test/spec/userSync_spec.js

@@ -110,9 +110,10 @@ describe('user sync', function () {
     expect(insertUserSyncIframeStub.getCall(0).args[0]).to.equal('http://example.com/iframe');
   });
 
-  it('should only trigger syncs once per page per bidder', function () {
+  it('should stop triggering user syncs after bidderDone', function () {
     const userSync = newTestUserSync({ pixelEnabled: true });
     userSync.registerSync('image', 'testBidder', 'http://example.com/1');
+    userSync.bidderDone('testBidder');
     userSync.syncUsers();
     userSync.registerSync('image', 'testBidder', 'http://example.com/2');
     userSync.registerSync('image', 'testBidder2', 'http://example.com/3');