prebid.js 8.7.0 → 8.9.0

package/src/constants.json

@@ -163,11 +163,17 @@
     "MAIN": 3
   },
   "NATIVE_KEYS_THAT_ARE_NOT_ASSETS": [
-    "privacyLink",
     "clickUrl",
     "sendTargetingKeys",
     "adTemplate",
     "rendererUrl",
     "type"
-  ]
+  ],
+  "FLOOR_VALUES": {
+	"NO_DATA": "noData",
+	"AD_UNIT": "adUnit",
+	"SET_CONFIG": "setConfig",
+	"FETCH": "fetch",
+	"SUCCESS": "success"
+  }
 }

package/src/native.js

@@ -480,6 +480,11 @@ export function toOrtbNativeRequest(legacyNativeAssets) {
       continue;
     }
 
+    if (key === 'privacyLink') {
+      ortb.privacy = 1;
+      continue;
+    }
+
     const asset = legacyNativeAssets[key];
     let required = 0;
     if (asset.required && isBoolean(asset.required)) {
@@ -623,6 +628,9 @@ export function fromOrtbNativeRequest(openRTBRequest) {
         oldNativeObject[prebidAssetName].len = asset.data.len;
       }
     }
+    if (openRTBRequest.privacy) {
+      oldNativeObject.privacyLink = { required: false };
+    }
     // video was not supported by old prebid assets
   }
   return oldNativeObject;
@@ -696,8 +704,11 @@ export function legacyPropertiesToOrtbNative(legacyNative) {
         // in general, native trackers seem to be neglected and/or broken
         response.jstracker = Array.isArray(value) ? value.join('') : value;
         break;
+      case 'privacyLink':
+        response.privacy = value;
+        break;
     }
-  })
+  });
   return response;
 }
 
