prebid.js 9.6.0 → 9.8.0

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/sharethroughBidAdapter_spec.js

@@ -346,6 +346,41 @@ describe('sharethrough adapter spec', function () {
 
           expect(openRtbReq.user.ext.eids).to.deep.equal([]);
         });
+
+        it('should add ORTB2 device data to the request', () => {
+          const bidderRequestWithOrtb2Device = {
+            ...bidderRequest,
+            ...{
+              ortb2: {
+                device: {
+                  w: 980,
+                  h: 1720,
+                  dnt: 0,
+                  ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/125.0.6422.80 Mobile/15E148 Safari/604.1',
+                  language: 'en',
+                  devicetype: 1,
+                  make: 'Apple',
+                  model: 'iPhone 12 Pro Max',
+                  os: 'iOS',
+                  osv: '17.4',
+                },
+              },
+            },
+          };
+
+          const [request] = spec.buildRequests(bidRequests, bidderRequestWithOrtb2Device);
+
+          expect(request.data.device.w).to.equal(bidderRequestWithOrtb2Device.ortb2.device.w);
+          expect(request.data.device.h).to.equal(bidderRequestWithOrtb2Device.ortb2.device.h);
+          expect(request.data.device.dnt).to.equal(bidderRequestWithOrtb2Device.ortb2.device.dnt);
+          expect(request.data.device.ua).to.equal(bidderRequestWithOrtb2Device.ortb2.device.ua);
+          expect(request.data.device.language).to.equal(bidderRequestWithOrtb2Device.ortb2.device.language);
+          expect(request.data.device.devicetype).to.equal(bidderRequestWithOrtb2Device.ortb2.device.devicetype);
+          expect(request.data.device.make).to.equal(bidderRequestWithOrtb2Device.ortb2.device.make);
+          expect(request.data.device.model).to.equal(bidderRequestWithOrtb2Device.ortb2.device.model);
+          expect(request.data.device.os).to.equal(bidderRequestWithOrtb2Device.ortb2.device.os);
+          expect(request.data.device.osv).to.equal(bidderRequestWithOrtb2Device.ortb2.device.osv);
+        });
       });
 
       describe('no referer provided', () => {

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/modules/ttdBidAdapter_spec.js

@@ -277,6 +277,13 @@ describe('ttdBidAdapter', function () {
       expect(url).to.equal('https://direct.adsrvr.org/bid/bidder/supplier');
     });
 
+    it('sends bid requests to the correct custom endpoint', function () {
+      let bannerBidRequestsWithCustomEndpoint = deepClone(baseBannerBidRequests);
+      bannerBidRequestsWithCustomEndpoint[0].params.useHttp2 = true;
+      const url = testBuildRequests(bannerBidRequestsWithCustomEndpoint, baseBidderRequest).url;
+      expect(url).to.equal('https://d2.adsrvr.org/bid/bidder/supplier');
+    });
+
     it('sends publisher id', function () {
       const requestBody = testBuildRequests(baseBannerBidRequests, baseBidderRequest).data;
       expect(requestBody.site).to.be.not.null;
@@ -442,7 +449,9 @@ describe('ttdBidAdapter', function () {
       let clonedBannerRequests = deepClone(baseBannerBidRequests);
       const battr = [1, 2, 3];
       clonedBannerRequests[0].ortb2Imp = {
-        battr: battr
+        banner: {
+          battr: battr
+        }
       };
       const requestBody = testBuildRequests(clonedBannerRequests, baseBidderRequest).data;
       expect(requestBody.imp[0].banner.battr).to.equal(battr);

package/test/spec/modules/viantOrtbBidAdapter_spec.js

@@ -268,7 +268,7 @@ describe('viantOrtbBidAdapter', function () {
     });
     it('sends bid requests to the correct endpoint', function () {
       const url = testBuildRequests(baseBannerBidRequests, baseBidderRequest)[0].url;
-      expect(url).to.equal('https://bidders-us-east-1.adelphic.net/d/rtb/v25/prebid/bidder');
+      expect(url).to.equal('https://bidders-us.adelphic.net/d/rtb/v25/prebid/bidder');
     });
 
     it('sends site', function () {

package/test/spec/modules/vidazooBidAdapter_spec.js

@@ -92,7 +92,7 @@ const VIDEO_BID = {
       'minduration': 0,
       'startdelay': 0,
       'linearity': 1,
-      'api': [2],
+      'api': [2, 7],
       'placement': 1
     }
   }
@@ -157,8 +157,14 @@ const BIDDER_REQUEST = {
           segment: [{id: '243'}],
         },
       ],
+    },
+    source: {
+      ext: {
+        omidpn: 'MyIntegrationPartner',
+        omidpv: '7.1'
+      }
     }
-  },
+  }
 };
 
 const SERVER_RESPONSE = {
@@ -359,7 +365,7 @@ describe('VidazooBidAdapter', function () {
           webSessionId: webSessionId,
           mediaTypes: {
             video: {
-              api: [2],
+              api: [2, 7],
               context: 'instream',
               linearity: 1,
               maxduration: 60,
@@ -373,7 +379,9 @@ describe('VidazooBidAdapter', function () {
               protocols: [2, 3, 5, 6],
               startdelay: 0
             }
-          }
+          },
+          omidpn: 'MyIntegrationPartner',
+          omidpv: '7.1'
         }
       })
       ;

package/test/spec/modules/wurflRtdProvider_spec.js

@@ -0,0 +1,324 @@
+import {
+  bidderData,
+  enrichBidderRequest,
+  lowEntropyData,
+  wurflSubmodule,
+} from 'modules/wurflRtdProvider';
+import * as ajaxModule from 'src/ajax';
+import { loadExternalScriptStub } from 'test/mocks/adloaderStub.js';
+
+describe('wurflRtdProvider', function () {
+  describe('wurflSubmodule', function () {
+    const altHost = 'http://example.local/wurfl.js';
+    const wurfl_pbjs = {
+      low_entropy_caps: ['complete_device_name', 'form_factor', 'is_mobile'],
+      caps: [
+        'advertised_browser',
+        'advertised_browser_version',
+        'advertised_device_os',
+        'advertised_device_os_version',
+        'brand_name',
+        'complete_device_name',
+        'form_factor',
+        'is_app_webview',
+        'is_full_desktop',
+        'is_mobile',
+        'is_robot',
+        'is_smartphone',
+        'is_smarttv',
+        'is_tablet',
+        'manufacturer_name',
+        'marketing_name'
+      ],
+      authorized_bidders: {
+        'bidder1': [0, 1, 2, 3, 4, 5, 6, 7, 10, 13, 15],
+        'bidder2': [5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
+      }
+    }
+
+    const WURFL = {
+      advertised_browser: 'Chrome',
+      advertised_browser_version: '125.0.6422.76',
+      advertised_device_os: 'Linux',
+      advertised_device_os_version: '6.5.0',
+      brand_name: 'Google',
+      complete_device_name: 'Google Chrome',
+      form_factor: 'Desktop',
+      is_app_webview: !1,
+      is_full_desktop: !0,
+      is_mobile: !1,
+      is_robot: !1,
+      is_smartphone: !1,
+      is_smarttv: !1,
+      is_tablet: !1,
+      manufacturer_name: '',
+      marketing_name: '',
+    }
+
+    // expected analytics values
+    const expectedStatsURL = 'https://prebid.wurflcloud.com/v1/prebid/stats';
+    const expectedData = JSON.stringify({ bidders: ['bidder1', 'bidder2'] });
+
+    let sandbox;
+
+    beforeEach(function() {
+      sandbox = sinon.createSandbox();
+      window.WURFLPromises = {
+        init: new Promise(function(resolve, reject) { resolve({ WURFL, wurfl_pbjs }) }),
+        complete: new Promise(function(resolve, reject) { resolve({ WURFL, wurfl_pbjs }) }),
+      };
+    });
+
+    afterEach(() => {
+      // Restore the original functions
+      sandbox.restore();
+      window.WURFLPromises = undefined;
+    });
+
+    // Bid request config
+    const reqBidsConfigObj = {
+      adUnits: [{
+        bids: [
+          { bidder: 'bidder1' },
+          { bidder: 'bidder2' },
+          { bidder: 'bidder3' },
+        ]
+      }],
+      ortb2Fragments: {
+        bidder: {},
+      }
+    };
+
+    it('initialises the WURFL RTD provider', function () {
+      expect(wurflSubmodule.init()).to.be.true;
+    });
+
+    it('should enrich the bid request data', (done) => {
+      const expectedURL = new URL(altHost);
+      expectedURL.searchParams.set('debug', true);
+      expectedURL.searchParams.set('mode', 'prebid');
+
+      const callback = () => {
+        expect(reqBidsConfigObj.ortb2Fragments.bidder).to.deep.equal({
+          bidder1: {
+            device: {
+              ext: {
+                wurfl: {
+                  advertised_browser: 'Chrome',
+                  advertised_browser_version: '125.0.6422.76',
+                  advertised_device_os: 'Linux',
+                  advertised_device_os_version: '6.5.0',
+                  brand_name: 'Google',
+                  complete_device_name: 'Google Chrome',
+                  form_factor: 'Desktop',
+                  is_app_webview: !1,
+                  is_robot: !1,
+                  is_tablet: !1,
+                  marketing_name: '',
+                },
+              },
+            },
+          },
+          bidder2: {
+            device: {
+              ext: {
+                wurfl: {
+                  complete_device_name: 'Google Chrome',
+                  form_factor: 'Desktop',
+                  is_app_webview: !1,
+                  is_full_desktop: !0,
+                  is_mobile: !1,
+                  is_robot: !1,
+                  is_smartphone: !1,
+                  is_smarttv: !1,
+                  is_tablet: !1,
+                  manufacturer_name: '',
+                },
+              },
+            },
+          },
+          bidder3: {
+            device: {
+              ext: {
+                wurfl: {
+                  complete_device_name: 'Google Chrome',
+                  form_factor: 'Desktop',
+                  is_mobile: !1,
+                },
+              },
+            },
+          },
+        });
+        done();
+      };
+
+      const config = {
+        params: {
+          altHost: altHost,
+          debug: true,
+        }
+      };
+      const userConsent = {};
+
+      wurflSubmodule.getBidRequestData(reqBidsConfigObj, callback, config, userConsent);
+      expect(loadExternalScriptStub.calledOnce).to.be.true;
+      const loadExternalScriptCall = loadExternalScriptStub.getCall(0);
+      expect(loadExternalScriptCall.args[0]).to.equal(expectedURL.toString());
+      expect(loadExternalScriptCall.args[1]).to.equal('wurfl');
+    });
+
+    it('onAuctionEndEvent: should send analytics data using navigator.sendBeacon, if available', () => {
+      const auctionDetails = {};
+      const config = {};
+      const userConsent = {};
+
+      const sendBeaconStub = sandbox.stub(navigator, 'sendBeacon');
+
+      // Call the function
+      wurflSubmodule.onAuctionEndEvent(auctionDetails, config, userConsent);
+
+      // Assertions
+      expect(sendBeaconStub.calledOnce).to.be.true;
+      expect(sendBeaconStub.calledWithExactly(expectedStatsURL, expectedData)).to.be.true;
+    });
+
+    it('onAuctionEndEvent: should send analytics data using fetch as fallback, if navigator.sendBeacon is not available', () => {
+      const auctionDetails = {};
+      const config = {};
+      const userConsent = {};
+
+      const sendBeaconStub = sandbox.stub(navigator, 'sendBeacon').value(undefined);
+      const windowFetchStub = sandbox.stub(window, 'fetch');
+      const fetchAjaxStub = sandbox.stub(ajaxModule, 'fetch');
+
+      // Call the function
+      wurflSubmodule.onAuctionEndEvent(auctionDetails, config, userConsent);
+
+      // Assertions
+      expect(sendBeaconStub.called).to.be.false;
+
+      expect(fetchAjaxStub.calledOnce).to.be.true;
+      const fetchAjaxCall = fetchAjaxStub.getCall(0);
+      expect(fetchAjaxCall.args[0]).to.equal(expectedStatsURL);
+      expect(fetchAjaxCall.args[1].method).to.equal('POST');
+      expect(fetchAjaxCall.args[1].body).to.equal(expectedData);
+      expect(fetchAjaxCall.args[1].mode).to.equal('no-cors');
+    });
+  });
+
+  describe('bidderData', () => {
+    it('should return the WURFL data for a bidder', () => {
+      const wjsData = {
+        capability1: 'value1',
+        capability2: 'value2',
+        capability3: 'value3',
+      };
+      const caps = ['capability1', 'capability2', 'capability3'];
+      const filter = [0, 2];
+
+      const result = bidderData(wjsData, caps, filter);
+
+      expect(result).to.deep.equal({
+        capability1: 'value1',
+        capability3: 'value3',
+      });
+    });
+
+    it('should return an empty object if the filter is empty', () => {
+      const wjsData = {
+        capability1: 'value1',
+        capability2: 'value2',
+        capability3: 'value3',
+      };
+      const caps = ['capability1', 'capability3'];
+      const filter = [];
+
+      const result = bidderData(wjsData, caps, filter);
+
+      expect(result).to.deep.equal({});
+    });
+  });
+
+  describe('lowEntropyData', () => {
+    it('should return the correct low entropy data for Apple devices', () => {
+      const wjsData = {
+        complete_device_name: 'Apple iPhone X',
+        form_factor: 'Smartphone',
+        is_mobile: !0,
+      };
+      const lowEntropyCaps = ['complete_device_name', 'form_factor', 'is_mobile'];
+      const expectedData = {
+        complete_device_name: 'Apple iPhone',
+        form_factor: 'Smartphone',
+        is_mobile: !0,
+      };
+      const result = lowEntropyData(wjsData, lowEntropyCaps);
+      expect(result).to.deep.equal(expectedData);
+    });
+
+    it('should return the correct low entropy data for Android devices', () => {
+      const wjsData = {
+        complete_device_name: 'Samsung SM-G981B (Galaxy S20 5G)',
+        form_factor: 'Smartphone',
+        is_mobile: !0,
+      };
+      const lowEntropyCaps = ['complete_device_name', 'form_factor', 'is_mobile'];
+      const expectedData = {
+        complete_device_name: 'Samsung SM-G981B (Galaxy S20 5G)',
+        form_factor: 'Smartphone',
+        is_mobile: !0,
+      };
+      const result = lowEntropyData(wjsData, lowEntropyCaps);
+      expect(result).to.deep.equal(expectedData);
+    });
+
+    it('should return an empty object if the lowEntropyCaps array is empty', () => {
+      const wjsData = {
+        complete_device_name: 'Samsung SM-G981B (Galaxy S20 5G)',
+        form_factor: 'Smartphone',
+        is_mobile: !0,
+      };
+      const lowEntropyCaps = [];
+      const expectedData = {};
+      const result = lowEntropyData(wjsData, lowEntropyCaps);
+      expect(result).to.deep.equal(expectedData);
+    });
+  });
+
+  describe('enrichBidderRequest', () => {
+    it('should enrich the bidder request with WURFL data', () => {
+      const reqBidsConfigObj = {
+        ortb2Fragments: {
+          bidder: {
+            exampleBidder: {
+              device: {
+                ua: 'user-agent',
+              }
+            }
+          }
+        }
+      };
+      const bidderCode = 'exampleBidder';
+      const wjsData = {
+        capability1: 'value1',
+        capability2: 'value2'
+      };
+
+      enrichBidderRequest(reqBidsConfigObj, bidderCode, wjsData);
+
+      expect(reqBidsConfigObj.ortb2Fragments.bidder).to.deep.equal({
+        exampleBidder: {
+          device: {
+            ua: 'user-agent',
+            ext: {
+              wurfl: {
+                capability1: 'value1',
+                capability2: 'value2'
+              }
+            }
+          }
+        }
+      });
+    });
+  });
+});

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/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);