prebid.js 7.51.0 → 7.53.0

package/test/spec/modules/eids_spec.js

@@ -348,6 +348,21 @@ describe('eids array generation for known sub-modules', function() {
     });
   });
 
+  it('euid', function() {
+    const userId = {
+      euid: {'id': 'Sample_AD_Token'}
+    };
+    const newEids = createEidsArray(userId);
+    expect(newEids.length).to.equal(1);
+    expect(newEids[0]).to.deep.equal({
+      source: 'euid.eu',
+      uids: [{
+        id: 'Sample_AD_Token',
+        atype: 3
+      }]
+    });
+  });
+
   it('kpuid', function() {
     const userId = {
       kpuid: 'Sample_Token'

package/test/spec/modules/eskimiBidAdapter_spec.js

@@ -1,155 +1,307 @@
-import {expect} from 'chai';
-import {spec} from 'modules/eskimiBidAdapter.js';
-
-const REQUEST = {
-  'bidderCode': 'eskimi',
-  'auctionId': 'auctionId-56a2-4f71-9098-720a68f2f708',
-  'bidderRequestId': 'requestId',
-  'bidRequest': [{
-    'bidder': 'eskimi',
-    'params': {
-      'placementId': 1003000,
-      'accId': 123
+import { expect } from 'chai';
+import { spec } from 'modules/eskimiBidAdapter.js';
+import * as utils from 'src/utils';
+
+const BANNER_BID = {
+  bidder: 'eskimi',
+  params: {
+    placementId: 1003000
+  },
+  mediaTypes: {
+    banner: {
+      sizes: [
+        [300, 250]
+      ],
     },
-    'sizes': [
-      [300, 250]
-    ],
-    'bidId': 'bidId1',
-    'adUnitCode': 'adUnitCode1',
-    'bidderRequestId': 'bidderRequestId',
-    'auctionId': 'auctionId-56a2-4f71-9098-720a68f2f708'
   },
-  {
-    'bidder': 'eskimi',
-    'params': {
-      'placementId': 1003001,
-      'accId': 123
+  adUnitCode: 'adUnitCode1',
+  bidId: 'bidId',
+  bidderRequestId: 'bidderRequestId',
+  auctionId: 'auctionId-56a2-4f71-9098-720a68f2f708',
+};
+
+const VIDEO_BID = {
+  bidder: 'eskimi',
+  params: {
+    placementId: 1003000
+  },
+  mediaTypes: {
+    video: {
+      context: 'outstream',
+      api: [1, 2, 4, 6],
+      mimes: ['video/mp4'],
+      playbackmethod: [2, 4, 6],
+      playerSize: [[1024, 768]],
+      protocols: [3, 4, 7, 8, 10],
+      placement: 1,
+      minduration: 0,
+      maxduration: 60,
+      startdelay: 0
     },
-    'sizes': [
-      [300, 250]
-    ],
-    'bidId': 'bidId2',
-    'adUnitCode': 'adUnitCode2',
-    'bidderRequestId': 'bidderRequestId',
-    'auctionId': 'auctionId-56a2-4f71-9098-720a68f2f708'
-  }],
-  'start': 1487883186070,
-  'auctionStart': 1487883186069,
-  'timeout': 3000
+  },
+  adUnitCode: 'adUnitCode1',
+  bidId: 'bidId',
+  bidderRequestId: 'bidderRequestId',
+  auctionId: 'auctionId-56a2-4f71-9098-720a68f2f708',
 };
 
-const RESPONSE = {
-  'headers': null,
-  'body': {
-    'id': 'requestId',
-    'seatbid': [
-      {
-        'bid': [
-          {
-            'id': 'bidId1',
-            'impid': 'bidId1',
-            'price': 0.18,
-            'adm': '<script>adm</script>',
-            'adid': '144762342',
-            'adomain': [
-              'https://dummydomain.com'
-            ],
-            'iurl': 'iurl',
-            'cid': '109',
-            'crid': 'creativeId',
-            'cat': [],
-            'w': 300,
-            'h': 250,
-            'ext': {
-              'prebid': {
-                'type': 'banner'
-              },
-              'bidder': {
-                'eskimi': {
-                  'brand_id': 334553,
-                  'auction_id': 514667951122925701,
-                  'bidder_id': 2,
-                  'bid_ad_type': 0
-                }
-              }
-            }
-          }
-        ],
-        'seat': 'seat'
-      }
-    ]
+const BIDDER_REQUEST = {
+  auctionId: 'auctionId-56a2-4f71-9098-720a68f2f708',
+  bidderRequestId: 'bidderRequestId',
+  timeout: 3000,
+  refererInfo: {
+    page: 'https://hello-world-page.com/',
+    domain: 'hello-world-page.com',
+    ref: 'http://example-domain.com/foo',
   }
 };
 
+const BANNER_BID_RESPONSE = {
+  'id': 'bidderRequestId',
+  'bidId': 'bidid',
+  'seatbid': [
+    {
+      'bid': [
+        {
+          'id': 'id',
+          'impid': 'bidId',
+          'price': 0.18,
+          'adm': '<script>adm</script>',
+          'adid': '144762342',
+          'burl': 'http://0.0.0.0:8181/burl',
+          'adomain': [
+            'https://dummydomain.com'
+          ],
+          'cid': 'cid',
+          'crid': 'crid',
+          'iurl': 'iurl',
+          'cat': [],
+          'w': 300,
+          'h': 250
+        }
+      ]
+    }
+  ],
+  'cur': 'USD'
+};
+
+const VIDEO_BID_RESPONSE = {
+  'id': 'bidderRequestId',
+  'bidid': 'bidid',
+  'seatbid': [
+    {
+      'bid': [
+        {
+          'id': 'id',
+          'impid': 'bidId',
+          'price': 1.09,
+          'adid': '144762342',
+          'burl': 'http://0.0.0.0:8181/burl',
+          'adm': '<VAST version="4.2"></VAST>',
+          'adomain': [
+            'https://dummydomain.com'
+          ],
+          'cid': 'cid',
+          'crid': 'crid',
+          'iurl': 'iurl',
+          'cat': [],
+          'h': 768,
+          'w': 1024
+        }
+      ]
+    }
+  ],
+  'cur': 'USD'
+};
+
 describe('Eskimi bid adapter', function () {
-  describe('isBidRequestValid', function () {
+  describe('isBidRequestValid()', function () {
     it('should accept request if placementId is passed', function () {
       let bid = {
         bidder: 'eskimi',
         params: {
           placementId: 123
+        },
+        mediaTypes: {
+          banner: {
+            sizes: [[300, 250]]
+          }
         }
       };
       expect(spec.isBidRequestValid(bid)).to.equal(true);
     });
-    it('reject requests without params', function () {
+
+    it('should reject requests without params', function () {
       let bid = {
         bidder: 'eskimi',
         params: {}
       };
       expect(spec.isBidRequestValid(bid)).to.equal(false);
     });
-  });
 
-  describe('buildRequests', function () {
-    it('creates request data', function () {
-      let request = spec.buildRequests(REQUEST.bidRequest, REQUEST)[0];
-      expect(request).to.exist.and.to.be.a('object');
-      const payload = request.data;
-      expect(payload.imp[0]).to.have.property('id', REQUEST.bidRequest[0].bidId);
-      expect(payload.imp[1]).to.have.property('id', REQUEST.bidRequest[1].bidId);
+    it('should return true when required params found', () => {
+      expect(spec.isBidRequestValid(BANNER_BID)).to.equal(true);
+      expect(spec.isBidRequestValid(VIDEO_BID)).to.equal(true);
     });
+  });
 
-    it('has gdpr data if applicable', function () {
-      const req = Object.assign({}, REQUEST, {
+  describe('buildRequests()', function () {
+    it('should have gdpr data if applicable', function () {
+      const bid = utils.deepClone(BANNER_BID);
+
+      const req = Object.assign({}, BIDDER_REQUEST, {
         gdprConsent: {
           consentString: 'consentString',
           gdprApplies: true,
         }
       });
-      let request = spec.buildRequests(REQUEST.bidRequest, req)[0];
+      let request = spec.buildRequests([bid], req)[0];
 
       const payload = request.data;
       expect(payload.user.ext).to.have.property('consent', req.gdprConsent.consentString);
       expect(payload.regs.ext).to.have.property('gdpr', 1);
     });
-  });
 
-  describe('interpretResponse', function () {
-    it('has bids', function () {
-      let request = spec.buildRequests(REQUEST.bidRequest, REQUEST)[0];
-      let bids = spec.interpretResponse(RESPONSE, request);
-      expect(bids).to.be.an('array').that.is.not.empty;
-      validateBidOnIndex(0);
-
-      function validateBidOnIndex(index) {
-        expect(bids[index]).to.have.property('currency', 'USD');
-        expect(bids[index]).to.have.property('requestId', RESPONSE.body.seatbid[0].bid[index].id);
-        expect(bids[index]).to.have.property('cpm', RESPONSE.body.seatbid[0].bid[index].price);
-        expect(bids[index]).to.have.property('width', RESPONSE.body.seatbid[0].bid[index].w);
-        expect(bids[index]).to.have.property('height', RESPONSE.body.seatbid[0].bid[index].h);
-        expect(bids[index]).to.have.property('ad', RESPONSE.body.seatbid[0].bid[index].adm);
-        expect(bids[index]).to.have.property('creativeId', RESPONSE.body.seatbid[0].bid[index].crid);
-        expect(bids[index]).to.have.property('ttl', 30);
-        expect(bids[index]).to.have.property('netRevenue', true);
-      }
+    it('should properly forward ORTB blocking params', function () {
+      let bid = utils.deepClone(BANNER_BID);
+      bid = utils.mergeDeep(bid, {
+        params: { bcat: ['IAB1-1'], badv: ['example.com'], bapp: ['com.example'] },
+        mediaTypes: { banner: { battr: [1] } }
+      });
+
+      let [request] = spec.buildRequests([bid], BIDDER_REQUEST);
+
+      expect(request).to.exist.and.to.be.an('object');
+      const payload = request.data;
+      expect(payload).to.have.deep.property('bcat', ['IAB1-1']);
+      expect(payload).to.have.deep.property('badv', ['example.com']);
+      expect(payload).to.have.deep.property('bapp', ['com.example']);
+      expect(payload.imp[0].banner).to.have.deep.property('battr', [1]);
+    });
+
+    context('when mediaType is banner', function () {
+      it('should build correct request for banner bid with both w, h', () => {
+        const bid = utils.deepClone(BANNER_BID);
+
+        const [request] = spec.buildRequests([bid], BIDDER_REQUEST);
+        const requestData = request.data;
+
+        expect(requestData.imp[0].banner.w).to.equal(300);
+        expect(requestData.imp[0].banner.h).to.equal(250);
+      });
+
+      it('should create request data', function () {
+        const bid = utils.deepClone(BANNER_BID);
+
+        let [request] = spec.buildRequests([bid], BIDDER_REQUEST);
+        expect(request).to.exist.and.to.be.a('object');
+        const payload = request.data;
+        expect(payload.imp[0]).to.have.property('id', bid.bidId);
+      });
     });
 
-    it('handles empty response', function () {
-      let request = spec.buildRequests(REQUEST.bidRequest, REQUEST)[0];
-      const EMPTY_RESP = Object.assign({}, RESPONSE, {'body': {}});
-      const bids = spec.interpretResponse(EMPTY_RESP, request);
-      expect(bids).to.be.empty;
+    context('when mediaType is video', function () {
+      it('should return false when there is no video in mediaTypes', () => {
+        const bid = utils.deepClone(VIDEO_BID);
+        delete bid.mediaTypes.video;
+
+        expect(spec.isBidRequestValid(bid)).to.equal(false);
+      });
+
+      it('should reutrn false if player size is not set', () => {
+        const bid = utils.deepClone(VIDEO_BID);
+        delete bid.mediaTypes.video.playerSize;
+
+        expect(spec.isBidRequestValid(bid)).to.equal(false);
+      });
+
+      it('should use bidder video params if they are set', () => {
+        const videoBidWithParams = utils.deepClone(VIDEO_BID);
+        const bidderVideoParams = {
+          api: [1, 2],
+          mimes: ['video/mp4', 'video/x-flv'],
+          playbackmethod: [3, 4],
+          protocols: [5, 6],
+          placement: 1,
+          minduration: 0,
+          maxduration: 60,
+          w: 1024,
+          h: 768,
+          startdelay: 0
+        };
+
+        videoBidWithParams.params.video = bidderVideoParams;
+
+        const requests = spec.buildRequests([videoBidWithParams], BIDDER_REQUEST);
+        const request = requests[0].data;
+
+        expect(request.imp[0]).to.deep.include({
+          video: {
+            ...bidderVideoParams,
+            w: videoBidWithParams.mediaTypes.video.playerSize[0][0],
+            h: videoBidWithParams.mediaTypes.video.playerSize[0][1],
+          },
+        });
+      });
     });
   });
+
+  describe('interpretResponse()', function () {
+    context('when mediaType is banner', function () {
+      it('should correctly interpret valid banner response', function () {
+        const bid = utils.deepClone(BANNER_BID);
+        const [request] = spec.buildRequests([bid], BIDDER_REQUEST);
+        const response = utils.deepClone(BANNER_BID_RESPONSE);
+
+        const bids = spec.interpretResponse({ body: response }, request);
+        expect(bids).to.be.an('array').that.is.not.empty;
+
+        expect(bids[0].mediaType).to.equal('banner');
+        expect(bids[0].burl).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].burl);
+        expect(bids[0].currency).to.equal('USD');
+        expect(bids[0].requestId).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].impid);
+        expect(bids[0].cpm).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].price);
+        expect(bids[0].width).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].w);
+        expect(bids[0].height).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].h);
+        expect(bids[0].ad).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].adm);
+        expect(bids[0].creativeId).to.equal(BANNER_BID_RESPONSE.seatbid[0].bid[0].crid);
+        expect(bids[0].meta.advertiserDomains[0]).to.equal('https://dummydomain.com');
+        expect(bids[0].ttl).to.equal(30);
+        expect(bids[0].netRevenue).to.equal(true);
+      });
+
+      it('should handle empty bid response', function () {
+        const bid = utils.deepClone(BANNER_BID);
+
+        let request = spec.buildRequests([bid], BIDDER_REQUEST)[0];
+        const EMPTY_RESP = Object.assign({}, BANNER_BID_RESPONSE, { 'body': {} });
+        const bids = spec.interpretResponse(EMPTY_RESP, request);
+        expect(bids).to.be.empty;
+      });
+    });
+    if (FEATURES.VIDEO) {
+      context('when mediaType is video', function () {
+        it('should correctly interpret valid instream video response', () => {
+          const bid = utils.deepClone(VIDEO_BID);
+
+          const [request] = spec.buildRequests([bid], BIDDER_REQUEST);
+          const bids = spec.interpretResponse({ body: VIDEO_BID_RESPONSE }, request);
+          expect(bids).to.be.an('array').that.is.not.empty;
+
+          expect(bids[0].mediaType).to.equal('video');
+          expect(bids[0].burl).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].burl);
+          expect(bids[0].currency).to.equal('USD');
+          expect(bids[0].requestId).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].impid);
+          expect(bids[0].cpm).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].price);
+          expect(bids[0].width).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].w);
+          expect(bids[0].height).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].h);
+          expect(bids[0].vastXml).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].adm);
+          expect(bids[0].creativeId).to.equal(VIDEO_BID_RESPONSE.seatbid[0].bid[0].crid);
+          expect(bids[0].meta.advertiserDomains[0]).to.equal('https://dummydomain.com');
+          expect(bids[0].ttl).to.equal(30);
+          expect(bids[0].netRevenue).to.equal(true);
+        });
+      });
+    }
+  });
 });

