prebid.js 7.22.0 → 7.23.1

package/test/spec/ortbConverter/video_spec.js

@@ -0,0 +1,189 @@
+import {fillVideoImp, fillVideoResponse, VALIDATIONS} from '../../../libraries/ortbConverter/processors/video.js';
+import {BANNER, VIDEO} from '../../../src/mediaTypes.js';
+
+describe('pbjs -> ortb video conversion', () => {
+  [
+    {
+      t: 'non-video request',
+      request: {
+        mediaTypes: {
+          banner: {}
+        }
+      },
+      imp: {}
+    },
+    {
+      t: 'instream video request',
+      request: {
+        mediaTypes: {
+          video: {
+            playerSize: [[1, 2]],
+            context: 'instream',
+            mimes: ['video/mp4'],
+            skip: 1,
+          }
+        }
+      },
+      imp: {
+        video: {
+          w: 1,
+          h: 2,
+          mimes: ['video/mp4'],
+          skip: 1,
+          placement: 1,
+        },
+      },
+    },
+    {
+      t: 'outstream video request',
+      request: {
+        mediaTypes: {
+          video: {
+            playerSize: [[1, 2]],
+            context: 'outstream',
+            mimes: ['video/mp4'],
+            skip: 1
+          }
+        }
+      },
+      imp: {
+        video: {
+          w: 1,
+          h: 2,
+          mimes: ['video/mp4'],
+          skip: 1,
+        },
+      },
+    },
+    {
+      t: 'video request with explicit placement',
+      request: {
+        mediaTypes: {
+          video: {
+            playerSize: [[1, 2]],
+            placement: 'explicit'
+          }
+        }
+      },
+      imp: {
+        video: {
+          w: 1,
+          h: 2,
+          placement: 'explicit',
+        }
+      }
+    },
+    {
+      t: 'video request with multiple playerSizes',
+      request: {
+        mediaTypes: {
+          video: {
+            playerSize: [[1, 2], [3, 4]]
+          }
+        }
+      },
+      imp: {
+        video: {
+          w: 1,
+          h: 2,
+        }
+      }
+    },
+    {
+      t: 'video request with 2-tuple playerSize',
+      request: {
+        mediaTypes: {
+          video: {
+            playerSize: [1, 2]
+          }
+        }
+      },
+      imp: {
+        video: {
+          w: 1,
+          h: 2,
+        }
+      }
+    },
+  ].forEach(({t, request, imp}) => {
+    it(`can handle ${t}`, () => {
+      const actual = {};
+      fillVideoImp(actual, request, {});
+      expect(actual).to.eql(imp);
+    });
+  });
+
+  it('should keep ortb2Imp.video', () => {
+    const imp = {
+      video: {
+        someParam: 'someValue'
+      }
+    };
+    fillVideoImp(imp, {mediaTypes: {video: {playerSize: [[1, 2]]}}}, {});
+    expect(imp.video.someParam).to.eql('someValue');
+  });
+
+  it('does nothing is context.mediaType is set but is not VIDEO', () => {
+    const imp = {};
+    fillVideoImp(imp, {mediaTypes: {video: {playerSize: [[1, 2]]}}}, {mediaType: BANNER});
+    expect(imp).to.eql({});
+  });
+});
+
+describe('ortb -> pbjs video conversion', () => {
+  [
+    {
+      t: 'non-video response',
+      seatbid: {},
+      response: {
+        mediaType: BANNER
+      },
+      expected: {
+        mediaType: BANNER
+      }
+    },
+    {
+      t: 'simple video response',
+      seatbid: {
+        adm: 'mockAdm',
+        nurl: 'mockNurl'
+      },
+      response: {
+        mediaType: VIDEO,
+      },
+      context: {
+        imp: {
+          video: {
+            w: 1,
+            h: 2
+          }
+        }
+      },
+      expected: {
+        mediaType: VIDEO,
+        playerWidth: 1,
+        playerHeight: 2,
+        vastXml: 'mockAdm',
+        vastUrl: 'mockNurl'
+      }
+    },
+    {
+      t: 'video response without playerSize',
+      seatbid: {},
+      response: {
+        mediaType: VIDEO,
+      },
+      context: {
+        imp: {}
+      },
+      expected: {
+        mediaType: VIDEO
+      }
+    }
+  ].forEach(({t, seatbid, context, response, expected}) => {
+    it(`can handle ${t}`, () => {
+      fillVideoResponse(response, seatbid, context);
+      expect(response).to.eql(expected);
+    })
+  })
+})

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

