prebid.js 9.4.0 → 9.5.0

package/test/spec/modules/paapi_spec.js

@@ -7,7 +7,7 @@ import {hook} from '../../../src/hook.js';
 import 'modules/appnexusBidAdapter.js';
 import 'modules/rubiconBidAdapter.js';
 import {
-  addPaapiConfigHook,
+  addPaapiConfigHook, addPaapiData,
   buyersToAuctionConfigs,
   getPAAPIConfig,
   getPAAPISize,
@@ -652,110 +652,171 @@ describe('paapi module', () => {
         config.resetConfig();
       });
 
-      function mark() {
-        return Object.fromEntries(
-          adapterManager.makeBidRequests(
-            adUnits,
-            Date.now(),
-            utils.getUniqueIdentifierStr(),
-            function callback() {
-            },
-            []
-          ).map(b => [b.bidderCode, b])
-        );
-      }
-
-      function expectFledgeFlags(...enableFlags) {
-        const bidRequests = mark();
-        expect(bidRequests.appnexus.paapi?.enabled).to.eql(enableFlags[0].enabled);
-        bidRequests.appnexus.bids.forEach(bid => expect(bid.ortb2Imp.ext.ae).to.eql(enableFlags[0].ae));
+      describe('makeBidRequests', () => {
+        function mark() {
+          return Object.fromEntries(
+            adapterManager.makeBidRequests(
+              adUnits,
+              Date.now(),
+              utils.getUniqueIdentifierStr(),
+              function callback() {
+              },
+              []
+            ).map(b => [b.bidderCode, b])
+          );
+        }
 
-        expect(bidRequests.rubicon.paapi?.enabled).to.eql(enableFlags[1].enabled);
-        bidRequests.rubicon.bids.forEach(bid => expect(bid.ortb2Imp?.ext?.ae).to.eql(enableFlags[1].ae));
+        function expectFledgeFlags(...enableFlags) {
+          const bidRequests = mark();
+          expect(bidRequests.appnexus.paapi?.enabled).to.eql(enableFlags[0].enabled);
+          bidRequests.appnexus.bids.forEach(bid => expect(bid.ortb2Imp.ext.ae).to.eql(enableFlags[0].ae));
 
-        Object.values(bidRequests).flatMap(req => req.bids).forEach(bid => {
-          if (bid.ortb2Imp?.ext?.ae) {
-            sinon.assert.match(bid.ortb2Imp.ext.igs, {
-              ae: bid.ortb2Imp.ext.ae,
-              biddable: 1
-            });
-          }
-        });
-      }
+          expect(bidRequests.rubicon.paapi?.enabled).to.eql(enableFlags[1].enabled);
+          bidRequests.rubicon.bids.forEach(bid => expect(bid.ortb2Imp?.ext?.ae).to.eql(enableFlags[1].ae));
 
-      describe('with setConfig()', () => {
-        it('should set paapi.enabled correctly per bidder', function () {
-          config.setConfig({
-            bidderSequence: 'fixed',
-            paapi: {
-              enabled: true,
-              bidders: ['appnexus'],
-              defaultForSlots: 1,
+          Object.values(bidRequests).flatMap(req => req.bids).forEach(bid => {
+            if (bid.ortb2Imp?.ext?.ae) {
+              sinon.assert.match(bid.ortb2Imp.ext.igs, {
+                ae: bid.ortb2Imp.ext.ae,
+                biddable: 1
+              });
             }
           });
-          expectFledgeFlags({enabled: true, ae: 1}, {enabled: false, ae: undefined});
-        });
+        }
 
-        it('should set paapi.enabled correctly for all bidders', function () {
-          config.setConfig({
-            bidderSequence: 'fixed',
-            paapi: {
-              enabled: true,
-              defaultForSlots: 1,
-            }
+        describe('with setConfig()', () => {
+          it('should set paapi.enabled correctly per bidder', function () {
+            config.setConfig({
+              bidderSequence: 'fixed',
+              paapi: {
+                enabled: true,
+                bidders: ['appnexus'],
+                defaultForSlots: 1,
+              }
+            });
+            expectFledgeFlags({enabled: true, ae: 1}, {enabled: false, ae: 0});
           });
-          expectFledgeFlags({enabled: true, ae: 1}, {enabled: true, ae: 1});
-        });
 
-        Object.entries({
-          'not set': {
-            cfg: {},
-            componentSeller: false
-          },
-          'set': {
-            cfg: {
-              componentSeller: {
-                auctionConfig: {
-                  decisionLogicURL: 'publisher.example'
-                }
-              }
-            },
-            componentSeller: true
-          }
-        }).forEach(([t, {cfg, componentSeller}]) => {
-          it(`should set request paapi.componentSeller = ${componentSeller} when config componentSeller is ${t}`, () => {
+          it('should set paapi.enabled correctly for all bidders', function () {
             config.setConfig({
+              bidderSequence: 'fixed',
               paapi: {
                 enabled: true,
                 defaultForSlots: 1,
-                ...cfg
               }
             });
-            Object.values(mark()).forEach(br => expect(br.paapi?.componentSeller).to.eql(componentSeller));
+            expectFledgeFlags({enabled: true, ae: 1}, {enabled: true, ae: 1});
+          });
+
+          Object.entries({
+            'not set': {
+              cfg: {},
+              componentSeller: false
+            },
+            'set': {
+              cfg: {
+                componentSeller: {
+                  auctionConfig: {
+                    decisionLogicURL: 'publisher.example'
+                  }
+                }
+              },
+              componentSeller: true
+            }
+          }).forEach(([t, {cfg, componentSeller}]) => {
+            it(`should set request paapi.componentSeller = ${componentSeller} when config componentSeller is ${t}`, () => {
+              config.setConfig({
+                paapi: {
+                  enabled: true,
+                  defaultForSlots: 1,
+                  ...cfg
+                }
+              });
+              Object.values(mark()).forEach(br => expect(br.paapi?.componentSeller).to.eql(componentSeller));
+            });
           });
         });
+      });
+      describe('addPaapiData', () => {
+        function getEnrichedAdUnits() {
+          const next = sinon.stub();
+          addPaapiData(next, adUnits);
+          sinon.assert.calledWith(next, adUnits);
+          return adUnits;
+        }
+
+        function getImpExt() {
+          const next = sinon.stub();
+          addPaapiData(next, adUnits);
+          sinon.assert.calledWith(next, adUnits);
+          return {
+            global: adUnits[0].ortb2Imp?.ext,
+            ...Object.fromEntries(adUnits[0].bids.map(bid => [bid.bidder, bid.ortb2Imp?.ext]))
+          }
+        }
 
         it('should not override pub-defined ext.ae', () => {
           config.setConfig({
-            bidderSequence: 'fixed',
             paapi: {
               enabled: true,
               defaultForSlots: 1,
             }
           });
           Object.assign(adUnits[0], {ortb2Imp: {ext: {ae: 0}}});
-          expectFledgeFlags({enabled: true, ae: 0}, {enabled: true, ae: 0});
+          sinon.assert.match(getImpExt(), {
+            global: {
+              ae: 0,
+            },
+            rubicon: undefined,
+            appnexus: undefined
+          });
         });
 
+        it('should override per-bidder when excluded via paapi.bidders', () => {
+          config.setConfig({
+            paapi: {
+              enabled: true,
+              defaultForSlots: 1,
+              bidders: ['rubicon']
+            }
+          })
+          sinon.assert.match(getImpExt(), {
+            global: {
+              ae: 1,
+              igs: {
+                ae: 1,
+                biddable: 1
+              }
+            },
+            rubicon: undefined,
+            appnexus: {
+              ae: 0,
+              igs: {
+                ae: 0,
+                biddable: 0
+              }
+            }
+          })
+        })
+
         it('should populate ext.igs when request has ext.ae', () => {
           config.setConfig({
-            bidderSequence: 'fixed',
             paapi: {
               enabled: true
             }
           });
           Object.assign(adUnits[0], {ortb2Imp: {ext: {ae: 3}}});
-          expectFledgeFlags({enabled: true, ae: 3}, {enabled: true, ae: 3});
+          sinon.assert.match(getImpExt(), {
+            global: {
+              ae: 3,
+              igs: {
+                ae: 3,
+                biddable: 1
+              }
+            },
+            rubicon: undefined,
+            appnexus: undefined,
+          });
         });
 
         it('should not override pub-defined ext.igs', () => {
@@ -765,16 +826,17 @@ describe('paapi module', () => {
             }
           });
           Object.assign(adUnits[0], {ortb2Imp: {ext: {ae: 1, igs: {biddable: 0}}}});
-          const bidReqs = mark();
-          Object.values(bidReqs).flatMap(req => req.bids).forEach(bid => {
-            sinon.assert.match(bid.ortb2Imp.ext, {
+          sinon.assert.match(getImpExt(), {
+            global: {
               ae: 1,
               igs: {
                 ae: 1,
                 biddable: 0
               }
-            });
-          });
+            },
+            rubicon: undefined,
+            appnexus: undefined
+          })
         });
 
         it('should fill ext.ae from ext.igs, if defined', () => {
@@ -784,60 +846,64 @@ describe('paapi module', () => {
             }
           });
           Object.assign(adUnits[0], {ortb2Imp: {ext: {igs: {}}}});
-          expectFledgeFlags({enabled: true, ae: 1}, {enabled: true, ae: 1});
+          sinon.assert.match(getImpExt(), {
+            global: {
+              ae: 1,
+              igs: {
+                ae: 1,
+                biddable: 1
+              }
+            },
+            appnexus: undefined,
+            rubicon: undefined
+          })
         });
-      });
 
-      describe('ortb2Imp.ext.paapi.requestedSize', () => {
-        beforeEach(() => {
-          config.setConfig({
-            paapi: {
-              enabled: true,
-              defaultForSlots: 1,
-            }
+        describe('ortb2Imp.ext.paapi.requestedSize', () => {
+          beforeEach(() => {
+            config.setConfig({
+              paapi: {
+                enabled: true,
+                defaultForSlots: 1,
+              }
+            });
           });
-        });
 
-        it('should default to value returned by getPAAPISize', () => {
-          getPAAPISizeStub.returns([123, 321]);
-          Object.values(mark()).flatMap(b => b.bids).forEach(bidRequest => {
-            sinon.assert.match(bidRequest.ortb2Imp.ext.paapi, {
+          it('should default to value returned by getPAAPISize', () => {
+            getPAAPISizeStub.returns([123, 321]);
+            expect(getImpExt().global.paapi).to.eql({
               requestedSize: {
                 width: 123,
                 height: 321
               }
             });
           });
-        });
 
-        it('should not be overridden, if provided by the pub', () => {
-          adUnits[0].ortb2Imp = {
-            ext: {
-              paapi: {
-                requestedSize: {
-                  width: '123px',
-                  height: '321px'
+          it('should not be overridden, if provided by the pub', () => {
+            adUnits[0].ortb2Imp = {
+              ext: {
+                paapi: {
+                  requestedSize: {
+                    width: '123px',
+                    height: '321px'
+                  }
                 }
               }
-            }
-          };
-          Object.values(mark()).flatMap(b => b.bids).forEach(bidRequest => {
-            sinon.assert.match(bidRequest.ortb2Imp.ext.paapi, {
+            };
+            expect(getImpExt().global.paapi).to.eql({
               requestedSize: {
                 width: '123px',
                 height: '321px'
               }
-            });
+            })
+            sinon.assert.notCalled(getPAAPISizeStub);
           });
-          sinon.assert.notCalled(getPAAPISizeStub);
-        });
 
-        it('should not be set if adUnit has no banner sizes', () => {
-          adUnits[0].mediaTypes = {
-            video: {}
-          };
-          Object.values(mark()).flatMap(b => b.bids).forEach(bidRequest => {
-            expect(bidRequest.ortb2Imp?.ext?.paapi?.requestedSize).to.not.exist;
+          it('should not be set if adUnit has no banner sizes', () => {
+            adUnits[0].mediaTypes = {
+              video: {}
+            };
+            expect(getImpExt().global?.paapi?.requestedSize).to.not.exist;
           });
         });
       });

package/test/spec/modules/permutiveRtdProvider_spec.js

@@ -484,7 +484,9 @@ describe('permutiveRtdProvider', function () {
           _psegs: [],
           _ppam: [],
           _pcrprs: [],
-          _pssps: { ssps: [], cohorts: [] }
+          _pindexs: [],
+          _pssps: { ssps: [], cohorts: [] },
+          _ppsts: {},
         })
 
         setBidderRtb(bidderConfig, moduleConfig, segmentsData)
@@ -568,6 +570,7 @@ describe('permutiveRtdProvider', function () {
       const data = transformedTargeting()
       expect(getSegments(250)).to.deep.equal(data)
     })
+
     it('should enforce max segments', function () {
       const max = 1
       const segments = getSegments(max)
@@ -584,6 +587,26 @@ describe('permutiveRtdProvider', function () {
         }
       }
     })
+
+    it('should coerce numbers to strings', function () {
+      setLocalStorage({ _prubicons: [1, 2, 3], _pssps: { ssps: ['foo', 'bar'], cohorts: [4, 5, 6] } })
+
+      const segments = getSegments(200)
+
+      expect(segments.rubicon).to.deep.equal(['1', '2', '3'])
+      expect(segments.ssp.ssps).to.deep.equal(['foo', 'bar'])
+      expect(segments.ssp.cohorts).to.deep.equal(['4', '5', '6'])
+    })
+
+    it('should return empty values on unexpected format', function () {
+      setLocalStorage({ _prubicons: 'a string instead?', _pssps: 123 })
+
+      const segments = getSegments(200)
+
+      expect(segments.rubicon).to.deep.equal([])
+      expect(segments.ssp.ssps).to.deep.equal([])
+      expect(segments.ssp.cohorts).to.deep.equal([])
+    })
   })
 
   describe('Existing key-value targeting', function () {
@@ -703,14 +726,25 @@ function getConfig () {
 }
 
 function transformedTargeting (data = getTargetingData()) {
+  const topics = (() => {
+    const topics = {}
+    for (const topic in data._ppsts) {
+      topics[topic] = data._ppsts[topic].map(String)
+    }
+    return topics
+  })()
+
   return {
-    ac: [...data._pcrprs, ...data._ppam, ...data._psegs.filter(seg => seg >= 1000000)],
-    appnexus: data._papns,
-    ix: data._pindexs,
-    rubicon: data._prubicons,
-    gam: data._pdfps,
-    ssp: data._pssps,
-    topics: data._ppsts,
+    ac: [...data._pcrprs, ...data._ppam, ...data._psegs.filter(seg => seg >= 1000000)].map(String),
+    appnexus: data._papns.map(String),
+    ix: data._pindexs.map(String),
+    rubicon: data._prubicons.map(String),
+    gam: data._pdfps.map(String),
+    ssp: {
+      ssps: data._pssps.ssps.map(String),
+      cohorts: data._pssps.cohorts.map(String)
+    },
+    topics,
   }
 }
 

package/test/spec/modules/prebidServerBidAdapter_spec.js

@@ -825,7 +825,7 @@ describe('S2S Adapter', function () {
         })
       })
     })
-    
+
     it('should set customHeaders correctly when publisher has provided it', () => {
       let configWithCustomHeaders = utils.deepClone(CONFIG);
       configWithCustomHeaders.customHeaders = { customHeader1: 'customHeader1Value' };
@@ -3578,18 +3578,32 @@ describe('S2S Adapter', function () {
         sinon.assert.calledWith(fledgeStub, sinon.match({auctionId, adUnitCode: AU, ortb2: undefined, ortb2Imp: undefined}), sinon.match({config: {id: 2}}))
       }
 
-      it('calls addComponentAuction alongside addBidResponse', function () {
+      it('calls addPaapiConfig alongside addBidResponse', function () {
         adapter.callBids(request, bidderRequests, addBidResponse, done, ajax);
         server.requests[0].respond(200, {}, JSON.stringify(mergeDeep({}, RESPONSE_OPENRTB, FLEDGE_RESP)));
         expect(addBidResponse.called).to.be.true;
         expectFledgeCalls();
       });
 
-      it('calls addComponentAuction when there is no bid in the response', () => {
+      it('calls addPaapiConfig when there is no bid in the response', () => {
         adapter.callBids(request, bidderRequests, addBidResponse, done, ajax);
         server.requests[0].respond(200, {}, JSON.stringify(FLEDGE_RESP));
         expect(addBidResponse.called).to.be.false;
         expectFledgeCalls();
+      });
+
+      it('wraps call in runWithBidder', () => {
+        let fail = false;
+        fledgeStub.callsFake(({bidder}) => {
+          try {
+            expect(bidder).to.exist.and.to.eql(config.getCurrentBidder());
+          } catch (e) {
+            fail = true;
+          }
+        });
+        adapter.callBids(request, bidderRequests, addBidResponse, done, ajax);
+        server.requests[0].respond(200, {}, JSON.stringify(FLEDGE_RESP));
+        expect(fail).to.be.false;
       })
     });
   });

package/test/spec/modules/proxistoreBidAdapter_spec.js

@@ -81,7 +81,7 @@ describe('ProxistoreBidAdapter', function () {
     it('should contain a valid url', function () {
       // has gdpr consent
       expect(request.url).equal(url.cookieBase);
-      // doens't have gpdr consent
+      // doens't have gdpr consent
       bidderRequest.gdprConsent.vendorData = null;
 
       request = spec.buildRequests([bid], bidderRequest);

package/test/spec/modules/pubmaticBidAdapter_spec.js

@@ -4084,6 +4084,46 @@ describe('PubMatic adapter', function () {
         })
       });
     }
+
+    describe('Banner Request param battr checking', function() {
+      it('should add battr params to bannerObj if present in ortb2Imp.banner', function() {
+        let originalBidRequests = utils.deepClone(bidRequests);
+        let bannerObj = utils.deepClone(originalBidRequests[0].ortb2Imp.banner);
+        originalBidRequests[0].ortb2Imp.banner = Object.assign(bannerObj, {
+          battr: [1, 2]
+        });
+
+        const req = spec.buildRequests(originalBidRequests, {
+          auctionId: 'new-auction-id'
+        });
+        let data = JSON.parse(req.data);
+        expect(data.imp[0]['banner']['battr']).to.exist.and.to.be.an('array');
+        expect(data.imp[0]['banner']['battr'][0]).to.equal(originalBidRequests[0].ortb2Imp.banner['battr'][0]);
+        expect(data.imp[0]['banner']['battr'][1]).to.equal(originalBidRequests[0].ortb2Imp.banner['battr'][1]);
+      });
+
+      it('should not add battr params to bannerObj if not present in ortb2Imp.banner', function() {
+        const req = spec.buildRequests(bidRequests, {
+          auctionId: 'new-auction-id'
+        });
+        let data = JSON.parse(req.data);
+        expect(data.imp[0]['banner']['battr']).to.equal(undefined);
+      });
+
+      it('should not add battr params if _checkParamDataType returns undefined (Mismatch data type)', function() {
+        let originalBidRequests = utils.deepClone(bidRequests);
+        let bannerObj = utils.deepClone(originalBidRequests[0].ortb2Imp.banner);
+        originalBidRequests[0].ortb2Imp.banner = Object.assign(bannerObj, {
+          battr: 1
+        });
+
+        const req = spec.buildRequests(originalBidRequests, {
+          auctionId: 'new-auction-id'
+        });
+        let data = JSON.parse(req.data);
+        expect(data.imp[0]['banner']['battr']).to.equal(undefined);
+      });
+    });
   });
 
   if (FEATURES.VIDEO) {