package/test/spec/modules/euidIdSystem_spec.js

@@ -0,0 +1,130 @@
+import {coreStorage, init, setSubmoduleRegistry, requestBidsHook} from 'modules/userId/index.js';
+import {config} from 'src/config.js';
+import * as utils from 'src/utils.js';
+import { euidIdSubmodule } from 'modules/euidIdSystem.js';
+import 'modules/consentManagement.js';
+import 'src/prebid.js';
+import { getGlobal } from 'src/prebidGlobal.js';
+import { server } from 'test/mocks/xhr.js';
+import { configureTimerInterceptors } from 'test/mocks/timers.js';
+import { cookieHelpers, runAuction, apiHelpers, setGdprApplies } from './uid2IdSystem_helpers.js';
+import {hook} from 'src/hook.js';
+import {uninstall as uninstallGdprEnforcement} from 'modules/gdprEnforcement.js';
+
+let expect = require('chai').expect;
+
+// N.B. Most of the EUID code is shared with UID2 - the tests here only cover the happy path.
+// Most of the functionality is covered by the UID2 tests.
+
+const moduleCookieName = '__euid_advertising_token';
+const publisherCookieName = '__EUID_SERVER_COOKIE';
+const initialToken = `initial-advertising-token`;
+const legacyToken = 'legacy-advertising-token';
+const refreshedToken = 'refreshed-advertising-token';
+const auctionDelayMs = 10;
+
+const makeEuidIdentityContainer = (token) => ({euid: {id: token}});
+const useLocalStorage = true;
+const makePrebidConfig = (params = null, extraSettings = {}, debug = false) => ({
+  userSync: { auctionDelay: auctionDelayMs, userIds: [{name: 'euid', params: {storage: useLocalStorage ? 'localStorage' : 'cookie', ...params}, ...extraSettings}] }, debug
+});
+
+const apiUrl = 'https://prod.euid.eu/v2/token/refresh';
+const headers = { 'Content-Type': 'application/json' };
+const makeSuccessResponseBody = () => btoa(JSON.stringify({ status: 'success', body: { ...apiHelpers.makeTokenResponse(initialToken), advertising_token: refreshedToken } }));
+const configureEuidResponse = (httpStatus, response) => server.respondWith('POST', apiUrl, (xhr) => xhr.respond(httpStatus, headers, response));
+const expectToken = (bid, token) => expect(bid?.userId ?? {}).to.deep.include(makeEuidIdentityContainer(token));
+const expectNoIdentity = (bid) => expect(bid).to.not.haveOwnProperty('userId');
+
+describe('EUID module', function() {
+  let suiteSandbox, testSandbox, timerSpy, fullTestTitle, restoreSubtleToUndefined = false;
+  before(function() {
+    uninstallGdprEnforcement();
+    hook.ready();
+    suiteSandbox = sinon.sandbox.create();
+    if (typeof window.crypto.subtle === 'undefined') {
+      restoreSubtleToUndefined = true;
+      window.crypto.subtle = { importKey: () => {}, decrypt: () => {} };
+    }
+    suiteSandbox.stub(window.crypto.subtle, 'importKey').callsFake(() => Promise.resolve());
+    suiteSandbox.stub(window.crypto.subtle, 'decrypt').callsFake((settings, key, data) => Promise.resolve(new Uint8Array([...settings.iv, ...data])));
+  });
+  after(function() {
+    suiteSandbox.restore();
+    if (restoreSubtleToUndefined) window.crypto.subtle = undefined;
+  });
+  beforeEach(function() {
+    init(config);
+    setSubmoduleRegistry([euidIdSubmodule]);
+  });
+  afterEach(function() {
+    $$PREBID_GLOBAL$$.requestBids.removeAll();
+    config.resetConfig();
+    cookieHelpers.clearCookies(moduleCookieName, publisherCookieName);
+    coreStorage.removeDataFromLocalStorage(moduleCookieName);
+  });
+
+  it('When a server-only token value is provided in config but consent is not available, it is not available to the auction.', async function() {
+    setGdprApplies();
+    config.setConfig(makePrebidConfig(null, {value: makeEuidIdentityContainer(initialToken)}));
+    const bid = await runAuction();
+    expectNoIdentity(bid);
+  });
+
+  it('When a server-only token value is provided in config, it is available to the auction.', async function() {
+    setGdprApplies(true);
+    config.setConfig(makePrebidConfig(null, {value: makeEuidIdentityContainer(initialToken)}));
+    const bid = await runAuction();
+    expectToken(bid, initialToken);
+  });
+
+  it('When a server-only token is provided in the module storage cookie but consent is not available, it is not available to the auction.', async function() {
+    setGdprApplies();
+    coreStorage.setCookie(moduleCookieName, legacyToken, cookieHelpers.getFutureCookieExpiry());
+    config.setConfig({userSync: {auctionDelay: auctionDelayMs, userIds: [{name: 'euid'}]}});
+    const bid = await runAuction();
+    expectNoIdentity(bid);
+  });
+
+  it('When a server-only token is provided in the module storage cookie, it is available to the auction.', async function() {
+    setGdprApplies(true);
+    coreStorage.setCookie(moduleCookieName, legacyToken, cookieHelpers.getFutureCookieExpiry());
+    config.setConfig({userSync: {auctionDelay: auctionDelayMs, userIds: [{name: 'euid'}]}});
+    const bid = await runAuction();
+    expectToken(bid, legacyToken);
+  })
+
+  it('When a valid response body is provided in config, it is available to the auction', async function() {
+    setGdprApplies(true);
+    const euidToken = apiHelpers.makeTokenResponse(initialToken, false, false);
+    config.setConfig(makePrebidConfig({euidToken}));
+    const bid = await runAuction();
+    expectToken(bid, initialToken);
+  })
+
+  it('When a valid response body is provided via cookie, it is available to the auction', async function() {
+    setGdprApplies(true);
+    const euidToken = apiHelpers.makeTokenResponse(initialToken, false, false);
+    cookieHelpers.setPublisherCookie(publisherCookieName, euidToken);
+    config.setConfig(makePrebidConfig({euidCookie: publisherCookieName}));
+    const bid = await runAuction();
+    expectToken(bid, initialToken);
+  })
+
+  it('When an expired token is provided in config, it calls the API.', function() {
+    setGdprApplies(true);
+    const euidToken = apiHelpers.makeTokenResponse(initialToken, true, true);
+    config.setConfig(makePrebidConfig({euidToken}));
+    expect(server.requests[0]?.url).to.have.string('https://prod.euid.eu/');
+  });
+
+  it('When an expired token is provided and the API responds in time, the refreshed token is provided to the auction.', async function() {
+    setGdprApplies(true);
+    const euidToken = apiHelpers.makeTokenResponse(initialToken, true, true);
+    configureEuidResponse(200, makeSuccessResponseBody());
+    config.setConfig(makePrebidConfig({euidToken}));
+    apiHelpers.respondAfterDelay(1);
+    const bid = await runAuction();
+    expectToken(bid, refreshedToken);
+  });
+});