prebid.js 8.8.0 → 8.9.0

package/test/spec/native_spec.js

@@ -862,6 +862,9 @@ describe('validate native', function () {
             }]
           },
           address: {},
+          privacyLink: {
+            required: true
+          }
         },
       },
     };
@@ -917,6 +920,7 @@ describe('validate native', function () {
         type: 9,
       }
     });
+    expect(ortb.privacy).to.equal(1);
   });
 
   ['bogusKey', 'clickUrl', 'privacyLink'].forEach(nativeKey => {
@@ -1024,11 +1028,14 @@ describe('validate native', function () {
     expect(oldNativeRequest.sponsoredBy).to.include({
       required: true,
       len: 25
-    })
+    });
     expect(oldNativeRequest.body).to.include({
       required: true,
       len: 140
-    })
+    });
+    expect(oldNativeRequest.privacyLink).to.include({
+      required: false
+    });
   });
 
   if (FEATURES.NATIVE) {
@@ -1199,6 +1206,12 @@ describe('legacyPropertiesToOrtbNative', () => {
       expect(native.jstracker).to.eql('some-markupsome-other-markup');
     })
   });
+  describe('privacylink', () => {
+    it('should convert privacyLink to privacy', () => {
+      const native = legacyPropertiesToOrtbNative({privacyLink: 'https:/my-privacy-link.com'});
+      expect(native.privacy).to.eql('https:/my-privacy-link.com');
+    })
+  })
 });
 
 describe('fireImpressionTrackers', () => {

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

@@ -0,0 +1,403 @@
+import {dep, attachCallbacks, fetcherFactory, toFetchRequest} from '../../../../src/ajax.js';
+import {config} from 'src/config.js';
+import {server} from '../../../mocks/xhr.js';
+import {sandbox} from 'sinon';
+
+const EXAMPLE_URL = 'https://www.example.com';
+
+describe('fetcherFactory', () => {
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+    server.autoTimeout = true;
+  });
+
+  afterEach(() => {
+    clock.runAll();
+    clock.restore();
+    config.resetConfig();
+  });
+
+  Object.entries({
+    'URL': EXAMPLE_URL,
+    'request object': new Request(EXAMPLE_URL)
+  }).forEach(([t, resource]) => {
+    it(`times out after timeout when fetching ${t}`, (done) => {
+      const fetch = fetcherFactory(1000);
+      const resp = fetch(resource);
+      clock.tick(900);
+      expect(server.requests[0].fetch.request.signal.aborted).to.be.false;
+      clock.tick(100);
+      expect(server.requests[0].fetch.request.signal.aborted).to.be.true;
+      resp.catch(() => done());
+    });
+  });
+
+  it('does not timeout after it completes', () => {
+    const fetch = fetcherFactory(1000);
+    const resp = fetch(EXAMPLE_URL);
+    server.requests[0].respond();
+    return resp.then(() => {
+      clock.tick(2000);
+      expect(server.requests[0].fetch.request.signal.aborted).to.be.false;
+    });
+  });
+
+  Object.entries({
+    'disableAjaxTimeout is set'() {
+      const fetcher = fetcherFactory(1000);
+      config.setConfig({disableAjaxTimeout: true});
+      return fetcher;
+    },
+    'timeout is null'() {
+      return fetcherFactory(null);
+    },
+  }).forEach(([t, mkFetcher]) => {
+    it(`does not timeout if ${t}`, (done) => {
+      const fetch = mkFetcher();
+      const pm = fetch(EXAMPLE_URL);
+      clock.tick(2000);
+      server.requests[0].respond();
+      pm.then(() => done());
+    });
+  });
+
+  Object.entries({
+    'local URL': ['/local.html', window.origin],
+    'remote URL': [EXAMPLE_URL + '/remote.html', EXAMPLE_URL],
+    'request with local URL': [new Request('/local.html'), window.origin],
+    'request with remote URL': [new Request(EXAMPLE_URL + '/remote.html'), EXAMPLE_URL]
+  }).forEach(([t, [resource, expectedOrigin]]) => {
+    describe(`using ${t}`, () => {
+      it('calls request, passing origin', () => {
+        const request = sinon.stub();
+        const fetch = fetcherFactory(1000, {request});
+        fetch(resource);
+        sinon.assert.calledWith(request, expectedOrigin);
+      });
+
+      Object.entries({
+        success: 'respond',
+        error: 'error'
+      }).forEach(([t, method]) => {
+        it(`calls done on ${t}, passing origin`, () => {
+          const done = sinon.stub();
+          const fetch = fetcherFactory(1000, {done});
+          const req = fetch(resource).catch(() => null).then(() => {
+            sinon.assert.calledWith(done, expectedOrigin);
+          });
+          server.requests[0][method]();
+          return req;
+        });
+      });
+    });
+  });
+});
+
+describe('toFetchRequest', () => {
+  Object.entries({
+    'simple POST': {
+      url: EXAMPLE_URL,
+      data: 'data',
+      expect: {
+        request: {
+          url: EXAMPLE_URL + '/',
+          method: 'POST',
+        },
+        text: 'data',
+        headers: {
+          'content-type': 'text/plain'
+        }
+      }
+    },
+    'POST with headers': {
+      url: EXAMPLE_URL,
+      data: '{"json": "body"}',
+      options: {
+        contentType: 'application/json',
+        customHeaders: {
+          'x-custom': 'value'
+        }
+      },
+      expect: {
+        request: {
+          url: EXAMPLE_URL + '/',
+          method: 'POST',
+        },
+        text: '{"json": "body"}',
+        headers: {
+          'content-type': 'application/json',
+          'X-Custom': 'value'
+        }
+      }
+    },
+    'simple GET': {
+      url: EXAMPLE_URL,
+      data: {p1: 'v1', p2: 'v2'},
+      options: {
+        method: 'GET',
+      },
+      expect: {
+        request: {
+          url: EXAMPLE_URL + '/?p1=v1&p2=v2',
+          method: 'GET'
+        },
+        text: '',
+        headers: {
+          'content-type': 'text/plain'
+        }
+      }
+    },
+    'GET with credentials': {
+      url: EXAMPLE_URL,
+      data: null,
+      options: {
+        method: 'GET',
+        withCredentials: true,
+      },
+      expect: {
+        request: {
+          url: EXAMPLE_URL + '/',
+          method: 'GET',
+          credentials: 'include'
+        },
+        text: '',
+        headers: {
+          'content-type': 'text/plain'
+        }
+      }
+    }
+  }).forEach(([t, {url, data, options, expect: {request, text, headers}}]) => {
+    it(`can build ${t}`, () => {
+      const req = toFetchRequest(url, data, options);
+      return req.text().then(body => {
+        Object.entries(request).forEach(([prop, val]) => {
+          expect(req[prop]).to.eql(val);
+        });
+        const hdr = new Headers(headers);
+        Array.from(req.headers.entries()).forEach(([name, val]) => {
+          expect(hdr.get(name)).to.eql(val);
+        });
+        expect(body).to.eql(text);
+      });
+    });
+  });
+
+  describe('browsingTopics', () => {
+    Object.entries({
+      'browsingTopics = true': [{browsingTopics: true}, true],
+      'browsingTopics = false': [{browsingTopics: false}, false],
+      'browsingTopics is undef': [{}, false]
+    }).forEach(([t, [opts, shouldBeSet]]) => {
+      describe(`when options has ${t}`, () => {
+        const sandbox = sinon.createSandbox();
+        afterEach(() => {
+          sandbox.restore();
+        });
+
+        it(`should ${!shouldBeSet ? 'not ' : ''}be set when in a secure context`, () => {
+          sandbox.stub(window, 'isSecureContext').get(() => true);
+          toFetchRequest(EXAMPLE_URL, null, opts);
+          sinon.assert.calledWithMatch(dep.makeRequest, sinon.match.any, {browsingTopics: shouldBeSet ? true : undefined});
+        });
+        it(`should not be set when not in a secure context`, () => {
+          sandbox.stub(window, 'isSecureContext').get(() => false);
+          toFetchRequest(EXAMPLE_URL, null, opts);
+          sinon.assert.calledWithMatch(dep.makeRequest, sinon.match.any, {browsingTopics: undefined});
+        });
+      })
+    })
+  })
+});
+
+describe('attachCallbacks', () => {
+  const sampleHeaders = new Headers({
+    'x-1': 'v1',
+    'x-2': 'v2'
+  });
+
+  function responseFactory(body, props) {
+    props = Object.assign({headers: sampleHeaders, url: EXAMPLE_URL}, props);
+    return function () {
+      return {
+        response: Object.defineProperties(new Response(body, props), {
+          url: {
+            get: () => props.url
+          }
+        }),
+        body: body || ''
+      };
+    };
+  }
+
+  function expectNullXHR(response) {
+    return new Promise((resolve, reject) => {
+      attachCallbacks(Promise.resolve(response), {
+        success: () => {
+          reject(new Error('should not succeed'));
+        },
+        error(statusText, xhr) {
+          expect(statusText).to.eql('');
+          sinon.assert.match(xhr, {
+            readyState: XMLHttpRequest.DONE,
+            status: 0,
+            statusText: '',
+            responseText: '',
+            response: '',
+            responseXML: null
+          });
+          expect(xhr.getResponseHeader('any')).to.be.null;
+          resolve();
+        }
+      });
+    });
+  }
+
+  it('runs error callback on rejections', () => {
+    return expectNullXHR(Promise.reject(new Error()));
+  });
+
+  Object.entries({
+    '2xx response': {
+      success: true,
+      makeResponse: responseFactory('body', {status: 200, statusText: 'OK'})
+    },
+    '2xx response with no body': {
+      success: true,
+      makeResponse: responseFactory(null, {status: 204, statusText: 'No content'})
+    },
+    '2xx response with XML': {
+      success: true,
+      xml: true,
+      makeResponse: responseFactory('<?xml><root><tag /></root>', {
+        status: 200,
+        statusText: 'OK',
+        headers: {'content-type': 'application/xml;charset=UTF8'}
+      })
+    },
+    '2xx response with HTML': {
+      success: true,
+      xml: true,
+      makeResponse: responseFactory('<html lang="en"><p></p></html>', {
+        status: 200,
+        statusText: 'OK',
+        headers: {'content-type': 'text/html;charset=UTF-8'}
+      })
+    },
+    '304 response': {
+      success: true,
+      makeResponse: responseFactory(null, {status: 304, statusText: 'Moved permanently'})
+    },
+    '4xx response': {
+      success: false,
+      makeResponse: responseFactory('body', {status: 400, statusText: 'Invalid request'})
+    },
+    '5xx response': {
+      success: false,
+      makeResponse: responseFactory('body', {status: 503, statusText: 'Gateway error'})
+    },
+    '4xx response with XML': {
+      success: false,
+      xml: true,
+      makeResponse: responseFactory('<?xml><root></root>', {
+        status: 404,
+        statusText: 'Not found',
+        headers: {
+          'content-type': 'application/xml'
+        }
+      })
+    }
+  }).forEach(([t, {success, makeResponse, xml}]) => {
+    const cbType = success ? 'success' : 'error';
+
+    describe(`for ${t}`, () => {
+      let response, body;
+      beforeEach(() => {
+        ({response, body} = makeResponse());
+      });
+
+      function checkXHR(xhr) {
+        sinon.assert.match(xhr, {
+          readyState: XMLHttpRequest.DONE,
+          status: response.status,
+          statusText: response.statusText,
+          responseType: '',
+          responseURL: response.url,
+          response: body,
+          responseText: body,
+        });
+        if (xml) {
+          expect(xhr.responseXML.querySelectorAll('*').length > 0).to.be.true;
+        } else {
+          expect(xhr.responseXML).to.not.exist;
+        }
+        Array.from(response.headers.entries()).forEach(([name, value]) => {
+          expect(xhr.getResponseHeader(name)).to.eql(value);
+        });
+        expect(xhr.getResponseHeader('$$missing-header')).to.be.null;
+      }
+
+      it(`runs ${cbType} callback`, (done) => {
+        attachCallbacks(Promise.resolve(response), {
+          success(payload, xhr) {
+            expect(success).to.be.true;
+            expect(payload).to.eql(body);
+            checkXHR(xhr);
+            done();
+          },
+          error(statusText, xhr) {
+            expect(success).to.be.false;
+            expect(statusText).to.eql(response.statusText);
+            checkXHR(xhr);
+            done();
+          }
+        });
+      });
+
+      it(`runs error callback if body cannot be retrieved`, () => {
+        response.text = () => Promise.reject(new Error());
+        return expectNullXHR(response);
+      });
+
+      if (success) {
+        it('accepts a single function as success callback', (done) => {
+          attachCallbacks(Promise.resolve(response), function (payload, xhr) {
+            expect(payload).to.eql(body);
+            checkXHR(xhr);
+            done();
+          })
+        })
+      }
+    });
+  });
+
+  describe('callback exceptions', () => {
+    Object.entries({
+      success: responseFactory(null, {status: 204}),
+      error: responseFactory('', {status: 400}),
+    }).forEach(([cbType, makeResponse]) => {
+      it(`do not choke ${cbType} callbacks`, () => {
+        const {response} = makeResponse();
+        return new Promise((resolve) => {
+          const result = {success: false, error: false};
+          attachCallbacks(Promise.resolve(response), {
+            success() {
+              result.success = true;
+              throw new Error();
+            },
+            error() {
+              result.error = true;
+              throw new Error();
+            }
+          });
+          setTimeout(() => resolve(result), 20);
+        }).then(result => {
+          Object.entries(result).forEach(([typ, ran]) => {
+            expect(ran).to.be[typ === cbType ? 'true' : 'false']
+          })
+        });
+      });
+    });
+  });
+});

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

