Core & priceFloors: pass bid request to bidCpmAdjustment; warn about invalid adUnit.floors definitions

modules/priceFloors.js

@@ -28,6 +28,7 @@ import {auctionManager} from '../src/auctionManager.js';
 import {IMP, PBS, registerOrtbProcessor, REQUEST} from '../src/pbjsORTB.js';
 import {timedAuctionHook, timedBidResponseHook} from '../src/utils/perfMetrics.js';
 import {beConvertCurrency} from '../src/utils/currency.js';
+import {adjustCpm} from '../src/utils/cpm.js';
 
 /**
  * @summary This Module is intended to provide users with the ability to dynamically set and enforce price floors on a per auction basis.
@@ -179,12 +180,8 @@ function generatePossibleEnumerations(arrayOfFields, delimiter) {
 /**
  * @summary If a the input bidder has a registered cpmadjustment it returns the input CPM after being adjusted
  */
-export function getBiddersCpmAdjustment(bidderName, inputCpm, bid, bidRequest) {
-  const adjustmentFunction = bidderSettings.get(bidderName, 'bidCpmAdjustment');
-  if (adjustmentFunction) {
-    return parseFloat(adjustmentFunction(inputCpm, { ...bid, cpm: inputCpm }, bidRequest));
-  }
-  return parseFloat(inputCpm);
+export function getBiddersCpmAdjustment(inputCpm, bid, bidRequest) {
+  return parseFloat(adjustCpm(inputCpm, {...bid, cpm: inputCpm}, bidRequest));
 }
 
 /**
@@ -254,7 +251,7 @@ export function getFloor(requestParams = {currency: 'USD', mediaType: '*', size:
     if (inverseFunction) {
       floorInfo.matchingFloor = inverseFunction(floorInfo.matchingFloor, bidRequest);
     } else {
-      let cpmAdjustment = getBiddersCpmAdjustment(bidRequest.bidder, floorInfo.matchingFloor, {}, bidRequest);
+      let cpmAdjustment = getBiddersCpmAdjustment(floorInfo.matchingFloor, null, bidRequest);
       floorInfo.matchingFloor = cpmAdjustment ? calculateAdjustedFloor(floorInfo.matchingFloor, cpmAdjustment) : floorInfo.matchingFloor;
     }
   }
@@ -313,6 +310,8 @@ export function getFloorDataFromAdUnits(adUnits) {
         // copy over the new rules into our values object
         Object.assign(accum.values, newRules);
       }
+    } else if (adUnit.floors != null) {
+      logWarn(`adUnit '${adUnit.code}' provides an invalid \`floor\` definition, it will be ignored for floor calculations`, adUnit);
     }
     return accum;
   }, {});
@@ -737,7 +736,7 @@ export const addBidResponseHook = timedBidResponseHook('priceFloors', function a
   }
 
   // ok we got the bid response cpm in our desired currency. Now we need to run the bidders CPMAdjustment function if it exists
-  adjustedCpm = getBiddersCpmAdjustment(bid.bidderCode, adjustedCpm, bid, matchingBidRequest);
+  adjustedCpm = getBiddersCpmAdjustment(adjustedCpm, bid, matchingBidRequest);
 
   // add necessary data information for analytics adapters / floor providers would possibly need
   addFloorDataToBid(floorData, floorInfo, bid, adjustedCpm);

src/auction.js

@@ -93,6 +93,7 @@ import CONSTANTS from './constants.json';
 import {GreedyPromise} from './utils/promise.js';
 import {useMetrics} from './utils/perfMetrics.js';
 import {createBid} from './bidfactory.js';
+import {adjustCpm} from './utils/cpm.js';
 
 const { syncUsers } = userSync;
 
@@ -971,17 +972,7 @@ function setKeys(keyValues, bidderSettings, custBidObj, bidReq) {
 }
 
 export function adjustBids(bid) {
-  let code = bid.bidderCode;
-  let bidPriceAdjusted = bid.cpm;
-  const bidCpmAdjustment = bidderSettings.get(code || null, 'bidCpmAdjustment');
-
-  if (bidCpmAdjustment && typeof bidCpmAdjustment === 'function') {
-    try {
-      bidPriceAdjusted = bidCpmAdjustment(bid.cpm, Object.assign({}, bid));
-    } catch (e) {
-      logError('Error during bid adjustment', 'bidmanager.js', e);
-    }
-  }
+  let bidPriceAdjusted = adjustCpm(bid.cpm, bid);
 
   if (bidPriceAdjusted >= 0) {
     bid.cpm = bidPriceAdjusted;

src/utils/cpm.js

@@ -0,0 +1,17 @@
+import {auctionManager} from '../auctionManager.js';
+import {bidderSettings} from '../bidderSettings.js';
+import {logError} from '../utils.js';
+
+export function adjustCpm(cpm, bidResponse, bidRequest, {index = auctionManager.index, bs = bidderSettings} = {}) {
+  bidRequest = bidRequest || index.getBidRequest(bidResponse);
+  const bidCpmAdjustment = bs.get(bidResponse?.bidderCode || bidRequest?.bidder, 'bidCpmAdjustment');
+
+  if (bidCpmAdjustment && typeof bidCpmAdjustment === 'function') {
+    try {
+      return bidCpmAdjustment(cpm, Object.assign({}, bidResponse), bidRequest);
+    } catch (e) {
+      logError('Error during bid adjustment', e);
+    }
+  }
+  return cpm;
+}

test/spec/unit/utils/cpm_spec.js

@@ -0,0 +1,64 @@
+import {adjustCpm} from '../../../../src/utils/cpm.js';
+
+describe('adjustCpm', () => {
+  const bidderCode = 'mockBidder';
+  let adjustmentFn, bs, index;
+  beforeEach(() => {
+    bs = {
+      get: sinon.stub()
+    }
+    index = {
+      getBidRequest: sinon.stub()
+    }
+    adjustmentFn = sinon.stub().callsFake((cpm) => cpm * 2);
+  })
+
+  it('throws when neither bidRequest nor bidResponse are provided', () => {
+    expect(() => adjustCpm(1)).to.throw();
+  })
+
+  it('always provides an object as bidResponse for the adjustment fn', () => {
+    bs.get.callsFake(() => adjustmentFn);
+    adjustCpm(1, null, {bidder: bidderCode}, {index, bs});
+    sinon.assert.calledWith(adjustmentFn, 1, {});
+  });
+
+  describe('when no bidRequest is provided', () => {
+    Object.entries({
+      'unavailable': undefined,
+      'found': {foo: 'bar'}
+    }).forEach(([t, req]) => {
+      describe(`and it is ${t} in the index`, () => {
+        beforeEach(() => {
+          bs.get.callsFake(() => adjustmentFn);
+          index.getBidRequest.callsFake(() => req)
+        });
+
+        it('provides it to the adjustment fn', () => {
+          const bidResponse = {bidderCode};
+          adjustCpm(1, bidResponse, undefined, {index, bs});
+          sinon.assert.calledWith(index.getBidRequest, bidResponse);
+          sinon.assert.calledWith(adjustmentFn, 1, bidResponse, req);
+        })
+      })
+    })
+  });
+
+  Object.entries({
+    'bidResponse': [{bidderCode}],
+    'bidRequest': [null, {bidder: bidderCode}],
+  }).forEach(([t, [bidResp, bidReq]]) => {
+    describe(`when passed ${t}`, () => {
+      beforeEach(() => {
+        bs.get.callsFake((bidder) => { if (bidder === bidderCode) return adjustmentFn });
+      });
+      it('retrieves the correct bidder code', () => {
+        expect(adjustCpm(1, bidResp, bidReq, {bs, index})).to.eql(2);
+      });
+      it('passes them to the adjustment fn', () => {
+        adjustCpm(1, bidResp, bidReq, {bs, index});
+        sinon.assert.calledWith(adjustmentFn, 1, bidResp == null ? sinon.match.any : bidResp, bidReq);
+      });
+    });
+  })
+});