prebid.js 7.0.0 → 7.1.0

package/test/spec/AnalyticsAdapter_spec.js

@@ -37,6 +37,14 @@ FEATURE: Analytics Adapters API
     adapter.disableAnalytics();
   });
 
+  it('should track enable status in `enabled`', () => {
+    expect(adapter.enabled).to.equal(false);
+    adapter.enableAnalytics();
+    expect(adapter.enabled).to.equal(true);
+    adapter.disableAnalytics();
+    expect(adapter.enabled).to.equal(false);
+  })
+
   it(`SHOULD call the endpoint WHEN an event occurs that is to be tracked`, function () {
     const eventType = BID_REQUESTED;
     const args = { some: 'data' };

package/test/spec/modules/aduptechBidAdapter_spec.js

@@ -527,6 +527,71 @@ describe('AduptechBidAdapter', () => {
           }
         ]);
       });
+
+      it('should build a request with floorPrices', () => {
+        const bidderRequest = {
+          auctionId: 'auctionId123',
+          refererInfo: {
+            page: 'http://crazy.canonical.url',
+            ref: 'http://crazy.referer.url'
+          },
+          gdprConsent: {
+            consentString: 'consentString123',
+            gdprApplies: true
+          }
+        };
+
+        const getFloorResponse = {
+          currency: 'USD',
+          floor: '1.23'
+        };
+
+        const validBidRequests = [
+          {
+            bidId: 'bidId1',
+            adUnitCode: 'adUnitCode1',
+            transactionId: 'transactionId1',
+            mediaTypes: {
+              banner: {
+                sizes: [[100, 200], [300, 400]]
+              }
+            },
+            params: {
+              publisher: 'publisher1',
+              placement: 'placement1'
+            },
+            getFloor: () => {
+              return getFloorResponse
+            }
+          }
+        ];
+
+        expect(spec.buildRequests(validBidRequests, bidderRequest)).to.deep.equal([
+          {
+            url: internal.buildEndpointUrl(validBidRequests[0].params.publisher),
+            method: ENDPOINT_METHOD,
+            data: {
+              auctionId: bidderRequest.auctionId,
+              pageUrl: bidderRequest.refererInfo.page,
+              referrer: bidderRequest.refererInfo.ref,
+              gdpr: {
+                consentString: bidderRequest.gdprConsent.consentString,
+                consentRequired: bidderRequest.gdprConsent.gdprApplies
+              },
+              imp: [
+                {
+                  bidId: validBidRequests[0].bidId,
+                  transactionId: validBidRequests[0].transactionId,
+                  adUnitCode: validBidRequests[0].adUnitCode,
+                  params: validBidRequests[0].params,
+                  banner: validBidRequests[0].mediaTypes.banner,
+                  floorPrice: getFloorResponse.floor
+                }
+              ]
+            }
+          }
+        ]);
+      });
     });
 
     describe('interpretResponse', () => {

package/test/spec/modules/consentManagement_spec.js

@@ -616,25 +616,84 @@ describe('consentManagement', function () {
           expect(gdprDataHandler.ready).to.be.true;
         });
 
-        it('allows the auction when CMP is unresponsive', (done) => {
-          setConsentConfig({
-            cmpApi: 'iab',
-            timeout: 10,
-            defaultGdprScope: true
+        describe('when proper consent is not available', () => {
+          let tcfStub;
+
+          function runAuction() {
+            setConsentConfig({
+              cmpApi: 'iab',
+              timeout: 10,
+              defaultGdprScope: true
+            });
+            return new Promise((resolve, reject) => {
+              requestBidsHook(() => {
+                didHookReturn = true;
+              }, {});
+              setTimeout(() => didHookReturn ? resolve() : reject(new Error('Auction did not run')), 20);
+            })
+          }
+
+          function mockTcfEvent(tcdata) {
+            tcfStub.callsFake((api, version, cb) => {
+              if (api === 'addEventListener' && version === 2) {
+                // eslint-disable-next-line standard/no-callback-literal
+                cb(tcdata, true)
+              }
+            });
+          }
+
+          beforeEach(() => {
+            tcfStub = sinon.stub(window, '__tcfapi');
           });
 
-          requestBidsHook(() => {
-            didHookReturn = true;
-          }, {});
+          afterEach(() => {
+            tcfStub.restore();
+          })
+
+          it('should continue auction with null consent when CMP is unresponsive', () => {
+            return runAuction().then(() => {
+              const consent = gdprDataHandler.getConsentData();
+              expect(consent.gdprApplies).to.be.true;
+              expect(consent.consentString).to.be.undefined;
+              expect(gdprDataHandler.ready).to.be.true;
+            });
+          });
 
-          setTimeout(() => {
-            expect(didHookReturn).to.be.true;
-            const consent = gdprDataHandler.getConsentData();
-            expect(consent.gdprApplies).to.be.true;
-            expect(consent.consentString).to.be.undefined;
-            expect(gdprDataHandler.ready).to.be.true;
-            done();
-          }, 20);
+          it('should use consent provided by events other than tcloaded', () => {
+            mockTcfEvent({
+              eventStatus: 'cmpuishown',
+              tcString: 'mock-consent-string',
+              vendorData: {}
+            });
+            return runAuction().then(() => {
+              const consent = gdprDataHandler.getConsentData();
+              expect(consent.gdprApplies).to.be.true;
+              expect(consent.consentString).to.equal('mock-consent-string');
+              expect(consent.vendorData.vendorData).to.eql({});
+              expect(gdprDataHandler.ready).to.be.true;
+            });
+          });
+
+          Object.entries({
+            'null': null,
+            'empty': '',
+            'undefined': undefined
+          }).forEach(([t, cs]) => {
+            // some CMPs appear to reply with an empty consent string in 'cmpuishown' - make sure we don't use that
+            it(`should NOT use "default" consent if string is ${t}`, () => {
+              mockTcfEvent({
+                eventStatus: 'cmpuishown',
+                tcString: cs,
+                vendorData: {random: 'junk'}
+              });
+              return runAuction().then(() => {
+                const consent = gdprDataHandler.getConsentData();
+                expect(consent.gdprApplies).to.be.true;
+                expect(consent.consentString).to.be.undefined;
+                expect(consent.vendorData).to.be.undefined;
+              });
+            })
+          });
         });
 
         it('It still considers it a valid cmp response if gdprApplies is not a boolean', function () {

package/test/spec/modules/cwireBidAdapter_spec.js

@@ -120,6 +120,19 @@ describe('C-WIRE bid adapter', () => {
       bid01.params.pageId = '3320';
       expect(spec.isBidRequestValid(bid01)).to.equal(false);
     });
+
+    it('should fail if cwcreative of type number', function () {
+      const bid01 = new BidRequestBuilder().withParams().build();
+      delete bid01.params.cwcreative;
+      bid01.params.cwcreative = 3320;
+      expect(spec.isBidRequestValid(bid01)).to.equal(false);
+    });
+
+    it('should pass with valid cwcreative of type string', function () {
+      const bid01 = new BidRequestBuilder().withParams().build();
+      bid01.params.cwcreative = 'i-am-a-string';
+      expect(spec.isBidRequestValid(bid01)).to.equal(true);
+    });
   });
 
   describe('C-WIRE - buildRequests()', function () {
@@ -131,7 +144,7 @@ describe('C-WIRE bid adapter', () => {
           }
         }
       }).withParams({
-        cwcreative: 54321,
+        cwcreative: '54321',
         cwapikey: 'xxx-xxx-yyy-zzz-uuid',
         refgroups: 'group_1',
       }).build();
@@ -144,7 +157,7 @@ describe('C-WIRE bid adapter', () => {
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.slots[0].sizes[0]).to.equal('1x1');
-      expect(requests.data.cwcreative).to.equal(54321);
+      expect(requests.data.cwcreative).to.equal('54321');
       expect(requests.data.cwapikey).to.equal('xxx-xxx-yyy-zzz-uuid');
       expect(requests.data.refgroups[0]).to.equal('group_1');
     });
@@ -159,7 +172,7 @@ describe('C-WIRE bid adapter', () => {
           }
         }
       }).withParams({
-        cwcreative: 1234,
+        cwcreative: '1234',
         cwapikey: 'api_key_5',
         refgroups: 'group_5',
       }).build();
@@ -171,7 +184,7 @@ describe('C-WIRE bid adapter', () => {
       expect(requests.data.slots.length).to.equal(2);
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.cwid).to.be.null;
-      expect(requests.data.cwcreative).to.equal(1234);
+      expect(requests.data.cwcreative).to.equal('1234');
       expect(requests.data.cwapikey).to.equal('api_key_5');
       expect(requests.data.refgroups[0]).to.equal('group_5');
     });
@@ -179,14 +192,14 @@ describe('C-WIRE bid adapter', () => {
     it('creates a valid request - read debug params from first bid, ignore second', function () {
       const bid01 = new BidRequestBuilder()
         .withParams({
-          cwcreative: 33,
+          cwcreative: '33',
           cwapikey: 'api_key_33',
           refgroups: 'group_33',
         }).build();
 
       const bid02 = new BidRequestBuilder()
         .withParams({
-          cwcreative: 1234,
+          cwcreative: '1234',
           cwapikey: 'api_key_5',
           refgroups: 'group_5',
         }).build();
@@ -198,7 +211,7 @@ describe('C-WIRE bid adapter', () => {
       expect(requests.data.slots.length).to.equal(2);
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.cwid).to.be.null;
-      expect(requests.data.cwcreative).to.equal(33);
+      expect(requests.data.cwcreative).to.equal('33');
       expect(requests.data.cwapikey).to.equal('api_key_33');
       expect(requests.data.refgroups[0]).to.equal('group_33');
     });
@@ -206,7 +219,7 @@ describe('C-WIRE bid adapter', () => {
     it('creates a valid request - read debug params from 3 different slots', function () {
       const bid01 = new BidRequestBuilder()
         .withParams({
-          cwcreative: 33,
+          cwcreative: '33',
         }).build();
 
       const bid02 = new BidRequestBuilder()
@@ -225,7 +238,7 @@ describe('C-WIRE bid adapter', () => {
       expect(requests.data.slots.length).to.equal(3);
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.cwid).to.be.null;
-      expect(requests.data.cwcreative).to.equal(33);
+      expect(requests.data.cwcreative).to.equal('33');
       expect(requests.data.cwapikey).to.equal('api_key_5');
       expect(requests.data.refgroups[0]).to.equal('group_5');
     });
@@ -244,7 +257,7 @@ describe('C-WIRE bid adapter', () => {
           }
         }
       }).withParams({
-        cwcreative: 54321,
+        cwcreative: '54321',
         cwapikey: 'xxx-xxx-yyy-zzz',
         refgroups: 'group_1',
       }).build();
@@ -257,7 +270,7 @@ describe('C-WIRE bid adapter', () => {
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.cwid).to.be.null;
       expect(requests.data.slots[0].sizes[0]).to.equal('1x1');
-      expect(requests.data.cwcreative).to.equal(654321);
+      expect(requests.data.cwcreative).to.equal('654321');
       expect(requests.data.cwapikey).to.equal('xxx-xxx-yyy-zzz');
       expect(requests.data.refgroups[0]).to.equal('group_2');
     });

package/test/spec/modules/pianoDmpAnalyticsAdapter_spec.js

@@ -0,0 +1,66 @@
+import pianoDmpAnalytics from 'modules/pianoDmpAnalyticsAdapter.js';
+import adapterManager from 'src/adapterManager';
+import * as events from 'src/events';
+import constants from 'src/constants.json';
+import { expect } from 'chai';
+
+describe('Piano DMP Analytics Adapter', () => {
+  let sandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+
+    sandbox.stub(events, 'getEvents').returns([]);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('track', () => {
+    beforeEach(() => {
+      adapterManager.enableAnalytics({
+        provider: 'pianoDmp',
+      });
+    });
+
+    afterEach(() => {
+      delete window.cX;
+      pianoDmpAnalytics.disableAnalytics();
+    });
+
+    it('should pass events to call queue', () => {
+      const eventsList = [
+        constants.EVENTS.AUCTION_INIT,
+        constants.EVENTS.AUCTION_END,
+        constants.EVENTS.BID_ADJUSTMENT,
+        constants.EVENTS.BID_TIMEOUT,
+        constants.EVENTS.BID_REQUESTED,
+        constants.EVENTS.BID_RESPONSE,
+        constants.EVENTS.NO_BID,
+        constants.EVENTS.BID_WON,
+      ];
+
+      // Given
+      const testEvents = eventsList.map((event) => ({
+        event,
+        args: { test: event },
+      }));
+
+      // When
+      testEvents.forEach(({ event, args }) => events.emit(event, args));
+
+      // Then
+      const callQueue = (window.cX || {}).callQueue;
+
+      expect(callQueue).to.be.an('array');
+      expect(callQueue.length).to.equal(testEvents.length);
+
+      callQueue.forEach(([method, params], index) => {
+        expect(method).to.equal('prebid');
+        expect(params.eventType).to.equal(testEvents[index].event);
+        expect(params.params).to.deep.equal(testEvents[index].args);
+      });
+    });
+  });
+});

package/test/spec/modules/synacormediaBidAdapter_spec.js

@@ -183,6 +183,14 @@ describe('synacormediaBidAdapter ', function () {
       }
     };
 
+    let bidderRequestWithTimeout = {
+      auctionId: 'xyz123',
+      refererInfo: {
+        referer: 'https://test.com/foo/bar'
+      },
+      timeout: 3000
+    };
+
     let bidderRequestWithCCPA = {
       auctionId: 'xyz123',
       refererInfo: {
@@ -295,6 +303,42 @@ describe('synacormediaBidAdapter ', function () {
       expect(reqVideo.data.imp).to.eql([expectedDataVideo1]);
     });
 
+    it('should return no tmax', function () {
+      let req = spec.buildRequests([validBidRequest], bidderRequest);
+      expect(req.data).to.not.have.property('tmax');
+    });
+
+    it('should return tmax equal to callback timeout', function () {
+      let req = spec.buildRequests([validBidRequest], bidderRequestWithTimeout);
+      expect(req.data.tmax).to.eql(bidderRequestWithTimeout.timeout);
+    });
+
+    it('should return tmax equal to smaller global timeout', function () {
+      let sandbox = sinon.sandbox.create();
+      sandbox.stub(config, 'getConfig').callsFake(key => {
+        const config = {
+          'bidderTimeout': bidderRequestWithTimeout.timeout - 100
+        };
+        return config[key];
+      });
+      let req = spec.buildRequests([validBidRequest], bidderRequestWithTimeout);
+      sandbox.restore();
+      expect(req.data.tmax).to.eql(bidderRequestWithTimeout.timeout - 100);
+    });
+
+    it('should return tmax equal to smaller callback timeout', function () {
+      let sandbox = sinon.sandbox.create();
+      sandbox.stub(config, 'getConfig').callsFake(key => {
+        const config = {
+          'bidderTimeout': bidderRequestWithTimeout.timeout + 100
+        };
+        return config[key];
+      });
+      let req = spec.buildRequests([validBidRequest], bidderRequestWithTimeout);
+      sandbox.restore();
+      expect(req.data.tmax).to.eql(bidderRequestWithTimeout.timeout);
+    });
+
     it('should return multiple bids when multiple valid requests with the same seatId are used', function () {
       let secondBidRequest = {
         bidId: 'foobar',

package/test/spec/modules/trafficgateBidAdapter_spec.js

@@ -0,0 +1,223 @@
+import { expect } from 'chai'
+import { spec } from '../../../modules/trafficgateBidAdapter'
+import { deepStrictEqual, notStrictEqual, ok, strictEqual } from 'assert'
+
+describe('TrafficGateAdapter', () => {
+  const bid = {
+    bidId: '9ec5b177515ee2e5',
+    bidder: 'trafficgate',
+    params: {
+      placementId: 1,
+      host: 'example'
+    },
+    mediaTypes: {
+      banner: {
+        sizes: [[300, 250]]
+      }
+    }
+  }
+
+  describe('isBidRequestValid', () => {
+    it('Should return true if there are bidId, params and placementId parameters present', () => {
+      strictEqual(true, spec.isBidRequestValid(bid))
+    })
+
+    it('Should return false if at least one of parameters is not present', () => {
+      const b = { ...bid }
+      delete b.params.placementId
+      strictEqual(false, spec.isBidRequestValid(b))
+    })
+
+    it('Should return false if at least one of parameters is not present', () => {
+      const b = { ...bid }
+      delete b.params.host
+      strictEqual(false, spec.isBidRequestValid(b))
+    })
+  })
+
+  describe('buildRequests', () => {
+    const serverRequest = spec.buildRequests([bid])
+
+    it('Creates a ServerRequest object with method, URL and data', () => {
+      ok(serverRequest)
+      ok(serverRequest.method)
+      ok(serverRequest.url)
+      ok(serverRequest.data)
+    })
+
+    it('Returns POST method', () => {
+      strictEqual('POST', serverRequest.method)
+    })
+
+    it('Returns valid URL', () => {
+      strictEqual('https://example.bc-plugin.com/?c=o&m=multi', serverRequest.url)
+    })
+
+    it('Returns valid data if array of bids is valid', () => {
+      const { data } = serverRequest
+      strictEqual('object', typeof data)
+      deepStrictEqual(['language', 'secure', 'host', 'page', 'placements'], Object.keys(data))
+      strictEqual('string', typeof data.language)
+      strictEqual('string', typeof data.host)
+      strictEqual('string', typeof data.page)
+      notStrictEqual(-1, [0, 1].indexOf(data.secure))
+
+      const placement = data.placements[0]
+      deepStrictEqual(['placementId', 'bidId', 'traffic'], Object.keys(placement))
+      strictEqual(1, placement.placementId)
+      strictEqual('9ec5b177515ee2e5', placement.bidId)
+      strictEqual('banner', placement.traffic)
+    })
+
+    it('Returns empty data if no valid requests are passed', () => {
+      deepStrictEqual([], spec.buildRequests([]))
+    })
+  })
+
+  describe('interpretResponse', () => {
+    const validData = [
+      {
+        body: [{
+          mediaType: 'banner',
+          width: 300,
+          height: 250,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '9ec5b177515ee2e5',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['test.com']
+          }
+        }]
+      },
+      {
+        body: [{
+          vastUrl: 'example.com',
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '9ec5b177515ee2e5',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['test.com']
+          }
+        }]
+      },
+      {
+        body: [{
+          mediaType: 'native',
+          clickUrl: 'example.com',
+          title: 'Test',
+          image: 'example.com',
+          creativeId: '2',
+          impressionTrackers: ['example.com'],
+          ttl: 120,
+          cpm: 0.4,
+          requestId: '9ec5b177515ee2e5',
+          netRevenue: true,
+          currency: 'USD',
+          meta: {
+            advertiserDomains: ['test.com']
+          }
+        }]
+      }
+    ]
+
+    for (const obj of validData) {
+      const { mediaType } = obj.body[0]
+
+      it(`Should interpret ${mediaType} response`, () => {
+        const response = spec.interpretResponse(obj)
+
+        expect(response).to.be.an('array')
+        strictEqual(1, response.length)
+
+        const copy = { ...obj.body[0] }
+        deepStrictEqual(copy, response[0])
+      })
+    }
+
+    for (const obj of validData) {
+      it(`Should interpret response has meta.advertiserDomains`, () => {
+        const response = spec.interpretResponse(obj)
+
+        expect(response[0]['meta']['advertiserDomains']).to.be.an('array')
+        expect(response[0]['meta']['advertiserDomains'][0]).to.be.an('string')
+      })
+    }
+
+    const invalidData = [
+      {
+        body: [{
+          width: 300,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '9ec5b177515ee2e5',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      },
+      {
+        body: [{
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '9ec5b177515ee2e5',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      },
+      {
+        body: [{
+          mediaType: 'native',
+          clickUrl: 'example.com',
+          title: 'Test',
+          impressionTrackers: ['example.com'],
+          ttl: 120,
+          requestId: '9ec5b177515ee2e5',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+        }]
+      }
+    ]
+
+    for (const obj of invalidData) {
+      const { mediaType } = obj.body[0]
+
+      it(`Should return an empty array if invalid ${mediaType} response is passed `, () => {
+        const response = spec.interpretResponse(obj)
+
+        expect(response).to.be.an('array')
+        strictEqual(0, response.length)
+      })
+    }
+
+    it('Should return an empty array if invalid response is passed', () => {
+      const response = spec.interpretResponse({
+        body: [{
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      })
+
+      expect(response).to.be.an('array')
+      strictEqual(0, response.length)
+    })
+  })
+})