prebid.js 6.4.0 → 6.8.0

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);
+    });
+  });
+});

package/test/spec/modules/welectBidAdapter_spec.js

@@ -0,0 +1,211 @@
+import { expect } from 'chai';
+import { spec as adapter } from 'modules/welectBidAdapter.js';
+
+describe('WelectAdapter', function () {
+  describe('Check methods existance', function () {
+    it('exists and is a function', function () {
+      expect(adapter.isBidRequestValid).to.exist.and.to.be.a('function');
+    });
+    it('exists and is a function', function () {
+      expect(adapter.buildRequests).to.exist.and.to.be.a('function');
+    });
+    it('exists and is a function', function () {
+      expect(adapter.interpretResponse).to.exist.and.to.be.a('function');
+    });
+  });
+
+  describe('Check method isBidRequestValid return', function () {
+    let bid = {
+      bidder: 'welect',
+      params: {
+        placementId: 'exampleAlias',
+        domain: 'www.welect.de'
+      },
+      sizes: [[640, 360]],
+      mediaTypes: {
+        video: {
+          context: 'instream'
+        }
+      },
+    };
+    let bid2 = {
+      bidder: 'welect',
+      params: {
+        domain: 'www.welect.de'
+      },
+      mediaTypes: {
+        video: {
+          context: 'instream',
+          playerSize: [640, 360]
+        }
+      },
+    };
+
+    it('should be true', function () {
+      expect(adapter.isBidRequestValid(bid)).to.be.true;
+    });
+
+    it('should be false because the placementId is missing', function () {
+      expect(adapter.isBidRequestValid(bid2)).to.be.false;
+    });
+  });
+
+  describe('Check buildRequests method', function () {
+    // Bids to be formatted
+    let bid1 = {
+      bidder: 'welect',
+      params: {
+        placementId: 'exampleAlias'
+      },
+      sizes: [[640, 360]],
+      mediaTypes: {
+        video: {
+          context: 'instream'
+        }
+      },
+      bidId: 'abdc'
+    };
+    let bid2 = {
+      bidder: 'welect',
+      params: {
+        placementId: 'exampleAlias',
+        domain: 'www.welect2.de'
+      },
+      sizes: [[640, 360]],
+      mediaTypes: {
+        video: {
+          context: 'instream'
+        }
+      },
+      bidId: 'abdc',
+      gdprConsent: {
+        gdprApplies: 1,
+        gdprConsent: 'some_string'
+      }
+    };
+
+    let data1 = {
+      bid_id: 'abdc',
+      width: 640,
+      height: 360
+    }
+
+    let data2 = {
+      bid_id: 'abdc',
+      width: 640,
+      height: 360,
+      gdpr_consent: {
+        gdprApplies: 1,
+        tcString: 'some_string'
+      }
+    }
+
+    // Formatted requets
+    let request1 = {
+      method: 'POST',
+      url: 'https://www.welect.de/api/v2/preflight/exampleAlias',
+      data: data1,
+      options: {
+        contentType: 'application/json',
+        withCredentials: false,
+        crossOrigin: true,
+      }
+    };
+
+    let request2 = {
+      method: 'POST',
+      url: 'https://www.welect2.de/api/v2/preflight/exampleAlias',
+      data: data2,
+      options: {
+        contentType: 'application/json',
+        withCredentials: false,
+        crossOrigin: true,
+      }
+    }
+
+    it('defaults to www.welect.de, without gdpr object', function () {
+      expect(adapter.buildRequests([bid1])).to.deep.equal([request1]);
+    })
+
+    it('must return the right formatted requests, with gdpr object', function () {
+      expect(adapter.buildRequests([bid2])).to.deep.equal([request2]);
+    });
+  });
+
+  describe('Check interpretResponse method return', function () {
+    // invalid server response
+    let unavailableResponse = {
+      body: {
+        available: false
+      }
+    };
+
+    let availableResponse = {
+      body: {
+        available: true,
+        bidResponse: {
+          ad: {
+            video: 'some vast url'
+          },
+          meta: {
+            advertiserDomains: [],
+          },
+          cpm: 17,
+          creativeId: 'svmpreview',
+          currency: 'EUR',
+          netRevenue: true,
+          requestId: 'some bid id',
+          ttl: 120,
+          vastUrl: 'some vast url',
+          height: 640,
+          width: 320
+        }
+      }
+    }
+    // bid Request
+    let bid = {
+      data: {
+        bid_id: 'some bid id',
+        width: 640,
+        height: 320,
+        gdpr_consent: {
+          gdprApplies: 1,
+          tcString: 'some_string'
+        }
+      },
+      method: 'POST',
+      url: 'https://www.welect.de/api/v2/preflight/exampleAlias',
+      options: {
+        contentType: 'application/json',
+        withCredentials: false,
+        crossOrigin: true,
+      }
+    };
+    // Formatted reponse
+    let result = {
+      ad: {
+        video: 'some vast url'
+      },
+      meta: {
+        advertiserDomains: []
+      },
+      cpm: 17,
+      creativeId: 'svmpreview',
+      currency: 'EUR',
+      height: 640,
+      netRevenue: true,
+      requestId: 'some bid id',
+      ttl: 120,
+      vastUrl: 'some vast url',
+      width: 320
+    }
+
+    it('if response reflects unavailability, should be empty', function () {
+      expect(adapter.interpretResponse(unavailableResponse, bid)).to.deep.equal([]);
+    });
+
+    it('if response reflects availability, should equal result', function () {
+      expect(adapter.interpretResponse(availableResponse, bid)).to.deep.equal([result])
+    })
+  });
+});

package/test/spec/modules/yahoosspBidAdapter_spec.js

@@ -177,6 +177,16 @@ describe('YahooSSP Bid Adapter:', () => {
     expect(obj).to.be.an('object');
   });
 
+  describe('Validate basic properties', () => {
+    it('should define the correct bidder code', () => {
+      expect(spec.code).to.equal('yahoossp')
+    });
+
+    it('should define the correct vendor ID', () => {
+      expect(spec.gvlid).to.equal(25)
+    });
+  });
+
   describe('getUserSyncs()', () => {
     const IMAGE_PIXEL_URL = 'http://image-pixel.com/foo/bar?1234&baz=true';
     const IFRAME_ONE_URL = 'http://image-iframe.com/foo/bar?1234&baz=true';