prebid.js 6.6.0 → 6.7.0

package/test/spec/modules/sharethroughBidAdapter_spec.js

@@ -1,4 +1,5 @@
 import { expect } from 'chai';
+import * as sinon from 'sinon';
 import { sharethroughAdapterSpec, sharethroughInternal } from 'modules/sharethroughBidAdapter.js';
 import { newBidder } from 'src/adapters/bidderFactory.js';
 import { config } from 'src/config';
@@ -157,7 +158,6 @@ describe('sharethrough adapter spec', function () {
               startdelay: 42,
               skipmin: 10,
               skipafter: 20,
-              placement: 1,
               delivery: 1,
               companiontype: 'companion type',
               companionad: 'companion ad',
@@ -205,6 +205,7 @@ describe('sharethrough adapter spec', function () {
             expect(openRtbReq.cur).to.deep.equal(['USD']);
             expect(openRtbReq.tmax).to.equal(242);
 
+            expect(Object.keys(openRtbReq.site)).to.have.length(3);
             expect(openRtbReq.site.domain).not.to.be.undefined;
             expect(openRtbReq.site.page).not.to.be.undefined;
             expect(openRtbReq.site.ref).to.equal('https://referer.com');
@@ -256,6 +257,17 @@ describe('sharethrough adapter spec', function () {
         });
       });
 
+      describe('no referer provided', () => {
+        beforeEach(() => {
+          bidderRequest = {};
+        });
+
+        it('should set referer to undefined', () => {
+          const openRtbReq = spec.buildRequests(bidRequests, bidderRequest)[0].data;
+          expect(openRtbReq.site.ref).to.be.undefined;
+        });
+      });
+
       describe('regulation', () => {
         describe('gdpr', () => {
           it('should populate request accordingly when gdpr applies', () => {
@@ -419,17 +431,90 @@ describe('sharethrough adapter spec', function () {
           expect(videoImp.startdelay).to.equal(0);
           expect(videoImp.skipmin).to.equal(0);
           expect(videoImp.skipafter).to.equal(0);
-          expect(videoImp.placement).to.be.undefined;
+          expect(videoImp.placement).to.equal(1);
           expect(videoImp.delivery).to.be.undefined;
           expect(videoImp.companiontype).to.be.undefined;
           expect(videoImp.companionad).to.be.undefined;
         });
 
-        it('should not return a video impression if context is outstream', () => {
-          bidRequests[1].mediaTypes.video.context = 'outstream';
-          const builtRequest = spec.buildRequests(bidRequests, bidderRequest)[1];
+        describe('outstream', () => {
+          it('should use placement value if provided', () => {
+            bidRequests[1].mediaTypes.video.context = 'outstream';
+            bidRequests[1].mediaTypes.video.placement = 3;
+
+            const builtRequest = spec.buildRequests(bidRequests, bidderRequest)[1];
+            const videoImp = builtRequest.data.imp[0].video;
+
+            expect(videoImp.placement).to.equal(3);
+          });
+
+          it('should default placement to 4 if not provided', () => {
+            bidRequests[1].mediaTypes.video.context = 'outstream';
+
+            const builtRequest = spec.buildRequests(bidRequests, bidderRequest)[1];
+            const videoImp = builtRequest.data.imp[0].video;
+
+            expect(videoImp.placement).to.equal(4);
+          });
+        });
+      });
+
+      describe('first party data', () => {
+        const firstPartyData = {
+          site: {
+            name: 'example',
+            keywords: 'power tools, drills',
+            search: 'drill',
+            content: {
+              userrating: '4',
+            },
+            ext: {
+              data: {
+                pageType: 'article',
+                category: 'repair',
+              },
+            },
+          },
+          user: {
+            yob: 1985,
+            gender: 'm',
+            ext: {
+              data: {
+                registered: true,
+                interests: ['cars'],
+              },
+            },
+          },
+        };
+
+        let configStub;
+
+        beforeEach(() => {
+          configStub = sinon.stub(config, 'getConfig');
+          configStub.withArgs('ortb2').returns(firstPartyData);
+        });
+
+        afterEach(() => {
+          configStub.restore();
+        });
+
+        it('should include first party data in open rtb request, site section', () => {
+          const openRtbReq = spec.buildRequests(bidRequests, bidderRequest)[0].data;
+
+          expect(openRtbReq.site.name).to.equal(firstPartyData.site.name);
+          expect(openRtbReq.site.keywords).to.equal(firstPartyData.site.keywords);
+          expect(openRtbReq.site.search).to.equal(firstPartyData.site.search);
+          expect(openRtbReq.site.content).to.deep.equal(firstPartyData.site.content);
+          expect(openRtbReq.site.ext).to.deep.equal(firstPartyData.site.ext);
+        });
+
+        it('should include first party data in open rtb request, user section', () => {
+          const openRtbReq = spec.buildRequests(bidRequests, bidderRequest)[0].data;
 
-          expect(builtRequest).to.be.undefined;
+          expect(openRtbReq.user.yob).to.equal(firstPartyData.user.yob);
+          expect(openRtbReq.user.gender).to.equal(firstPartyData.user.gender);
+          expect(openRtbReq.user.ext.data).to.deep.equal(firstPartyData.user.ext.data);
+          expect(openRtbReq.user.ext.eids).not.to.be.undefined;
         });
       });
     });

package/test/spec/modules/synacormediaBidAdapter_spec.js

@@ -1231,4 +1231,74 @@ describe('synacormediaBidAdapter ', function () {
       expect(usersyncs).to.be.an('array').that.is.empty;
     });
   });
+
+  describe('Bid Requests with price module should use if available', function () {
+    let validVideoBidRequest = {
+      bidder: 'synacormedia',
+      params: {
+        bidfloor: '0.50',
+        seatId: 'prebid',
+        placementId: 'demo1',
+        pos: 1,
+        video: {}
+      },
+      renderer: {
+        url: '../syncOutstreamPlayer.js'
+      },
+      mediaTypes: {
+        video: {
+          playerSize: [[300, 250]],
+          context: 'outstream'
+        }
+      },
+      adUnitCode: 'div-1',
+      transactionId: '0869f34e-090b-4b20-84ee-46ff41405a39',
+      sizes: [[300, 250]],
+      bidId: '22b3a2268d9f0e',
+      bidderRequestId: '1d195910597e13',
+      auctionId: '3375d336-2aea-4ee7-804c-6d26b621ad20',
+      src: 'client',
+      bidRequestsCount: 1,
+      bidderRequestsCount: 1,
+      bidderWinsCount: 0
+    };
+
+    let validBannerBidRequest = {
+      bidId: '9876abcd',
+      sizes: [[300, 250]],
+      params: {
+        bidfloor: '0.50',
+        seatId: 'prebid',
+        placementId: '1234',
+      }
+    };
+
+    let bidderRequest = {
+      refererInfo: {
+        referer: 'http://localhost:9999/'
+      },
+      bidderCode: 'synacormedia',
+      auctionId: 'f8a75621-d672-4cbb-9275-3db7d74fb110'
+    };
+
+    it('should return valid bidfloor using price module for banner/video impression', function () {
+      let bannerRequest = spec.buildRequests([validBannerBidRequest], bidderRequest);
+      let videoRequest = spec.buildRequests([validVideoBidRequest], bidderRequest);
+
+      expect(bannerRequest.data.imp[0].bidfloor).to.equal(0.5);
+      expect(videoRequest.data.imp[0].bidfloor).to.equal(0.5);
+
+      let priceModuleFloor = 3;
+      let floorResponse = { currency: 'USD', floor: priceModuleFloor };
+
+      validBannerBidRequest.getFloor = () => { return floorResponse; };
+      validVideoBidRequest.getFloor = () => { return floorResponse; };
+
+      bannerRequest = spec.buildRequests([validBannerBidRequest], bidderRequest);
+      videoRequest = spec.buildRequests([validVideoBidRequest], bidderRequest);
+
+      expect(bannerRequest.data.imp[0].bidfloor).to.equal(priceModuleFloor);
+      expect(videoRequest.data.imp[0].bidfloor).to.equal(priceModuleFloor);
+    });
+  });
 });

package/test/spec/modules/viewability_spec.js

@@ -0,0 +1,280 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as utils from 'src/utils.js';
+import * as viewability from 'modules/viewability.js';
+
+describe('viewability test', () => {
+  describe('start measurement', () => {
+    let sandbox;
+    let intersectionObserverStub;
+    let setTimeoutStub;
+    let observeCalled;
+    let unobserveCalled;
+    let ti = 1;
+    beforeEach(() => {
+      observeCalled = false;
+      unobserveCalled = false;
+      sandbox = sinon.sandbox.create();
+
+      let fakeIntersectionObserver = (stateChange, options) => {
+        return {
+          observe: (element) => {
+            observeCalled = true;
+            stateChange([{ isIntersecting: true }]);
+          },
+          unobserve: (element) => {
+            unobserveCalled = true;
+          },
+        };
+      };
+
+      intersectionObserverStub = sandbox.stub(window, 'IntersectionObserver').callsFake(fakeIntersectionObserver);
+      setTimeoutStub = sandbox.stub(window, 'setTimeout').callsFake((callback, timeout) => {
+        callback();
+        return ti++;
+      });
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('should trigger appropriate callbacks', () => {
+      viewability.startMeasurement('0', {}, { method: 'img', value: 'http://my.tracker/123' }, { inViewThreshold: 0.5, timeInView: 1000 });
+
+      sinon.assert.called(intersectionObserverStub);
+      sinon.assert.called(setTimeoutStub);
+      expect(observeCalled).to.equal(true);
+      expect(unobserveCalled).to.equal(true);
+    });
+
+    it('should trigger img tracker', () => {
+      let triggerPixelSpy = sandbox.spy(utils, ['triggerPixel']);
+      viewability.startMeasurement('1', {}, { method: 'img', value: 'http://my.tracker/123' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(triggerPixelSpy.callCount).to.equal(1);
+    });
+
+    it('should trigger js tracker', () => {
+      let insertHtmlIntoIframeSpy = sandbox.spy(utils, ['insertHtmlIntoIframe']);
+      viewability.startMeasurement('2', {}, { method: 'js', value: 'http://my.tracker/123.js' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(insertHtmlIntoIframeSpy.callCount).to.equal(1);
+    });
+
+    it('should trigger callback tracker', () => {
+      let callbackFired = false;
+      viewability.startMeasurement('3', {}, { method: 'callback', value: () => { callbackFired = true; } }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(callbackFired).to.equal(true);
+    });
+
+    it('should check for vid uniqueness', () => {
+      let logWarnSpy = sandbox.spy(utils, 'logWarn');
+      viewability.startMeasurement('4', {}, { method: 'js', value: 'http://my.tracker/123.js' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(logWarnSpy.callCount).to.equal(0);
+
+      viewability.startMeasurement('4', {}, { method: 'js', value: 'http://my.tracker/123.js' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(logWarnSpy.callCount).to.equal(1);
+      expect(logWarnSpy.calledWith(`${viewability.MODULE_NAME}: must provide an unregistered vid`, '4')).to.equal(true);
+    });
+
+    it('should check for valid criteria', () => {
+      let logWarnSpy = sandbox.spy(utils, 'logWarn');
+      viewability.startMeasurement('5', {}, { method: 'js', value: 'http://my.tracker/123.js' }, { timeInView: 1000 });
+      expect(logWarnSpy.callCount).to.equal(1);
+      expect(logWarnSpy.calledWith(`${viewability.MODULE_NAME}: missing criteria`, { timeInView: 1000 })).to.equal(true);
+    });
+
+    it('should check for valid tracker', () => {
+      let logWarnSpy = sandbox.spy(utils, 'logWarn');
+      viewability.startMeasurement('6', {}, { method: 'callback', value: 'string' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      expect(logWarnSpy.callCount).to.equal(1);
+      expect(logWarnSpy.calledWith(`${viewability.MODULE_NAME}: invalid tracker`, { method: 'callback', value: 'string' })).to.equal(true);
+    });
+
+    it('should check if element provided', () => {
+      let logWarnSpy = sandbox.spy(utils, 'logWarn');
+      viewability.startMeasurement('7', undefined, { method: 'js', value: 'http://my.tracker/123.js' }, { timeInView: 1000 });
+      expect(logWarnSpy.callCount).to.equal(1);
+      expect(logWarnSpy.calledWith(`${viewability.MODULE_NAME}: no html element provided`)).to.equal(true);
+    });
+  });
+
+  describe('stop measurement', () => {
+    let sandbox;
+    let intersectionObserverStub;
+    let setTimeoutStub;
+    let clearTimeoutStub;
+    let observeCalled;
+    let unobserveCalled;
+    let stateChangeBackup;
+    let ti = 1;
+    beforeEach(() => {
+      observeCalled = false;
+      unobserveCalled = false;
+      sandbox = sinon.sandbox.create();
+
+      let fakeIntersectionObserver = (stateChange, options) => {
+        return {
+          observe: (element) => {
+            stateChangeBackup = stateChange;
+            observeCalled = true;
+            stateChange([{ isIntersecting: true }]);
+          },
+          unobserve: (element) => {
+            unobserveCalled = true;
+          },
+        };
+      };
+
+      intersectionObserverStub = sandbox.stub(window, 'IntersectionObserver').callsFake(fakeIntersectionObserver);
+      setTimeoutStub = sandbox.stub(window, 'setTimeout').callsFake((callback, timeout) => {
+        // skipping the callback
+        return ti++;
+      });
+      clearTimeoutStub = sandbox.stub(window, 'clearTimeout').callsFake((timeoutId) => { });
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('should clear the timeout', () => {
+      viewability.startMeasurement('10', {}, { method: 'img', value: 'http://my.tracker/123' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      stateChangeBackup([{ isIntersecting: false }]);
+      sinon.assert.called(intersectionObserverStub);
+      sinon.assert.called(setTimeoutStub);
+      sinon.assert.called(clearTimeoutStub);
+      expect(observeCalled).to.equal(true);
+    });
+
+    it('should unobserve', () => {
+      viewability.startMeasurement('11', {}, { method: 'img', value: 'http://my.tracker/123' }, { inViewThreshold: 0.5, timeInView: 1000 });
+      sinon.assert.called(intersectionObserverStub);
+      sinon.assert.called(setTimeoutStub);
+      expect(observeCalled).to.equal(true);
+      expect(unobserveCalled).to.equal(false);
+
+      viewability.stopMeasurement('11');
+      expect(unobserveCalled).to.equal(true);
+      sinon.assert.called(clearTimeoutStub);
+    });
+
+    it('should check for vid existence', () => {
+      let logWarnSpy = sandbox.spy(utils, 'logWarn');
+      viewability.stopMeasurement('100');
+      expect(logWarnSpy.callCount).to.equal(1);
+      expect(logWarnSpy.calledWith(`${viewability.MODULE_NAME}: must provide a registered vid`, '100')).to.equal(true);
+    });
+  });
+
+  describe('handle creative messages', () => {
+    let sandbox;
+    let intersectionObserverStub;
+    let setTimeoutStub;
+    let observeCalled;
+    let unobserveCalled;
+    let ti = 1;
+    let getElementsByTagStub;
+    let getElementByIdStub;
+
+    let fakeContentWindow = {};
+    beforeEach(() => {
+      observeCalled = false;
+      unobserveCalled = false;
+      sandbox = sinon.sandbox.create();
+
+      let fakeIntersectionObserver = (stateChange, options) => {
+        return {
+          observe: (element) => {
+            observeCalled = true;
+            stateChange([{ isIntersecting: true }]);
+          },
+          unobserve: (element) => {
+            unobserveCalled = true;
+          },
+        };
+      };
+
+      intersectionObserverStub = sandbox.stub(window, 'IntersectionObserver').callsFake(fakeIntersectionObserver);
+      setTimeoutStub = sandbox.stub(window, 'setTimeout').callsFake((callback, timeout) => {
+        callback();
+        return ti++;
+      });
+
+      getElementsByTagStub = sandbox.stub(document, 'getElementsByTagName').callsFake((tagName) => {
+        return [{
+          contentWindow: fakeContentWindow,
+        }];
+      });
+      getElementByIdStub = sandbox.stub(document, 'getElementById').callsFake((id) => {
+        return {};
+      });
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('should find element by contentWindow', () => {
+      let viewabilityRecord = {
+        vid: 1000,
+        tracker: {
+          value: 'http://my.tracker/123',
+          method: 'img',
+        },
+        criteria: { inViewThreshold: 0.5, timeInView: 1000 },
+        message: 'Prebid Viewability',
+        action: 'startMeasurement',
+      };
+      let data = JSON.stringify(viewabilityRecord);
+
+      viewability.receiveMessage({
+        data: data,
+        source: fakeContentWindow,
+      });
+
+      sinon.assert.called(getElementsByTagStub);
+      sinon.assert.called(intersectionObserverStub);
+      sinon.assert.called(setTimeoutStub);
+      expect(observeCalled).to.equal(true);
+      expect(unobserveCalled).to.equal(true);
+    });
+
+    it('should find element by id', () => {
+      let viewabilityRecord = {
+        vid: 1001,
+        tracker: {
+          value: 'http://my.tracker/123',
+          method: 'img',
+        },
+        criteria: { inViewThreshold: 0.5, timeInView: 1000 },
+        message: 'Prebid Viewability',
+        action: 'startMeasurement',
+        elementId: '1',
+      };
+      let data = JSON.stringify(viewabilityRecord);
+      viewability.receiveMessage({
+        data: data,
+      });
+
+      sinon.assert.called(getElementByIdStub);
+      sinon.assert.called(intersectionObserverStub);
+      sinon.assert.called(setTimeoutStub);
+      expect(observeCalled).to.equal(true);
+      expect(unobserveCalled).to.equal(true);
+    });
+
+    it('should stop measurement', () => {
+      let viewabilityRecord = {
+        vid: 1001,
+        message: 'Prebid Viewability',
+        action: 'stopMeasurement',
+      };
+      let data = JSON.stringify(viewabilityRecord);
+      viewability.receiveMessage({
+        data: data,
+      });
+
+      expect(unobserveCalled).to.equal(true);
+    });
+  });
+});