@@ -20,6 +20,7 @@ import { setSizeConfig } from 'src/sizeMapping.js';
 import {find, includes} from 'src/polyfill.js';
 import s2sTesting from 'modules/s2sTesting.js';
 import {hook} from '../../../../src/hook.js';
+import {auctionManager} from '../../../../src/auctionManager.js';
 var events = require('../../../../src/events');
 
 const CONFIG = {
@@ -2543,4 +2544,105 @@ describe('adapterManager tests', function () {
       })
     });
   });
+
+  describe('callDataDeletionRequest', () => {
+    function delMethodForBidder(bidderCode) {
+      const del = sinon.stub();
+      adapterManager.registerBidAdapter({
+        callBids: sinon.stub(),
+        getSpec() {
+          return {
+            onDataDeletionRequest: del
+          }
+        }
+      }, bidderCode);
+      return del;
+    }
+
+    function delMethodForAnalytics(provider) {
+      const del = sinon.stub();
+      adapterManager.registerAnalyticsAdapter({
+        code: provider,
+        adapter: {
+          enableAnalytics: sinon.stub(),
+          onDataDeletionRequest: del,
+        },
+      })
+      return del;
+    }
+
+    Object.entries({
+      'bid adapters': delMethodForBidder,
+      'analytics adapters': delMethodForAnalytics
+    }).forEach(([t, getDelMethod]) => {
+      describe(t, () => {
+        it('invokes onDataDeletionRequest', () => {
+          const del = getDelMethod('mockAdapter');
+          adapterManager.callDataDeletionRequest();
+          sinon.assert.calledOnce(del);
+        });
+
+        it('does not choke if onDeletionRequest throws', () => {
+          const del1 = getDelMethod('mockAdapter1');
+          const del2 = getDelMethod('mockAdapter2');
+          del1.throws(new Error());
+          adapterManager.callDataDeletionRequest();
+          sinon.assert.calledOnce(del1);
+          sinon.assert.calledOnce(del2);
+        });
+      })
+    })
+
+    describe('for bid adapters', () => {
+      let bidderRequests;
+
+      beforeEach(() => {
+        bidderRequests = [];
+        sinon.stub(auctionManager, 'getBidsRequested').callsFake(() => bidderRequests);
+      })
+      afterEach(() => {
+        auctionManager.getBidsRequested.restore();
+      })
+
+      it('does not invoke onDataDeletionRequest on aliases', () => {
+        const del = delMethodForBidder('mockBidder');
+        adapterManager.aliasBidAdapter('mockBidder', 'mockBidderAlias');
+        adapterManager.aliasBidAdapter('mockBidderAlias2', 'mockBidderAlias');
+        adapterManager.callDataDeletionRequest();
+        sinon.assert.calledOnce(del);
+      });
+
+      it('passes known bidder requests', () => {
+        const del1 = delMethodForBidder('mockBidder1');
+        const del2 = delMethodForBidder('mockBidder2');
+        adapterManager.aliasBidAdapter('mockBidder1', 'mockBidder1Alias');
+        adapterManager.aliasBidAdapter('mockBidder1Alias', 'mockBidder1Alias2')
+        bidderRequests = [
+          {
+            bidderCode: 'mockBidder1',
+            id: 0
+          },
+          {
+            bidderCode: 'mockBidder2',
+            id: 1,
+          },
+          {
+            bidderCode: 'mockBidder1Alias',
+            id: 2,
+          },
+          {
+            bidderCode: 'someOtherBidder',
+            id: 3
+          },
+          {
+            bidderCode: 'mockBidder1Alias2',
+            id: 4
+          }
+        ];
+        adapterManager.callDataDeletionRequest();
+        sinon.assert.calledWith(del1, [bidderRequests[0], bidderRequests[2], bidderRequests[4]]);
+        sinon.assert.calledWith(del2, [bidderRequests[1]]);
+      })
+    })
+  });
 });

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

@@ -269,6 +269,40 @@ describe('targeting tests', function () {
     bidCacheFilterFunction = undef;
   });
 
