prebid.js 7.30.0 → 7.31.0

package/test/spec/modules/confiantRtdProvider_spec.js

@@ -0,0 +1,107 @@
+import * as utils from '../../../src/utils.js';
+import * as hook from '../../../src/hook.js'
+import * as events from '../../../src/events.js';
+import CONSTANTS from '../../../src/constants.json';
+
+import confiantModule from '../../../modules/confiantRtdProvider.js';
+
+const {
+  injectConfigScript,
+  setupPage,
+  subscribeToConfiantCommFrame,
+  registerConfiantSubmodule
+} = confiantModule;
+
+describe('Confiant RTD module', function () {
+  describe('setupPage()', function() {
+    it('should return false if propertId is not present in config', function() {
+      expect(setupPage({})).to.be.false;
+      expect(setupPage({ params: {} })).to.be.false;
+      expect(setupPage({ params: { propertyId: '' } })).to.be.false;
+    });
+
+    it('should return true if expected parameters are present', function() {
+      expect(setupPage({ params: { propertyId: 'clientId' } })).to.be.true;
+    });
+  });
+
+  describe('Module initialization', function() {
+    let insertElementStub;
+    beforeEach(function() {
+      insertElementStub = sinon.stub(utils, 'insertElement');
+    });
+    afterEach(function() {
+      utils.insertElement.restore();
+    });
+
+    it('should subscribe to rovided Window object', function () {
+      const mockWindow = { addEventListener: sinon.spy() };
+
+      subscribeToConfiantCommFrame(mockWindow);
+
+      sinon.assert.calledOnce(mockWindow.addEventListener);
+    });
+
+    it('should fire BillableEvent as a result for message in comm window', function() {
+      let listenerCallback;
+      const mockWindow = { addEventListener: (a, cb) => (listenerCallback = cb) };
+      let billableEventsCounter = 0;
+
+      events.on(CONSTANTS.EVENTS.BILLABLE_EVENT, (e) => {
+        if (e.vendor === 'confiant') {
+          billableEventsCounter++;
+          expect(e.type).to.equal('impression');
+          expect(e.billingId).to.be.a('number');
+          expect(e.auctionId).to.equal('auctionId');
+          expect(e.transactionId).to.equal('transactionId');
+        }
+      });
+
+      subscribeToConfiantCommFrame(mockWindow);
+      listenerCallback({
+        data: {
+          auctionId: 'auctionId',
+          transactionId: 'transactionId'
+        }
+      });
+      listenerCallback({
+        data: {
+          auctionId: 'auctionId',
+          transactionId: 'transactionId'
+        }
+      });
+
+      expect(billableEventsCounter).to.equal(2);
+    });
+  });
+
+  describe('Sumbodule execution', function() {
+    let submoduleStub;
+    let insertElementStub;
+    beforeEach(function () {
+      submoduleStub = sinon.stub(hook, 'submodule');
+      insertElementStub = sinon.stub(utils, 'insertElement');
+    });
+    afterEach(function () {
+      utils.insertElement.restore();
+      submoduleStub.restore();
+    });
+
+    function initModule() {
+      registerConfiantSubmodule();
+
+      expect(submoduleStub.calledOnceWith('realTimeData')).to.equal(true);
+
+      const registeredSubmoduleDefinition = submoduleStub.getCall(0).args[1];
+      expect(registeredSubmoduleDefinition).to.be.an('object');
+      expect(registeredSubmoduleDefinition).to.have.own.property('name', 'confiant');
+      expect(registeredSubmoduleDefinition).to.have.own.property('init').that.is.a('function');
+
+      return registeredSubmoduleDefinition;
+    }
+
+    it('should register Confiant submodule', function () {
+      initModule();
+    });
+  });
+});

package/test/spec/modules/feedadBidAdapter_spec.js

