prebid.js 5.14.0 → 5.18.0

package/test/spec/modules/adqueryBidAdapter_spec.js

@@ -0,0 +1,185 @@
+import { expect } from 'chai'
+import { spec } from 'modules/adqueryBidAdapter.js'
+import { newBidder } from 'src/adapters/bidderFactory.js'
+import * as utils from '../../../src/utils';
+
+describe('adqueryBidAdapter', function () {
+  const adapter = newBidder(spec)
+  let bidRequest = {
+    bidder: 'adquery',
+    params: {
+      placementId: '6d93f2a0e5f0fe2cc3a6e9e3ade964b43b07f897',
+      type: 'banner300x250'
+    },
+    mediaTypes: {
+      banner: {
+        sizes: [[300, 250]],
+      }
+    }
+  }
+
+  let expectedResponse = {
+    'body': {
+      'data':
+        {
+          'requestId': 1,
+          'emission_id': 1,
+          'eventTracker': 'https://example.com',
+          'externalEmissionCodes': 'https://example.com',
+          'impressionTracker': 'https://example.com',
+          'viewabilityTracker': 'https://example.com',
+          'clickTracker': 'https://example.com',
+          'link': 'https://example.com',
+          'logo': 'https://example.com',
+          'medias': [
+            {
+              'src': 'banner/2021-04-09/938',
+              'ext': 'zip',
+              'type': 3,
+            }
+          ],
+          'domain': 'https://example.com',
+          'urlAdq': 'https://example.com',
+          'creationId': 1,
+          'currency': 'PLN',
+          'adDomains': ['https://example.com'],
+          'tag': '<ad-adquery data-type="banner300x250"  data-placement="6d93f2a0e5f0fe2cc3a6e9e3ade964b43b07f897"> </ad-adquery>',
+          'adqLib': 'https://example.com/js/example.js',
+          'mediaType': {'width': 300, 'height': 250, 'name': 'banner', 'type': 'banner300x250'},
+          'cpm': 2.5,
+          'meta': {
+            'advertiserDomains': ['example.com'],
+            'mediaType': 'banner',
+          }
+        }
+    }
+  }
+  describe('codes', function () {
+    it('should return a bidder code of adquery', function () {
+      expect(spec.code).to.equal('adquery')
+    })
+  })
+
+  describe('isBidRequestValid', function () {
+    let inValidBid = Object.assign({}, bidRequest)
+    delete inValidBid.params
+    it('should return true if all params present', function () {
+      expect(spec.isBidRequestValid(bidRequest)).to.equal(true)
+    })
+
+    it('should return false if any parameter missing', function () {
+      expect(spec.isBidRequestValid(inValidBid)).to.be.false
+    })
+  })
+
+  describe('buildRequests', function () {
+    let req = spec.buildRequests([ bidRequest ], { refererInfo: { } })[0]
+    let rdata
+
+    it('should return request object', function () {
+      expect(req).to.not.be.null
+    })
+
+    it('should build request data', function () {
+      expect(req.data).to.not.be.null
+    })
+
+    it('should include one request', function () {
+      rdata = req.data;
+      expect(rdata.data).to.not.be.null
+    })
+
+    it('should include placementCode', function () {
+      expect(rdata.placementCode).not.be.null
+    })
+
+    it('should include qid', function () {
+      expect(rdata.qid).not.be.null
+    })
+
+    it('should include type', function () {
+      expect(rdata.type !== null).not.be.null
+    })
+
+    it('should include all publisher params', function () {
+      expect(rdata.type !== null && rdata.placementCode !== null).to.be.true
+    })
+
+    it('should include bidder', function () {
+      expect(rdata.bidder !== null).to.be.true
+    })
+  })
+
+  describe('interpretResponse', function () {
+    it('should get the correct bid response', function () {
+      let result = spec.interpretResponse(expectedResponse)
+      expect(result).to.be.an('array')
+    })
+
+    it('validate response params', function() {
+      const newResponse = spec.interpretResponse(expectedResponse, bidRequest);
+      expect(newResponse[0].requestId).to.be.equal(1)
+    });
+    it('handles empty bid response', function () {
+      let response = {
+        body: {}
+      };
+      let result = spec.interpretResponse(response);
+      expect(result.length).to.equal(0);
+    })
+  })
+
+  describe('getUserSyncs', function () {
+    it('should return iframe sync', function () {
+      let sync = spec.getUserSyncs()
+      expect(sync.length).to.equal(1)
+      expect(sync[0].type === 'iframe')
+      expect(typeof sync[0].url === 'string')
+    })
+
+    it('Should return array of objects with proper sync config , include GDPR', function() {
+      const syncData = spec.getUserSyncs({}, {}, {
+        consentString: 'ALL',
+        gdprApplies: true,
+      }, {});
+      expect(syncData).to.be.an('array').which.is.not.empty;
+      expect(syncData[0]).to.be.an('object')
+      expect(syncData[0].type).to.be.a('string')
+      expect(syncData[0].type).to.equal('image')
+    });
+  })
+
+  describe('test onBidWon function', function () {
+    beforeEach(function() {
+      sinon.stub(utils, 'triggerPixel');
+    });
+    afterEach(function() {
+      utils.triggerPixel.restore();
+    });
+    it('exists and is a function', () => {
+      expect(spec.onBidWon).to.exist.and.to.be.a('function');
+    });
+    it('should return nothing', function () {
+      var response = spec.onBidWon({});
+      expect(response).to.be.an('undefined')
+      expect(utils.triggerPixel.called).to.equal(true);
+    });
+  })
+
+  describe('onTimeout', function () {
+    const timeoutData = [{
+      timeout: null
+    }];
+
+    it('should exists and be a function', () => {
+      expect(spec.onTimeout).to.exist.and.to.be.a('function');
+    });
+    it('should include timeoutData', function () {
+      expect(spec.onTimeout(timeoutData)).to.be.undefined;
+    })
+  });
+
+  it(`onSetTargeting is present and type function`, function () {
+    expect(spec.onSetTargeting).to.exist.and.to.be.a('function')
+  });
+})

