prebid.js 8.52.0 → 8.52.2

package/test/spec/modules/fledgeForGpt_spec.js

@@ -4,7 +4,6 @@ import {
   setPAAPIConfigFactory,
   slotConfigurator
 } from 'modules/fledgeForGpt.js';
-import * as gptUtils from '../../../libraries/gptUtils/gptUtils.js';
 import 'modules/appnexusBidAdapter.js';
 import 'modules/rubiconBidAdapter.js';
 import {deepSetValue} from '../../../src/utils.js';
@@ -25,81 +24,94 @@ describe('fledgeForGpt module', () => {
   });
 
   describe('slotConfigurator', () => {
-    let mockGptSlot, setGptConfig;
-    beforeEach(() => {
-      mockGptSlot = {
+    let setGptConfig;
+    function mockGptSlot(auPath) {
+      return {
         setConfig: sinon.stub(),
-        getAdUnitPath: () => 'mock/gpt/au'
-      };
-      sandbox.stub(gptUtils, 'getGptSlotForAdUnitCode').callsFake(() => mockGptSlot);
+        getAdUnitPath: () => auPath
+      }
+    }
+    beforeEach(() => {
       setGptConfig = slotConfigurator();
     });
-    it('should set GPT slot config', () => {
-      setGptConfig('au', [fledgeAuctionConfig]);
-      sinon.assert.calledWith(gptUtils.getGptSlotForAdUnitCode, 'au');
-      sinon.assert.calledWith(mockGptSlot.setConfig, {
-        componentAuction: [{
-          configKey: 'bidder',
-          auctionConfig: fledgeAuctionConfig,
-        }]
-      });
-    });
 
-    describe('when reset = true', () => {
-      it('should reset GPT slot config', () => {
-        setGptConfig('au', [fledgeAuctionConfig]);
-        mockGptSlot.setConfig.resetHistory();
-        gptUtils.getGptSlotForAdUnitCode.resetHistory();
-        setGptConfig('au', [], true);
-        sinon.assert.calledWith(gptUtils.getGptSlotForAdUnitCode, 'au');
-        sinon.assert.calledWith(mockGptSlot.setConfig, {
-          componentAuction: [{
-            configKey: 'bidder',
-            auctionConfig: null
-          }]
+    Object.entries({
+      'single slot': [mockGptSlot('mock/gpt/au')],
+      'multiple slots': [mockGptSlot('mock/gpt/au'), mockGptSlot('mock/gpt/au2')]
+    }).forEach(([t, gptSlots]) => {
+      describe(`when ad unit code matches ${t}`, () => {
+        it('should set GPT slot config', () => {
+          setGptConfig('au', gptSlots, [fledgeAuctionConfig]);
+          gptSlots.forEach(slot => {
+            sinon.assert.calledWith(slot.setConfig, {
+              componentAuction: [{
+                configKey: 'bidder',
+                auctionConfig: fledgeAuctionConfig,
+              }]
+            });
+          })
         });
-      });
+        describe('when reset = true', () => {
+          it('should reset GPT slot config', () => {
+            setGptConfig('au', gptSlots, [fledgeAuctionConfig]);
+            gptSlots.forEach(slot => slot.setConfig.resetHistory());
+            setGptConfig('au', gptSlots, [], true);
+            gptSlots.forEach(slot => {
+              sinon.assert.calledWith(slot.setConfig, {
+                componentAuction: [{
+                  configKey: 'bidder',
+                  auctionConfig: null
+                }]
+              });
+            })
+          });
 
-      it('should reset only sellers with no fresh config', () => {
-        setGptConfig('au', [{seller: 's1'}, {seller: 's2'}]);
-        mockGptSlot.setConfig.resetHistory();
-        setGptConfig('au', [{seller: 's1'}], true);
-        sinon.assert.calledWith(mockGptSlot.setConfig, {
-          componentAuction: [{
-            configKey: 's1',
-            auctionConfig: {seller: 's1'}
-          }, {
-            configKey: 's2',
-            auctionConfig: null
-          }]
-        })
-      });
+          it('should reset only sellers with no fresh config', () => {
+            setGptConfig('au', gptSlots, [{seller: 's1'}, {seller: 's2'}]);
+            gptSlots.forEach(slot => slot.setConfig.resetHistory());
+            setGptConfig('au', gptSlots, [{seller: 's1'}], true);
+            gptSlots.forEach(slot => {
+              sinon.assert.calledWith(slot.setConfig, {
+                componentAuction: [{
+                  configKey: 's1',
+                  auctionConfig: {seller: 's1'}
+                }, {
+                  configKey: 's2',
+                  auctionConfig: null
+                }]
+              })
+            })
+          });
 
-      it('should not reset sellers that were already reset', () => {
-        setGptConfig('au', [{seller: 's1'}]);
-        setGptConfig('au', [], true);
-        mockGptSlot.setConfig.resetHistory();
-        setGptConfig('au', [], true);
-        sinon.assert.notCalled(mockGptSlot.setConfig);
-      })
+          it('should not reset sellers that were already reset', () => {
+            setGptConfig('au', gptSlots, [{seller: 's1'}]);
+            setGptConfig('au', gptSlots, [], true);
+            gptSlots.forEach(slot => slot.setConfig.resetHistory());
+            setGptConfig('au', gptSlots, [], true);
+            gptSlots.forEach(slot => sinon.assert.notCalled(slot.setConfig));
+          })
 
-      it('should keep track of configuration history by slot', () => {
-        setGptConfig('au1', [{seller: 's1'}]);
-        setGptConfig('au1', [{seller: 's2'}], false);
-        setGptConfig('au2', [{seller: 's3'}]);
-        mockGptSlot.setConfig.resetHistory();
-        setGptConfig('au1', [], true);
-        sinon.assert.calledWith(mockGptSlot.setConfig, {
-          componentAuction: [{
-            configKey: 's1',
-            auctionConfig: null
-          }, {
-            configKey: 's2',
-            auctionConfig: null
-          }]
+          it('should keep track of configuration history by ad unit', () => {
+            setGptConfig('au1', gptSlots, [{seller: 's1'}]);
+            setGptConfig('au1', gptSlots, [{seller: 's2'}], false);
+            setGptConfig('au2', gptSlots, [{seller: 's3'}]);
+            gptSlots.forEach(slot => slot.setConfig.resetHistory());
+            setGptConfig('au1', gptSlots, [], true);
+            gptSlots.forEach(slot => {
+              sinon.assert.calledWith(slot.setConfig, {
+                componentAuction: [{
+                  configKey: 's1',
+                  auctionConfig: null
+                }, {
+                  configKey: 's2',
+                  auctionConfig: null
+                }]
+              });
+            })
+          })
         });
       })
-    });
+    })
   });
   describe('onAuctionConfig', () => {
     [
@@ -124,12 +136,14 @@ describe('fledgeForGpt module', () => {
 
             it(`should ${shouldSetConfig ? '' : 'NOT'} set GPT slot configuration`, () => {
               const auctionConfig = {componentAuctions: [{seller: 'mock1'}, {seller: 'mock2'}]};
+              const mockSlot = {};
+              const getSlot = sinon.stub().returns({});
               const setGptConfig = sinon.stub();
               const markAsUsed = sinon.stub();
-              onAuctionConfigFactory(setGptConfig)('aid', {au1: auctionConfig, au2: null}, markAsUsed);
+              onAuctionConfigFactory(setGptConfig, getSlot)('aid', {au1: auctionConfig, au2: null}, markAsUsed);
               if (shouldSetConfig) {
-                sinon.assert.calledWith(setGptConfig, 'au1', auctionConfig.componentAuctions);
-                sinon.assert.calledWith(setGptConfig, 'au2', []);
+                sinon.assert.calledWith(setGptConfig, 'au1', [mockSlot], auctionConfig.componentAuctions);
+                sinon.assert.calledWith(setGptConfig, 'au2', [mockSlot], []);
                 sinon.assert.calledWith(markAsUsed, 'au1');
               } else {
                 sinon.assert.notCalled(setGptConfig);
@@ -142,11 +156,12 @@ describe('fledgeForGpt module', () => {
     })
   });
   describe('setPAAPIConfigForGpt', () => {
-    let getPAAPIConfig, setGptConfig, setPAAPIConfigForGPT;
+    let getPAAPIConfig, setGptConfig, getSlots, setPAAPIConfigForGPT;
     beforeEach(() => {
       getPAAPIConfig = sinon.stub();
       setGptConfig = sinon.stub();
-      setPAAPIConfigForGPT = setPAAPIConfigFactory(getPAAPIConfig, setGptConfig);
+      getSlots = sinon.stub().callsFake((codes) => Object.fromEntries(codes.map(code => [code, ['mock-slot']])))
+      setPAAPIConfigForGPT = setPAAPIConfigFactory(getPAAPIConfig, setGptConfig, getSlots);
     });
 
     Object.entries({
@@ -161,6 +176,12 @@ describe('fledgeForGpt module', () => {
       })
     });
 
+    it('passes customSlotMatching to getSlots', () => {
+      getPAAPIConfig.returns({au1: {}});
+      setPAAPIConfigForGPT('mock-filters', 'mock-custom-matching');
+      sinon.assert.calledWith(getSlots, ['au1'], 'mock-custom-matching');
+    })
+
     it('sets GPT slot config for each ad unit that has PAAPI config, and resets the rest', () => {
       const cfg = {
         au1: {
@@ -175,7 +196,7 @@ describe('fledgeForGpt module', () => {
       setPAAPIConfigForGPT('mock-filters');
       sinon.assert.calledWith(getPAAPIConfig, 'mock-filters');
       Object.entries(cfg).forEach(([au, config]) => {
-        sinon.assert.calledWith(setGptConfig, au, config?.componentAuctions ?? [], true);
+        sinon.assert.calledWith(setGptConfig, au, ['mock-slot'], config?.componentAuctions ?? [], true);
       })
     });
   });

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

@@ -1,5 +1,6 @@
 import {expect} from 'chai';
 import {
+  getGPTSlotsForAdUnits,
   filters,
   getHighestCpmBidsFromBidPool,
   sortByDealAndPriceBucketOrCpm,
@@ -1310,6 +1311,17 @@ describe('targeting tests', function () {
   describe('setTargetingForAst', function () {
     let sandbox,
       apnTagStub;
+
+    before(() => {
+      if (window.apntag?.setKeywords == null) {
+        const orig = window.apntag;
+        window.apntag = {setKeywords: () => {}}
+        after(() => {
+          window.apntag = orig;
+        })
+      }
+    });
+
     beforeEach(function() {
       sandbox = sinon.createSandbox();
       sandbox.stub(targetingInstance, 'resetPresetTargetingAST');
@@ -1346,4 +1358,62 @@ describe('targeting tests', function () {
       expect(apnTagStub.getCall(1).args[1]).to.deep.equal({HB_BIDDER: 'appnexus'});
     });
   });
+
+  describe('getGPTSlotsForAdUnits', () => {
+    function mockSlot(path, elId) {
+      return {
+        getAdUnitPath() {
+          return path;
+        },
+        getSlotElementId() {
+          return elId;
+        }
+      }
+    }
+
+    let slots;
+
+    beforeEach(() => {
+      slots = [
+        mockSlot('slot/1', 'div-1'),
+        mockSlot('slot/2', 'div-2'),
+      ]
+    });
+
+    Object.entries({
+      'ad unit path': ['slot/1', 'slot/2'],
+      'element id': ['div-1', 'div-2']
+    }).forEach(([t, adUnitCodes]) => {
+      it(`can find slots by ${t}`, () => {
+        expect(getGPTSlotsForAdUnits(adUnitCodes, null, () => slots)).to.eql(Object.fromEntries(adUnitCodes.map((au, i) => [au, [slots[i]]])));
+      })
+    });
+
+    it('returns empty list on no match', () => {
+      expect(getGPTSlotsForAdUnits(['missing', 'slot/2'], null, () => slots)).to.eql({
+        missing: [],
+        'slot/2': [slots[1]]
+      });
+    });
+
+    it('can use customSlotMatching', () => {
+      const csm = (slot) => {
+        if (slot.getAdUnitPath() === 'slot/1') {
+          return (au) => {
+            return au === 'custom'
+          }
+        }
+      }
+      expect(getGPTSlotsForAdUnits(['div-2', 'custom'], csm, () => slots)).to.eql({
+        'custom': [slots[0]],
+        'div-2': [slots[1]]
+      })
+    });
+
+    it('can handle repeated adUnitCodes', () => {
+      expect(getGPTSlotsForAdUnits(['div-1', 'div-1'], null, () => slots)).to.eql({
+        'div-1': [slots[0]]
+      })
+    })
+  })
 });