@@ -780,8 +791,8 @@ export function toLegacyResponse(ortbResponse, ortbRequest) {
   legacyResponse.impressionTrackers = [];
   let jsTrackers = [];
 
-  if (ortbRequest?.imptrackers) {
-    legacyResponse.impressionTrackers.push(...ortbRequest.imptrackers);
+  if (ortbResponse.imptrackers) {
+    legacyResponse.impressionTrackers.push(...ortbResponse.imptrackers);
   }
   for (const eventTracker of ortbResponse?.eventtrackers || []) {
     if (eventTracker.event === TRACKER_EVENTS.impression && eventTracker.method === TRACKER_METHODS.img) {

package/test/mocks/xhr.js

@@ -1,12 +1,236 @@
 import {getUniqueIdentifierStr} from '../../src/utils.js';
+import {GreedyPromise} from '../../src/utils/promise.js';
+import {fakeXhr} from 'nise';
+import {dep} from 'src/ajax.js';
 
-export let server = sinon.createFakeServer();
-export let xhr = global.XMLHttpRequest;
+export const xhr = sinon.useFakeXMLHttpRequest();
+export const server = mockFetchServer();
 
-beforeEach(function() {
-  server.restore();
-  server = sinon.createFakeServer();
-  xhr = global.XMLHttpRequest;
+/**
+ * An (incomplete) replica of nise's fakeServer, but backing fetch used in ajax.js (rather than XHR).
+ */
+function mockFetchServer() {
+  const sandbox = sinon.createSandbox();
+  const bodies = new WeakMap();
+  const requests = [];
+  const {DONE, UNSENT} = XMLHttpRequest;
+
+  function makeRequest(resource, options) {
+    const requestBody = options?.body || bodies.get(resource);
+    const request = new Request(resource, options);
+    bodies.set(request, requestBody);
+    return request;
+  }
+
+  function mockXHR(resource, options) {
+    let resolve, reject;
+    const promise = new GreedyPromise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+
+    function error(reason = new TypeError('Failed to fetch')) {
+      mockReq.status = 0;
+      reject(reason);
+    }
+
+    const request = makeRequest(resource, options);
+    request.signal.onabort = () => error(new DOMException('The user aborted a request'));
+    let responseHeaders;
+
+    const mockReq = {
+      fetch: {
+        request,
+        requestBody: bodies.get(request),
+        promise,
+      },
+      readyState: UNSENT,
+      url: request.url,
+      method: request.method,
+      requestBody: bodies.get(request),
+      status: 0,
+      statusText: '',
+      requestHeaders: new Proxy(request.headers, {
+        get(target, prop) {
+          return typeof prop === 'string' && target.has(prop) ? target.get(prop) : {}[prop];
+        },
+        has(target, prop) {
+          return typeof prop === 'string' && target.has(prop);
+        },
+        ownKeys(target) {
+          return Array.from(target.keys());
+        },
+        getOwnPropertyDescriptor(target, prop) {
+          if (typeof prop === 'string' && target.has(prop)) {
+            return {
+              enumerable: true,
+              configurable: true,
+              writable: false,
+              value: target.get(prop)
+            }
+          }
+        }
+      }),
+      withCredentials: request.credentials === 'include',
+      setStatus(status) {
+        // nise replaces invalid status with 200
+        status = typeof status === 'number' ? status : 200;
+        mockReq.status = status;
+        mockReq.statusText = fakeXhr.FakeXMLHttpRequest.statusCodes[status] || '';
+      },
+      setResponseHeaders(headers) {
+        responseHeaders = headers;
+      },
+      setResponseBody(body) {
+        if (mockReq.status === 0) {
+          error();
+          return;
+        }
+        const resp = Object.defineProperties(new Response(body, {
+          status: mockReq.status,
+          statusText: mockReq.statusText,
+          headers: responseHeaders || {},
+        }), {
+          url: {
+            get: () => mockReq.fetch.request.url,
+          }
+        });
+        mockReq.readyState = DONE;
+        // tests expect respond() to run everything immediately,
+        // so make body available syncronously
+        resp.text = () => GreedyPromise.resolve(body || '');
+        Object.assign(mockReq.fetch, {
+          response: resp,
+          responseBody: body || ''
+        })
+        resolve(resp);
+      },
+      respond(status = 200, headers, body) {
+        mockReq.setStatus(status);
+        mockReq.setResponseHeaders(headers);
+        mockReq.setResponseBody(body);
+      },
+      error
+    };
+    return mockReq;
+  }
+
+  let enabled = false;
+  let timeoutsEnabled = false;
+
+  function enable() {
+    if (!enabled) {
+      sandbox.stub(dep, 'fetch').callsFake((resource, options) => {
+        const req = mockXHR(resource, options);
+        requests.push(req);
+        return req.fetch.promise;
+      });
+      sandbox.stub(dep, 'makeRequest').callsFake(makeRequest);
+      const timeout = dep.timeout;
+      sandbox.stub(dep, 'timeout').callsFake(function () {
+        if (timeoutsEnabled) {
+          return timeout.apply(null, arguments);
+        } else {
+          return {};
+        }
+      });
+      enabled = true;
+    }
+  }
+
+  enable();
+
+  const responders = [];
+
+  function respondWith() {
+    let response, urlMatcher, methodMatcher;
+    urlMatcher = methodMatcher = () => true;
+    switch (arguments.length) {
+      case 1:
+        ([response] = arguments);
+        break;
+      case 2:
+        ([urlMatcher, response] = arguments);
+        break;
+      case 3:
+        ([methodMatcher, urlMatcher, response] = arguments);
+        methodMatcher = ((toMatch) => (method) => method === toMatch)(methodMatcher);
+        break;
+      default:
+        throw new Error('Invalid respondWith invocation');
+    }
+    if (typeof urlMatcher.exec === 'function') {
+      urlMatcher = ((rx) => (url) => rx.exec(url)?.slice(1))(urlMatcher);
+    } else if (typeof urlMatcher === 'string') {
+      urlMatcher = ((toMatch) => (url) => url === toMatch)(urlMatcher);
+    }
+    responders.push((req) => {
+      if (req.readyState !== DONE && methodMatcher(req.method)) {
+        const arg = urlMatcher(req.url);
+        if (arg) {
+          if (typeof response === 'function') {
+            response(req, ...(Array.isArray(arg) ? arg : []));
+          } else if (typeof response === 'string') {
+            req.respond(200, null, response);
+          } else {
+            req.respond.apply(req, response);
+          }
+        }
+      }
+    });
+  }
+
+  function resetState() {
+    requests.length = 0;
+    responders.length = 0;
+    timeoutsEnabled = false;
+  }
+
+  return {
+    requests,
+    enable,
+    restore() {
+      resetState();
+      sandbox.restore();
+      enabled = false;
+    },
+    reset() {
+      sandbox.resetHistory();
+      resetState();
+    },
+    respondWith,
+    respond() {
+      if (arguments.length > 0) {
+        respondWith.apply(null, arguments);
+      }
+      requests.forEach(req => {
+        for (let i = responders.length - 1; i >= 0; i--) {
+          responders[i](req);
+          if (req.readyState === DONE) break;
+        }
+        if (req.readyState !== DONE) {
+          req.respond(404, {}, '');
+        }
+      });
+    },
+    /**
+     * the timeout mechanism is quite different between XHR and fetch
+     * by default, mocked fetch does not time out - to reflect fakeServer XHRs
+     * note that many tests will fire requests without caring or waiting for their response -
+     * if they are timed out later, during unrelated tests, the log messages might interfere with their
+     * assertions
+     */
+    get autoTimeout() {
+      return timeoutsEnabled;
+    },
+    set autoTimeout(val) {
+      timeoutsEnabled = !!val;
+    }
+  };
+}
+
+beforeEach(function () {
+  server.reset();
 });
 
 const bid = getUniqueIdentifierStr().substring(4);
@@ -20,12 +244,35 @@ afterEach(function () {
       return (s) => s.split('\n').map(s => `${preamble} ${s}`).join('\n');
     })();
 
+    function format(obj, body = null) {
+      if (obj == null) return obj;
+      const fmt = {};
+      let node = obj;
+      while (node != null) {
+        Object.keys(node).forEach((k) => {
+          const val = obj[k];
+          if (typeof val !== 'function' && !fmt.hasOwnProperty(k)) {
+            fmt[k] = val;
+          }
+        });
+        node = Object.getPrototypeOf(node);
+      }
+      if (obj.headers != null) {
+        fmt.headers = Object.fromEntries(obj.headers.entries())
+      }
+      fmt.body = body;
+      return fmt;
+    }
+
 
-    console.log(prepend(`XHR mock state after failure (for test '${this.currentTest.fullTitle()}'): ${server.requests.length} requests`))
+    console.log(prepend(`XHR mock state after failure (for test '${this.currentTest.fullTitle()}'): ${server.requests.length} requests`));
     server.requests.forEach((req, i) => {
       console.log(prepend(`Request #${i}:`));
-      console.log(prepend(JSON.stringify(req, null, 2)));
-    })
+      console.log(prepend(JSON.stringify({
+        request: format(req.fetch.request, req.fetch.requestBody),
+        response: format(req.fetch.response, req.fetch.responseBody)
+      }, null, 2)));
+    });
   }
 });
 /* eslint-enable */

package/test/spec/libraries/mspa/activityControls_spec.js

@@ -35,6 +35,12 @@ describe('Consent interpretation', () => {
       }));
       expect(result).to.equal(true);
     });
