prebid.js 6.20.0 → 6.22.0

package/test/spec/modules/prebidServerBidAdapter_spec.js

@@ -18,6 +18,7 @@ import { decorateAdUnitsWithNativeParams } from '../../../src/native.js';
 import { auctionManager } from '../../../src/auctionManager.js';
 import { stubAuctionIndex } from '../../helpers/indexStub.js';
 import { registerBidder } from 'src/adapters/bidderFactory.js';
+import {getGlobal} from '../../../src/prebidGlobal.js';
 
 let CONFIG = {
   accountId: '1',
@@ -1038,6 +1039,205 @@ describe('S2S Adapter', function () {
           })
         ).to.be.true;
       });
+
+      it('should find the floor when not all bidderRequests contain it', () => {
+        config.setConfig({
+          s2sConfig: {
+            ...CONFIG,
+            bidders: ['b1', 'b2']
+          },
+        });
+        const bidderRequests = [
+          {
+            ...BID_REQUESTS[0],
+            bidderCode: 'b1',
+            bids: [{
+              bidder: 'b1',
+              bidId: 1,
+            }]
+          },
+          {
+            ...BID_REQUESTS[0],
+            bidderCode: 'b2',
+            bids: [{
+              bidder: 'b2',
+              bidId: 2,
+              getFloor: () => ({
+                currency: 'CUR',
+                floor: 123
+              })
+            }],
+          }
+        ];
+        const adUnits = [
+          {
+            code: 'au1',
+            transactionId: 't1',
+            mediaTypes: {
+              banner: {sizes: [1, 1]}
+            },
+            bids: [{bidder: 'b1', bid_id: 1}]
+          },
+          {
+            code: 'au2',
+            transactionId: 't2',
+            bids: [{bidder: 'b2', bid_id: 2}],
+            mediaTypes: {
+              banner: {sizes: [1, 1]}
+            }
+          }
+        ];
+        const s2sReq = {
+          ...REQUEST,
+          ad_units: adUnits
+        }
+
+        adapter.callBids(s2sReq, bidderRequests, addBidResponse, done, ajax);
+
+        const pbsReq = JSON.parse(server.requests[server.requests.length - 1].requestBody);
+        const [imp1, imp2] = pbsReq.imp;
+
+        expect(imp1.bidfloor).to.be.undefined;
+        expect(imp1.bidfloorcur).to.be.undefined;
+
+        expect(imp2.bidfloor).to.eql(123);
+        expect(imp2.bidfloorcur).to.eql('CUR');
+      });
+
+      describe('when different bids have different floors', () => {
+        let s2sReq;
+        beforeEach(() => {
+          config.setConfig({
+            s2sConfig: {
+              ...CONFIG,
+              bidders: ['b1', 'b2', 'b3']
+            },
+          });
+          BID_REQUESTS = [
+            {
+              ...BID_REQUESTS[0],
+              bidderCode: 'b2',
+              bids: [{
+                bidder: 'b2',
+                bidId: 2,
+                getFloor: () => ({
+                  currency: '1',
+                  floor: 2
+                })
+              }],
+            },
+            {
+              ...BID_REQUESTS[0],
+              bidderCode: 'b1',
+              bids: [{
+                bidder: 'b1',
+                bidId: 1,
+                getFloor: () => ({
+                  floor: 10,
+                  currency: '0.1'
+                })
+              }]
+            },
+            {
+              ...BID_REQUESTS[0],
+              bidderCode: 'b3',
+              bids: [{
+                bidder: 'b3',
+                bidId: 3,
+                getFloor: () => ({
+                  currency: '10',
+                  floor: 1
+                })
+              }],
+            }
+          ];
+          s2sReq = {
+            ...REQUEST,
+            ad_units: [
+              {
+                code: 'au1',
+                transactionId: 't1',
+                mediaTypes: {
+                  banner: {sizes: [1, 1]}
+                },
+                bids: [
+                  {bidder: 'b2', bid_id: 2},
+                  {bidder: 'b3', bid_id: 3},
+                  {bidder: 'b1', bid_id: 1},
+                ]
+              }
+            ]
+          };
+        });
+
+        Object.entries({
+          'cannot compute a floor': (bid) => { bid.getFloor = () => { throw new Error() } },
+          'does not set a floor': (bid) => { delete bid.getFloor; },
+        }).forEach(([t, updateBid]) => {
+          it(`should not set pricefloor if any one of them ${t}`, () => {
+            updateBid(BID_REQUESTS[1].bids[0]);
+            adapter.callBids(s2sReq, BID_REQUESTS, addBidResponse, done, ajax);
+            const pbsReq = JSON.parse(server.requests[server.requests.length - 1].requestBody);
+            expect(pbsReq.imp[0].bidfloor).to.be.undefined;
+            expect(pbsReq.imp[0].bidfloorcur).to.be.undefined;
+          });
+        })
+
+        Object.entries({
+          'is available': {
+            expectDesc: 'minimum after conversion',
+            expectedFloor: 10,
+            expectedCur: '0.1',
+            conversionFn: (amount, from, to) => {
+              from = parseFloat(from);
+              to = parseFloat(to);
+              return amount * from / to;
+            },
+          },
+          'is not available': {
+            expectDesc: 'absolute minimum',
+            expectedFloor: 1,
+            expectedCur: '10',
+            conversionFn: null
+          },
+          'is not working': {
+            expectDesc: 'first',
+            expectedFloor: 2,
+            expectedCur: '1',
+            conversionFn: () => {
+              throw new Error();
+            }
+          }
+        }).forEach(([t, {expectDesc, expectedFloor, expectedCur, conversionFn}]) => {
+          describe(`and currency conversion ${t}`, () => {
+            let mockConvertCurrency;
+            const origConvertCurrency = getGlobal().convertCurrency;
+            beforeEach(() => {
+              if (conversionFn) {
+                getGlobal().convertCurrency = mockConvertCurrency = sinon.stub().callsFake(conversionFn)
+              } else {
+                mockConvertCurrency = null;
+                delete getGlobal().convertCurrency;
+              }
+            });
+
+            afterEach(() => {
+              if (origConvertCurrency != null) {
+                getGlobal().convertCurrency = origConvertCurrency;
+              } else {
+                delete getGlobal().convertCurrency;
+              }
+            })
+
+            it(`should pick the ${expectDesc}`, () => {
+              adapter.callBids(s2sReq, BID_REQUESTS, addBidResponse, done, ajax);
+              const pbsReq = JSON.parse(server.requests[server.requests.length - 1].requestBody);
+              expect(pbsReq.imp[0].bidfloor).to.eql(expectedFloor);
+              expect(pbsReq.imp[0].bidfloorcur).to.eql(expectedCur);
+            });
+          });
+        });
+      });
     });
 
     it('adds device.w and device.h even if the config lacks a device object', function () {

package/test/spec/modules/pubmaticBidAdapter_spec.js

@@ -3130,6 +3130,115 @@ describe('PubMatic adapter', function () {
       });
     });
 