@@ -358,14 +358,20 @@ describe('FeedAdAdapter', function () {
     const pixelSync2 = {type: 'image', url: 'the pixel url 2'};
     const iFrameSync1 = {type: 'iframe', url: 'the iFrame url 1'};
     const iFrameSync2 = {type: 'iframe', url: 'the iFrame url 2'};
+    const mockServerResponse = (content) => {
+      if (!(content instanceof Array)) {
+        content = [content];
+      }
+      return content.map(it => ({body: it}));
+    };
 
     it('should pass through the syncs out of the extension fields of the server response', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1, pixelSync2],
           iframes: [iFrameSync1, iFrameSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: true, pixelEnabled: true}, serverResponse)
       expect(result).to.deep.equal([
         pixelSync1,
@@ -376,7 +382,7 @@ describe('FeedAdAdapter', function () {
     });
 
     it('should concat the syncs of all responses', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1],
           iframes: [iFrameSync2],
@@ -391,7 +397,7 @@ describe('FeedAdAdapter', function () {
         ext: {
           pixels: [pixelSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: true, pixelEnabled: true}, serverResponse);
       expect(result).to.deep.equal([
         pixelSync1,
@@ -402,7 +408,7 @@ describe('FeedAdAdapter', function () {
     });
 
     it('should filter out duplicates', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1, pixelSync1],
           iframes: [iFrameSync2, iFrameSync2],
@@ -411,7 +417,7 @@ describe('FeedAdAdapter', function () {
         ext: {
           iframes: [iFrameSync2, iFrameSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: true, pixelEnabled: true}, serverResponse);
       expect(result).to.deep.equal([
         pixelSync1,
@@ -420,12 +426,12 @@ describe('FeedAdAdapter', function () {
     });
 
     it('should not include iFrame syncs if the option is disabled', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1, pixelSync2],
           iframes: [iFrameSync1, iFrameSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: false, pixelEnabled: true}, serverResponse);
       expect(result).to.deep.equal([
         pixelSync1,
@@ -434,12 +440,12 @@ describe('FeedAdAdapter', function () {
     });
 
     it('should not include pixel syncs if the option is disabled', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1, pixelSync2],
           iframes: [iFrameSync1, iFrameSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: true, pixelEnabled: false}, serverResponse);
       expect(result).to.deep.equal([
         iFrameSync1,
@@ -448,15 +454,34 @@ describe('FeedAdAdapter', function () {
     });
 
     it('should not include any syncs if the sync options are disabled or missing', function () {
-      const serverResponse = [{
+      const serverResponse = mockServerResponse([{
         ext: {
           pixels: [pixelSync1, pixelSync2],
           iframes: [iFrameSync1, iFrameSync2],
         }
-      }];
+      }]);
       const result = spec.getUserSyncs({iframeEnabled: false, pixelEnabled: false}, serverResponse);
       expect(result).to.deep.equal([]);
     });
+
+    it('should handle empty responses', function () {
+      const serverResponse = mockServerResponse([]);
+      const result = spec.getUserSyncs({iframeEnabled: true, pixelEnabled: true}, serverResponse)
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should not throw if the server response is weird', function () {
+      const responses = [
+        mockServerResponse(null),
+        mockServerResponse('null'),
+        mockServerResponse(1234),
+        mockServerResponse({}),
+        mockServerResponse([{}, 123]),
+      ];
+      responses.forEach(it => {
+        expect(() => spec.getUserSyncs({iframeEnabled: true, pixelEnabled: true}, it)).not.to.throw;
+      });
+    });
   });
 
   describe('event tracking calls', function () {
@@ -592,7 +617,7 @@ describe('FeedAdAdapter', function () {
             prebid_bid_id: bidId,
             prebid_transaction_id: transactionId,
             referer,
-            sdk_version: '1.0.3'
+            sdk_version: '1.0.4'
           };
           subject(data);
           expect(server.requests.length).to.equal(1);

package/test/spec/ortbConverter/pbsExtensions/adUnitCode_spec.js

@@ -0,0 +1,23 @@
+import {setImpAdUnitCode} from '../../../../libraries/pbsExtensions/processors/adUnitCode.js';
+
+describe('pbjs -> ortb adunit code to imp[].ext.prebid.adunitcode', () => {
+  function setImp(bidRequest) {
+    const imp = {};
+    setImpAdUnitCode(imp, bidRequest);
+    return imp;
+  }
+
+  it('it sets adunitcode in ext.prebid.adunitcode when adUnitCode is present', () => {
+    expect(setImp({bidder: 'mockBidder', adUnitCode: 'mockAdUnit'})).to.eql({
+      'ext': {
+        'prebid': {
+          'adunitcode': 'mockAdUnit'
+        }
+      }
+    })
+  });
+
+  it('does not set adunitcode in ext.prebid.adunitcode if adUnit is undefined', () => {
+    expect(setImp({bidder: 'mockBidder'})).to.eql({});
+  });
+});

package/test/spec/unit/pbjs_api_spec.js

@@ -1810,6 +1810,16 @@ describe('Unit: Prebid Module', function () {
         })
       });
 
+      it('filtering adUnits by adUnitCodes', () => {
+        $$PREBID_GLOBAL$$.requestBids({
+          adUnits: [{code: 'one'}, {code: 'two'}],
+          adUnitCodes: 'two'
+        });
+        sinon.assert.calledWith(startAuctionStub, sinon.match({
+          adUnits: [{code: 'two'}]
+        }));
+      });
+
       it('passing bidder-specific FPD as ortb2Fragments.bidder', () => {
         configObj.setBidderConfig({
           bidders: ['bidderA', 'bidderC'],
@@ -1869,6 +1879,7 @@ describe('Unit: Prebid Module', function () {
           mediaTypes: {banner: {sizes: [[300, 250]]}},
           bids: [{bidder: 'bd'}]
         }],
+        adUnitCodes: ['au'],
         ortb2Fragments
       });
       sinon.assert.calledWith(newAuctionStub, sinon.match({