prebid.js 6.1.0 → 6.5.0

package/test/spec/modules/zeta_global_sspAnalyticsAdapter_spec.js

@@ -0,0 +1,427 @@
+import zetaAnalyticsAdapter from 'modules/zeta_global_sspAnalyticsAdapter.js';
+import {config} from 'src/config';
+import CONSTANTS from 'src/constants.json';
+import {logError} from '../../../src/utils';
+
+let utils = require('src/utils');
+let events = require('src/events');
+
+const MOCK = {
+  STUB: {
+    'auctionId': '25c6d7f5-699a-4bfc-87c9-996f915341fa'
+  },
+  AUCTION_END: {
+    'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+    'timestamp': 1638441234544,
+    'auctionEnd': 1638441234784,
+    'auctionStatus': 'completed',
+    'adUnits': [
+      {
+        'code': '/19968336/header-bid-tag-0',
+        'mediaTypes': {
+          'banner': {
+            'sizes': [
+              [
+                300,
+                250
+              ],
+              [
+                300,
+                600
+              ]
+            ]
+          }
+        },
+        'bids': [
+          {
+            'bidder': 'zeta_global_ssp',
+            'params': {
+              'sid': 111,
+              'tags': {
+                'shortname': 'prebid_analytics_event_test_shortname',
+                'position': 'test_position'
+              }
+            }
+          },
+          {
+            'bidder': 'appnexus',
+            'params': {
+              'placementId': 13232385
+            }
+          }
+        ],
+        'sizes': [
+          [
+            300,
+            250
+          ],
+          [
+            300,
+            600
+          ]
+        ],
+        'transactionId': '6b29369c-0c2e-414e-be1f-5867aec18d83'
+      }
+    ],
+    'adUnitCodes': [
+      '/19968336/header-bid-tag-0'
+    ],
+    'bidderRequests': [
+      {
+        'bidderCode': 'zeta_global_ssp',
+        'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+        'bidderRequestId': '1207cb49191887',
+        'bids': [
+          {
+            'bidder': 'zeta_global_ssp',
+            'params': {
+              'sid': 111,
+              'tags': {
+                'shortname': 'prebid_analytics_event_test_shortname',
+                'position': 'test_position'
+              }
+            },
+            'mediaTypes': {
+              'banner': {
+                'sizes': [
+                  [
+                    300,
+                    250
+                  ],
+                  [
+                    300,
+                    600
+                  ]
+                ]
+              }
+            },
+            'adUnitCode': '/19968336/header-bid-tag-0',
+            'transactionId': '6b29369c-0c2e-414e-be1f-5867aec18d83',
+            'sizes': [
+              [
+                300,
+                250
+              ],
+              [
+                300,
+                600
+              ]
+            ],
+            'bidId': '206be9a13236af',
+            'bidderRequestId': '1207cb49191887',
+            'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+            'src': 'client',
+            'bidRequestsCount': 1,
+            'bidderRequestsCount': 1,
+            'bidderWinsCount': 0
+          }
+        ],
+        'auctionStart': 1638441234544,
+        'timeout': 400,
+        'refererInfo': {
+          'referer': 'http://test-zeta-ssp.net:63342/zeta-ssp/ssp/_dev/examples/page_banner.html',
+          'reachedTop': true,
+          'isAmp': false,
+          'numIframes': 0,
+          'stack': [
+            'http://test-zeta-ssp.net:63342/zeta-ssp/ssp/_dev/examples/page_banner.html'
+          ],
+          'canonicalUrl': null
+        },
+        'start': 1638441234547
+      },
+      {
+        'bidderCode': 'appnexus',
+        'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+        'bidderRequestId': '32b97f0a935422',
+        'bids': [
+          {
+            'bidder': 'appnexus',
+            'params': {
+              'placementId': 13232385
+            },
+            'mediaTypes': {
+              'banner': {
+                'sizes': [
+                  [
+                    300,
+                    250
+                  ],
+                  [
+                    300,
+                    600
+                  ]
+                ]
+              }
+            },
+            'adUnitCode': '/19968336/header-bid-tag-0',
+            'transactionId': '6b29369c-0c2e-414e-be1f-5867aec18d83',
+            'sizes': [
+              [
+                300,
+                250
+              ],
+              [
+                300,
+                600
+              ]
+            ],
+            'bidId': '41badc0e164c758',
+            'bidderRequestId': '32b97f0a935422',
+            'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+            'src': 'client',
+            'bidRequestsCount': 1,
+            'bidderRequestsCount': 1,
+            'bidderWinsCount': 0
+          }
+        ],
+        'auctionStart': 1638441234544,
+        'timeout': 400,
+        'refererInfo': {
+          'referer': 'http://test-zeta-ssp.net:63342/zeta-ssp/ssp/_dev/examples/page_banner.html',
+          'reachedTop': true,
+          'isAmp': false,
+          'numIframes': 0,
+          'stack': [
+            'http://test-zeta-ssp.net:63342/zeta-ssp/ssp/_dev/examples/page_banner.html'
+          ],
+          'canonicalUrl': null
+        },
+        'start': 1638441234550
+      }
+    ],
+    'noBids': [
+      {
+        'bidder': 'appnexus',
+        'params': {
+          'placementId': 13232385
+        },
+        'mediaTypes': {
+          'banner': {
+            'sizes': [
+              [
+                300,
+                250
+              ],
+              [
+                300,
+                600
+              ]
+            ]
+          }
+        },
+        'adUnitCode': '/19968336/header-bid-tag-0',
+        'transactionId': '6b29369c-0c2e-414e-be1f-5867aec18d83',
+        'sizes': [
+          [
+            300,
+            250
+          ],
+          [
+            300,
+            600
+          ]
+        ],
+        'bidId': '41badc0e164c758',
+        'bidderRequestId': '32b97f0a935422',
+        'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+        'src': 'client',
+        'bidRequestsCount': 1,
+        'bidderRequestsCount': 1,
+        'bidderWinsCount': 0
+      }
+    ],
+    'bidsReceived': [
+      {
+        'bidderCode': 'zeta_global_ssp',
+        'width': 480,
+        'height': 320,
+        'statusMessage': 'Bid available',
+        'adId': '5759bb3ef7be1e8',
+        'requestId': '206be9a13236af',
+        'mediaType': 'banner',
+        'source': 'client',
+        'cpm': 2.258302852806723,
+        'currency': 'USD',
+        'ad': 'test_ad',
+        'ttl': 200,
+        'creativeId': '456456456',
+        'netRevenue': true,
+        'meta': {
+          'advertiserDomains': [
+            'viaplay.fi'
+          ]
+        },
+        'originalCpm': 2.258302852806723,
+        'originalCurrency': 'USD',
+        'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+        'responseTimestamp': 1638441234670,
+        'requestTimestamp': 1638441234547,
+        'bidder': 'zeta_global_ssp',
+        'adUnitCode': '/19968336/header-bid-tag-0',
+        'timeToRespond': 123,
+        'pbLg': '2.00',
+        'pbMg': '2.20',
+        'pbHg': '2.25',
+        'pbAg': '2.25',
+        'pbDg': '2.25',
+        'pbCg': '',
+        'size': '480x320',
+        'adserverTargeting': {
+          'hb_bidder': 'zeta_global_ssp',
+          'hb_adid': '5759bb3ef7be1e8',
+          'hb_pb': '2.20',
+          'hb_size': '480x320',
+          'hb_source': 'client',
+          'hb_format': 'banner',
+          'hb_adomain': 'viaplay.fi'
+        }
+      }
+    ],
+    'winningBids': [],
+    'timeout': 400
+  },
+  AD_RENDER_SUCCEEDED: {
+    'doc': {
+      'location': {
+        'href': 'http://test-zeta-ssp.net:63342/zeta-ssp/ssp/_dev/examples/page_banner.html',
+        'protocol': 'http:',
+        'host': 'localhost:63342',
+        'hostname': 'localhost',
+        'port': '63342',
+        'pathname': '/zeta-ssp/ssp/_dev/examples/page_banner.html',
+        'hash': '',
+        'origin': 'http://test-zeta-ssp.net:63342',
+        'ancestorOrigins': {
+          '0': 'http://test-zeta-ssp.net:63342'
+        }
+      }
+    },
+    'bid': {
+      'bidderCode': 'zeta_global_ssp',
+      'width': 480,
+      'height': 320,
+      'statusMessage': 'Bid available',
+      'adId': '5759bb3ef7be1e8',
+      'requestId': '206be9a13236af',
+      'mediaType': 'banner',
+      'source': 'client',
+      'cpm': 2.258302852806723,
+      'currency': 'USD',
+      'ad': 'test_ad',
+      'ttl': 200,
+      'creativeId': '456456456',
+      'netRevenue': true,
+      'meta': {
+        'advertiserDomains': [
+          'viaplay.fi'
+        ]
+      },
+      'originalCpm': 2.258302852806723,
+      'originalCurrency': 'USD',
+      'auctionId': '75e394d9-ccce-4978-9238-91e6a1ac88a1',
+      'responseTimestamp': 1638441234670,
+      'requestTimestamp': 1638441234547,
+      'bidder': 'zeta_global_ssp',
+      'adUnitCode': '/19968336/header-bid-tag-0',
+      'timeToRespond': 123,
+      'pbLg': '2.00',
+      'pbMg': '2.20',
+      'pbHg': '2.25',
+      'pbAg': '2.25',
+      'pbDg': '2.25',
+      'pbCg': '',
+      'size': '480x320',
+      'adserverTargeting': {
+        'hb_bidder': 'zeta_global_ssp',
+        'hb_adid': '5759bb3ef7be1e8',
+        'hb_pb': '2.20',
+        'hb_size': '480x320',
+        'hb_source': 'client',
+        'hb_format': 'banner',
+        'hb_adomain': 'viaplay.fi'
+      },
+      'status': 'rendered',
+      'params': [
+        {
+          'sid': 111,
+          'tags': {
+            'shortname': 'prebid_analytics_event_test_shortname',
+            'position': 'test_position'
+          }
+        }
+      ]
+    },
+    'adId': '5759bb3ef7be1e8'
+  }
+}
+
+describe('Zeta Global SSP Analytics Adapter', function() {
+  let sandbox;
+  let xhr;
+  let requests;
+
+  beforeEach(function() {
+    sandbox = sinon.sandbox.create();
+    requests = [];
+    xhr = sandbox.useFakeXMLHttpRequest();
+    xhr.onCreate = request => requests.push(request);
+    sandbox.stub(events, 'getEvents').returns([]);
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+    config.resetConfig();
+  });
+
+  it('should require publisherId', function () {
+    sandbox.stub(utils, 'logError');
+    zetaAnalyticsAdapter.enableAnalytics({
+      options: {}
+    });
+    expect(utils.logError.called).to.equal(true);
+  });
+
+  describe('handle events', function() {
+    beforeEach(function() {
+      zetaAnalyticsAdapter.enableAnalytics({
+        options: {
+          sid: 111
+        }
+      });
+    });
+
+    afterEach(function () {
+      zetaAnalyticsAdapter.disableAnalytics();
+    });
+
+    it('events are sent', function() {
+      this.timeout(5000);
+      events.emit(CONSTANTS.EVENTS.AUCTION_INIT, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.AUCTION_END, MOCK.AUCTION_END);
+      events.emit(CONSTANTS.EVENTS.BID_ADJUSTMENT, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BID_TIMEOUT, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BID_REQUESTED, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BID_RESPONSE, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.NO_BID, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BID_WON, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BIDDER_DONE, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BIDDER_ERROR, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.SET_TARGETING, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BEFORE_REQUEST_BIDS, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BEFORE_BIDDER_HTTP, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.REQUEST_BIDS, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.ADD_AD_UNITS, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.AD_RENDER_FAILED, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.AD_RENDER_SUCCEEDED, MOCK.AD_RENDER_SUCCEEDED);
+      events.emit(CONSTANTS.EVENTS.TCF2_ENFORCEMENT, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.AUCTION_DEBUG, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.BID_VIEWABLE, MOCK.STUB);
+      events.emit(CONSTANTS.EVENTS.STALE_RENDER, MOCK.STUB);
+
+      expect(requests.length).to.equal(2);
+      expect(JSON.parse(requests[0].requestBody)).to.deep.equal(MOCK.AUCTION_END);
+      expect(JSON.parse(requests[1].requestBody)).to.deep.equal(MOCK.AD_RENDER_SUCCEEDED);
+    });
+  });
+});

