prebid.js 5.18.0 → 6.1.0

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': {}
                   }
@@ -1334,6 +1335,20 @@ describe('AppNexusAdapter', function () {
       expect(Object.keys(result[0].meta)).to.include.members(['advertiserId']);
     });
 
+    it('should add brand id', function() {
+      let responseBrandId = deepClone(response);
+      responseBrandId.tags[0].ads[0].brand_id = 123;
+
+      let bidderRequest = {
+        bids: [{
+          bidId: '3db3773286ee59',
+          adUnitCode: 'code'
+        }]
+      }
+      let result = spec.interpretResponse({ body: responseBrandId }, {bidderRequest});
+      expect(Object.keys(result[0].meta)).to.include.members(['brandId']);
+    });
+
     it('should add advertiserDomains', function() {
       let responseAdvertiserId = deepClone(response);
       responseAdvertiserId.tags[0].ads[0].adomain = ['123'];

package/test/spec/modules/atsAnalyticsAdapter_spec.js

@@ -12,11 +12,15 @@ 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 () {
@@ -25,18 +29,20 @@ describe('ats analytics adapter', function () {
     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'
       };
@@ -62,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 = {
@@ -90,7 +96,7 @@ describe('ats analytics adapter', function () {
       let expectedAfterBid = {
         'Data': [{
           'has_envelope': true,
-          'adapter_version': 2,
+          'adapter_version': 3,
           'bidder': 'appnexus',
           'bid_id': '30c77d079cdf17',
           'auction_id': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
@@ -103,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 = [
         {
@@ -148,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;
@@ -156,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');
@@ -204,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 () {

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: [{

package/test/spec/modules/browsiRtdProvider_spec.js

@@ -1,5 +1,6 @@
 import * as browsiRTD from '../../../modules/browsiRtdProvider.js';
 import {makeSlot} from '../integration/faker/googletag.js';
+import * as utils from '../../../src/utils'
 
 describe('browsi Real time  data sub module', function () {
   const conf = {
@@ -29,11 +30,11 @@ describe('browsi Real time  data sub module', function () {
   });
 
   it('should match placement with ad unit', function () {
-    const slot = makeSlot({code: '/57778053/Browsi_Demo_300x250', divId: 'browsiAd_1'});
+    const slot = makeSlot({code: '/123/abc', divId: 'browsiAd_1'});
 
-    const test1 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_300x250']); // true
-    const test2 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_300x250', '/57778053/Browsi']); // true
-    const test3 = browsiRTD.isIdMatchingAdUnit(slot, ['/57778053/Browsi_Demo_Low']); // false
+    const test1 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/abc']); // true
+    const test2 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/abc', '/456/def']); // true
+    const test3 = browsiRTD.isIdMatchingAdUnit(slot, ['/123/def']); // false
     const test4 = browsiRTD.isIdMatchingAdUnit(slot, []); // true
 
     expect(test1).to.equal(true);
@@ -43,12 +44,12 @@ describe('browsi Real time  data sub module', function () {
   });
 
   it('should return correct macro values', function () {
-    const slot = makeSlot({code: '/57778053/Browsi_Demo_300x250', divId: 'browsiAd_1'});
+    const slot = makeSlot({code: '/123/abc', divId: 'browsiAd_1'});
 
     slot.setTargeting('test', ['test', 'value']);
     // slot getTargeting doesn't act like GPT so we can't expect real value
     const macroResult = browsiRTD.getMacroId({p: '<AD_UNIT>/<KEY_test>'}, slot);
-    expect(macroResult).to.equal('/57778053/Browsi_Demo_300x250/NA');
+    expect(macroResult).to.equal('/123/abc/NA');
 
     const macroResultB = browsiRTD.getMacroId({}, slot);
     expect(macroResultB).to.equal('browsiAd_1');
@@ -72,7 +73,7 @@ describe('browsi Real time  data sub module', function () {
     it('should return prediction from server', function () {
       makeSlot({code: 'hasPrediction', divId: 'hasPrediction'});
       const data = {
-        p: {'hasPrediction': {p: 0.234}},
+        p: {'hasPrediction': {ps: {0: 0.234}}},
         kn: 'bv',
         pmd: undefined
       };
@@ -80,4 +81,58 @@ describe('browsi Real time  data sub module', function () {
       expect(browsiRTD.browsiSubmodule.getTargetingData(['hasPrediction'])).to.eql({hasPrediction: {bv: '0.20'}});
     })
   })
+
+  describe('should return matching prediction', function () {
+    const predictions = {
+      0: 0.123,
+      1: 0.254,
+      3: 0,
+      4: 0.8
+    }
+    const singlePrediction = {
+      0: 0.123
+    }
+    it('should return raw value if valid', function () {
+      expect(browsiRTD.getCurrentData(predictions, 0)).to.equal(0.123);
+      expect(browsiRTD.getCurrentData(predictions, 1)).to.equal(0.254);
+    })
+    it('should return 0 for prediction = 0', function () {
+      expect(browsiRTD.getCurrentData(predictions, 3)).to.equal(0);
+    })
+    it('should return -1 for invalid params', function () {
+      expect(browsiRTD.getCurrentData(null, 3)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(predictions, null)).to.equal(-1);
+    })
+    it('should return prediction according to object keys length ', function () {
+      expect(browsiRTD.getCurrentData(singlePrediction, 0)).to.equal(0.123);
+      expect(browsiRTD.getCurrentData(singlePrediction, 1)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(singlePrediction, 2)).to.equal(-1);
+      expect(browsiRTD.getCurrentData(predictions, 4)).to.equal(0.8);
+      expect(browsiRTD.getCurrentData(predictions, 5)).to.equal(0.8);
+      expect(browsiRTD.getCurrentData(predictions, 8)).to.equal(0.8);
+    })
+  })
+  describe('should set bid request data', function () {
+    const data = {
+      p: {
+        'adUnit1': {ps: {0: 0.234}},
+        'adUnit2': {ps: {0: 0.134}}},
+      kn: 'bv',
+      pmd: undefined
+    };
+    browsiRTD.setData(data);
+    const fakeAdUnits = [
+      {
+        code: 'adUnit1'
+      },
+      {
+        code: 'adUnit2'
+      }
+    ]
+    browsiRTD.browsiSubmodule.getBidRequestData({adUnits: fakeAdUnits}, () => {}, {}, null);
+    it('should set ad unit params with prediction values', function () {
+      expect(utils.deepAccess(fakeAdUnits[0], 'ortb2Imp.ext.data.browsi')).to.eql({bv: '0.20'});
+      expect(utils.deepAccess(fakeAdUnits[1], 'ortb2Imp.ext.data.browsi')).to.eql({bv: '0.10'});
+    })
+  })
 });