+  describe('isBidNotExpired', () => {
+    let clock;
+    beforeEach(() => {
+      clock = sandbox.useFakeTimers(0);
+    });
+
+    Object.entries({
+      'bid.ttlBuffer': (bid, ttlBuffer) => {
+        bid.ttlBuffer = ttlBuffer
+      },
+      'setConfig({ttlBuffer})': (_, ttlBuffer) => {
+        config.setConfig({ttlBuffer})
+      },
+    }).forEach(([t, setup]) => {
+      describe(`respects ${t}`, () => {
+        [0, 2].forEach(ttlBuffer => {
+          it(`when ttlBuffer is ${ttlBuffer}`, () => {
+            const bid = {
+              responseTimestamp: 0,
+              ttl: 10,
+            }
+            setup(bid, ttlBuffer);
+
+            expect(filters.isBidNotExpired(bid)).to.be.true;
+            clock.tick((bid.ttl - ttlBuffer) * 1000 - 100);
+            expect(filters.isBidNotExpired(bid)).to.be.true;
+            clock.tick(101);
+            expect(filters.isBidNotExpired(bid)).to.be.false;
+          });
+        });
+      });
+    });
+  });
+
   describe('getAllTargeting', function () {
     let amBidsReceivedStub;
     let amGetAdUnitsStub;

package/test/spec/unit/pbjs_api_spec.js

@@ -21,7 +21,8 @@ import {hook} from '../../../src/hook.js';
 import {reset as resetDebugging} from '../../../src/debugging.js';
 import $$PREBID_GLOBAL$$ from 'src/prebid.js';
 import {resetAuctionState} from 'src/auction.js';
-
+import {stubAuctionIndex} from '../../helpers/indexStub.js';
+import {createBid} from '../../../src/bidfactory.js';
 var assert = require('chai').assert;
 var expect = require('chai').expect;
 
@@ -1241,7 +1242,7 @@ describe('Unit: Prebid Module', function () {
 
     it('should require doc and id params', function () {
       $$PREBID_GLOBAL$$.renderAd();
-      var error = 'Error trying to write ad Id :undefined to the page. Missing document or adId';
+      var error = 'Error trying to write ad Id :undefined to the page. Missing adId';
       assert.ok(spyLogError.calledWith(error), 'expected param error was logged');
     });
 
@@ -1458,7 +1459,7 @@ describe('Unit: Prebid Module', function () {
 
   describe('requestBids', function () {
     let logMessageSpy;
-    let makeRequestsStub;
+    let makeRequestsStub, createAuctionStub;
     let adUnits;
     let clock;
     before(function () {
@@ -1467,7 +1468,6 @@ describe('Unit: Prebid Module', function () {
     after(function () {
       clock.restore();
     });
-    let bidsBackHandlerStub = sinon.stub();
 
     const BIDDER_CODE = 'sampleBidder';
     let bids = [{
@@ -1504,11 +1504,12 @@ describe('Unit: Prebid Module', function () {
       'start': 1000
     }];
 
+    let spec, indexStub, auction, completeAuction;
+
     beforeEach(function () {
       logMessageSpy = sinon.spy(utils, 'logMessage');
       makeRequestsStub = sinon.stub(adapterManager, 'makeBidRequests');
       makeRequestsStub.returns(bidRequests);
-
       adUnits = [{
         code: 'adUnit-code',
         mediaTypes: {
@@ -1516,45 +1517,53 @@ describe('Unit: Prebid Module', function () {
             sizes: [[300, 250]]
           }
         },
+        transactionId: 'mock-tid',
         bids: [
           {bidder: BIDDER_CODE, params: {placementId: 'id'}},
         ]
       }];
-      let adUnitCodes = ['adUnit-code'];
-      let auction = auctionModule.newAuction({
-        adUnits,
-        adUnitCodes,
-        callback: bidsBackHandlerStub,
-        cbTimeout: 2000
-      });
-      let createAuctionStub = sinon.stub(auctionModule, 'newAuction');
-      createAuctionStub.returns(auction);
-    });
-
-    afterEach(function () {
-      clock.restore();
-      adapterManager.makeBidRequests.restore();
-      auctionModule.newAuction.restore();
-      utils.logMessage.restore();
-    });
-
-    it('should execute callback after timeout', function () {
-      let spec = {
+      indexStub = sinon.stub(auctionManager, 'index');
+      indexStub.get(() => stubAuctionIndex({adUnits, bidRequests}))
+      sinon.stub(adapterManager, 'callBids').callsFake((_, bidrequests, addBidResponse, adapterDone) => {
+        completeAuction = (bidsReceived) => {
+          bidsReceived.forEach((bid) => addBidResponse(bid.adUnitCode, Object.assign(createBid(), bid)));
+          bidRequests.forEach((req) => adapterDone.call(req));
+        }
+      })
+      const origNewAuction = auctionModule.newAuction;
+      sinon.stub(auctionModule, 'newAuction').callsFake(function (opts) {
+        auction = origNewAuction(opts);
+        return auction;
+      })
+      spec = {
         code: BIDDER_CODE,
         isBidRequestValid: sinon.stub(),
         buildRequests: sinon.stub(),
         interpretResponse: sinon.stub(),
         getUserSyncs: sinon.stub(),
-        onTimeout: sinon.stub()
+        onTimeout: sinon.stub(),
+        onSetTargeting: sinon.stub(),
       };
 
       registerBidder(spec);
       spec.buildRequests.returns([{'id': 123, 'method': 'POST'}]);
       spec.isBidRequestValid.returns(true);
       spec.interpretResponse.returns(bids);
+    });
+
+    afterEach(function () {
+      clock.restore();
+      adapterManager.makeBidRequests.restore();
+      adapterManager.callBids.restore();
+      indexStub.restore();
+      auction.getBidsReceived = () => [];
+      auctionModule.newAuction.restore();
+      utils.logMessage.restore();
+    });
 
+    it('should execute callback after timeout', function () {
       let requestObj = {
-        bidsBackHandler: null, // does not need to be defined because of newAuction mock in beforeEach
+        bidsBackHandler: sinon.stub(),
         timeout: 2000,
         adUnits: adUnits
       };
@@ -1567,26 +1576,13 @@ describe('Unit: Prebid Module', function () {
       clock.tick(1);
       assert.ok(logMessageSpy.calledWith(sinon.match(re)), 'executeCallback called');
 
-      expect(bidsBackHandlerStub.getCall(0).args[1]).to.equal(true,
+      expect(requestObj.bidsBackHandler.getCall(0).args[1]).to.equal(true,
         'bidsBackHandler should be called with timedOut=true');
 
       sinon.assert.called(spec.onTimeout);
     });
 
-    it('should execute callback after setTargeting', function () {
-      let spec = {
-        code: BIDDER_CODE,
-        isBidRequestValid: sinon.stub(),
-        buildRequests: sinon.stub(),
-        interpretResponse: sinon.stub(),
-        onSetTargeting: sinon.stub()
-      };
-
-      registerBidder(spec);
-      spec.buildRequests.returns([{'id': 123, 'method': 'POST'}]);
-      spec.isBidRequestValid.returns(true);
-      spec.interpretResponse.returns(bids);
-
+    it('should execute `onSetTargeting` after setTargetingForGPTAsync', function () {
       const bidId = 1;
       const auctionId = 1;
       let adResponse = Object.assign({
@@ -1595,6 +1591,7 @@ describe('Unit: Prebid Module', function () {
         width: 300,
         height: 250,
         adUnitCode: bidRequests[0].bids[0].adUnitCode,
+        transactionId: 'mock-tid',
         adserverTargeting: {
           'hb_bidder': BIDDER_CODE,
           'hb_adid': bidId,
@@ -1603,20 +1600,102 @@ describe('Unit: Prebid Module', function () {
         },
         bidder: bids[0].bidderCode,
       }, bids[0]);
-      auction.getBidsReceived = function() { return [adResponse]; }
-      auction.getAuctionId = () => auctionId;
 
       let requestObj = {
-        bidsBackHandler: null, // does not need to be defined because of newAuction mock in beforeEach
+        bidsBackHandler: null,
         timeout: 2000,
         adUnits: adUnits
       };
 
       $$PREBID_GLOBAL$$.requestBids(requestObj);
+      completeAuction([adResponse]);
       $$PREBID_GLOBAL$$.setTargetingForGPTAsync();
 
       sinon.assert.called(spec.onSetTargeting);
     });
+
+    describe('returns a promise that resolves', () => {
+      function delayHook(next, ...args) {
+        setTimeout(() => next(...args))
+      }
+
+      beforeEach(() => {
+        // make sure the return value works correctly when hooks give up priority
+        $$PREBID_GLOBAL$$.requestBids.before(delayHook)
+      });
+
+      afterEach(() => {
+        $$PREBID_GLOBAL$$.requestBids.getHooks({hook: delayHook}).remove();
+      });
+
+      Object.entries({
+        'immediately, without bidsBackHandler': (req) => $$PREBID_GLOBAL$$.requestBids(req),
+        'after bidsBackHandler': (() => {
+          const bidsBackHandler = sinon.stub();
+          return function (req) {
+            return $$PREBID_GLOBAL$$.requestBids({...req, bidsBackHandler}).then(({bids, timedOut, auctionId}) => {
+              sinon.assert.calledWith(bidsBackHandler, bids, timedOut, auctionId);
+              return {bids, timedOut, auctionId};
+            })
+          }
+        })(),
+        'after a bidsBackHandler that throws': (req) => $$PREBID_GLOBAL$$.requestBids({...req, bidsBackHandler: () => { throw new Error() }})
+      }).forEach(([t, requestBids]) => {
+        describe(t, () => {
+          it('with no args, when no adUnits are defined', () => {
+            return requestBids({}).then((res) => {
+              expect(res).to.eql({
+                bids: undefined,
+                timedOut: undefined,
+                auctionId: undefined
+              });
+            });
+          });
+
+          it('on timeout', (done) => {
+            requestBids({
+              auctionId: 'mock-auctionId',
+              adUnits,
+              timeout: 10
+            }).then(({timedOut, bids, auctionId}) => {
+              expect(timedOut).to.be.true;
+              expect(bids).to.eql({});
+              expect(auctionId).to.eql('mock-auctionId');
+              done();
+            });
+            clock.tick(12);
+          });
+
+          it('with auction result', (done) => {
+            const bid = {
+              bidder: 'mock-bidder',
+              adUnitCode: adUnits[0].code,
+              transactionId: adUnits[0].transactionId
+            }
+            requestBids({
+              adUnits,
+            }).then(({bids}) => {
+              sinon.assert.match(bids[bid.adUnitCode].bids[0], bid)
+              done();
+            });
+            // `completeAuction` won't work until we're out of `delayHook`
+            // and the mocked auction has been set up;
+            // setTimeout here takes us after the setTimeout in `delayHook`
+            setTimeout(() => completeAuction([bid]));
+          })
+        })
+      })
+    })
+
+    it('should transfer ttlBuffer to adUnit.ttlBuffer', () => {
+      $$PREBID_GLOBAL$$.requestBids({
+        ttlBuffer: 123,
+        adUnits: [adUnits[0], {...adUnits[0], ttlBuffer: 0}]
+      });
+      sinon.assert.calledWithMatch(auctionModule.newAuction, {
+        adUnits: sinon.match((units) => units[0].ttlBuffer === 123 && units[1].ttlBuffer === 0)
+      })
+    });
   })
 
   describe('requestBids', function () {

package/test/spec/utils_spec.js

@@ -2,7 +2,7 @@ import { getAdServerTargeting } from 'test/fixtures/fixtures.js';
 import { expect } from 'chai';
 import CONSTANTS from 'src/constants.json';
 import * as utils from 'src/utils.js';
-import {deepEqual, waitForElementToLoad} from 'src/utils.js';
+import {memoize, deepEqual, waitForElementToLoad} from 'src/utils.js';
 
 var assert = require('assert');
 
@@ -1260,3 +1260,47 @@ describe('Utils', function () {
     });
   });
 });
+
+describe('memoize', () => {
+  let fn;
+
+  beforeEach(() => {
+    fn = sinon.stub().callsFake(function() {
+      return Array.from(arguments);
+    });
+  });
+
+  it('delegates to fn', () => {
+    expect(memoize(fn)('one', 'two')).to.eql(['one', 'two']);
+  });
+
+  it('caches result after first call, if first argument is the same', () => {
+    const mem = memoize(fn);
+    mem('one', 'two');
+    expect(mem('one', 'three')).to.eql(['one', 'two']);
+    expect(fn.callCount).to.equal(1);
+  });
+
+  it('delegates again when the first argument changes', () => {
+    const mem = memoize(fn);
+    mem('one', 'two');
+    expect(mem('two', 'one')).to.eql(['two', 'one']);
+    expect(fn.callCount).to.eql(2);
+  });
+
+  it('can clear cache with .clear', () => {
+    const mem = memoize(fn);
+    mem('arg');
+    mem.clear();
+    expect(mem('arg')).to.eql(['arg']);
+    expect(fn.callCount).to.equal(2);
+  });
+
+  it('allows setting cache keys', () => {
+    const mem = memoize(fn, (...args) => args.join(','))
+    mem('one', 'two');
+    mem('one', 'three');
+    expect(mem('one', 'three')).to.eql(['one', 'three']);
+    expect(fn.callCount).to.eql(2);
+  })
+})