prebid.js 7.51.0 → 7.53.0

package/test/spec/modules/conceptxBidAdapter_spec.js

@@ -0,0 +1,136 @@
+// import or require modules necessary for the test, e.g.:
+import { expect } from 'chai'; // may prefer 'assert' in place of 'expect'
+import { spec } from 'modules/conceptxBidAdapter.js';
+import { newBidder } from 'src/adapters/bidderFactory.js';
+// import { config } from 'src/config.js';
+
+describe('conceptxBidAdapter', function () {
+  const URL = 'https://conceptx.cncpt-central.com/openrtb';
+
+  // before(() => {
+
+  // });
+
+  // after(() => {
+  //   // $$PREBID_GLOBAL$$.bidderSettings = {};
+  // });
+
+  // afterEach(function () {
+  //   config.resetConfig();
+  // });
+
+  const ENDPOINT_URL = `${URL}`;
+  const ENDPOINT_URL_CONSENT = `${URL}?gdpr_applies=true&consentString=ihaveconsented`;
+  const adapter = newBidder(spec);
+
+  const bidderRequests = [
+    {
+      bidId: '123',
+      bidder: 'conceptx',
+      params: {
+        site: 'example',
+        adunit: 'some-id-3'
+      },
+      mediaTypes: {
+        banner: {
+          sizes: [[930, 180]],
+        }
+      },
+    }
+  ]
+
+  const singleBidRequest = {
+    bid: [
+      {
+        bidId: '123',
+      }
+    ]
+  }
+
+  const serverResponse = {
+    body: {
+      'bidResponses': [
+        {
+          'ads': [
+            {
+              'referrer': 'http://localhost/prebidpage_concept_bidder.html',
+              'ttl': 360,
+              'html': '<h1>DUMMY</h1>',
+              'requestId': '214dfadd1f8826',
+              'cpm': 46,
+              'currency': 'DKK',
+              'width': 930,
+              'height': 180,
+              'creativeId': 'FAKE-ID',
+              'meta': {
+                'mediaType': 'banner'
+              },
+              'netRevenue': true,
+              'destinationUrls': {
+                'destination': 'https://concept.dk'
+              }
+            }
+          ],
+          'matchedAdCount': 1,
+          'targetId': '214dfadd1f8826'
+        }
+      ]
+    }
+  }
+
+  describe('inherited functions', function () {
+    it('exists and is a function', function () {
+      expect(adapter.callBids).to.exist.and.to.be.a('function');
+    });
+  });
+
+  describe('isBidRequestValid', function () {
+    it('should return true when required params found', function () {
+      expect(spec.isBidRequestValid(bidderRequests[0])).to.equal(true);
+    });
+  });
+
+  describe('buildRequests', function () {
+    it('Test requests', function () {
+      const request = spec.buildRequests(bidderRequests, {});
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('data');
+      const bid = JSON.parse(request[0].data).adUnits[0]
+      expect(bid.site).to.equal('example');
+      expect(bid.adunit).to.equal('some-id-3');
+      expect(JSON.stringify(bid.dimensions)).to.equal(JSON.stringify([
+        [930, 180]]));
+    });
+  });
+
+  describe('user privacy', function () {
+    it('should NOT send GDPR Consent data if gdprApplies equals undefined', function () {
+      let request = spec.buildRequests(bidderRequests, { gdprConsent: { gdprApplies: undefined, consentString: 'iDoNotConsent' } });
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL);
+    });
+    it('should send GDPR Consent data if gdprApplies', function () {
+      let request = spec.buildRequests(bidderRequests, { gdprConsent: { gdprApplies: true, consentString: 'ihaveconsented' } });
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL_CONSENT);
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('should return valid response when passed valid server response', function () {
+      const interpretedResponse = spec.interpretResponse(serverResponse, singleBidRequest);
+      const ad = serverResponse.body.bidResponses[0].ads[0]
+      expect(interpretedResponse).to.have.lengthOf(1);
+      expect(interpretedResponse[0].cpm).to.equal(ad.cpm);
+      expect(interpretedResponse[0].width).to.equal(Number(ad.width));
+      expect(interpretedResponse[0].height).to.equal(Number(ad.height));
+      expect(interpretedResponse[0].creativeId).to.equal(ad.creativeId);
+      expect(interpretedResponse[0].currency).to.equal(ad.currency);
+      expect(interpretedResponse[0].netRevenue).to.equal(true);
+      expect(interpretedResponse[0].ad).to.equal(ad.html);
+      expect(interpretedResponse[0].ttl).to.equal(360);
+    });
+  });
+});