+    it('should be true (basic consent conditions do not pass) with covered set to zero (invalid state)', () => {
+      const result = isBasicConsentDenied(mkConsent({
+        MspaCoveredTransaction: 0
+      }));
+      expect(result).to.equal(true);
+    });
     it('should not deny when consent for under-13 is null', () => {
       expect(isBasicConsentDenied(mkConsent({
         KnownChildSensitiveDataConsents: [0, null]

package/test/spec/modules/adagioBidAdapter_spec.js

@@ -322,6 +322,21 @@ describe('Adagio bid adapter', () => {
       expect(requests[0].data.adUnits[0].transactionId).to.not.exist;
     });
 
+    it('should enrich prebid bid requests params', function() {
+      const expectedAuctionId = '373bcda7-9794-4f1c-be2c-0d223d11d579'
+      const expectedPageviewId = '56befc26-8cf0-472d-b105-73896df8eb89';
+      sandbox.stub(utils, 'generateUUID').returns(expectedAuctionId);
+      sandbox.stub(adagio, 'getPageviewId').returns(expectedPageviewId);
+
+      const bid01 = new BidRequestBuilder().withParams().build();
+      const bidderRequest = new BidderRequestBuilder().build();
+
+      spec.buildRequests([bid01], bidderRequest);
+
+      expect(bid01.params.adagioAuctionId).eq(expectedAuctionId);
+      expect(bid01.params.pageviewId).eq(expectedPageviewId);
+    });
+
     it('should enqueue computed features for collect usage', function() {
       sandbox.stub(Date, 'now').returns(12345);
 

package/test/spec/modules/adlooxAdServerVideo_spec.js

@@ -1,11 +1,11 @@
 import adapterManager from 'src/adapterManager.js';
 import analyticsAdapter from 'modules/adlooxAnalyticsAdapter.js';
-import { ajax } from 'src/ajax.js';
 import { buildVideoUrl } from 'modules/adlooxAdServerVideo.js';
 import { expect } from 'chai';
 import * as events from 'src/events.js';
 import { targeting } from 'src/targeting.js';
 import * as utils from 'src/utils.js';
+import {server} from '../../mocks/xhr.js';
 
 const analyticsAdapterName = 'adloox';
 
@@ -199,11 +199,9 @@ describe('Adloox Ad Server Video', function () {
     });
 
     describe('process VAST', function () {
-      let server = null;
       let BID = null;
       let getWinningBidsStub;
       beforeEach(function () {
-        server = sinon.createFakeServer();
         BID = utils.deepClone(bid);
         getWinningBidsStub = sinon.stub(targeting, 'getWinningBids')
         getWinningBidsStub.withArgs(adUnit.code).returns([ BID ]);
@@ -212,8 +210,6 @@ describe('Adloox Ad Server Video', function () {
         getWinningBidsStub.restore();
         getWinningBidsStub = undefined;
         BID = null;
-        server.restore();
-        server = null;
       });
 
       it('should return URL unchanged for non-VAST', function (done) {

package/test/spec/modules/adlooxRtdProvider_spec.js

@@ -1,12 +1,12 @@
 import adapterManager from 'src/adapterManager.js';
 import analyticsAdapter from 'modules/adlooxAnalyticsAdapter.js';
 import {auctionManager} from 'src/auctionManager.js';
-import { config as _config } from 'src/config.js';
 import { expect } from 'chai';
 import * as events from 'src/events.js';
 import * as prebidGlobal from 'src/prebidGlobal.js';
 import { subModuleObj as rtdProvider } from 'modules/adlooxRtdProvider.js';
 import * as utils from 'src/utils.js';
+import {server} from '../../mocks/xhr.js';
 
 const analyticsAdapterName = 'adloox';
 
@@ -139,16 +139,12 @@ describe('Adloox RTD Provider', function () {
       expect(analyticsAdapter.context).is.null;
     });
 
-    let server = null;
     let CONFIG = null;
     beforeEach(function () {
-      server = sinon.createFakeServer();
       CONFIG = utils.deepClone(config);
     });
     afterEach(function () {
       CONFIG = null;
-      server.restore();
-      server = null;
     });
 
     it('should fetch segments', function (done) {

package/test/spec/modules/admaticBidAdapter_spec.js

@@ -28,6 +28,7 @@ describe('admaticBidAdapter', () => {
       'bidderRequestId': '22edbae2733bf6',
       'auctionId': '1d1a030790a475',
       'creativeId': 'er2ee',
+      'ortb2Imp': { 'ext': { 'instl': 1 } },
       'ortb2': { 'badv': ['admatic.com.tr'] }
     };
 
@@ -52,6 +53,7 @@ describe('admaticBidAdapter', () => {
           'networkId': 10433394,
           'host': 'layer.serve.admatic.com.tr'
         },
+        'ortb2Imp': { 'ext': { 'instl': 1 } },
         'ortb2': { 'badv': ['admatic.com.tr'] },
         'mediaTypes': {
           'banner': {
@@ -162,6 +164,7 @@ describe('admaticBidAdapter', () => {
           'networkId': 10433394,
           'host': 'layer.serve.admatic.com.tr'
         },
+        'ortb2Imp': { 'ext': { 'instl': 1 } },
         'ortb2': { 'badv': ['admatic.com.tr'] },
         'mediaTypes': {
           'banner': {
@@ -284,6 +287,7 @@ describe('admaticBidAdapter', () => {
               'sizes': [[300, 250], [728, 90]]
             }
           },
+          'ortb2Imp': { 'ext': { 'instl': 1 } },
           'ortb2': { 'badv': ['admatic.com.tr'] },
           getFloor: inputParams => {
             if (inputParams.mediaType === BANNER && inputParams.size[0] === 300 && inputParams.size[1] === 250) {
@@ -308,6 +312,7 @@ describe('admaticBidAdapter', () => {
           'networkId': 10433394,
           'host': 'layer.serve.admatic.com.tr'
         },
+        'ortb2Imp': { 'ext': { 'instl': 1 } },
         'ortb2': { 'badv': ['admatic.com.tr'] },
         'adUnitCode': 'adunit-code',
         'sizes': [[300, 250], [728, 90]],

package/test/spec/modules/adqueryIdSystem_spec.js

@@ -1,5 +1,6 @@
-import { adqueryIdSubmodule, storage } from 'modules/adqueryIdSystem.js';
-import { server } from 'test/mocks/xhr.js';
+import {adqueryIdSubmodule, storage} from 'modules/adqueryIdSystem.js';
+import {server} from 'test/mocks/xhr.js';
+import sinon from 'sinon';
 
 const config = {
   storage: {
@@ -18,7 +19,7 @@ describe('AdqueryIdSystem', function () {
     });
   });
 
-  describe('getId', function() {
+  describe('getId', function () {
     let getDataFromLocalStorageStub;
 
     beforeEach(function() {
@@ -29,7 +30,7 @@ describe('AdqueryIdSystem', function () {
       getDataFromLocalStorageStub.restore();
     });
 
-    it('gets a adqueryId', function() {
+    it('gets a adqueryId', function () {
       const config = {
         params: {}
       };
@@ -37,36 +38,24 @@ describe('AdqueryIdSystem', function () {
       const callback = adqueryIdSubmodule.getId(config).callback;
       callback(callbackSpy);
       const request = server.requests[0];
-      expect(request.url).to.eq(`https://bidder.adquery.io/prebid/qid`);
-      request.respond(200, { 'Content-Type': 'application/json' }, JSON.stringify({ qid: 'qid' }));
-      expect(callbackSpy.lastCall.lastArg).to.deep.equal({qid: 'qid'});
+      expect(request.url).to.contains(`https://bidder.adquery.io/prebid/qid?qid=`);
+      request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify({qid: '6dd9eab7dfeab7df6dd9ea'}));
+      expect(callbackSpy.lastCall.lastArg).to.deep.equal('6dd9eab7dfeab7df6dd9ea');
     });
 
-    it('gets a cached adqueryId', function() {
-      const config = {
-        params: {}
-      };
-      getDataFromLocalStorageStub.withArgs('qid').returns('qid');
-
-      const callbackSpy = sinon.spy();
-      const callback = adqueryIdSubmodule.getId(config).callback;
-      callback(callbackSpy);
-      expect(callbackSpy.lastCall.lastArg).to.deep.equal({qid: 'qid'});
-    });
-
-    it('allows configurable id url', function() {
+    it('allows configurable id url', function () {
       const config = {
         params: {
-          url: 'https://bidder.adquery.io'
+          url: 'https://another_bidder.adquery.io/qid'
         }
       };
       const callbackSpy = sinon.spy();
       const callback = adqueryIdSubmodule.getId(config).callback;
       callback(callbackSpy);
       const request = server.requests[0];
-      expect(request.url).to.eq('https://bidder.adquery.io');
-      request.respond(200, { 'Content-Type': 'application/json' }, JSON.stringify({ qid: 'testqid' }));
-      expect(callbackSpy.lastCall.lastArg).to.deep.equal({qid: 'testqid'});
+      expect(request.url).to.contains('https://another_bidder.adquery.io');
+      request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify({qid: 'testqid'}));
+      expect(callbackSpy.lastCall.lastArg).to.deep.equal('testqid');
     });
   });
 });

package/test/spec/modules/bidViewability_spec.js

@@ -245,18 +245,31 @@ describe('#bidViewability', function() {
     let logWinningBidNotFoundSpy;
     let callBidViewableBidderSpy;
     let winningBidsArray;
+    let callBidBillableBidderSpy;
+    let adUnits = [
+      {
+        'code': 'abc123',
+        'bids': [
+          {
+            'bidder': 'pubmatic'
+          }
+        ]
+      }
+    ];
 
     beforeEach(function() {
       sandbox = sinon.sandbox.create();
       triggerPixelSpy = sandbox.spy(utils, ['triggerPixel']);
       eventsEmitSpy = sandbox.spy(events, ['emit']);
       callBidViewableBidderSpy = sandbox.spy(adapterManager, ['callBidViewableBidder']);
+      callBidBillableBidderSpy = sandbox.spy(adapterManager, ['callBidBillableBidder']);
       // mocking winningBidsArray
       winningBidsArray = [];
       sandbox.stub(prebidGlobal, 'getGlobal').returns({
         getAllWinningBids: function (number) {
           return winningBidsArray;
-        }
+        },
+        adUnits
       });
     });
 
@@ -293,5 +306,23 @@ describe('#bidViewability', function() {
       // CONSTANTS.EVENTS.BID_VIEWABLE is NOT triggered
       expect(eventsEmitSpy.callCount).to.equal(0);
     });
+
+    it('should call the callBidBillableBidder function if the viewable bid is associated with an ad unit with deferBilling set to true', function() {
+      let moduleConfig = {};
+      const deferredBillingAdUnit = {
+        'code': '/harshad/Jan/2021/',
+        'deferBilling': true,
+        'bids': [
+          {
+            'bidder': 'pubmatic'
+          }
+        ]
+      };
+      adUnits.push(deferredBillingAdUnit);
+      winningBidsArray.push(PBJS_WINNING_BID);
+      bidViewability.impressionViewableHandler(moduleConfig, GPT_SLOT, null);
+      expect(callBidBillableBidderSpy.callCount).to.equal(1);
+      sinon.assert.calledWith(callBidBillableBidderSpy, PBJS_WINNING_BID);
+    });
   });
 });

package/test/spec/modules/brandmetricsRtdProvider_spec.js

@@ -67,6 +67,8 @@ const NO_USP_CONSENT = {
   usp: '1NYY'
 };
 
+const UNDEFINED_USER_CONSENT = {};
+
 function mockSurveyLoaded(surveyConf) {
   const commands = window._brandmetrics || [];
   commands.forEach(command => {
@@ -120,6 +122,10 @@ describe('BrandmetricsRTD module', () => {
   it('should not init when there is no usp- consent', () => {
     expect(brandmetricsRTD.brandmetricsSubmodule.init(VALID_CONFIG, NO_USP_CONSENT)).to.equal(false);
   });
+
+  it('should init if there are no consent- objects defined', () => {
+    expect(brandmetricsRTD.brandmetricsSubmodule.init(VALID_CONFIG, UNDEFINED_USER_CONSENT)).to.equal(true);
+  });
 });
 
 describe('getBidRequestData', () => {