prebid.js 7.12.0 → 7.13.0

package/test/spec/modules/oneKeyRtdProvider_spec.js

@@ -0,0 +1,152 @@
+import {oneKeyDataSubmodule} from 'modules/oneKeyRtdProvider.js';
+import {getAdUnits} from '../../fixtures/fixtures.js';
+
+const defaultSeed = {
+  version: '0.1',
+  transaction_ids: [
+    'd566b02a-a6e2-4c87-98dc-f5623cd9e828',
+    'f7ffe3cc-0d58-4ec4-b687-1d3d410a48fe'
+  ],
+  publisher: 'cmp.pafdemopublisher.com',
+  source: {
+    domain: 'cmp.pafdemopublisher.com',
+    timestamp: 1657116880,
+    signature: '6OmdrSGwagPpugGFuQ4VGjzqYadHxWIXPaLItk0vA1lmi/EQyRvNF5seXStfwKWRnC7HZlOIGSjA6g7HAuofWw=='
+
+  }
+};
+
+const defaultOrb2WithTransmission = {
+  user: {
+    ext: {
+      paf: {
+        transmission: {
+          seed: defaultSeed
+        }
+      }
+    }
+  }
+};
+
+const defaultRtdConfig = {
+  params: {
+    proxyHostName: 'host'
+  }
+};
+
+describe('oneKeyDataSubmodule', () => {
+  var bidsConfig;
+  beforeEach(() => {
+    // Fresh bidsConfig because it can be altered
+    // during the tests.
+    bidsConfig = getReqBidsConfig();
+    setUpOneKey();
+  });
+
+  it('successfully instantiates', () => {
+    expect(oneKeyDataSubmodule.init()).to.equal(true);
+  });
+
+  it('call OneKey API once it is loaded', () => {
+    const done = sinon.spy();
+
+    oneKeyDataSubmodule.getBidRequestData(bidsConfig, done, defaultRtdConfig);
+
+    expect(bidsConfig).to.eql(getReqBidsConfig());
+    expect(done.callCount).to.equal(0);
+    expect(window.OneKey.queue.length).to.equal(1);
+  });
+
+  it('don\'t change anything without a seed', () => {
+    window.OneKey.generateSeed = (_transactionIds) => {
+      return Promise.resolve(undefined);
+    };
+
+    // Act
+    return new Promise(resolve => {
+      oneKeyDataSubmodule.getBidRequestData(bidsConfig, resolve, defaultRtdConfig);
+      executeOneKeyQueue();
+    })
+
+    // Assert
+      .then(() => {
+        expect(bidsConfig).to.eql(getReqBidsConfig());
+      });
+  });
+
+  [ // Test cases
+    {
+      description: 'global orb2',
+      rtdConfig: defaultRtdConfig,
+      expectedFragment: {
+        global: {
+          ...defaultOrb2WithTransmission
+        },
+        bidder: {}
+      }
+    },
+
+    {
+      description: 'bidder-specific orb2',
+      rtdConfig: {
+        params: {
+          proxyHostName: 'host',
+          bidders: [ 'bidder42', 'bidder24' ]
+        }
+      },
+      expectedFragment: {
+        global: { },
+        bidder: {
+          bidder42: {
+            ...defaultOrb2WithTransmission
+          },
+          bidder24: {
+            ...defaultOrb2WithTransmission
+          }
+        }
+      }
+    }
+  ].forEach(testCase => {
+    it(`update adUnits with transaction-ids and transmission in ${testCase.description}`, () => {
+      // Act
+      return new Promise(resolve => {
+        oneKeyDataSubmodule.getBidRequestData(bidsConfig, resolve, testCase.rtdConfig);
+        executeOneKeyQueue();
+      })
+
+      // Assert
+        .then(() => {
+        // Verify transaction-ids without equality
+        // because they are generated UUID.
+          bidsConfig.adUnits.forEach((adUnit) => {
+            expect(adUnit.ortb2Imp.ext.data.paf.transaction_id).to.not.be.undefined;
+          });
+          expect(bidsConfig.ortb2Fragments).to.eql(testCase.expectedFragment);
+        });
+    });
+  });
+});
+
+const getReqBidsConfig = () => {
+  return {
+    adUnits: getAdUnits(),
+    ortb2Fragments: {
+      global: {},
+      bidder: {}
+    }
+  }
+}
+
+const setUpOneKey = () => {
+  window.OneKey.queue = [];
+  OneKey.generateSeed = (_transactionIds) => {
+    return Promise.resolve(defaultSeed);
+  };
+}
+
+const executeOneKeyQueue = () => {
+  while (window.OneKey.queue.length > 0) {
+    window.OneKey.queue[0]();
+    window.OneKey.queue.shift();
+  }
+}