+    describe('Request param acat checking', function() {
+      let multipleBidRequests = [
+		  {
+          bidder: 'pubmatic',
+          params: {
+			  publisherId: '301',
+			  adSlot: '/15671365/DMDemo@300x250:0',
+			  kadfloor: '1.2',
+			  pmzoneid: 'aabc, ddef',
+			  kadpageurl: 'www.publisher.com',
+			  yob: '1986',
+			  gender: 'M',
+			  lat: '12.3',
+			  lon: '23.7',
+			  wiid: '1234567890',
+			  profId: '100',
+			  verId: '200',
+			  currency: 'AUD',
+			  dctr: 'key1=val1|key2=val2,!val3'
+          },
+          placementCode: '/19968336/header-bid-tag-1',
+          sizes: [[300, 250], [300, 600]],
+          bidId: '23acc48ad47af5',
+          requestId: '0fb4905b-9456-4152-86be-c6f6d259ba99',
+          bidderRequestId: '1c56ad30b9b8ca8',
+          transactionId: '92489f71-1bf2-49a0-adf9-000cea934729'
+		  },
+		  {
+          bidder: 'pubmatic',
+          params: {
+			  publisherId: '301',
+			  adSlot: '/15671365/DMDemo@300x250:0',
+			  kadfloor: '1.2',
+			  pmzoneid: 'aabc, ddef',
+			  kadpageurl: 'www.publisher.com',
+			  yob: '1986',
+			  gender: 'M',
+			  lat: '12.3',
+			  lon: '23.7',
+			  wiid: '1234567890',
+			  profId: '100',
+			  verId: '200',
+			  currency: 'GBP',
+			  dctr: 'key1=val3|key2=val1,!val3|key3=val123'
+          },
+          placementCode: '/19968336/header-bid-tag-1',
+          sizes: [[300, 250], [300, 600]],
+          bidId: '23acc48ad47af5',
+          requestId: '0fb4905b-9456-4152-86be-c6f6d259ba99',
+          bidderRequestId: '1c56ad30b9b8ca8',
+          transactionId: '92489f71-1bf2-49a0-adf9-000cea934729'
+		  }
+      ];
+
+      it('acat: pass only strings', function() {
+		  multipleBidRequests[0].params.acat = [1, 2, 3, 'IAB1', 'IAB2'];
+		  let request = spec.buildRequests(multipleBidRequests, {
+          auctionId: 'new-auction-id'
+		  });
+		  let data = JSON.parse(request.data);
+		  expect(data.ext.acat).to.exist.and.to.deep.equal(['IAB1', 'IAB2']);
+      });
+
+	  it('acat: trim the strings', function() {
+        multipleBidRequests[0].params.acat = ['   IAB1    ', '   IAB2   '];
+        let request = spec.buildRequests(multipleBidRequests, {
+          auctionId: 'new-auction-id'
+        });
+        let data = JSON.parse(request.data);
+        expect(data.ext.acat).to.exist.and.to.deep.equal(['IAB1', 'IAB2']);
+      });
+
+	  it('acat: pass only unique strings', function() {
+        multipleBidRequests[0].params.acat = ['IAB1', 'IAB2', 'IAB1', 'IAB2', 'IAB1', 'IAB2'];
+        multipleBidRequests[1].params.acat = ['IAB1', 'IAB2', 'IAB1', 'IAB2', 'IAB1', 'IAB3'];
+        let request = spec.buildRequests(multipleBidRequests, {
+          auctionId: 'new-auction-id'
+        });
+        let data = JSON.parse(request.data);
+        expect(data.ext.acat).to.exist.and.to.deep.equal(['IAB1', 'IAB2', 'IAB3']);
+      });
+      it('ortb2.ext.prebid.bidderparams.pubmatic.acat should be passed in request payload', function() {
+        let sandbox = sinon.sandbox.create();
+        sandbox.stub(config, 'getConfig').callsFake(key => {
+          const config = {
+            'ortb2': {
+              ext: {
+                prebid: {
+                  bidderparams: {
+                    pubmatic: {
+                      acat: ['IAB1', 'IAB2', 'IAB1', 'IAB2', 'IAB1', 'IAB2']
+                    }
+                  }
+                }
+              }
+            }
+          };
+          return config[key];
+        });
+        const request = spec.buildRequests(bidRequests, {
+          auctionId: 'new-auction-id',
+          bidderCode: 'pubmatic'
+        });
+        let data = JSON.parse(request.data);
+        expect(data.ext.acat).to.deep.equal(['IAB1', 'IAB2']);
+        sandbox.restore();
+      });
+    });
+
     describe('Request param bcat checking', function() {
       let multipleBidRequests = [
         {
@@ -3231,6 +3340,26 @@ describe('PubMatic adapter', function () {
         });
         let data = JSON.parse(request.data);
         expect(data.bcat).to.deep.equal(undefined);
+      });
+
+	  it('ortb2.bcat should merged with slot level bcat param', function() {
+        multipleBidRequests[0].params.bcat = ['IAB-1', 'IAB-2'];
+        let sandbox = sinon.sandbox.create();
+        sandbox.stub(config, 'getConfig').callsFake(key => {
+          const config = {
+            'ortb2': {
+              bcat: ['IAB-3', 'IAB-4']
+            }
+          };
+          return config[key];
+        });
+        const request = spec.buildRequests(multipleBidRequests, {
+          auctionId: 'new-auction-id',
+          bidderCode: 'pubmatic'
+        });
+        let data = JSON.parse(request.data);
+        expect(data.bcat).to.deep.equal(['IAB-1', 'IAB-2', 'IAB-3', 'IAB-4']);
+        sandbox.restore();
       });
     });
 

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