package/test/spec/modules/zeta_global_sspBidAdapter_spec.js

@@ -1,4 +1,5 @@
 import {spec} from '../../../modules/zeta_global_sspBidAdapter.js'
+import {BANNER, VIDEO} from '../../../src/mediaTypes';
 
 describe('Zeta Ssp Bid Adapter', function () {
   const eids = [
@@ -143,7 +144,22 @@ describe('Zeta Ssp Bid Adapter', function () {
                   'https://example2.com'
                 ],
                 h: 150,
-                w: 200
+                w: 200,
+                ext: {
+                  bidtype: 'video'
+                }
+              },
+              {
+                id: 'auctionId3',
+                impid: 'impId3',
+                price: 0.2,
+                adm: '<?xml version=\\"1.0\\"?><VAST version=\\"4.0\\">',
+                crid: 'creativeId3',
+                adomain: [
+                  'https://example3.com'
+                ],
+                h: 400,
+                w: 300
               }
             ]
           }
@@ -159,6 +175,8 @@ describe('Zeta Ssp Bid Adapter', function () {
     const receivedBid1 = response.body.seatbid[0].bid[0];
     expect(bid1).to.not.be.empty;
     expect(bid1.ad).to.equal(receivedBid1.adm);
+    expect(bid1.vastXml).to.be.undefined;
+    expect(bid1.mediaType).to.equal(BANNER);
     expect(bid1.cpm).to.equal(receivedBid1.price);
     expect(bid1.height).to.equal(receivedBid1.h);
     expect(bid1.width).to.equal(receivedBid1.w);
@@ -169,11 +187,25 @@ describe('Zeta Ssp Bid Adapter', function () {
     const receivedBid2 = response.body.seatbid[0].bid[1];
     expect(bid2).to.not.be.empty;
     expect(bid2.ad).to.equal(receivedBid2.adm);
+    expect(bid2.vastXml).to.equal(receivedBid2.adm);
+    expect(bid2.mediaType).to.equal(VIDEO);
     expect(bid2.cpm).to.equal(receivedBid2.price);
     expect(bid2.height).to.equal(receivedBid2.h);
     expect(bid2.width).to.equal(receivedBid2.w);
     expect(bid2.requestId).to.equal(receivedBid2.impid);
     expect(bid2.meta.advertiserDomains).to.equal(receivedBid2.adomain);
+
+    const bid3 = bidResponse[2];
+    const receivedBid3 = response.body.seatbid[0].bid[2];
+    expect(bid3).to.not.be.empty;
+    expect(bid3.ad).to.equal(receivedBid3.adm);
+    expect(bid3.vastXml).to.equal(receivedBid3.adm);
+    expect(bid3.mediaType).to.equal(VIDEO);
+    expect(bid3.cpm).to.equal(receivedBid3.price);
+    expect(bid3.height).to.equal(receivedBid3.h);
+    expect(bid3.width).to.equal(receivedBid3.w);
+    expect(bid3.requestId).to.equal(receivedBid3.impid);
+    expect(bid3.meta.advertiserDomains).to.equal(receivedBid3.adomain);
   });
 
   it('Different cases for user syncs', function () {

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

@@ -5,6 +5,7 @@ import { createBidReceived } from 'test/fixtures/fixtures.js';
 import CONSTANTS from 'src/constants.json';
 import { auctionManager } from 'src/auctionManager.js';
 import * as utils from 'src/utils.js';
+import {deepClone} from 'src/utils.js';
 
 const bid1 = {
   'bidderCode': 'rubicon',
@@ -461,6 +462,50 @@ describe('targeting tests', function () {
       });
     });
 
+    describe('targetingControls.allowZeroCpmBids', function () {
+      let bid4;
+      let bidderSettingsStorage;
+
+      before(function() {
+        bidderSettingsStorage = $$PREBID_GLOBAL$$.bidderSettings;
+      });
+
+      beforeEach(function () {
+        bid4 = utils.deepClone(bid1);
+        bid4.adserverTargeting = {
+          hb_pb: '0.0',
+          hb_adid: '567891011',
+          hb_bidder: 'appnexus',
+        };
+        bid4.bidder = bid4.bidderCode = 'appnexus';
+        bid4.cpm = 0;
+        bidsReceived = [bid4];
+      });
+
+      after(function() {
+        bidsReceived = [bid1, bid2, bid3];
+        $$PREBID_GLOBAL$$.bidderSettings = bidderSettingsStorage;
+      })
+
+      it('targeting should not include a 0 cpm by default', function() {
+        bid4.adserverTargeting = {};
+        const targeting = targetingInstance.getAllTargeting(['/123456/header-bid-tag-0']);
+        expect(targeting['/123456/header-bid-tag-0']).to.deep.equal({});
+      });
+
+      it('targeting should allow a 0 cpm with targetingControls.allowZeroCpmBids set to true', function () {
+        $$PREBID_GLOBAL$$.bidderSettings = {
+          standard: {
+            allowZeroCpmBids: true
+          }
+        };
+
+        const targeting = targetingInstance.getAllTargeting(['/123456/header-bid-tag-0']);
+        expect(targeting['/123456/header-bid-tag-0']).to.include.all.keys('hb_pb', 'hb_bidder', 'hb_adid', 'hb_bidder_appnexus', 'hb_adid_appnexus', 'hb_pb_appnexus');
+        expect(targeting['/123456/header-bid-tag-0']['hb_pb']).to.equal('0.0')
+      });
+    });
+
     describe('targetingControls.allowTargetingKeys', function () {
       let bid4;
 
@@ -501,6 +546,77 @@ describe('targeting tests', function () {
       });
     });
 
+    describe('targetingControls.addTargetingKeys', function () {
+      let winningBid = null;
+
+      beforeEach(function () {
+        bidsReceived = [bid1, bid2, nativeBid1, nativeBid2].map(deepClone);
+        bidsReceived.forEach((bid) => {
+          bid.adserverTargeting[CONSTANTS.TARGETING_KEYS.SOURCE] = 'test-source';
+          bid.adUnitCode = 'adunit';
+          if (winningBid == null || bid.cpm > winningBid.cpm) {
+            winningBid = bid;
+          }
+        });
+        enableSendAllBids = true;
+      });
+
+      const expandKey = function (key) {
+        const keys = new Set();
+        if (winningBid.adserverTargeting[key] != null) {
+          keys.add(key);
+        }
+        bidsReceived
+          .filter((bid) => bid.adserverTargeting[key] != null)
+          .map((bid) => bid.bidderCode)
+          .forEach((code) => keys.add(`${key}_${code}`.substr(0, 20)));
+        return new Array(...keys);
+      }
+
+      const targetingResult = function () {
+        return targetingInstance.getAllTargeting(['adunit'])['adunit'];
+      }
+
+      it('should include added keys', function () {
+        config.setConfig({
+          targetingControls: {
+            addTargetingKeys: ['SOURCE']
+          }
+        });
+        expect(targetingResult()).to.include.all.keys(...expandKey(CONSTANTS.TARGETING_KEYS.SOURCE));
+      });
+
+      it('should keep default and native keys', function() {
+        config.setConfig({
+          targetingControls: {
+            addTargetingKeys: ['SOURCE']
+          }
+        });
+        const defaultKeys = new Set(Object.values(CONSTANTS.DEFAULT_TARGETING_KEYS));
+        Object.values(CONSTANTS.NATIVE_KEYS).forEach((k) => defaultKeys.add(k));
+
+        const expectedKeys = new Set();
+        bidsReceived
+          .map((bid) => Object.keys(bid.adserverTargeting))
+          .reduce((left, right) => left.concat(right), [])
+          .filter((key) => defaultKeys.has(key))
+          .map(expandKey)
+          .reduce((left, right) => left.concat(right), [])
+          .forEach((k) => expectedKeys.add(k));
+        expect(targetingResult()).to.include.all.keys(...expectedKeys);
+      });
+
+      it('should not be allowed together with allowTargetingKeys', function () {
+        config.setConfig({
+          targetingControls: {
+            allowTargetingKeys: [CONSTANTS.TARGETING_KEYS.BIDDER],
+            addTargetingKeys: [CONSTANTS.TARGETING_KEYS.SOURCE]
+          }
+        });
+        expect(targetingResult).to.throw();
+      });
+    });
+
     describe('targetingControls.allowSendAllBidsTargetingKeys', function () {
       let bid4;
 

package/test/spec/utils_spec.js

@@ -2,6 +2,7 @@ import { getAdServerTargeting } from 'test/fixtures/fixtures.js';
 import { expect } from 'chai';
 import CONSTANTS from 'src/constants.json';
 import * as utils from 'src/utils.js';
+import {waitForElementToLoad} from 'src/utils.js';
 
 var assert = require('assert');
 
@@ -1198,4 +1199,41 @@ describe('Utils', function () {
       });
     });
   });
+
+  describe('waitForElementToLoad', () => {
+    let element;
+    let callbacks;
+
+    function callback() {
+      callbacks++;
+    }
+
+    function delay(delay = 0) {
+      return new Promise((resolve) => {
+        window.setTimeout(resolve, delay);
+      })
+    }
+
+    beforeEach(() => {
+      callbacks = 0;
+      element = window.document.createElement('div');
+    });
+
+    it('should respect timeout if set', () => {
+      waitForElementToLoad(element, 50).then(callback);
+      return delay(60).then(() => {
+        expect(callbacks).to.equal(1);
+      });
+    });
+
+    ['load', 'error'].forEach((event) => {
+      it(`should complete on '${event} event'`, () => {
+        waitForElementToLoad(element).then(callback);
+        element.dispatchEvent(new Event(event));
+        return delay().then(() => {
+          expect(callbacks).to.equal(1);
+        })
+      });
+    });
+  });
 });

package/test/test_deps.js

@@ -0,0 +1,3 @@
+require('test/helpers/prebidGlobal.js');
+require('test/mocks/adloaderStub.js');
+require('test/mocks/xhr.js');

package/test/test_index.js

@@ -1,6 +1,4 @@
-require('test/helpers/prebidGlobal.js');
-require('test/mocks/adloaderStub.js');
-require('test/mocks/xhr.js');
+require('./test_deps.js');
 
 var testsContext = require.context('.', true, /_spec$/);
 testsContext.keys().forEach(testsContext);