package/test/spec/modules/permutiveRtdProvider_spec.js

@@ -5,9 +5,11 @@ import {
   initSegments,
   isAcEnabled,
   isPermutiveOnPage,
-  setBidderRtb
+  setBidderRtb,
+  getModuleConfig,
+  PERMUTIVE_SUBMODULE_CONFIG_KEY,
 } from 'modules/permutiveRtdProvider.js'
-import { deepAccess } from '../../../src/utils.js'
+import { deepAccess, deepSetValue, mergeDeep } from '../../../src/utils.js'
 import { config } from 'src/config.js'
 
 describe('permutiveRtdProvider', function () {
@@ -29,6 +31,154 @@ describe('permutiveRtdProvider', function () {
     })
   })
 
+  describe('getModuleConfig', function () {
+    beforeEach(function () {
+      // Reads data from the cache
+      permutiveSubmodule.init()
+    })
+
+    const liftToParams = (params) => ({ params })
+
+    const getDefaultConfig = () => ({
+      waitForIt: false,
+      params: {
+        maxSegs: 500,
+        acBidders: [],
+        overwrites: {},
+      },
+    })
+
+    const storeConfigInCacheAndInit = (data) => {
+      const dataToStore = { [PERMUTIVE_SUBMODULE_CONFIG_KEY]: data }
+      setLocalStorage(dataToStore)
+      // Reads data from the cache
+      permutiveSubmodule.init()
+
+      // Cleanup
+      return () => removeLocalStorage(dataToStore)
+    }
+
+    const setWindowPermutivePrebid = (getPermutiveRtdConfig) => {
+      // Read from Permutive
+      const backup = window.permutive
+
+      deepSetValue(window, 'permutive.addons.prebid', {
+        getPermutiveRtdConfig,
+      })
+
+      // Cleanup
+      return () => window.permutive = backup
+    }
+
+    it('should return default values', function () {
+      const config = getModuleConfig({})
+      expect(config).to.deep.equal(getDefaultConfig())
+    })
+
+    it('should override deeply on custom config', function () {
+      const defaultConfig = getDefaultConfig()
+
+      const customModuleConfig = { waitForIt: true, params: { acBidders: ['123'] } }
+      const config = getModuleConfig(customModuleConfig)
+
+      expect(config).to.deep.equal(mergeDeep(defaultConfig, customModuleConfig))
+    })
+
+    it('should override deeply on cached config', function () {
+      const defaultConfig = getDefaultConfig()
+
+      const cachedParamsConfig = { acBidders: ['123'] }
+      const cleanupCache = storeConfigInCacheAndInit(cachedParamsConfig)
+
+      const config = getModuleConfig({})
+
+      expect(config).to.deep.equal(mergeDeep(defaultConfig, liftToParams(cachedParamsConfig)))
+
+      // Cleanup
+      cleanupCache()
+    })
+
+    it('should override deeply on Permutive Rtd config', function () {
+      const defaultConfig = getDefaultConfig()
+
+      const permutiveRtdConfigParams = { acBidders: ['123'], overwrites: { '123': true } }
+      const cleanupPermutive = setWindowPermutivePrebid(function () {
+        return permutiveRtdConfigParams
+      })
+
+      const config = getModuleConfig({})
+
+      expect(config).to.deep.equal(mergeDeep(defaultConfig, liftToParams(permutiveRtdConfigParams)))
+
+      // Cleanup
+      cleanupPermutive()
+    })
+
+    it('should NOT use cached Permutive Rtd config if window.permutive is available', function () {
+      const defaultConfig = getDefaultConfig()
+
+      // As Permutive is available on the window object, this value won't be used.
+      const cachedParamsConfig = { acBidders: ['123'] }
+      const cleanupCache = storeConfigInCacheAndInit(cachedParamsConfig)
+
+      const permutiveRtdConfigParams = { acBidders: ['456'], overwrites: { '123': true } }
+      const cleanupPermutive = setWindowPermutivePrebid(function () {
+        return permutiveRtdConfigParams
+      })
+
+      const config = getModuleConfig({})
+
+      expect(config).to.deep.equal(mergeDeep(defaultConfig, liftToParams(permutiveRtdConfigParams)))
+
+      // Cleanup
+      cleanupCache()
+      cleanupPermutive()
+    })
+
+    it('should handle calling Permutive method throwing error', function () {
+      const defaultConfig = getDefaultConfig()
+
+      const cleanupPermutive = setWindowPermutivePrebid(function () {
+        throw new Error()
+      })
+
+      const config = getModuleConfig({})
+
+      expect(config).to.deep.equal(defaultConfig)
+
+      // Cleanup
+      cleanupPermutive()
+    })
+
+    it('should override deeply in priority order', function () {
+      const defaultConfig = getDefaultConfig()
+
+      // As Permutive is available on the window object, this value won't be used.
+      const cachedConfig = { acBidders: ['123'] }
+      const cleanupCache = storeConfigInCacheAndInit(cachedConfig)
+
+      // Read from Permutive
+      const permutiveRtdConfig = { acBidders: ['456'] }
+      const cleanupPermutive = setWindowPermutivePrebid(function () {
+        return permutiveRtdConfig
+      })
+
+      const customModuleConfig = { params: { acBidders: ['789'], maxSegs: 499 } }
+      const config = getModuleConfig(customModuleConfig)
+
+      // The configs are in reverse priority order as configs are merged left to right. So the priority is,
+      // 1. customModuleConfig <- set by publisher with pbjs.setConfig
+      // 2. permutiveRtdConfig <- set by the publisher using Permutive.
+      // 3. defaultConfig
+      const configMergedInPriorityOrder = mergeDeep(defaultConfig, liftToParams(permutiveRtdConfig), customModuleConfig)
+      expect(config).to.deep.equal(configMergedInPriorityOrder)
+
+      // Cleanup
+      cleanupCache()
+      cleanupPermutive()
+    })
+  })
+
   describe('ortb2 config', function () {
     beforeEach(function () {
       config.resetConfig()

package/test/spec/modules/pubmaticBidAdapter_spec.js

@@ -1103,8 +1103,24 @@ describe('PubMatic adapter', function () {
         expect(data.imp[0].ext.key_val).to.exist.and.to.equal(bidRequests[0].params.dctr);
         expect(data.imp[0].bidfloorcur).to.equal(bidRequests[0].params.currency);
         expect(data.source.ext.schain).to.deep.equal(bidRequests[0].schain);
+        expect(data.ext.epoch).to.exist;
   		});
 
+      it('Set tmax from global config if not set by requestBids method', function() {
+        let sandbox = sinon.sandbox.create();
+        sandbox.stub(config, 'getConfig').callsFake((key) => {
+			  var config = {
+            bidderTimeout: 3000
+			  };
+			  return config[key];
+        });
+        let request = spec.buildRequests(bidRequests, {
+			  auctionId: 'new-auction-id', timeout: 3000
+        });
+        let data = JSON.parse(request.data);
+        expect(data.tmax).to.deep.equal(3000);
+        sandbox.restore();
+      });
       describe('Marketplace parameters', function() {
         let bidderSettingStub;
         beforeEach(function() {

package/test/spec/modules/tripleliftBidAdapter_spec.js

@@ -714,6 +714,24 @@ describe('triplelift adapter', function () {
       expect(payload.user).to.deep.equal({ext: {eids: [{source: 'criteo.com', uids: [{id, ext: {rtiPartner: 'criteoId'}}]}]}});
     });
 
+    it('should add adqueryId to the payload if included', function () {
+      const id = '%7B%22qid%22%3A%229c985f8cc31d9b3c000d%22%7D';
+      bidRequests[0].userIdAsEids = [{ source: 'adquery.io', uids: [{ id }] }];
+      const request = tripleliftAdapterSpec.buildRequests(bidRequests, bidderRequest);
+      const payload = request.data;
+      expect(payload).to.exist;
+      expect(payload.user).to.deep.equal({ext: {eids: [{source: 'adquery.io', uids: [{id, ext: {rtiPartner: 'adquery.io'}}]}]}});
+    });
+
+    it('should add amxRtbId to the payload if included', function () {
+      const id = 'Ok9JQkBM-UFlAXEZQ-UUNBQlZOQzgrUFhW-UUNBQkRQTUBPQVpVWVxNXlZUUF9AUFhAUF9PXFY/';
+      bidRequests[0].userIdAsEids = [{ source: 'amxrtb.com', uids: [{ id }] }];
+      const request = tripleliftAdapterSpec.buildRequests(bidRequests, bidderRequest);
+      const payload = request.data;
+      expect(payload).to.exist;
+      expect(payload.user).to.deep.equal({ext: {eids: [{source: 'amxrtb.com', uids: [{id, ext: {rtiPartner: 'amxrtb.com'}}]}]}});
+    });
+
     it('should add tdid, idl_env and criteoId to the payload if both are included', function () {
       const tdidId = '6bca7f6b-a98a-46c0-be05-6020f7604598';
       const idlEnvId = 'XY6104gr0njcH9UDIR7ysFFJcm2XNpqeJTYslleJ_cMlsFOfZI';

package/test/spec/modules/trustpidSystem_spec.js

@@ -22,14 +22,6 @@ describe('trustpid System', () => {
   });
 
   describe('trustpid getId()', () => {
-    before(() => {
-      window.FC_CONF = {
-        TELCO_ACRONYM: {
-          'domain.with.acronym': 'acronymValue',
-        }
-      };
-    });
-
     afterEach(() => {
       storage.removeDataFromLocalStorage(connectDataKey);
       storage.removeDataFromLocalStorage(connectDomainKey);
@@ -52,7 +44,7 @@ describe('trustpid System', () => {
     it('tests if localstorage & JSON works properly ', () => {
       const idGraph = {
         'domain': 'domainValue',
-        'umid': 'umidValue',
+        'atid': 'atidValue',
       };
       storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
       expect(JSON.parse(storage.getDataFromLocalStorage(connectDataKey))).to.have.property('connectId');
@@ -61,7 +53,7 @@ describe('trustpid System', () => {
     it('returns {callback: func} if domains don\'t match', () => {
       const idGraph = {
         'domain': 'domainValue',
-        'umid': 'umidValue',
+        'atid': 'atidValue',
       };
       storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('differentDomainValue'));
       storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
@@ -70,33 +62,33 @@ describe('trustpid System', () => {
 
     it('returns {id: {trustpid: data.trustpid}} if we have the right data stored in the localstorage ', () => {
       const idGraph = {
-        'domain': 'domain.with.acronym',
-        'umid': 'umidValue',
+        'domain': 'test.domain',
+        'atid': 'atidValue',
       };
-      storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('domain.with.acronym'));
+      storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('test.domain'));
       storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
       const response = trustpidSubmodule.getId();
       expect(response).to.have.property('id');
       expect(response.id).to.have.property('trustpid');
-      expect(response.id.trustpid).to.be.equal('umidValue-acronymValue');
+      expect(response.id.trustpid).to.be.equal('atidValue');
     });
 
     it('returns {trustpid: data.trustpid} if we have the right data stored in the localstorage right after the callback is called', (done) => {
       const idGraph = {
-        'domain': 'domain.with.acronym',
-        'umid': 'umidValue',
+        'domain': 'test.domain',
+        'atid': 'atidValue',
       };
       const response = trustpidSubmodule.getId();
       expect(response).to.have.property('callback');
       expect(response.callback.toString()).contain('result(callback)');
 
       if (typeof response.callback === 'function') {
-        storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('domain.with.acronym'));
+        storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('test.domain'));
         storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
         response.callback(function (result) {
           expect(result).to.not.be.null;
           expect(result).to.have.property('trustpid');
-          expect(result.trustpid).to.be.equal('umidValue-acronymValue');
+          expect(result.trustpid).to.be.equal('atidValue');
           done()
         })
       }
@@ -104,8 +96,8 @@ describe('trustpid System', () => {
 
     it('returns null if domains don\'t match', (done) => {
       const idGraph = {
-        'domain': 'domain.with.acronym',
-        'umid': 'umidValue',
+        'domain': 'test.domain',
+        'atid': 'atidValue',
       };
       storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('differentDomainValue'));
       storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
@@ -127,8 +119,8 @@ describe('trustpid System', () => {
 
     it('returns {trustpid: data.trustpid} if we have the right data stored in the localstorage right after 500ms delay', (done) => {
       const idGraph = {
-        'domain': 'domain.with.acronym',
-        'umid': 'umidValue',
+        'domain': 'test.domain',
+        'atid': 'atidValue',
       };
 
       const response = trustpidSubmodule.getId();
@@ -137,13 +129,13 @@ describe('trustpid System', () => {
 
       if (typeof response.callback === 'function') {
         setTimeout(() => {
-          storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('domain.with.acronym'));
+          storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('test.domain'));
           storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
         }, 500);
         response.callback(function (result) {
           expect(result).to.not.be.null;
           expect(result).to.have.property('trustpid');
-          expect(result.trustpid).to.be.equal('umidValue-acronymValue');
+          expect(result.trustpid).to.be.equal('atidValue');
           done()
         })
       }
@@ -151,8 +143,8 @@ describe('trustpid System', () => {
 
     it('returns null if we have the data stored in the localstorage after 500ms delay and the max (waiting) delay is only 200ms ', (done) => {
       const idGraph = {
-        'domain': 'domain.with.acronym',
-        'umid': 'umidValue',
+        'domain': 'test.domain',
+        'atid': 'atidValue',
       };
 
       const response = trustpidSubmodule.getId({params: {maxDelayTime: 200}});
@@ -161,7 +153,7 @@ describe('trustpid System', () => {
 
       if (typeof response.callback === 'function') {
         setTimeout(() => {
-          storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('domain.with.acronym'));
+          storage.setDataInLocalStorage(connectDomainKey, JSON.stringify('test.domain'));
           storage.setDataInLocalStorage(connectDataKey, JSON.stringify(getStorageData(idGraph)));
         }, 500);
         response.callback(function (result) {
@@ -202,17 +194,7 @@ describe('trustpid System', () => {
     });
   });
 
-  describe('trustpid messageHandler for acronyms', () => {
-    before(() => {
-      window.FC_CONF = {
-        TELCO_ACRONYM: {
-          'domain1': 'abcd',
-          'domain2': 'efgh',
-          'domain3': 'ijkl',
-        }
-      };
-    });
-
+  describe('trustpid messageHandler', () => {
     afterEach(() => {
       storage.removeDataFromLocalStorage(connectDataKey);
       storage.removeDataFromLocalStorage(connectDomainKey);
@@ -223,16 +205,16 @@ describe('trustpid System', () => {
     })
 
     const domains = [
-      {domain: 'domain1', acronym: 'abcd'},
-      {domain: 'domain2', acronym: 'efgh'},
-      {domain: 'domain3', acronym: 'ijkl'},
+      'domain1',
+      'domain2',
+      'domain3',
     ];
 
-    domains.forEach(({domain, acronym}) => {
-      it(`correctly sets trustpid value and acronym to ${acronym} for ${domain}`, (done) => {
+    domains.forEach(domain => {
+      it(`correctly sets trustpid value for domain name ${domain}`, (done) => {
         const idGraph = {
           'domain': domain,
-          'umid': 'umidValue',
+          'atid': 'atidValue',
         };
 
         storage.setDataInLocalStorage(connectDomainKey, JSON.stringify(domain));
@@ -247,7 +229,7 @@ describe('trustpid System', () => {
         const response = trustpidSubmodule.getId();
         expect(response).to.have.property('id');
         expect(response.id).to.have.property('trustpid');
-        expect(response.id.trustpid).to.be.equal(`umidValue-${acronym}`);
+        expect(response.id.trustpid).to.be.equal('atidValue');
         done();
       });
     });

package/test/spec/native_spec.js

@@ -1212,8 +1212,8 @@ describe('fireClickTrackers', () => {
     fetchURL = sinon.stub();
   });
 
-  function runTrackers(resp) {
-    fireClickTrackers(resp, {fetchURL});
+  function runTrackers(resp, assetId = null) {
+    fireClickTrackers(resp, assetId, {fetchURL});
   }
 
   it('should load each URL in link.clicktrackers', () => {
@@ -1225,6 +1225,21 @@ describe('fireClickTrackers', () => {
     });
     urls.forEach(url => sinon.assert.calledWith(fetchURL, url));
   })
+
+  it('should load each URL in asset.link.clicktrackers, when response is ORTB', () => {
+    const urls = ['asset_url1', 'asset_url2'];
+    runTrackers({
+      assets: [
+        {
+          id: 1,
+          link: {
+            clicktrackers: urls
+          }
+        }
+      ],
+    }, 1);
+    urls.forEach(url => sinon.assert.calledWith(fetchURL, url));
+  })
 })
 
 describe('toOrtbNativeResponse', () => {