prebid.js 6.1.0 → 6.5.0

package/test/spec/modules/livewrappedAnalyticsAdapter_spec.js

@@ -552,6 +552,28 @@ describe('Livewrapped analytics adapter', function () {
       expect(message.wins[0].floor).to.equal(1.1);
       expect(message.wins[1].floor).to.equal(2.2);
     });
+
+    it('should forward runner-up data as given by Livewrapped wrapper', function () {
+      events.emit(AUCTION_INIT, MOCK.AUCTION_INIT);
+      events.emit(BID_REQUESTED, MOCK.BID_REQUESTED);
+
+      events.emit(BID_RESPONSE, MOCK.BID_RESPONSE[0]);
+      events.emit(BID_WON, Object.assign({},
+        MOCK.BID_WON[0],
+        {
+          'rUp': 'rUpObject'
+        }));
+      events.emit(AUCTION_END, MOCK.AUCTION_END);
+
+      clock.tick(BID_WON_TIMEOUT + 1000);
+
+      expect(server.requests.length).to.equal(1);
+      let request = server.requests[0];
+      let message = JSON.parse(request.requestBody);
+
+      expect(message.wins.length).to.equal(1);
+      expect(message.wins[0].rUp).to.equal('rUpObject');
+    });
   });
 
   describe('when given other endpoint', function () {

package/test/spec/modules/livewrappedBidAdapter_spec.js

@@ -885,6 +885,37 @@ describe('Livewrapped adapter tests', function () {
     expect(data.rtbData.user.ext.eids).to.deep.equal(testbidRequest.bids[0].userIdAsEids);
   });
 
+  it('should merge user ids with existing ortb2', function() {
+    sandbox.stub(utils, 'isSafariBrowser').callsFake(() => false);
+    sandbox.stub(storage, 'cookiesAreEnabled').callsFake(() => true);
+
+    let origGetConfig = config.getConfig;
+    sandbox.stub(config, 'getConfig').callsFake(function (key) {
+      if (key === 'ortb2') {
+        return {user: {ext: {prop: 'value'}}};
+      }
+      return origGetConfig.apply(config, arguments);
+    });
+
+    let testbidRequest = clone(bidderRequest);
+    delete testbidRequest.bids[0].params.userId;
+    testbidRequest.bids[0].userIdAsEids = [
+      {
+        'source': 'pubcid.org',
+        'uids': [{
+          'id': 'publisher-common-id',
+          'atype': 1
+        }]
+      }
+    ];
+
+    let result = spec.buildRequests(testbidRequest.bids, testbidRequest);
+    let data = JSON.parse(result.data);
+    var expected = {user: {ext: {prop: 'value', eids: testbidRequest.bids[0].userIdAsEids}}}
+
+    expect(data.rtbData).to.deep.equal(expected);
+  });
+
   it('should send schain object if available', function() {
     sandbox.stub(utils, 'isSafariBrowser').callsFake(() => false);
     sandbox.stub(storage, 'cookiesAreEnabled').callsFake(() => true);

package/test/spec/modules/loglyliftBidAdapter_spec.js

@@ -0,0 +1,172 @@
+import { expect } from 'chai';
+import { spec } from '../../../modules/loglyliftBidAdapter';
+import * as utils from 'src/utils.js';
+
+describe('loglyliftBidAdapter', function () {
+  const nativeBidRequests = [{
+    bidder: 'loglylift',
+    bidId: '254304ac29e265',
+    params: {
+      adspotId: 16
+    },
+    adUnitCode: '/19968336/prebid_native_example_1',
+    transactionId: '10aee457-617c-4572-ab5b-99df1d73ccb4',
+    sizes: [
+      []
+    ],
+    bidderRequestId: '15da3afd9632d7',
+    auctionId: 'f890b7d9-e787-4237-ac21-6d8554abac9f',
+    mediaTypes: {
+      native: {
+        body: {
+          required: true
+        },
+        icon: {
+          required: false
+        },
+        title: {
+          required: true
+        },
+        image: {
+          required: true
+        },
+        sponsoredBy: {
+          required: true
+        }
+      }
+    }
+  }];
+
+  const bidderRequest = {
+    refererInfo: {
+      referer: 'fakeReferer',
+      reachedTop: true,
+      numIframes: 1,
+      stack: []
+    },
+    auctionStart: 1632194172781,
+    bidderCode: 'loglylift',
+    bidderRequestId: '15da3afd9632d7',
+    auctionId: 'f890b7d9-e787-4237-ac21-6d8554abac9f',
+    timeout: 3000
+  };
+
+  const nativeServerResponse = {
+    body: {
+      bids: [{
+        requestId: '254304ac29e265',
+        cpm: 10.123,
+        width: 360,
+        height: 360,
+        creativeId: '123456789',
+        currency: 'JPY',
+        netRevenue: true,
+        ttl: 30,
+        meta: {
+          advertiserDomains: ['advertiserexample.com']
+        },
+        native: {
+          clickUrl: 'https://dsp.logly.co.jp/click?ad=EXAMPECLICKURL',
+          image: {
+            url: 'https://cdn.logly.co.jp/images/000/194/300/normal.jpg',
+            width: '360',
+            height: '360'
+          },
+          impressionTrackers: [
+            'https://b.logly.co.jp/sorry.html'
+          ],
+          sponsoredBy: 'logly',
+          title: 'Native Title',
+        }
+      }],
+    }
+  };
+
+  describe('isBidRequestValid', function () {
+    it('should return true if the adspotId parameter is present', function () {
+      expect(spec.isBidRequestValid(nativeBidRequests[0])).to.be.true;
+    });
+
+    it('should return false if the adspotId parameter is not present', function () {
+      let bidRequest = utils.deepClone(nativeBidRequests[0]);
+      delete bidRequest.params.adspotId;
+      expect(spec.isBidRequestValid(bidRequest)).to.be.false;
+    });
+  });
+
+  describe('buildRequests', function () {
+    it('should generate a valid single POST request for multiple bid requests', function () {
+      const request = spec.buildRequests(nativeBidRequests, bidderRequest)[0];
+      expect(request.method).to.equal('POST');
+      expect(request.url).to.equal('https://bid.logly.co.jp/prebid/client/v1?adspot_id=16');
+      expect(request.data).to.exist;
+
+      const data = JSON.parse(request.data);
+      expect(data.auctionId).to.equal(nativeBidRequests[0].auctionId);
+      expect(data.bidderRequestId).to.equal(nativeBidRequests[0].bidderRequestId);
+      expect(data.transactionId).to.equal(nativeBidRequests[0].transactionId);
+      expect(data.adUnitCode).to.equal(nativeBidRequests[0].adUnitCode);
+      expect(data.bidId).to.equal(nativeBidRequests[0].bidId);
+      expect(data.mediaTypes).to.deep.equal(nativeBidRequests[0].mediaTypes);
+      expect(data.params).to.deep.equal(nativeBidRequests[0].params);
+      expect(data.prebidJsVersion).to.equal('6.5.0-pre');
+      expect(data.url).to.exist;
+      expect(data.domain).to.exist;
+      expect(data.referer).to.equal(bidderRequest.refererInfo.referer);
+      expect(data.auctionStartTime).to.equal(bidderRequest.auctionStart);
+      expect(data.currency).to.exist;
+      expect(data.timeout).to.equal(bidderRequest.timeout);
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('should return an empty array if an invalid response is passed', function () {
+      const interpretedResponse = spec.interpretResponse({}, {});
+      expect(interpretedResponse).to.be.an('array').that.is.empty;
+    });
+
+    it('should return valid response when passed valid server response', function () {
+      const request = spec.buildRequests(nativeBidRequests, bidderRequest)[0];
+      const interpretedResponse = spec.interpretResponse(nativeServerResponse, request);
+
+      expect(interpretedResponse).to.have.lengthOf(1);
+      expect(interpretedResponse[0].cpm).to.equal(nativeServerResponse.body.bids[0].cpm);
+      expect(interpretedResponse[0].width).to.equal(nativeServerResponse.body.bids[0].width);
+      expect(interpretedResponse[0].height).to.equal(nativeServerResponse.body.bids[0].height);
+      expect(interpretedResponse[0].creativeId).to.equal(nativeServerResponse.body.bids[0].creativeId);
+      expect(interpretedResponse[0].currency).to.equal(nativeServerResponse.body.bids[0].currency);
+      expect(interpretedResponse[0].netRevenue).to.equal(nativeServerResponse.body.bids[0].netRevenue);
+      expect(interpretedResponse[0].ttl).to.equal(nativeServerResponse.body.bids[0].ttl);
+      expect(interpretedResponse[0].native).to.deep.equal(nativeServerResponse.body.bids[0].native);
+      expect(interpretedResponse[0].meta.advertiserDomains[0]).to.equal(nativeServerResponse.body.bids[0].meta.advertiserDomains[0]);
+    });
+  });
+
+  describe('getUserSync tests', function () {
+    it('UserSync test : check type = iframe, check usermatch URL', function () {
+      const syncOptions = {
+        'iframeEnabled': true
+      }
+      let userSync = spec.getUserSyncs(syncOptions, [nativeServerResponse]);
+      expect(userSync[0].type).to.equal('iframe');
+      const USER_SYNC_URL = 'https://sync.logly.co.jp/sync/sync.html';
+      expect(userSync[0].url).to.equal(USER_SYNC_URL);
+    });
+
+    it('When iframeEnabled is false, no userSync should be returned', function () {
+      const syncOptions = {
+        'iframeEnabled': false
+      }
+      let userSync = spec.getUserSyncs(syncOptions, [nativeServerResponse]);
+      expect(userSync).to.be.an('array').that.is.empty;
+    });
+
+    it('When nativeServerResponses empty, no userSync should be returned', function () {
+      const syncOptions = {
+        'iframeEnabled': false
+      }
+      let userSync = spec.getUserSyncs(syncOptions, []);
+      expect(userSync).to.be.an('array').that.is.empty;
+    });
+  });
+});

package/test/spec/modules/lotamePanoramaIdSystem_spec.js

@@ -2,6 +2,7 @@ import {
   lotamePanoramaIdSubmodule,
   storage,
 } from 'modules/lotamePanoramaIdSystem.js';
+import { uspDataHandler } from 'src/adapterManager.js';
 import * as utils from 'src/utils.js';
 import { server } from 'test/mocks/xhr.js';
 import sinon from 'sinon';
@@ -16,6 +17,7 @@ describe('LotameId', function() {
   let setLocalStorageStub;
   let removeFromLocalStorageStub;
   let timeStampStub;
+  let uspConsentDataStub;
 
   const nowTimestamp = new Date().getTime();
 
@@ -30,6 +32,7 @@ describe('LotameId', function() {
       'removeDataFromLocalStorage'
     );
     timeStampStub = sinon.stub(utils, 'timestamp').returns(nowTimestamp);
+    uspConsentDataStub = sinon.stub(uspDataHandler, 'getConsentData');
   });
 
   afterEach(function () {
@@ -40,6 +43,7 @@ describe('LotameId', function() {
     setLocalStorageStub.restore();
     removeFromLocalStorageStub.restore();
     timeStampStub.restore();
+    uspConsentDataStub.restore();
   });
 
   describe('caching initial data received from the remote server', function () {
@@ -726,4 +730,227 @@ describe('LotameId', function() {
       );
     });
   });
+
+  describe('with a custom client id', function () {
+    describe('with a client expiry set', function () {
+      beforeEach(function () {
+        getCookieStub
+          .withArgs('panoramaId_expiry_1234')
+          .returns(String(Date.now() + 500 * 1000));
+      });
+
+      describe('and an existing pano id', function() {
+        let submoduleCallback;
+        beforeEach(function () {
+          getCookieStub
+            .withArgs('panoramaId_expiry')
+            .returns(String(Date.now() + 100000));
+          getCookieStub
+            .withArgs('panoramaId')
+            .returns(
+              'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87c'
+            );
+          submoduleCallback = lotamePanoramaIdSubmodule.getId(
+            {
+              params: {
+                clientId: '1234',
+              },
+            },
+            {
+              gdprApplies: false,
+            }
+          );
+        });
+
+        it('should not call the remote server when getId is called nor get an id', function () {
+          expect(submoduleCallback).to.be.eql({
+            id: undefined,
+            reason: 'NO_CLIENT_CONSENT',
+          });
+        });
+      });
+
+      describe('and no existing pano id', function () {
+        let submoduleCallback;
+
+        beforeEach(function () {
+          // Let the panoramaId_expiry be empty
+
+          submoduleCallback = lotamePanoramaIdSubmodule.getId(
+            {
+              params: {
+                clientId: '1234',
+              },
+            },
+            {
+              gdprApplies: false,
+            }
+          );
+        });
+
+        it('should not call the remote server nor return an id', function () {
+          expect(submoduleCallback).to.be.eql({
+            id: undefined,
+            reason: 'NO_CLIENT_CONSENT',
+          });
+        });
+      });
+    });
+
+    describe('with no client expiry set', function () {
+      describe('and no existing pano id', function () {
+        let request;
+        let callBackSpy = sinon.spy();
+
+        beforeEach(function () {
+          uspConsentDataStub.returns('1NNN');
+          let submoduleCallback = lotamePanoramaIdSubmodule.getId(
+            {
+              params: {
+                clientId: '1234',
+              },
+            },
+            {
+              gdprApplies: false,
+            }
+          ).callback;
+          submoduleCallback(callBackSpy);
+
+          request = server.requests[0];
+
+          request.respond(
+            200,
+            responseHeader,
+            JSON.stringify({
+              profile_id: '4ec137245858469eb94a4e248f238694',
+              core_id:
+                'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87f',
+              expiry_ts: 3600000,
+            })
+          );
+        });
+
+        it('should call the remote server when getId is called', function () {
+          expect(callBackSpy.calledOnce).to.be.true;
+        });
+
+        it('should pass the usp consent string and client id back', function () {
+          expect(request.url).to.be.eq(
+            'https://id.crwdcntrl.net/id?gdpr_applies=false&us_privacy=1NNN&c=1234'
+          );
+        });
+
+        it('should NOT set an expiry for the client', function () {
+          sinon.assert.neverCalledWith(
+            setCookieStub,
+            'panoramaId_expiry_1234',
+            sinon.match.number
+          );
+        });
+      });
+
+      describe('and an existing pano id', function () {
+        let submoduleCallback;
+
+        beforeEach(function () {
+          getCookieStub
+            .withArgs('panoramaId_expiry')
+            .returns(String(Date.now() + 100000));
+          getCookieStub
+            .withArgs('panoramaId')
+            .returns(
+              'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87c'
+            );
+          submoduleCallback = lotamePanoramaIdSubmodule.getId(
+            {
+              params: {
+                clientId: '1234',
+              },
+            },
+            {
+              gdprApplies: false,
+            }
+          );
+        });
+
+        it('should not call the remote server but use the cached value', function () {
+          expect(submoduleCallback).to.be.eql({
+            id: 'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87c',
+          });
+        });
+
+        it('should NOT set an expiry for the client', function () {
+          sinon.assert.neverCalledWith(
+            setCookieStub,
+            'panoramaId_expiry_1234',
+            sinon.match.number
+          );
+        });
+      });
+    });
+    describe('when client consent has errors', function () {
+      let request;
+      let callBackSpy = sinon.spy();
+
+      beforeEach(function () {
+        let submoduleCallback = lotamePanoramaIdSubmodule.getId(
+          {
+            params: {
+              clientId: '1234',
+            },
+          },
+          {
+            gdprApplies: false,
+          }
+        ).callback;
+        submoduleCallback(callBackSpy);
+
+        request = server.requests[0];
+
+        request.respond(
+          200,
+          responseHeader,
+          JSON.stringify({
+            expiry_ts: 3600000,
+            errors: [111],
+            no_consent: 'CLIENT',
+          })
+        );
+      });
+
+      it('should call the remote server when getId is called', function () {
+        expect(callBackSpy.calledOnce).to.be.true;
+      });
+
+      it('should pass client id back', function () {
+        expect(request.url).to.be.eq(
+          'https://id.crwdcntrl.net/id?gdpr_applies=false&c=1234'
+        );
+      });
+
+      it('should set the received expiry for the client', function() {
+        sinon.assert.calledWith(
+          setCookieStub,
+          'panoramaId_expiry_1234',
+          3600000
+        );
+      });
+
+      it('should not clear the cache for the panorama id', function() {
+        sinon.assert.neverCalledWith(
+          setCookieStub,
+          'panoramaId',
+          sinon.match.any
+        );
+      });
+
+      it('should not clear the cache for the panorama id expiry', function () {
+        sinon.assert.neverCalledWith(
+          setCookieStub,
+          'panoramaId_expiry',
+          sinon.match.any
+        );
+      });
+    });
+  });
 });