prebid.js 9.7.0 → 9.9.0

package/test/spec/modules/richaudienceBidAdapter_spec.js

@@ -35,6 +35,53 @@ describe('Richaudience adapter tests', function () {
     user: {}
   }];
 
+  var DEFAULT_PARAMS_NEW_DSA = [{
+    adUnitCode: 'test-div',
+    bidId: '2c7c8e9c900244',
+    mediaTypes: {
+      banner: {
+        sizes: [
+          [300, 250], [300, 600], [728, 90], [970, 250]]
+      }
+    },
+    bidder: 'richaudience',
+    params: {
+      bidfloor: 0.5,
+      pid: 'ADb1f40rmi',
+      supplyType: 'site',
+      keywords: 'key1=value1;key2=value2'
+    },
+    auctionId: '0cb3144c-d084-4686-b0d6-f5dbe917c563',
+    bidRequestsCount: 1,
+    bidderRequestId: '1858b7382993ca',
+    ortb2: {
+      regs: {
+        ext: {
+          dsa: {
+            dsarequired: 2,
+            pubrender: 1,
+            datatopub: 1,
+            transparency: [
+              {
+                domain: 'richaudience.com',
+                dsaparams: [1, 3, 6]
+              },
+              {
+                domain: 'adpone.com',
+                dsaparams: [8, 10, 12]
+              },
+              {
+                domain: 'sunmedia.com',
+                dsaparams: [14, 16, 18]
+              }
+            ]
+          }
+        }
+      }
+    },
+    user: {}
+  }];
+
   var DEFAULT_PARAMS_NEW_SIZES_GPID = [{
     adUnitCode: 'test-div',
     bidId: '2c7c8e9c900244',
@@ -893,6 +940,21 @@ describe('Richaudience adapter tests', function () {
     expect(requestContent).to.have.property('schain').to.deep.equal(schain);
   })
 
+  it('should pass DSA', function() {
+    const request = spec.buildRequests(DEFAULT_PARAMS_NEW_DSA, {
+      gdprConsent: {
+        consentString: 'BOZcQl_ObPFjWAeABAESCD-AAAAjx7_______9______9uz_Ov_v_f__33e8__9v_l_7_-___u_-33d4-_1vf99yfm1-7ftr3tp_87ues2_Xur__59__3z3_NohBgA',
+        gdprApplies: true
+      },
+      refererInfo: {}
+    })
+    const requestContent = JSON.parse(request[0].data);
+    expect(requestContent).to.have.property('dsa').property('dsarequired').and.to.equal(2)
+    expect(requestContent).to.have.property('dsa').property('pubrender').and.to.equal(1);
+    expect(requestContent).to.have.property('dsa').property('datatopub').and.to.equal(1);
+    expect(requestContent.dsa.transparency[0]).to.have.property('domain').and.to.equal('richaudience.com');
+  })
+
   it('should pass gpid', function() {
     const request = spec.buildRequests(DEFAULT_PARAMS_NEW_SIZES_GPID, {
       gdprConsent: {

package/test/spec/modules/rubiconBidAdapter_spec.js

@@ -3987,6 +3987,16 @@ describe('the rubicon adapter', function () {
             let bids = spec.interpretResponse({body: response}, {data: request});
             expect(bids).to.have.nested.property('[0].native');
           });
+          it('should set 0 to bids width and height if `w` and `h` in response object not defined', () => {
+            const nativeBidderRequest = addNativeToBidRequest(bidderRequest);
+            const request = converter.toORTB({bidderRequest: nativeBidderRequest, bidRequests: nativeBidderRequest.bids});
+            let response = getNativeResponse({impid: request.imp[0].id});
+            delete response.seatbid[0].bid[0].w;
+            delete response.seatbid[0].bid[0].h
+            let bids = spec.interpretResponse({body: response}, {data: request});
+            expect(bids[0].width).to.equal(0);
+            expect(bids[0].height).to.equal(0);
+          })
         });
       }
 

package/test/spec/modules/targetVideoAdServerVideo_spec.js

@@ -0,0 +1,179 @@
+import {expect} from 'chai';
+import {buildVideoUrl} from 'modules/targetVideoAdServerVideo.js';
+import {targeting} from 'src/targeting.js';
+import * as utils from 'src/utils.js';
+import {hook} from '../../../src/hook.js';
+import AD_UNIT from 'test/fixtures/video/adUnit.json';
+
+describe('TargetVideo Ad Server Video', function() {
+  before(() => {
+    hook.ready();
+  });
+
+  let sandbox, bid, adUnit;
+  const unitUrl = { iu: 'https://example.com/ads/bid?iu=/video' };
+  const unitId = { iu: '/video' };
+  const allTargeting = {
+    'hb_format': 'video',
+    'hb_source': 'client',
+    'hb_size': '640x480',
+    'hb_pb': '5.00',
+    'hb_adid': '2c4f6cc3ba128a',
+    'hb_bidder': 'testBidder2',
+    'hb_format_testBidder2': 'video',
+    'hb_source_testBidder2': 'client',
+    'hb_size_testBidder2': '640x480',
+    'hb_pb_testBidder2': '5.00',
+    'hb_adid_testBidder2': '2c4f6cc3ba128a',
+    'hb_bidder_testBidder2': 'testBidder2',
+    'hb_format_targetVideo': 'video',
+    'hb_source_targetVideo': 'client',
+    'hb_size_targetVideo': '640x480',
+    'hb_pb_targetVideo': '5.00',
+    'hb_adid_targetVideo': '44e0b5f2e5cace',
+    'hb_bidder_targetVideo': 'targetVideo'
+  };
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+    bid = {
+      videoCacheKey: '123',
+      adserverTargeting: {
+        hb_adid: 'ad_id',
+        hb_cache_id: '123',
+        hb_uuid: '123',
+      },
+    };
+    adUnit = utils.deepClone(AD_UNIT);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should return undefined if required properties are missing', () => {
+    const url1 = buildVideoUrl({ params: {} });
+    const url2 = buildVideoUrl({ adUnit: {} });
+    const url3 = buildVideoUrl({ bid: {} });
+
+    expect(url1).to.be.undefined;
+    expect(url2).to.be.undefined;
+    expect(url3).to.be.undefined;
+  });
+
+  it('should require options.adUnit or options.bid', () => {
+    const options = {
+      params: { ...unitUrl }
+    };
+
+    const getWinningBidsStub = sandbox.stub(targeting, 'getWinningBids').returns([bid]);
+    const getAllTargetingDataStub = sandbox.stub(targeting, 'getAllTargeting').returns(allTargeting);
+
+    const url1 = buildVideoUrl(options);
+    expect(url1).to.be.undefined;
+
+    const url2 = buildVideoUrl(Object.assign(options, { adUnit }));
+    expect(url2).to.be.string;
+
+    const url3 = buildVideoUrl(Object.assign(options, { bid }));
+    expect(url3).to.be.string;
+
+    getWinningBidsStub.restore();
+    getAllTargetingDataStub.restore();
+  });
+
+  it('should build URL correctly with valid parameters', () => {
+    const optionsUrl = {
+      params: { ...unitUrl }
+    };
+
+    const optionsId = {
+      params: { ...unitId }
+    };
+
+    const getWinningBidsStub = sandbox.stub(targeting, 'getWinningBids').returns([bid]);
+    const getAllTargetingDataStub = sandbox.stub(targeting, 'getAllTargeting').returns(allTargeting);
+
+    const url1 = buildVideoUrl(Object.assign(optionsUrl, { bid, adUnit }));
+    const url2 = buildVideoUrl(Object.assign(optionsId, { bid, adUnit }));
+
+    expect(url1).to.include('https://example.com/ads/bid?iu=/video');
+    expect(url1).to.include('hb_adid=ad_id');
+    expect(url1).to.include('hb_cache_id=123');
+    expect(url1).to.include('hb_uuid=123');
+
+    expect(url2).to.include('https://vid.tvserve.io/ads/bid?iu=/video');
+    expect(url2).to.include('hb_adid=ad_id');
+    expect(url2).to.include('hb_cache_id=123');
+    expect(url2).to.include('hb_uuid=123');
+
+    getWinningBidsStub.restore();
+    getAllTargetingDataStub.restore();
+  });
+
+  it('should include default query parameters', () => {
+    const options = {
+      params: { ...unitUrl }
+    };
+
+    const getWinningBidsStub = sandbox.stub(targeting, 'getWinningBids').returns([bid]);
+    const getAllTargetingDataStub = sandbox.stub(targeting, 'getAllTargeting').returns(allTargeting);
+
+    const url = buildVideoUrl(Object.assign(options, { bid, adUnit }));
+
+    expect(url).to.include('autoplay=[autoplay]');
+    expect(url).to.include('mute=[vpmute]');
+    expect(url).to.include('page_url=[page_url]');
+    expect(url).to.include('cachebuster=[timestamp]');
+    expect(url).to.include('consent=[consent]');
+
+    getWinningBidsStub.restore();
+    getAllTargetingDataStub.restore();
+  });
+
+  it('should add cust_params correctly', () => {
+    const optionsUrl = {
+      params: {
+        ...unitUrl,
+        cust_params: {
+          targeting_1: 'foo',
+          targeting_2: 'bar'
+        }
+      }
+    };
+
+    const optionsId = {
+      params: {
+        ...unitId,
+        cust_params: {
+          targeting_1: 'foo',
+          targeting_2: 'bar'
+        }
+      }
+    };
+
+    const optionsToMergeCustParams = {
+      params: {
+        iu: 'https://example.com/ads/bid?iu=/video&cust_params=targeting_1%3Dbaz',
+        cust_params: {
+          targeting_1: 'foo',
+          targeting_2: 'bar'
+        }
+      }
+    };
+
+    const getWinningBidsStub = sandbox.stub(targeting, 'getWinningBids').returns([bid]);
+    const getAllTargetingDataStub = sandbox.stub(targeting, 'getAllTargeting').returns(allTargeting);
+
+    const url1 = buildVideoUrl(Object.assign(optionsUrl, { bid, adUnit }));
+    const url2 = buildVideoUrl(Object.assign(optionsId, { bid, adUnit }));
+    const url3 = buildVideoUrl(Object.assign(optionsToMergeCustParams, { bid, adUnit }));
+
+    expect(url1).to.include('cust_params=targeting_1%3Dfoo%26targeting_2%3Dbar');
+    expect(url2).to.include('cust_params=targeting_1%3Dfoo%26targeting_2%3Dbar');
+    expect(url3).to.include('cust_params=targeting_1%3Dbaz%26targeting_2%3Dbar');
+
+    getWinningBidsStub.restore();
+    getAllTargetingDataStub.restore();
+  });
+});

package/test/spec/modules/trafficgateBidAdapter_spec.js

@@ -1006,7 +1006,7 @@ describe('TrafficgateOpenxRtbAdapter', function () {
           // enrich bid request with userId key/value
 
           const request = spec.buildRequests(bidRequestsWithUserId, mockBidderRequest);
-          expect(request[0].data.user.ext.eids).to.equal(userIdAsEids);
+          expect(request[0].data.user.ext.eids).to.eql(userIdAsEids);
         });
 
         it(`when no user ids are available, it should not send any extended ids`, function () {

package/test/spec/ortbConverter/userId_spec.js

@@ -6,13 +6,34 @@ describe('pbjs - ortb user eids', () => {
     setOrtbUserExtEids(req, {}, {
       bidRequests: [
         {
-          userIdAsEids: {e: 'id'}
+          userIdAsEids: [{e: 'id'}]
         }
       ]
     });
-    expect(req.user.ext.eids).to.eql({e: 'id'});
+    expect(req.user.ext.eids).to.eql([{e: 'id'}]);
   });
 
+  it('should not override eids from fpd', () => {
+    const req = {
+      user: {
+        ext: {
+          eids: [{existing: 'id'}]
+        }
+      }
+    };
+    setOrtbUserExtEids(req, {}, {
+      bidRequests: [
+        {
+          userIdAsEids: [{nw: 'id'}]
+        }
+      ]
+    });
+    expect(req.user.ext.eids).to.eql([
+      {nw: 'id'},
+      {existing: 'id'},
+    ])
+  })
+
   it('has no effect if requests have no eids', () => {
     const req = {};
     setOrtbUserExtEids(req, {}, [{}]);

package/test/spec/unit/adRendering_spec.js

@@ -1,7 +1,7 @@
 import * as events from 'src/events.js';
 import * as utils from 'src/utils.js';
 import {
-  doRender, getBidToRender,
+  doRender, emitAdRenderSucceeded, getBidToRender,
   getRenderingData,
   handleCreativeEvent,
   handleNativeMessage,
@@ -12,6 +12,7 @@ import {expect} from 'chai/index.mjs';
 import {config} from 'src/config.js';
 import {VIDEO} from '../../../src/mediaTypes.js';
 import {auctionManager} from '../../../src/auctionManager.js';
+import adapterManager from '../../../src/adapterManager.js';
 
 describe('adRendering', () => {
   let sandbox;
@@ -267,4 +268,29 @@ describe('adRendering', () => {
       sinon.assert.calledWith(fireTrackers, data, bid);
     })
   })
+
+  describe('onAdRenderSucceeded', () => {
+    let mockAdapterSpec, bids;
+    beforeEach(() => {
+      mockAdapterSpec = {
+        onAdRenderSucceeded: sinon.stub()
+      };
+      adapterManager.bidderRegistry['mockBidder'] = {
+        bidder: 'mockBidder',
+        getSpec: function () { return mockAdapterSpec; },
+      };
+      bids = [
+        { bidder: 'mockBidder', params: { placementId: 'id' } },
+      ];
+    });
+
+    afterEach(function () {
+      delete adapterManager.bidderRegistry['mockBidder'];
+    });
+
+    it('should invoke onAddRenderSucceeded on emitAdRenderSucceeded', () => {
+      emitAdRenderSucceeded({ bid: bids[0] });
+      sinon.assert.called(mockAdapterSpec.onAdRenderSucceeded);
+    });
+  });
 });

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

@@ -428,6 +428,16 @@ describe('adapterManager tests', function () {
         sinon.assert.notCalled(criteoSpec.onBidViewable);
       })
     });
+
+    describe('onAdRenderSucceeded', function () {
+      beforeEach(() => {
+        criteoSpec.onAdRenderSucceeded = sinon.stub()
+      });
+      it('should call spec\'s onAdRenderSucceeded callback', function () {
+        adapterManager.callAdRenderSucceededBidder(bids[0].bidder, bids[0]);
+        sinon.assert.called(criteoSpec.onAdRenderSucceeded);
+      });
+    });
   })
   describe('onBidderError', function () {
     const bidder = 'appnexus';

package/test/spec/unit/utils/focusTimeout_spec.js

@@ -1,4 +1,4 @@
-import setFocusTimeout from '../../../../src/utils/focusTimeout';
+import {setFocusTimeout, reset} from '../../../../src/utils/focusTimeout';
 
 export const setDocumentHidden = (hidden) => {
   Object.defineProperty(document, 'hidden', {
@@ -9,10 +9,12 @@ export const setDocumentHidden = (hidden) => {
 };
 
 describe('focusTimeout', () => {
-  let clock;
+  let clock, callback;
 
   beforeEach(() => {
+    reset()
     clock = sinon.useFakeTimers();
+    callback = sinon.spy();
   });
 
   afterEach(() => {
@@ -20,14 +22,21 @@ describe('focusTimeout', () => {
   })
 
   it('should invoke callback when page is visible', () => {
-    let callback = sinon.stub();
     setFocusTimeout(callback, 2000);
     clock.tick(2000);
     expect(callback.called).to.be.true;
   });
 
+  it('should not choke if page starts hidden', () => {
+    setDocumentHidden(true);
+    reset();
+    setDocumentHidden(false);
+    setFocusTimeout(callback, 1000);
+    clock.tick(1000);
+    sinon.assert.called(callback);
+  })
+
   it('should not invoke callback if page was hidden', () => {
-    let callback = sinon.stub();
     setFocusTimeout(callback, 2000);
     setDocumentHidden(true);
     clock.tick(3000);
@@ -35,7 +44,6 @@ describe('focusTimeout', () => {
   });
 
   it('should defer callback execution when page is hidden', () => {
-    let callback = sinon.stub();
     setFocusTimeout(callback, 4000);
     clock.tick(2000);
     setDocumentHidden(true);
@@ -46,8 +54,27 @@ describe('focusTimeout', () => {
     expect(callback.called).to.be.true;
   });
 
+  it('should not execute deferred callbacks again', () => {
+    setDocumentHidden(true);
+    setFocusTimeout(callback, 1000);
+    clock.tick(2000);
+    [false, true, false].forEach(setDocumentHidden);
+    clock.tick(2000);
+    sinon.assert.calledOnce(callback);
+  });
+
+  it('should run callbacks that expire while page is hidden', () => {
+    setFocusTimeout(callback, 1000);
+    clock.tick(500);
+    setDocumentHidden(true);
+    clock.tick(1000);
+    setDocumentHidden(false);
+    sinon.assert.notCalled(callback);
+    clock.tick(1000);
+    sinon.assert.called(callback);
+  })
+
   it('should return updated timerId after page was showed again', () => {
-    let callback = sinon.stub();
     const getCurrentTimerId = setFocusTimeout(callback, 4000);
     const oldTimerId = getCurrentTimerId();
     clock.tick(2000);