@@ -11,6 +11,7 @@ import * as events from 'src/events.js';
 import {hook} from '../../../../src/hook.js';
 import {auctionManager} from '../../../../src/auctionManager.js';
 import {stubAuctionIndex} from '../../../helpers/indexStub.js';
+import { bidderSettings } from '../../../../src/bidderSettings.js';
 
 const CODE = 'sampleBidder';
 const MOCK_BIDS_REQUEST = {
@@ -1022,6 +1023,142 @@ describe('validate bid response: ', function () {
     expect(addBidResponseStub.firstCall.args[0]).to.equal('mock/placement');
     expect(logErrorSpy.callCount).to.equal(0);
   });
+
+  describe(' Check for alternateBiddersList ', function() {
+    let bidRequest;
+    let bids1;
+    let logWarnSpy;
+    let bidderSettingStub, aliasRegistryStub;
+    let aliasRegistry;
+
+    beforeEach(function () {
+      bidRequest = {
+        bids: [{
+          bidId: '1',
+          bidder: CODE,
+          auctionId: 'first-bid-id',
+          adUnitCode: 'mock/placement',
+          transactionId: 'au',
+        }]
+      };
+
+      bids1 = Object.assign({},
+        bids[0],
+        {
+          bidderCode: 'validAlternateBidder',
+          adapterCode: 'knownAdapter1'
+        }
+      );
+      logWarnSpy = sinon.spy(utils, 'logWarn');
+      bidderSettingStub = sinon.stub(bidderSettings, 'get');
+      aliasRegistry = {};
+      aliasRegistryStub = sinon.stub(adapterManager, 'aliasRegistry');
+      aliasRegistryStub.get(() => aliasRegistry);
+    });
+
+    afterEach(function () {
+      logWarnSpy.restore();
+      bidderSettingStub.restore();
+      aliasRegistryStub.restore();
+    });
+
+    it('should log warning when bidder is unknown and allowAlternateBidderCodes flag is false', function () {
+      bidderSettingStub.returns(false);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(false);
+      expect(logWarnSpy.callCount).to.equal(1);
+    });
+
+    it('should accept the bid, when allowAlternateBidderCodes flag is undefined (default should be true)', function () {
+      bidderSettingStub.returns(undefined);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(true);
+      expect(logWarnSpy.callCount).to.equal(0);
+      expect(logErrorSpy.callCount).to.equal(0);
+    });
+
+    it('should log warning when the particular bidder is not specified in allowedAlternateBidderCodes and allowAlternateBidderCodes flag is true', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['invalidAlternateBidder02']);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(false);
+      expect(logWarnSpy.callCount).to.equal(1);
+    });
+
+    it('should accept the bid, when allowedAlternateBidderCodes is empty and allowAlternateBidderCodes flag is true', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns();
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(true);
+      expect(logWarnSpy.callCount).to.equal(0);
+      expect(logErrorSpy.callCount).to.equal(0);
+    });
+
+    it('should accept the bid, when allowedAlternateBidderCodes is marked as * and allowAlternateBidderCodes flag is true', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['*']);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(true);
+      expect(logWarnSpy.callCount).to.equal(0);
+      expect(logErrorSpy.callCount).to.equal(0);
+    });
+
+    it('should accept the bid, when allowedAlternateBidderCodes contains bidder name and allowAlternateBidderCodes flag is true', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(true);
+      bidderSettingStub.withArgs(CODE, 'allowedAlternateBidderCodes').returns(['validAlternateBidder']);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(true);
+      expect(logWarnSpy.callCount).to.equal(0);
+      expect(logErrorSpy.callCount).to.equal(0);
+    });
+
+    it('should not accept the bid, when bidder is an alias but bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
+      aliasRegistry = {'validAlternateBidder': CODE};
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(false);
+      expect(logWarnSpy.callCount).to.equal(1);
+    });
+
+    it('should not accept the bid, when bidderSetting is missing for the bidder. It should fallback to standard setting and reject the bid', function () {
+      bidderSettingStub.withArgs(CODE, 'allowAlternateBidderCodes').returns(false);
+
+      const bidder = newBidder(spec);
+      spec.interpretResponse.returns(bids1);
+      bidder.callBids(bidRequest, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+
+      expect(addBidResponseStub.calledOnce).to.equal(false);
+      expect(logWarnSpy.callCount).to.equal(1);
+    });
+  })
 });
 
 describe('preload mapping url hook', function() {