package/test/spec/modules/afpBidAdapter_spec.js

@@ -0,0 +1,306 @@
+import includes from 'core-js-pure/features/array/includes.js'
+import cloneDeep from 'lodash/cloneDeep'
+import unset from 'lodash/unset'
+import { expect } from 'chai'
+import { BANNER, VIDEO } from '../../../src/mediaTypes.js'
+import {
+  spec,
+  IN_IMAGE_BANNER_TYPE,
+  IN_IMAGE_MAX_BANNER_TYPE,
+  IN_CONTENT_BANNER_TYPE,
+  IN_CONTENT_VIDEO_TYPE,
+  OUT_CONTENT_VIDEO_TYPE,
+  IN_CONTENT_STORY_TYPE,
+  ACTION_SCROLLER_TYPE,
+  ACTION_SCROLLER_LIGHT_TYPE,
+  JUST_BANNER_TYPE,
+  BIDDER_CODE,
+  SSP_ENDPOINT,
+  REQUEST_METHOD,
+  TEST_PAGE_URL,
+  IS_DEV, mediaTypeByPlaceType
+} from 'modules/afpBidAdapter.js'
+
+const placeId = '613221112871613d1517d181'
+const bidId = '2a67c5577ff6a5'
+const transactionId = '7e8515a2-2ed9-4733-b976-6c2596a03287'
+const imageUrl = 'https://rtbinsight.ru/content/images/size/w1000/2021/05/ximage-30.png.pagespeed.ic.IfuX4zAEPP.png'
+const placeContainer = '#container'
+const imageWidth = 600
+const imageHeight = 400
+const pageUrl = IS_DEV ? TEST_PAGE_URL : 'referer'
+const sizes = [[imageWidth, imageHeight]]
+const bidderRequest = {
+  refererInfo: { referer: pageUrl },
+}
+const mediaTypeBanner = { [BANNER]: {sizes: [[imageWidth, imageHeight]]} }
+const mediaTypeVideo = { [VIDEO]: {playerSize: [[imageWidth, imageHeight]]} }
+const commonParams = {
+  placeId,
+  placeContainer,
+}
+const commonParamsForInImage = Object.assign({}, commonParams, {
+  imageUrl,
+  imageWidth,
+  imageHeight,
+})
+const configByPlaceType = {
+  get [IN_IMAGE_BANNER_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParamsForInImage, {
+        placeType: IN_IMAGE_BANNER_TYPE
+      }),
+    })
+  },
+  get [IN_IMAGE_MAX_BANNER_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParamsForInImage, {
+        placeType: IN_IMAGE_MAX_BANNER_TYPE
+      }),
+    })
+  },
+  get [IN_CONTENT_BANNER_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParams, {
+        placeType: IN_CONTENT_BANNER_TYPE
+      }),
+    })
+  },
+  get [IN_CONTENT_VIDEO_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeVideo,
+      params: Object.assign({}, commonParams, {
+        placeType: IN_CONTENT_VIDEO_TYPE
+      }),
+    })
+  },
+  get [OUT_CONTENT_VIDEO_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeVideo,
+      params: Object.assign({}, commonParams, {
+        placeType: OUT_CONTENT_VIDEO_TYPE
+      }),
+    })
+  },
+  get [IN_CONTENT_STORY_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParams, {
+        placeType: IN_CONTENT_STORY_TYPE
+      }),
+    })
+  },
+  get [ACTION_SCROLLER_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParams, {
+        placeType: ACTION_SCROLLER_TYPE
+      }),
+    })
+  },
+  get [ACTION_SCROLLER_LIGHT_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParams, {
+        placeType: ACTION_SCROLLER_LIGHT_TYPE
+      }),
+    })
+  },
+  get [JUST_BANNER_TYPE]() {
+    return cloneDeep({
+      mediaTypes: mediaTypeBanner,
+      params: Object.assign({}, commonParams, {
+        placeType: JUST_BANNER_TYPE
+      }),
+    })
+  },
+}
+const getTransformedConfig = ({mediaTypes, params}) => {
+  return {
+    params: params,
+    sizes,
+    bidId,
+    bidder: BIDDER_CODE,
+    mediaTypes: mediaTypes,
+    transactionId,
+  }
+}
+const validBidRequests = Object.keys(configByPlaceType).map(key => getTransformedConfig(configByPlaceType[key]))
+
+describe('AFP Adapter', function() {
+  describe('isBidRequestValid method', function() {
+    describe('returns true', function() {
+      describe('when config has all mandatory params', () => {
+        Object.keys(configByPlaceType).forEach(placeType => {
+          it(`and ${placeType} config has the correct value`, function() {
+            const isBidRequestValid = spec.isBidRequestValid(configByPlaceType[placeType])
+            expect(isBidRequestValid).to.equal(true)
+          })
+        })
+      })
+    })
+    describe('returns false', function() {
+      const checkMissingParams = (placesTypes, missingParams) =>
+        placesTypes.forEach(placeType =>
+          missingParams.forEach(missingParam => {
+            const config = configByPlaceType[placeType]
+            it(`${placeType} does not have the ${missingParam}.`, function() {
+              unset(config, missingParam)
+              const isBidRequestValid = spec.isBidRequestValid(config)
+              expect(isBidRequestValid).to.equal(false)
+            })
+          })
+        )
+
+      describe('when params are not correct', function() {
+        checkMissingParams(Object.keys(configByPlaceType), ['params.placeId', 'params.placeType'])
+        checkMissingParams([IN_IMAGE_BANNER_TYPE, IN_IMAGE_MAX_BANNER_TYPE],
+          ['params.imageUrl', 'params.imageWidth', 'params.imageHeight'])
+
+        it('does not have a the correct placeType.', function() {
+          const config = configByPlaceType[IN_IMAGE_BANNER_TYPE]
+          config.params.placeType = 'something'
+          const isBidRequestValid = spec.isBidRequestValid(config)
+          expect(isBidRequestValid).to.equal(false)
+        })
+      })
+      describe('when video mediaType object is not correct.', function() {
+        checkMissingParams([IN_CONTENT_VIDEO_TYPE, OUT_CONTENT_VIDEO_TYPE],
+          [`mediaTypes.${VIDEO}.playerSize`, `mediaTypes.${VIDEO}`])
+        checkMissingParams([
+          IN_IMAGE_BANNER_TYPE,
+          IN_IMAGE_MAX_BANNER_TYPE,
+          IN_CONTENT_BANNER_TYPE,
+          IN_CONTENT_STORY_TYPE,
+          ACTION_SCROLLER_TYPE,
+          ACTION_SCROLLER_LIGHT_TYPE,
+          JUST_BANNER_TYPE
+        ], [`mediaTypes.${BANNER}.sizes`, `mediaTypes.${BANNER}`])
+      })
+    })
+  })
+
+  describe('buildRequests method', function() {
+    const request = spec.buildRequests(validBidRequests, bidderRequest)
+
+    it('Url should be correct', function() {
+      expect(request.url).to.equal(SSP_ENDPOINT)
+    })
+
+    it('Method should be correct', function() {
+      expect(request.method).to.equal(REQUEST_METHOD)
+    })
+
+    describe('Common data request should be correct', function() {
+      it('pageUrl should be correct', function() {
+        expect(request.data.pageUrl).to.equal(pageUrl)
+      })
+      it('bidRequests should be array', function() {
+        expect(Array.isArray(request.data.bidRequests)).to.equal(true)
+      })
+
+      request.data.bidRequests.forEach((bid, index) => {
+        describe(`bid with ${validBidRequests[index].params.placeType} should be correct`, function() {
+          it('bidId should be correct', function() {
+            expect(bid.bidId).to.equal(bidId)
+          })
+          it('placeId should be correct', function() {
+            expect(bid.placeId).to.equal(placeId)
+          })
+          it('transactionId should be correct', function() {
+            expect(bid.transactionId).to.equal(transactionId)
+          })
+          it('sizes should be correct', function() {
+            expect(bid.sizes).to.equal(sizes)
+          })
+
+          if (includes([IN_IMAGE_BANNER_TYPE, IN_IMAGE_MAX_BANNER_TYPE], validBidRequests[index].params.placeType)) {
+            it('imageUrl should be correct', function() {
+              expect(bid.imageUrl).to.equal(imageUrl)
+            })
+            it('imageWidth should be correct', function() {
+              expect(bid.imageWidth).to.equal(Math.floor(imageWidth))
+            })
+            it('imageHeight should be correct', function() {
+              expect(bid.imageHeight).to.equal(Math.floor(imageHeight))
+            })
+          }
+        })
+      })
+    })
+  })
+
+  describe('interpretResponse method', function() {
+    it('should return a void array, when the server response are not correct.', function() {
+      const request = { data: JSON.stringify({}) }
+      const serverResponse = {
+        body: {}
+      }
+      const bids = spec.interpretResponse(serverResponse, request)
+      expect(Array.isArray(bids)).to.equal(true)
+      expect(bids.length).to.equal(0)
+    })
+    it('should return a void array, when the server response have not got bids.', function() {
+      const request = { data: JSON.stringify({}) }
+      const serverResponse = { body: { bids: [] } }
+      const bids = spec.interpretResponse(serverResponse, request)
+      expect(Array.isArray(bids)).to.equal(true)
+      expect(bids.length).to.equal(0)
+    })
+    describe('when the server response return a bids', function() {
+      Object.keys(configByPlaceType).forEach(placeType => {
+        it(`should return a bid with ${placeType} placeType`, function() {
+          const cpm = 10
+          const currency = 'RUB'
+          const creativeId = '123'
+          const netRevenue = true
+          const width = sizes[0][0]
+          const height = sizes[0][1]
+          const adSettings = {
+            content: 'html'
+          }
+          const placeSettings = {
+            placeType,
+          }
+          const request = spec.buildRequests([validBidRequests[0]], bidderRequest)
+          const serverResponse = {
+            body: {
+              bids: [
+                {
+                  bidId,
+                  cpm,
+                  currency,
+                  creativeId,
+                  netRevenue,
+                  width,
+                  height,
+                  adSettings,
+                  placeSettings,
+                }
+              ]
+            }
+          }
+          const bids = spec.interpretResponse(serverResponse, request)
+          expect(bids.length).to.equal(1)
+          expect(bids[0].requestId).to.equal(bidId)
+          expect(bids[0].meta.mediaType).to.equal(mediaTypeByPlaceType[placeSettings.placeType])
+          expect(bids[0].cpm).to.equal(cpm)
+          expect(bids[0].width).to.equal(width)
+          expect(bids[0].height).to.equal(height)
+          expect(bids[0].currency).to.equal(currency)
+          expect(bids[0].netRevenue).to.equal(netRevenue)
+
+          if (mediaTypeByPlaceType[placeSettings.placeType] === BANNER) {
+            expect(typeof bids[0].ad).to.equal('string')
+          } else if (mediaTypeByPlaceType[placeSettings.placeType] === VIDEO) {
+            expect(typeof bids[0].vastXml).to.equal('string')
+            expect(typeof bids[0].renderer).to.equal('object')
+          }
+        })
+      })
+    })
+  })
+})

package/test/spec/modules/atsAnalyticsAdapter_spec.js

@@ -5,16 +5,18 @@ 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;
 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();
   });
 
   afterEach(function () {
@@ -22,6 +24,7 @@ describe('ats analytics adapter', function () {
     atsAnalyticsAdapter.getUserAgent.restore();
     atsAnalyticsAdapter.disableAnalytics();
     Math.random.restore();
+    sandbox.restore();
   });
 
   describe('track', function () {
@@ -87,7 +90,7 @@ describe('ats analytics adapter', function () {
       let expectedAfterBid = {
         'Data': [{
           'has_envelope': true,
-          'adapter_version': 1,
+          'adapter_version': 2,
           'bidder': 'appnexus',
           'bid_id': '30c77d079cdf17',
           'auction_id': 'a5b849e5-87d7-4205-8300-d063084fcfb7',
@@ -185,6 +188,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);
@@ -205,5 +214,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);
+    })
   })
 })