@@ -14,7 +14,7 @@ import {bidderSettings} from '../../../../src/bidderSettings.js';
 import {decorateAdUnitsWithNativeParams} from '../../../../src/native.js';
 import * as activityRules from 'src/activities/rules.js';
 import {MODULE_TYPE_BIDDER} from '../../../../src/activities/modules.js';
-import {ACTIVITY_TRANSMIT_TID} from '../../../../src/activities/activities.js';
+import {ACTIVITY_TRANSMIT_TID, ACTIVITY_TRANSMIT_UFPD} from '../../../../src/activities/activities.js';
 
 const CODE = 'sampleBidder';
 const MOCK_BIDS_REQUEST = {
@@ -319,7 +319,7 @@ describe('bidders created by newBidder', function () {
       expect(ajaxStub.calledOnce).to.equal(true);
       expect(ajaxStub.firstCall.args[0]).to.equal(url);
       expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
-      expect(ajaxStub.firstCall.args[3]).to.deep.equal({
+      sinon.assert.match(ajaxStub.firstCall.args[3], {
         method: 'POST',
         contentType: 'text/plain',
         withCredentials: true
@@ -344,11 +344,11 @@ describe('bidders created by newBidder', function () {
       expect(ajaxStub.calledOnce).to.equal(true);
       expect(ajaxStub.firstCall.args[0]).to.equal(url);
       expect(ajaxStub.firstCall.args[2]).to.equal(JSON.stringify(data));
-      expect(ajaxStub.firstCall.args[3]).to.deep.equal({
+      sinon.assert.match(ajaxStub.firstCall.args[3], {
         method: 'POST',
         contentType: 'application/json',
         withCredentials: true
-      });
+      })
     });
 
     it('should make the appropriate GET request', function () {
@@ -367,10 +367,10 @@ describe('bidders created by newBidder', function () {
       expect(ajaxStub.calledOnce).to.equal(true);
       expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
       expect(ajaxStub.firstCall.args[2]).to.be.undefined;
-      expect(ajaxStub.firstCall.args[3]).to.deep.equal({
+      sinon.assert.match(ajaxStub.firstCall.args[3], {
         method: 'GET',
         withCredentials: true
-      });
+      })
     });
 
     it('should make the appropriate GET request when options are passed', function () {
@@ -391,10 +391,10 @@ describe('bidders created by newBidder', function () {
       expect(ajaxStub.calledOnce).to.equal(true);
       expect(ajaxStub.firstCall.args[0]).to.equal(`${url}?arg=2`);
       expect(ajaxStub.firstCall.args[2]).to.be.undefined;
-      expect(ajaxStub.firstCall.args[3]).to.deep.equal({
+      sinon.assert.match(ajaxStub.firstCall.args[3], {
         method: 'GET',
         withCredentials: false
-      });
+      })
     });
 
     it('should make multiple calls if the spec returns them', function () {
@@ -420,6 +420,78 @@ describe('bidders created by newBidder', function () {
       expect(ajaxStub.calledTwice).to.equal(true);
     });
 
+    describe('browsingTopics ajax option', () => {
+      let transmitUfpdAllowed, bidder;
+      beforeEach(() => {
+        activityRules.isActivityAllowed.reset();
+        activityRules.isActivityAllowed.callsFake((activity) => activity === ACTIVITY_TRANSMIT_UFPD ? transmitUfpdAllowed : true);
+        bidder = newBidder(spec);
+        spec.isBidRequestValid.returns(true);
+      });
+
+      it(`should be set to false when adapter sets browsingTopics = false`, () => {
+        transmitUfpdAllowed = true;
+        spec.buildRequests.returns([
+          {
+            method: 'GET',
+            url: 'url',
+            options: {
+              browsingTopics: false
+            }
+          }
+        ]);
+        bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+        sinon.assert.calledWith(ajaxStub, 'url', sinon.match.any, sinon.match.any, sinon.match({
+          browsingTopics: false
+        }));
+      });
+
+      Object.entries({
+        'allowed': true,
+        'not allowed': false
+      }).forEach(([t, allow]) => {
+        it(`should be set to ${allow} when transmitUfpd is ${t}`, () => {
+          transmitUfpdAllowed = allow;
+          spec.buildRequests.returns([
+            {
+              method: 'GET',
+              url: '1',
+            },
+            {
+              method: 'POST',
+              url: '2',
+              data: {}
+            },
+            {
+              method: 'GET',
+              url: '3',
+              options: {
+                browsingTopics: true
+              }
+            },
+            {
+              method: 'POST',
+              url: '4',
+              data: {},
+              options: {
+                browsingTopics: true
+              }
+            }
+          ]);
+          bidder.callBids(MOCK_BIDS_REQUEST, addBidResponseStub, doneStub, ajaxStub, onTimelyResponseStub, wrappedCallback);
+          ['1', '2', '3', '4'].forEach(url => {
+            sinon.assert.calledWith(
+              ajaxStub,
+              url,
+              sinon.match.any,
+              sinon.match.any,
+              sinon.match({browsingTopics: allow})
+            );
+          });
+        });
+      });
+    });
+
     it('should not add bids for each placement code if no requests are given', function () {
       const bidder = newBidder(spec);
 

package/test/spec/videoCache_spec.js

@@ -174,7 +174,7 @@ describe('The video cache', function () {
       const request = server.requests[0];
       request.method.should.equal('POST');
       request.url.should.equal('https://prebid.adnxs.com/pbc/v1/cache');
-      request.requestHeaders['Content-Type'].should.equal('text/plain;charset=utf-8');
+      request.requestHeaders['Content-Type'].should.equal('text/plain');
       let payload = {
         puts: [{
           type: 'xml',
@@ -224,7 +224,7 @@ describe('The video cache', function () {
       const request = server.requests[0];
       request.method.should.equal('POST');
       request.url.should.equal('https://prebid.adnxs.com/pbc/v1/cache');
-      request.requestHeaders['Content-Type'].should.equal('text/plain;charset=utf-8');
+      request.requestHeaders['Content-Type'].should.equal('text/plain');
       let payload = {
         puts: [{
           type: 'xml',
@@ -295,7 +295,7 @@ describe('The video cache', function () {
       const request = server.requests[0];
       request.method.should.equal('POST');
       request.url.should.equal('https://prebid.adnxs.com/pbc/v1/cache');
-      request.requestHeaders['Content-Type'].should.equal('text/plain;charset=utf-8');
+      request.requestHeaders['Content-Type'].should.equal('text/plain');
       let payload = {
         puts: [{
           type: 'xml',
@@ -356,7 +356,7 @@ describe('The video cache', function () {
       const request = server.requests[0];
       request.method.should.equal('POST');
       request.url.should.equal('https://prebid.adnxs.com/pbc/v1/cache');
-      request.requestHeaders['Content-Type'].should.equal('text/plain;charset=utf-8');
+      request.requestHeaders['Content-Type'].should.equal('text/plain');
 
       JSON.parse(request.requestBody).should.deep.equal({
         puts: [{