prebid.js 5.16.0 → 5.20.0

package/test/spec/modules/adnuntiusBidAdapter_spec.js

@@ -185,6 +185,74 @@ describe('adnuntiusBidAdapter', function () {
     });
   });
 
+  describe('user privacy', function () {
+    it('should send GDPR Consent data if gdprApplies', function () {
+      let request = spec.buildRequests(bidRequests, { gdprConsent: { gdprApplies: true, consentString: 'consentString' } });
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL_CONSENT);
+    });
+
+    it('should not send GDPR Consent data if gdprApplies equals undefined', function () {
+      let request = spec.buildRequests(bidRequests, { gdprConsent: { gdprApplies: undefined, consentString: 'consentString' } });
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL);
+    });
+
+    it('should pass segments if available in config', function () {
+      config.setBidderConfig({
+        bidders: ['adnuntius', 'other'],
+        config: {
+          ortb2: {
+            user: {
+              data: [{
+                name: 'adnuntius',
+                segment: [{ id: 'segment1' }, { id: 'segment2' }]
+              },
+              {
+                name: 'other',
+                segment: ['segment3']
+              }],
+            }
+          }
+        }
+      });
+
+      const request = config.runWithBidder('adnuntius', () => spec.buildRequests(bidRequests));
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL_SEGMENTS);
+    });
+
+    it('should skip segments in config if not either id or array of strings', function () {
+      config.setBidderConfig({
+        bidders: ['adnuntius', 'other'],
+        config: {
+          ortb2: {
+            user: {
+              data: [{
+                name: 'adnuntius',
+                segment: [{ id: 'segment1' }, { id: 'segment2' }, { id: 'segment3' }]
+              },
+              {
+                name: 'other',
+                segment: [{
+                  notright: 'segment4'
+                }]
+              }],
+            }
+          }
+        }
+      });
+
+      const request = config.runWithBidder('adnuntius', () => spec.buildRequests(bidRequests));
+      expect(request.length).to.equal(1);
+      expect(request[0]).to.have.property('url')
+      expect(request[0].url).to.equal(ENDPOINT_URL_SEGMENTS);
+    });
+  });
+
   describe('user privacy', function () {
     it('should send GDPR Consent data if gdprApplies', function () {
       let request = spec.buildRequests(bidRequests, { gdprConsent: { gdprApplies: true, consentString: 'consentString' } });

package/test/spec/modules/adtelligentBidAdapter_spec.js

@@ -17,6 +17,7 @@ const aliasEP = {
   mediafuse: 'https://ghb.hbmp.mediafuse.com/v2/auction/',
   navelix: 'https://ghb.hb.navelix.com/v2/auction/',
   bidsxchange: 'https://ghb.hbd.bidsxchange.com/v2/auction/',
+  streamkey: 'https://ghb.hb.streamkey.net/v2/auction/',
 };
 
 const DEFAULT_ADATPER_REQ = { bidderCode: 'adtelligent' };

package/test/spec/modules/akamaiDapRtdProvider_spec.js

@@ -0,0 +1,246 @@
+import {config} from 'src/config.js';
+import {SEGMENTS_STORAGE_KEY, TOKEN_STORAGE_KEY, dapUtils, addRealTimeData, getRealTimeData, akamaiDapRtdSubmodule, storage} from 'modules/akamaiDapRtdProvider.js';
+import {server} from 'test/mocks/xhr.js';
+import logMessage from 'src/utils.js'
+const responseHeader = {'Content-Type': 'application/json'};
+
+describe('akamaiDapRtdProvider', function() {
+  let getDataFromLocalStorageStub;
+  let getDapTokenStub;
+
+  const testReqBidsConfigObj = {
+    adUnits: [
+      {
+        bids: ['bid1', 'bid2']
+      }
+    ]
+  };
+
+  const onDone = function() { return true };
+
+  const onSuccess = function() { return ('request', 200, 'success') };
+
+  const cmoduleConfig = {
+    'name': 'dap',
+    'waitForIt': true,
+    'params': {
+      'apiHostname': 'prebid.dap.akadns.net',
+      'apiVersion': 'x1',
+      'domain': 'prebid.org',
+      'identityType': 'dap-signature:1.0.0',
+      'segtax': 503,
+      'tokenTtl': 5
+    }
+  }
+
+  const sampleConfig = {
+    'api_hostname': 'prebid.dap.akadns.net',
+    'api_version': 'x1',
+    'domain': 'prebid.org',
+    'segtax': 503
+  }
+  const sampleIdentity = {
+    type: 'dap-signature:1.0.0'
+  };
+
+  beforeEach(function() {
+    config.resetConfig();
+    getDataFromLocalStorageStub = sinon.stub(storage, 'getDataFromLocalStorage')
+  });
+
+  afterEach(function () {
+    getDataFromLocalStorageStub.restore();
+  });
+
+  describe('akamaiDapRtdSubmodule', function() {
+    it('successfully instantiates', function () {
+		  expect(akamaiDapRtdSubmodule.init()).to.equal(true);
+    });
+  });
+
+  describe('Get Real-Time Data', function() {
+    it('gets rtd from local storage cache', function() {
+      const rtdConfig = {
+        params: {
+          segmentCache: true
+        }
+      };
+
+      const bidConfig = {};
+
+      const rtdUserObj1 = {
+        name: 'www.dataprovider3.com',
+        ext: {
+          taxonomyname: 'iab_audience_taxonomy'
+        },
+        segment: [
+          {
+            id: '1918'
+          },
+          {
+            id: '1939'
+          }
+        ]
+      };
+
+      const cachedRtd = {
+        rtd: {
+          ortb2: {
+            user: {
+              data: [rtdUserObj1]
+            }
+          }
+        }
+      };
+
+      getDataFromLocalStorageStub.withArgs(SEGMENTS_STORAGE_KEY).returns(JSON.stringify(cachedRtd));
+
+      expect(config.getConfig().ortb2).to.be.undefined;
+      getRealTimeData(bidConfig, () => {}, rtdConfig, {});
+      expect(config.getConfig().ortb2.user.data).to.deep.include.members([rtdUserObj1]);
+    });
+
+    it('should initalise and return with config', function () {
+      expect(getRealTimeData(testReqBidsConfigObj, onDone, cmoduleConfig)).to.equal(undefined)
+    });
+  });
+
+  describe('dapTokenize', function () {
+    it('dapTokenize error callback', function () {
+      let configAsync = JSON.parse(JSON.stringify(sampleConfig));
+      let submoduleCallback = dapUtils.dapTokenize(configAsync, sampleIdentity,
+        function(token, status, xhr) {
+        },
+        function(xhr, status, error) {
+        }
+      );
+      let request = server.requests[0];
+      request.respond(400, responseHeader, JSON.stringify('error'));
+      expect(submoduleCallback).to.equal(undefined);
+    });
+
+    it('dapTokenize success callback', function () {
+      let configAsync = JSON.parse(JSON.stringify(sampleConfig));
+      let submoduleCallback = dapUtils.dapTokenize(configAsync, sampleIdentity,
+        function(token, status, xhr) {
+        },
+        function(xhr, status, error) {
+        }
+      );
+      let request = server.requests[0];
+      request.respond(200, responseHeader, JSON.stringify('success'));
+      expect(submoduleCallback).to.equal(undefined);
+    });
+  });
+
+  describe('dapTokenize and dapMembership incorrect params', function () {
+    it('Onerror and config are null', function () {
+      expect(dapUtils.dapTokenize(null, 'identity', null, null)).to.be.equal(undefined);
+      expect(dapUtils.dapMembership(null, 'identity', null, null)).to.be.equal(undefined);
+      const config = {
+        'api_hostname': 'prebid.dap.akadns.net',
+        'api_version': 1,
+        'domain': '',
+        'segtax': 503
+      };
+      let identity = {
+        type: 'dap-signature:1.0.0'
+      };
+      expect(dapUtils.dapTokenize(config, identity, null, null)).to.be.equal(undefined);
+      expect(dapUtils.dapMembership(config, 'token', null, null)).to.be.equal(undefined);
+    });
+
+    it('dapGetToken success', function () {
+      let dapTokenizeStub = sinon.stub(dapUtils, 'dapTokenize').returns(onSuccess);
+      expect(dapUtils.dapGetToken(sampleConfig, 'token',
+        function(token, status, xhr) {
+        },
+        function(xhr, status, error) {
+        }
+      )).to.be.equal(null);
+      dapTokenizeStub.restore();
+    });
+  });
+
+  describe('dapMembership', function () {
+    it('dapMembership success callback', function () {
+      let configAsync = JSON.parse(JSON.stringify(sampleConfig));
+      let submoduleCallback = dapUtils.dapMembership(configAsync, 'token',
+        function(token, status, xhr) {
+        },
+        function(xhr, status, error) {
+        }
+      );
+      let request = server.requests[0];
+      request.respond(200, responseHeader, JSON.stringify('success'));
+      expect(submoduleCallback).to.equal(undefined);
+    });
+
+    it('dapMembership error callback', function () {
+      let configAsync = JSON.parse(JSON.stringify(sampleConfig));
+      let submoduleCallback = dapUtils.dapMembership(configAsync, 'token',
+        function(token, status, xhr) {
+        },
+        function(xhr, status, error) {
+        }
+      );
+      let request = server.requests[0];
+      request.respond(400, responseHeader, JSON.stringify('error'));
+      expect(submoduleCallback).to.equal(undefined);
+    });
+  });
+
+  describe('dapMembership', function () {
+    it('should invoke the getDapToken and getDapMembership', function () {
+      let config = {
+        api_hostname: cmoduleConfig.params.apiHostname,
+        api_version: cmoduleConfig.params.apiVersion,
+        domain: cmoduleConfig.params.domain,
+        segtax: cmoduleConfig.params.segtax
+      };
+      let identity = {
+        type: cmoduleConfig.params.identityType
+      };
+
+      let membership = {
+        said: 'item.said1',
+        cohorts: 'item.cohorts',
+        attributes: null
+      };
+
+      let getDapTokenStub = sinon.stub(dapUtils, 'dapGetToken').returns('token3');
+      let getDapMembershipStub = sinon.stub(dapUtils, 'dapGetMembership').returns(membership);
+      let dapTokenizeStub = sinon.stub(dapUtils, 'dapTokenize').returns('response', 200, 'request');
+      getRealTimeData(testReqBidsConfigObj, onDone, cmoduleConfig);
+      expect(getDapTokenStub.calledOnce).to.be.equal(true);
+      expect(getDapMembershipStub.calledOnce).to.be.equal(true);
+      getDapTokenStub.restore();
+      getDapMembershipStub.restore();
+      dapTokenizeStub.restore();
+    });
+  });
+
+  describe('dapMembershipToRtbSegment', function () {
+    it('dapMembershipToRtbSegment', function () {
+      let membership1 = {
+        said: 'item.said1',
+        cohorts: 'item.cohorts',
+        attributes: null
+      };
+      const config = {
+        apiHostname: 'prebid.dap.akadns.net',
+        apiVersion: 'x1',
+        domain: 'prebid.org',
+        tokenTtl: 5,
+        segtax: 503
+      };
+      let identity = {
+        type: 'dap-signature:1.0.0'
+      };
+
+      expect(dapUtils.dapGetMembership(config, 'token')).to.equal(null)
+      const membership = {cohorts: ['1', '5', '7']}
+      expect(dapUtils.dapMembershipToRtbSegment(membership, config)).to.not.equal(undefined);
+    });
+  });
+});

package/test/spec/modules/appnexusBidAdapter_spec.js

@@ -1047,7 +1047,8 @@ describe('AppNexusAdapter', function () {
                 'trackers': [
                   {
                     'impression_urls': [
-                      'https://lax1-ib.adnxs.com/impression'
+                      'https://lax1-ib.adnxs.com/impression',
+                      'https://www.test.com/tracker'
                     ],
                     'video_events': {}
                   }

package/test/spec/modules/atsAnalyticsAdapter_spec.js

@@ -5,16 +5,22 @@ import {server} from '../../mocks/xhr.js';
 import {parseBrowser} from '../../../modules/atsAnalyticsAdapter.js';
 import {getStorageManager} from '../../../src/storageManager.js';
 import {analyticsUrl} from '../../../modules/atsAnalyticsAdapter.js';
+let utils = require('src/utils');
 
 let events = require('src/events');
 let constants = require('src/constants.json');
 
 export const storage = getStorageManager();
+let sandbox;
+let clock;
+let now = new Date();
 
 describe('ats analytics adapter', function () {
   beforeEach(function () {
     sinon.stub(events, 'getEvents').returns([]);
     storage.setCookie('_lr_env_src_ats', 'true', 'Thu, 01 Jan 1970 00:00:01 GMT');
+    sandbox = sinon.sandbox.create();
+    clock = sandbox.useFakeTimers(now.getTime());
   });
 
   afterEach(function () {
@@ -22,18 +28,21 @@ describe('ats analytics adapter', function () {
     atsAnalyticsAdapter.getUserAgent.restore();
     atsAnalyticsAdapter.disableAnalytics();
     Math.random.restore();
+    sandbox.restore();
+    clock.restore();
   });
 
   describe('track', function () {
     it('builds and sends request and response data', function () {
       sinon.stub(Math, 'random').returns(0.99);
-      sinon.stub(atsAnalyticsAdapter, 'shouldFireRequest').returns(true);
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
-      let now = new Date();
+
       now.setTime(now.getTime() + 3600000);
       storage.setCookie('_lr_env_src_ats', 'true', now.toUTCString());
       storage.setCookie('_lr_sampling_rate', '10', now.toUTCString());
 
+      this.timeout(2100);
+
       let initOptions = {
         pid: '10433394'
       };
@@ -59,7 +68,7 @@ describe('ats analytics adapter', function () {
         'refererInfo': {
           'referer': 'https://example.com/dev'
         },
-        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
+        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7'
       };
       // prepare general auction - response
       let bidResponse = {
@@ -87,7 +96,7 @@ describe('ats analytics adapter', function () {
       let expectedAfterBid = {
         'Data': [{
           'has_envelope': true,
-          'adapter_version': 1,
+          'adapter_version': 3,
           'bidder': 'appnexus',
           'bid_id': '30c77d079cdf17',
           'auction_id': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
@@ -100,10 +109,30 @@ describe('ats analytics adapter', function () {
           'response_time_stamp': '2020-02-03T14:23:11.978Z',
           'currency': 'USD',
           'cpm': 0.5,
-          'net_revenue': true
+          'net_revenue': true,
+          'bid_won': true
         }]
       };
 
+      let wonRequest = {
+        'adId': '2eddfdc0c791dc',
+        'mediaType': 'banner',
+        'requestId': '30c77d079cdf17',
+        'cpm': 0.5,
+        'creativeId': 29681110,
+        'currency': 'USD',
+        'netRevenue': true,
+        'ttl': 300,
+        'auctionId': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
+        'statusMessage': 'Bid available',
+        'responseTimestamp': 1633525319061,
+        'requestTimestamp': 1633525319258,
+        'bidder': 'appnexus',
+        'adUnitCode': 'div-gpt-ad-1438287399331-0',
+        'size': '300x250',
+        'status': 'rendered'
+      };
+
       // lets simulate that some bidders timeout
       let bidTimeoutArgsV1 = [
         {
@@ -145,6 +174,14 @@ describe('ats analytics adapter', function () {
 
       // Step 5: Send auction end event
       events.emit(constants.EVENTS.AUCTION_END, {});
+      // Step 6: Send bid won event
+      events.emit(constants.EVENTS.BID_WON, wonRequest);
+
+      sandbox.stub($$PREBID_GLOBAL$$, 'getAllWinningBids').callsFake((key) => {
+        return [wonRequest]
+      });
+
+      clock.tick(2000);
 
       let requests = server.requests.filter(req => {
         return req.url.indexOf(analyticsUrl) > -1;
@@ -153,13 +190,12 @@ describe('ats analytics adapter', function () {
       expect(requests.length).to.equal(1);
 
       let realAfterBid = JSON.parse(requests[0].requestBody);
-      // Step 6: assert real data after bid and expected data
+
+      // Step 7: assert real data after bid and expected data
       expect(realAfterBid['Data']).to.deep.equal(expectedAfterBid['Data']);
 
       // check that the publisher ID is configured via options
       expect(atsAnalyticsAdapter.context.pid).to.equal(initOptions.pid);
-
-      atsAnalyticsAdapter.shouldFireRequest.restore();
     })
     it('check browser is safari', function () {
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
@@ -185,6 +221,12 @@ describe('ats analytics adapter', function () {
       let browser = parseBrowser();
       expect(browser).to.equal('Firefox');
     })
+    it('check browser is unknown', function () {
+      sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns(undefined);
+      sinon.stub(Math, 'random').returns(0.99);
+      let browser = parseBrowser();
+      expect(browser).to.equal('Unknown');
+    })
     it('should not fire analytics request if sampling rate is 0', function () {
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
       sinon.stub(Math, 'random').returns(0.99);
@@ -195,7 +237,7 @@ describe('ats analytics adapter', function () {
       sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
       sinon.stub(Math, 'random').returns(0.99);
       // publisher can try to pass anything they want but we will set sampling rate to 100, which means we will have 1% of requests
-      let result = atsAnalyticsAdapter.shouldFireRequest(10);
+      let result = atsAnalyticsAdapter.shouldFireRequest(8);
       expect(result).to.equal(true);
     })
     it('should not fire analytics request if math random is something other then 0.99', function () {
@@ -205,5 +247,31 @@ describe('ats analytics adapter', function () {
       let result = atsAnalyticsAdapter.shouldFireRequest(10);
       expect(result).to.equal(false);
     })
+
+    it('should set cookie value to 10 for _lr_sampling_rate', function () {
+      sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
+      sinon.stub(Math, 'random').returns(0.99);
+      atsAnalyticsAdapter.setSamplingCookie(10);
+      let samplingRate = storage.getCookie('_lr_sampling_rate');
+      expect(samplingRate).to.equal('10');
+    })
+
+    it('should set cookie value to 0 for _lr_sampling_rate', function () {
+      sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
+      sinon.stub(Math, 'random').returns(0.99);
+      atsAnalyticsAdapter.setSamplingCookie(0);
+      let samplingRate = storage.getCookie('_lr_sampling_rate');
+      expect(samplingRate).to.equal('0');
+    })
+
+    it('enable analytics', function () {
+      sandbox.stub(utils, 'logError');
+      sinon.stub(atsAnalyticsAdapter, 'getUserAgent').returns('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25');
+      sinon.stub(Math, 'random').returns(0.99);
+      atsAnalyticsAdapter.enableAnalytics({
+        options: {}
+      });
+      expect(utils.logError.called).to.equal(true);
+    })
   })
 })

package/test/spec/modules/betweenBidAdapter_spec.js

@@ -23,6 +23,32 @@ describe('betweenBidAdapterTests', function () {
     let req_data = JSON.parse(request.data)[0].data;
     expect(req_data.bidid).to.equal('bid1234');
   });
+
+  it('validate_video_params', function () {
+    let bidRequestData = [{
+      bidId: 'bid1234',
+      bidder: 'between',
+      params: {w: 240, h: 400, s: 1112},
+      mediaTypes: {
+        video: {
+          context: 'outstream',
+          playerSize: [970, 250],
+          maxd: 123,
+          mind: 234,
+          codeType: 'unknown code type'
+        }
+      },
+    }];
+    let request = spec.buildRequests(bidRequestData);
+    let req_data = JSON.parse(request.data)[0].data;
+
+    expect(req_data.mediaType).to.equal(2);
+    expect(req_data.maxd).to.equal(123);
+    expect(req_data.mind).to.equal(234);
+    expect(req_data.pos).to.equal('atf');
+    expect(req_data.codeType).to.equal('inpage');
+  });
+
   it('validate itu param', function() {
     let bidRequestData = [{
       bidId: 'bid1234',
@@ -230,6 +256,21 @@ describe('betweenBidAdapterTests', function () {
     expect(bid.requestId).to.equal('bid1234');
     expect(bid.ad).to.equal('Ad html');
   });
+
+  it('validate_response_video_params', function () {
+    let serverResponse = {
+      body: [{
+        mediaType: 2,
+        vastXml: 'vastXml',
+      }]
+    };
+    let bids = spec.interpretResponse(serverResponse);
+    expect(bids).to.have.lengthOf(1);
+    let bid = bids[0];
+    expect(bid.mediaType).to.equal(2);
+    expect(bid.vastXml).to.equal('vastXml');
+  });
+
   it('validate response params without currency', function () {
     let serverResponse = {
       body: [{