package/test/spec/modules/connectIdSystem_spec.js

@@ -2,7 +2,7 @@ import {expect} from 'chai';
 import {connectIdSubmodule, storage} from 'modules/connectIdSystem.js';
 import {server} from '../../mocks/xhr';
 import {parseQS, parseUrl} from 'src/utils.js';
-import {uspDataHandler} from 'src/adapterManager.js';
+import {uspDataHandler, gppDataHandler} from 'src/adapterManager.js';
 
 const TEST_SERVER_URL = 'http://localhost:9876/';
 
@@ -14,6 +14,10 @@ describe('Yahoo ConnectID Submodule', () => {
   const OVERRIDE_ENDPOINT = 'https://foo/bar';
   const STORAGE_KEY = 'connectId';
   const USP_DATA = '1YYY';
+  const GPP_DATA = {
+    gppString: 'gppconsent',
+    applicableSections: [6, 7]
+  };
 
   it('should have the correct module name declared', () => {
     expect(connectIdSubmodule.name).to.equal('connectId');
@@ -34,6 +38,7 @@ describe('Yahoo ConnectID Submodule', () => {
     let localStorageEnabledStub;
     let removeLocalStorageDataStub;
     let uspConsentDataStub;
+    let gppConsentDataStub;
 
     let consentData;
     beforeEach(() => {
@@ -48,10 +53,12 @@ describe('Yahoo ConnectID Submodule', () => {
       localStorageEnabledStub = sinon.stub(storage, 'localStorageIsEnabled');
       removeLocalStorageDataStub = sinon.stub(storage, 'removeDataFromLocalStorage');
       uspConsentDataStub = sinon.stub(uspDataHandler, 'getConsentData');
+      gppConsentDataStub = sinon.stub(gppDataHandler, 'getConsentData');
 
       cookiesEnabledStub.returns(true);
       localStorageEnabledStub.returns(true);
       uspConsentDataStub.returns(USP_DATA);
+      gppConsentDataStub.returns(GPP_DATA);
 
       consentData = {
         gdprApplies: 1,
@@ -69,6 +76,7 @@ describe('Yahoo ConnectID Submodule', () => {
       localStorageEnabledStub.restore();
       removeLocalStorageDataStub.restore();
       uspConsentDataStub.restore();
+      gppConsentDataStub.restore();
     });
 
     function invokeGetIdAPI(configParams, consentData) {
@@ -135,37 +143,254 @@ describe('Yahoo ConnectID Submodule', () => {
         }, consentData)).to.be.undefined;
         expect(ajaxStub.callCount).to.equal(0);
       });
-
-      it('returns undefined if the pixelId param is passed, but the he and puid param are not passed', () => {
-        expect(invokeGetIdAPI({
-          pixelId: PIXEL_ID
-        }, consentData)).to.be.undefined;
-        expect(ajaxStub.callCount).to.equal(0);
-      });
     });
 
     describe('with valid module configuration', () => {
       describe('when data is in client storage', () => {
-        it('returns an object with the stored ID from cookies for valid module configuration', () => {
+        it('returns an object with the stored ID from cookies for valid module configuration and sync is done', () => {
           const cookieData = {connectId: 'foobar'};
           getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
           let result = invokeGetIdAPI({
             he: HASHED_EMAIL,
             pixelId: PIXEL_ID
           }, consentData);
+
+          expect(result).to.be.an('object').that.has.all.keys('id', 'callback');
+          expect(result.id).to.deep.equal(cookieData);
+          expect(typeof result.callback).to.equal('function');
+        });
+
+        it('returns an object with the stored ID from cookies for valid module configuration with no user sync', () => {
+          const last13Days = Date.now() - (60 * 60 * 24 * 1000 * 13);
+          const cookieData = {connectId: 'foobar', he: HASHED_EMAIL, lastSynced: last13Days};
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          let result = invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+
+          expect(result).to.be.an('object').that.has.all.keys('id');
+          expect(result.id.lastUsed).to.be.a('number');
+          cookieData.lastUsed = result.id.lastUsed;
+          expect(result.id).to.deep.equal(cookieData);
+        });
+
+        it('returns an object with the stored ID and refreshes the storages with the new lastUsed', () => {
+          const last13Days = Date.now() - (60 * 60 * 24 * 1000 * 13);
+          const cookieData = {connectId: 'foobar', he: HASHED_EMAIL, lastSynced: last13Days, lastUsed: 1};
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          const dateNowStub = sinon.stub(Date, 'now');
+          dateNowStub.returns(20);
+          const newCookieData = Object.assign({}, cookieData, {lastUsed: 20})
+          let result = invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+          dateNowStub.restore();
+
+          const expiryDelta = new Date(60 * 60 * 24 * 365 * 1000);
+          expect(result).to.be.an('object').that.has.all.keys('id');
+          expect(setCookieStub.calledOnce).to.be.true;
+          expect(setCookieStub.firstCall.args[0]).to.equal(STORAGE_KEY);
+          expect(setCookieStub.firstCall.args[1]).to.equal(JSON.stringify(newCookieData));
+          expect(setCookieStub.firstCall.args[2]).to.equal(expiryDelta.toUTCString());
+          expect(setLocalStorageStub.calledOnce).to.be.true;
+          expect(setLocalStorageStub.firstCall.args[0]).to.equal(STORAGE_KEY);
+          expect(setLocalStorageStub.firstCall.args[1]).to.equal(JSON.stringify(newCookieData));
+        });
+
+        it('returns an object with the stored ID from cookies and no sync when puid stays the same', () => {
+          const last13Days = Date.now() - (60 * 60 * 24 * 1000 * 13);
+          const cookieData = {connectId: 'foobar', puid: '123', lastSynced: last13Days};
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          const dateNowStub = sinon.stub(Date, 'now');
+          dateNowStub.returns(20);
+          let result = invokeGetIdAPI({
+            puid: '123',
+            pixelId: PIXEL_ID
+          }, consentData);
+          dateNowStub.restore();
+
           expect(result).to.be.an('object').that.has.all.keys('id');
+          cookieData.lastUsed = 20;
           expect(result.id).to.deep.equal(cookieData);
         });
 
-        it('returns an object with the stored ID from localStorage for valid module configuration', () => {
+        it('returns an object with the stored ID from cookies and syncs because of expired auto generated puid', () => {
+          const last13Days = Date.now() - (60 * 60 * 24 * 1000 * 13);
+          const last31Days = Date.now() - (60 * 60 * 24 * 1000 * 31);
+          const cookieData = {connectId: 'foo', he: 'email', lastSynced: last13Days, puid: '9', lastUsed: last31Days};
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          let result = invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+
+          delete cookieData.puid;
+          expect(result).to.be.an('object').that.has.all.keys('id', 'callback');
+          expect(result.id).to.deep.equal(cookieData);
+          expect(typeof result.callback).to.equal('function');
+        });
+
+        it('returns an object with the stored ID from cookies and does not sync for valid auto generated puid', () => {
+          const last13Days = Date.now() - (60 * 60 * 24 * 1000 * 13);
+          const last29Days = Date.now() - (60 * 60 * 24 * 1000 * 29);
+          const cookieData = {
+            connectId: 'foo',
+            he: HASHED_EMAIL,
+            lastSynced: last13Days,
+            puid: '9',
+            lastUsed: last29Days
+          };
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          const dateNowStub = sinon.stub(Date, 'now');
+          dateNowStub.returns(20);
+          let result = invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+          dateNowStub.restore();
+
+          expect(result).to.be.an('object').that.has.all.keys('id');
+          cookieData.lastUsed = 20;
+          expect(result.id).to.deep.equal(cookieData);
+        });
+
+        it('returns an object with the stored ID from localStorage for valid module configuration and sync is done', () => {
           const localStorageData = {connectId: 'foobarbaz'};
           getLocalStorageStub.withArgs(STORAGE_KEY).returns(localStorageData);
           let result = invokeGetIdAPI({
             he: HASHED_EMAIL,
             pixelId: PIXEL_ID
           }, consentData);
-          expect(result).to.be.an('object').that.has.all.keys('id');
+
+          expect(result).to.be.an('object').that.has.all.keys('id', 'callback');
           expect(result.id).to.deep.equal(localStorageData);
+          expect(typeof result.callback).to.equal('function');
+        });
+
+        it('returns an object with the stored ID from localStorage and refreshes the cookie storage', () => {
+          const localStorageData = {connectId: 'foobarbaz'};
+          getLocalStorageStub.withArgs(STORAGE_KEY).returns(localStorageData);
+          const dateNowStub = sinon.stub(Date, 'now');
+          dateNowStub.returns(1);
+          let result = invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+          dateNowStub.restore();
+
+          const expiryDelta = new Date(1 + 60 * 60 * 24 * 365 * 1000);
+          expect(result).to.be.an('object').that.has.all.keys('id', 'callback');
+          expect(setCookieStub.calledOnce).to.be.true;
+          expect(setCookieStub.firstCall.args[0]).to.equal(STORAGE_KEY);
+          expect(setCookieStub.firstCall.args[1]).to.equal(JSON.stringify(localStorageData));
+          expect(setCookieStub.firstCall.args[2]).to.equal(expiryDelta.toUTCString());
+        });
+
+        it('Makes an ajax GET request to the production API endpoint with stored puid when id is stale', () => {
+          const last15Days = Date.now() - (60 * 60 * 24 * 1000 * 15);
+          const last29Days = Date.now() - (60 * 60 * 24 * 1000 * 29);
+          const cookieData = {
+            connectId: 'foobar',
+            he: HASHED_EMAIL,
+            lastSynced: last15Days,
+            puid: '981',
+            lastUsed: last29Days
+          };
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+
+          const expectedParams = {
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID,
+            '1p': '0',
+            gdpr: '1',
+            gdpr_consent: consentData.consentString,
+            v: '1',
+            url: TEST_SERVER_URL,
+            us_privacy: USP_DATA,
+            puid: '981',
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
+          };
+          const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
+
+          expect(ajaxStub.firstCall.args[0].indexOf(`${PROD_ENDPOINT}?`)).to.equal(0);
+          expect(requestQueryParams).to.deep.equal(expectedParams);
+          expect(ajaxStub.firstCall.args[3]).to.deep.equal({method: 'GET', withCredentials: true});
+        });
+
+        it('Makes an ajax GET request to the production API endpoint without the stored puid after 30 days', () => {
+          const last31Days = Date.now() - (60 * 60 * 24 * 1000 * 31);
+          const cookieData = {
+            connectId: 'foobar',
+            he: HASHED_EMAIL,
+            lastSynced: last31Days,
+            puid: '981',
+            lastUsed: last31Days
+          };
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID
+          }, consentData);
+
+          const expectedParams = {
+            he: HASHED_EMAIL,
+            pixelId: PIXEL_ID,
+            '1p': '0',
+            gdpr: '1',
+            gdpr_consent: consentData.consentString,
+            v: '1',
+            url: TEST_SERVER_URL,
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
+          };
+          const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
+
+          expect(ajaxStub.firstCall.args[0].indexOf(`${PROD_ENDPOINT}?`)).to.equal(0);
+          expect(requestQueryParams).to.deep.equal(expectedParams);
+          expect(ajaxStub.firstCall.args[3]).to.deep.equal({method: 'GET', withCredentials: true});
+        });
+
+        it('Makes an ajax GET request to the production API endpoint with provided puid', () => {
+          const last3Days = Date.now() - (60 * 60 * 24 * 1000 * 3);
+          const cookieData = {
+            connectId: 'foobar',
+            he: HASHED_EMAIL,
+            lastSynced: last3Days,
+            puid: '981',
+            lastUsed: last3Days
+          };
+          getCookieStub.withArgs(STORAGE_KEY).returns(JSON.stringify(cookieData));
+          invokeGetIdAPI({
+            pixelId: PIXEL_ID,
+            puid: PUBLISHER_USER_ID
+          }, consentData);
+
+          const expectedParams = {
+            pixelId: PIXEL_ID,
+            puid: PUBLISHER_USER_ID,
+            he: HASHED_EMAIL,
+            '1p': '0',
+            gdpr: '1',
+            gdpr_consent: consentData.consentString,
+            v: '1',
+            url: TEST_SERVER_URL,
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
+          };
+          const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
+
+          expect(ajaxStub.firstCall.args[0].indexOf(`${PROD_ENDPOINT}?`)).to.equal(0);
+          expect(requestQueryParams).to.deep.equal(expectedParams);
+          expect(ajaxStub.firstCall.args[3]).to.deep.equal({method: 'GET', withCredentials: true});
         });
 
         it('deletes local storage data when expiry has passed', () => {
@@ -284,7 +509,9 @@ describe('Yahoo ConnectID Submodule', () => {
             gdpr_consent: consentData.consentString,
             v: '1',
             url: TEST_SERVER_URL,
-            us_privacy: USP_DATA
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
           };
           const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
 
@@ -307,7 +534,9 @@ describe('Yahoo ConnectID Submodule', () => {
             pixelId: PIXEL_ID,
             gdpr_consent: consentData.consentString,
             url: TEST_SERVER_URL,
-            us_privacy: USP_DATA
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
           };
           const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
 
@@ -332,7 +561,9 @@ describe('Yahoo ConnectID Submodule', () => {
             gdpr_consent: consentData.consentString,
             v: '1',
             url: TEST_SERVER_URL,
-            us_privacy: USP_DATA
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
           };
           const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
 
@@ -347,6 +578,31 @@ describe('Yahoo ConnectID Submodule', () => {
             endpoint: OVERRIDE_ENDPOINT
           }, consentData);
 
+          const expectedParams = {
+            he: HASHED_EMAIL,
+            '1p': '0',
+            gdpr: '1',
+            gdpr_consent: consentData.consentString,
+            v: '1',
+            url: TEST_SERVER_URL,
+            us_privacy: USP_DATA,
+            gpp: GPP_DATA.gppString,
+            gpp_sid: GPP_DATA.applicableSections.join(',')
+          };
+          const requestQueryParams = parseQS(ajaxStub.firstCall.args[0].split('?')[1]);
+
+          expect(ajaxStub.firstCall.args[0].indexOf(`${OVERRIDE_ENDPOINT}?`)).to.equal(0);
+          expect(requestQueryParams).to.deep.equal(expectedParams);
+          expect(ajaxStub.firstCall.args[3]).to.deep.equal({method: 'GET', withCredentials: true});
+        });
+
+        it('Makes an ajax GET request to the specified override API endpoint without GPP', () => {
+          gppConsentDataStub.returns(undefined);
+          invokeGetIdAPI({
+            he: HASHED_EMAIL,
+            endpoint: OVERRIDE_ENDPOINT
+          }, consentData);
+
           const expectedParams = {
             he: HASHED_EMAIL,
             '1p': '0',
@@ -409,12 +665,12 @@ describe('Yahoo ConnectID Submodule', () => {
           });
         });
 
-        it('stores the result in client cookie storage', () => {
+        it('stores the result in client both storages', () => {
           const dateNowStub = sinon.stub(Date, 'now');
           dateNowStub.returns(0);
           getAjaxFnStub.restore();
           const upsResponse = {connectid: 'foobarbaz'};
-          const expiryDelta = new Date(60 * 60 * 24 * 14 * 1000);
+          const expiryDelta = new Date(60 * 60 * 24 * 365 * 1000);
           invokeGetIdAPI({
             puid: PUBLISHER_USER_ID,
             pixelId: PIXEL_ID
@@ -425,14 +681,23 @@ describe('Yahoo ConnectID Submodule', () => {
             {'Content-Type': 'application/json'},
             JSON.stringify(upsResponse)
           );
+          const storage = Object.assign({}, upsResponse, {
+            puid: PUBLISHER_USER_ID,
+            lastSynced: 0,
+            lastUsed: 0
+          });
+          dateNowStub.restore();
+
           expect(setCookieStub.calledOnce).to.be.true;
           expect(setCookieStub.firstCall.args[0]).to.equal(STORAGE_KEY);
-          expect(setCookieStub.firstCall.args[1]).to.equal(JSON.stringify(upsResponse));
+          expect(setCookieStub.firstCall.args[1]).to.equal(JSON.stringify(storage));
           expect(setCookieStub.firstCall.args[2]).to.equal(expiryDelta.toUTCString());
           expect(setCookieStub.firstCall.args[3]).to.equal(null);
           const cookieDomain = parseUrl(TEST_SERVER_URL).hostname;
           expect(setCookieStub.firstCall.args[4]).to.equal(`.${cookieDomain}`);
-          dateNowStub.restore();
+          expect(setLocalStorageStub.calledOnce).to.be.true;
+          expect(setLocalStorageStub.firstCall.args[0]).to.equal(STORAGE_KEY);
+          expect(setLocalStorageStub.firstCall.args[1]).to.deep.equal(JSON.stringify(storage));
         });
 
         it('stores the result in localStorage if cookies are not permitted', () => {
@@ -441,10 +706,12 @@ describe('Yahoo ConnectID Submodule', () => {
           const dateNowStub = sinon.stub(Date, 'now');
           dateNowStub.returns(0);
           const upsResponse = {connectid: 'barfoo'};
-          const expectedStoredData = JSON.stringify({
+          const expectedStoredData = {
             connectid: 'barfoo',
-            __expires: 60 * 60 * 24 * 14 * 1000
-          });
+            puid: PUBLISHER_USER_ID,
+            lastSynced: 0,
+            lastUsed: 0
+          };
           invokeGetIdAPI({
             puid: PUBLISHER_USER_ID,
             pixelId: PIXEL_ID
@@ -455,10 +722,11 @@ describe('Yahoo ConnectID Submodule', () => {
             {'Content-Type': 'application/json'},
             JSON.stringify(upsResponse)
           );
+          dateNowStub.restore();
+
           expect(setLocalStorageStub.calledOnce).to.be.true;
           expect(setLocalStorageStub.firstCall.args[0]).to.equal(STORAGE_KEY);
-          expect(setLocalStorageStub.firstCall.args[1]).to.deep.equal(expectedStoredData);
-          dateNowStub.restore();
+          expect(setLocalStorageStub.firstCall.args[1]).to.deep.equal(JSON.stringify(expectedStoredData));
         });
       });
     });

package/test/spec/modules/criteoBidAdapter_spec.js

@@ -1062,6 +1062,90 @@ describe('The Criteo bidding adapter', function () {
       expect(request.data.source.ext.schain).to.equal(expectedSchain);
     });
 
+    it('should properly build a request with bcat field', function () {
+      const bcat = [ 'IAB1', 'IAB2' ];
+      const bidRequests = [
+        {
+          bidder: 'criteo',
+          adUnitCode: 'bid-123',
+          transactionId: 'transaction-123',
+          mediaTypes: {
+            banner: {
+              sizes: [[728, 90]]
+            }
+          },
+          params: {
+            zoneId: 123,
+          },
+        },
+      ];
+      const bidderRequest = {
+        ortb2: {
+          bcat
+        }
+      };
+
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.data.bcat).to.not.be.null;
+      expect(request.data.bcat).to.equal(bcat);
+    });
+
+    it('should properly build a request with badv field', function () {
+      const badv = [ 'ford.com' ];
+      const bidRequests = [
+        {
+          bidder: 'criteo',
+          adUnitCode: 'bid-123',
+          transactionId: 'transaction-123',
+          mediaTypes: {
+            banner: {
+              sizes: [[728, 90]]
+            }
+          },
+          params: {
+            zoneId: 123,
+          },
+        },
+      ];
+      const bidderRequest = {
+        ortb2: {
+          badv
+        }
+      };
+
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.data.badv).to.not.be.null;
+      expect(request.data.badv).to.equal(badv);
+    });
+
+    it('should properly build a request with bapp field', function () {
+      const bapp = [ 'com.foo.mygame' ];
+      const bidRequests = [
+        {
+          bidder: 'criteo',
+          adUnitCode: 'bid-123',
+          transactionId: 'transaction-123',
+          mediaTypes: {
+            banner: {
+              sizes: [[728, 90]]
+            }
+          },
+          params: {
+            zoneId: 123,
+          },
+        },
+      ];
+      const bidderRequest = {
+        ortb2: {
+          bapp
+        }
+      };
+
+      const request = spec.buildRequests(bidRequests, bidderRequest);
+      expect(request.data.bapp).to.not.be.null;
+      expect(request.data.bapp).to.equal(bapp);
+    });
+
     it('should properly build a request with if ccpa consent field is not provided', function () {
       const bidRequests = [
         {
@@ -2373,7 +2457,7 @@ describe('The Criteo bidding adapter', function () {
 
       const adapters = { Prebid: function () { } };
       const adaptersMock = sinon.mock(adapters);
-      adaptersMock.expects('Prebid').withExactArgs(PROFILE_ID_PUBLISHERTAG, ADAPTER_VERSION, bidRequests, bidderRequest, '$prebid.version$').once().returns(prebidAdapter);
+      adaptersMock.expects('Prebid').withExactArgs(PROFILE_ID_PUBLISHERTAG, ADAPTER_VERSION, bidRequests, bidderRequest, '$prebid.version$', sinon.match.any).once().returns(prebidAdapter);
 
       global.Criteo = {
         PubTag: {