prebid.js 7.46.0 → 7.47.0

package/modules/vidoomyBidAdapter.md

@@ -27,7 +27,12 @@ var adUnits = [
         params: {
           id: '123123',
           pid: '123123',
-          bidfloor: 0.5 // This is optional
+          bidfloor: 0.5, // This is optional
+          bcat: ['IAB1-1'], // Optional - default is []
+          badv: ['example.com'], // Optional - default is []
+          bapp: ['app.com'], // Optional - default is []
+          btype: [1, 2, 3], // Optional - default is []
+          battr: [1, 2, 3] // Optional - default is []
         }
       }
     ]
@@ -52,7 +57,12 @@ var adUnits = [
         params: {
           id: '123123',
           pid: '123123',
-          bidfloor: 0.5 // This is optional
+          bidfloor: 0.5, // This is optional
+          bcat: ['IAB1-1'], // Optional - default is []
+          badv: ['example.com'],  // Optional - default is []
+          bapp: ['app.com'], // Optional - default is []
+          btype: [1, 2, 3], // Optional - default is []
+          battr: [1, 2, 3] // Optional - default is []
         }
       }
     ]

package/modules/yieldmoBidAdapter.js

@@ -83,7 +83,7 @@ export const spec = {
           gdprApplies: deepAccess(bidderRequest, 'gdprConsent.gdprApplies') || '',
           cmp: deepAccess(bidderRequest, 'gdprConsent.consentString') || '',
           gpp: deepAccess(bidderRequest, 'gppConsent.gppString') || '',
-          gpp_sid: deepAccess(bidderRequest, 'gppConsent.applicableSections') || ''
+          gpp_sid: deepAccess(bidderRequest, 'gppConsent.applicableSections') || []
         }),
         us_privacy: deepAccess(bidderRequest, 'uspConsent') || ''
       };
@@ -525,7 +525,7 @@ function populateOpenRtbGdpr(openRtbRequest, bidderRequest) {
     deepSetValue(openRtbRequest, 'regs.ext.gdpr', gdpr && gdpr.gdprApplies ? 1 : 0);
     deepSetValue(openRtbRequest, 'user.ext.consent', gdpr && gdpr.consentString ? gdpr.consentString : '');
   }
-  if (gppsid) {
+  if (gppsid && gppsid.length > 0) {
     deepSetValue(openRtbRequest, 'regs.ext.gpp_sid', gppsid);
   }
   const uspConsent = deepAccess(bidderRequest, 'uspConsent');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prebid.js",
-  "version": "7.46.0",
+  "version": "7.47.0",
   "description": "Header Bidding Management Library",
   "main": "src/prebid.js",
   "scripts": {

package/test/spec/modules/criteoIdSystem_spec.js

@@ -1,5 +1,6 @@
 import { criteoIdSubmodule, storage } from 'modules/criteoIdSystem.js';
 import * as utils from 'src/utils.js';
+import { gdprDataHandler, uspDataHandler, gppDataHandler } from '../../../src/adapterManager.js';
 import { server } from '../../mocks/xhr';
 
 const pastDateString = new Date(0).toString()
@@ -17,6 +18,9 @@ describe('CriteoId module', function () {
   let timeStampStub;
   let parseUrlStub;
   let triggerPixelStub;
+  let gdprConsentDataStub;
+  let uspConsentDataStub;
+  let gppConsentDataStub;
 
   beforeEach(function (done) {
     getCookieStub = sinon.stub(storage, 'getCookie');
@@ -27,6 +31,9 @@ describe('CriteoId module', function () {
     timeStampStub = sinon.stub(utils, 'timestamp').returns(nowTimestamp);
     parseUrlStub = sinon.stub(utils, 'parseUrl').returns({ protocol: 'https', hostname: 'testdev.com' })
     triggerPixelStub = sinon.stub(utils, 'triggerPixel');
+    gdprConsentDataStub = sinon.stub(gdprDataHandler, 'getConsentData');
+    uspConsentDataStub = sinon.stub(uspDataHandler, 'getConsentData');
+    gppConsentDataStub = sinon.stub(gppDataHandler, 'getConsentData');
     done();
   });
 
@@ -39,6 +46,9 @@ describe('CriteoId module', function () {
     timeStampStub.restore();
     triggerPixelStub.restore();
     parseUrlStub.restore();
+    gdprConsentDataStub.restore();
+    uspConsentDataStub.restore();
+    gppConsentDataStub.restore();
   });
 
   const storageTestCases = [
@@ -136,11 +146,11 @@ describe('CriteoId module', function () {
   }));
 
   const gdprConsentTestCases = [
-    { consentData: { gdprApplies: true, consentString: 'expectedConsentString' }, expected: 'expectedConsentString' },
-    { consentData: { gdprApplies: false, consentString: 'expectedConsentString' }, expected: undefined },
-    { consentData: { gdprApplies: true, consentString: undefined }, expected: undefined },
-    { consentData: { gdprApplies: 'oui', consentString: 'expectedConsentString' }, expected: undefined },
-    { consentData: undefined, expected: undefined }
+    { consentData: { gdprApplies: true, consentString: 'expectedConsentString' }, expectedGdprConsent: 'expectedConsentString', expectedGdpr: '1' },
+    { consentData: { gdprApplies: false, consentString: 'expectedConsentString' }, expectedGdprConsent: 'expectedConsentString', expectedGdpr: '0' },
+    { consentData: { gdprApplies: true, consentString: undefined }, expectedGdprConsent: undefined, expectedGdpr: '1' },
+    { consentData: { gdprApplies: 'oui', consentString: 'expectedConsentString' }, expectedGdprConsent: 'expectedConsentString', expectedGdpr: '0' },
+    { consentData: undefined, expectedGdprConsent: undefined, expectedGdpr: undefined }
   ];
 
   it('should call sync pixels if request by backend', function () {
@@ -225,14 +235,94 @@ describe('CriteoId module', function () {
 
   gdprConsentTestCases.forEach(testCase => it('should call user sync url with the gdprConsent', function () {
     let callBackSpy = sinon.spy();
-    let result = criteoIdSubmodule.getId(undefined, testCase.consentData);
+
+    gdprConsentDataStub.returns(testCase.consentData);
+
+    let result = criteoIdSubmodule.getId(undefined);
+    result.callback(callBackSpy);
+
+    let request = server.requests[0];
+
+    if (testCase.expectedGdprConsent) {
+      expect(request.url).to.have.string(`gdprString=${testCase.expectedGdprConsent}`);
+    } else {
+      expect(request.url).to.not.have.string('gdprString=');
+    }
+
+    if (testCase.expectedGdpr) {
+      expect(request.url).to.have.string(`gdpr=${testCase.expectedGdpr}`);
+    } else {
+      expect(request.url).to.not.have.string('gdpr=');
+    }
+
+    request.respond(
+      200,
+      { 'Content-Type': 'application/json' },
+      JSON.stringify({})
+    );
+
+    expect(callBackSpy.calledOnce).to.be.true;
+  }));
+
+  [undefined, 'abc'].forEach(usPrivacy => it('should call user sync url with the us privacy string', function () {
+    let callBackSpy = sinon.spy();
+
+    uspConsentDataStub.returns(usPrivacy);
+
+    let result = criteoIdSubmodule.getId(undefined);
     result.callback(callBackSpy);
 
     let request = server.requests[0];
-    if (testCase.expected) {
-      expect(request.url).to.have.string(`gdprString=${testCase.expected}`);
+
+    if (usPrivacy) {
+      expect(request.url).to.have.string(`us_privacy=${usPrivacy}`);
+    } else {
+      expect(request.url).to.not.have.string('us_privacy=');
+    }
+
+    request.respond(
+      200,
+      { 'Content-Type': 'application/json' },
+      JSON.stringify({})
+    );
+
+    expect(callBackSpy.calledOnce).to.be.true;
+  }));
+
+  [
+    {
+      consentData: {
+        gppString: 'abc',
+        applicableSections: [1]
+      },
+      expectedGpp: 'abc',
+      expectedGppSid: '1'
+    },
+    {
+      consentData: undefined,
+      expectedGpp: undefined,
+      expectedGppSid: undefined
+    }
+  ].forEach(testCase => it('should call user sync url with the gpp string', function () {
+    let callBackSpy = sinon.spy();
+
+    gppConsentDataStub.returns(testCase.consentData);
+
+    let result = criteoIdSubmodule.getId(undefined);
+    result.callback(callBackSpy);
+
+    let request = server.requests[0];
+
+    if (testCase.expectedGpp) {
+      expect(request.url).to.have.string(`gpp=${testCase.expectedGpp}`);
+    } else {
+      expect(request.url).to.not.have.string('gpp=');
+    }
+
+    if (testCase.expectedGppSid) {
+      expect(request.url).to.have.string(`gpp_sid=${testCase.expectedGppSid}`);
     } else {
-      expect(request.url).to.not.have.string('gdprString');
+      expect(request.url).to.not.have.string('gpp_sid=');
     }
 
     request.respond(

package/test/spec/modules/emtvBidAdapter_spec.js

@@ -0,0 +1,400 @@
+import { expect } from 'chai';
+import { spec } from '../../../modules/emtvBidAdapter.js';
+import { BANNER, VIDEO, NATIVE } from '../../../src/mediaTypes.js';
+import { getUniqueIdentifierStr } from '../../../src/utils.js';
+
+const bidder = 'emtv'
+const adUrl = 'https://us-east-ep.engagemedia.tv/pbjs';
+const syncUrl = 'https://cs.engagemedia.tv';
+
+describe('EMTVBidAdapter', function () {
+  const bids = [
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [BANNER]: {
+          sizes: [[300, 250]]
+        }
+      },
+      params: {
+        placementId: 'testBanner',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [VIDEO]: {
+          playerSize: [[300, 300]],
+          minduration: 5,
+          maxduration: 60
+        }
+      },
+      params: {
+        placementId: 'testVideo',
+      }
+    },
+    {
+      bidId: getUniqueIdentifierStr(),
+      bidder: bidder,
+      mediaTypes: {
+        [NATIVE]: {
+          native: {
+            title: {
+              required: true
+            },
+            body: {
+              required: true
+            },
+            icon: {
+              required: true,
+              size: [64, 64]
+            }
+          }
+        }
+      },
+      params: {
+        placementId: 'testNative',
+      }
+    }
+  ];
+
+  const invalidBid = {
+    bidId: getUniqueIdentifierStr(),
+    bidder: bidder,
+    mediaTypes: {
+      [BANNER]: {
+        sizes: [[300, 250]]
+      }
+    },
+    params: {
+
+    }
+  }
+
+  const bidderRequest = {
+    uspConsent: '1---',
+    gdprConsent: 'COvFyGBOvFyGBAbAAAENAPCAAOAAAAAAAAAAAEEUACCKAAA.IFoEUQQgAIQwgIwQABAEAAAAOIAACAIAAAAQAIAgEAACEAAAAAgAQBAAAAAAAGBAAgAAAAAAAFAAECAAAgAAQARAEQAAAAAJAAIAAgAAAYQEAAAQmAgBC3ZAYzUw',
+    refererInfo: {
+      referer: 'https://test.com'
+    }
+  };
+
+  describe('isBidRequestValid', function () {
+    it('Should return true if there are bidId, params and key parameters present', function () {
+      expect(spec.isBidRequestValid(bids[0])).to.be.true;
+    });
+    it('Should return false if at least one of parameters is not present', function () {
+      expect(spec.isBidRequestValid(invalidBid)).to.be.false;
+    });
+  });
+
+  describe('buildRequests', function () {
+    let serverRequest = spec.buildRequests(bids, bidderRequest);
+
+    it('Creates a ServerRequest object with method, URL and data', function () {
+      expect(serverRequest).to.exist;
+      expect(serverRequest.method).to.exist;
+      expect(serverRequest.url).to.exist;
+      expect(serverRequest.data).to.exist;
+    });
+
+    it('Returns POST method', function () {
+      expect(serverRequest.method).to.equal('POST');
+    });
+
+    it('Returns valid URL', function () {
+      expect(serverRequest.url).to.equal(adUrl);
+    });
+
+    it('Returns general data valid', function () {
+      let data = serverRequest.data;
+      expect(data).to.be.an('object');
+      expect(data).to.have.all.keys('deviceWidth',
+        'deviceHeight',
+        'language',
+        'secure',
+        'host',
+        'page',
+        'placements',
+        'coppa',
+        'ccpa',
+        'gdpr',
+        'tmax'
+      );
+      expect(data.deviceWidth).to.be.a('number');
+      expect(data.deviceHeight).to.be.a('number');
+      expect(data.language).to.be.a('string');
+      expect(data.secure).to.be.within(0, 1);
+      expect(data.host).to.be.a('string');
+      expect(data.page).to.be.a('string');
+      expect(data.coppa).to.be.a('number');
+      expect(data.gdpr).to.be.a('string');
+      expect(data.ccpa).to.be.a('string');
+      expect(data.tmax).to.be.a('number');
+      expect(data.placements).to.have.lengthOf(3);
+    });
+
+    it('Returns valid placements', function () {
+      const { placements } = serverRequest.data;
+      for (let i = 0, len = placements.length; i < len; i++) {
+        const placement = placements[i];
+        expect(placement.placementId).to.be.oneOf(['testBanner', 'testVideo', 'testNative']);
+        expect(placement.adFormat).to.be.oneOf([BANNER, VIDEO, NATIVE]);
+        expect(placement.bidId).to.be.a('string');
+        expect(placement.schain).to.be.an('object');
+        expect(placement.bidfloor).to.exist.and.to.equal(0);
+        expect(placement.type).to.exist.and.to.equal('publisher');
+
+        if (placement.adFormat === BANNER) {
+          expect(placement.sizes).to.be.an('array');
+        }
+        switch (placement.adFormat) {
+          case BANNER:
+            expect(placement.sizes).to.be.an('array');
+            break;
+          case VIDEO:
+            expect(placement.playerSize).to.be.an('array');
+            expect(placement.minduration).to.be.an('number');
+            expect(placement.maxduration).to.be.an('number');
+            break;
+          case NATIVE:
+            expect(placement.native).to.be.an('object');
+            break;
+        }
+      }
+    });
+
+    it('Returns data with gdprConsent and without uspConsent', function () {
+      delete bidderRequest.uspConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.gdpr).to.exist;
+      expect(data.gdpr).to.be.a('string');
+      expect(data.gdpr).to.equal(bidderRequest.gdprConsent);
+      expect(data.ccpa).to.not.exist;
+      delete bidderRequest.gdprConsent;
+    });
+
+    it('Returns data with uspConsent and without gdprConsent', function () {
+      bidderRequest.uspConsent = '1---';
+      delete bidderRequest.gdprConsent;
+      serverRequest = spec.buildRequests(bids, bidderRequest);
+      let data = serverRequest.data;
+      expect(data.ccpa).to.exist;
+      expect(data.ccpa).to.be.a('string');
+      expect(data.ccpa).to.equal(bidderRequest.uspConsent);
+      expect(data.gdpr).to.not.exist;
+    });
+
+    it('Returns empty data if no valid requests are passed', function () {
+      serverRequest = spec.buildRequests([], bidderRequest);
+      let data = serverRequest.data;
+      expect(data.placements).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('interpretResponse', function () {
+    it('Should interpret banner response', function () {
+      const banner = {
+        body: [{
+          mediaType: 'banner',
+          width: 300,
+          height: 250,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let bannerResponses = spec.interpretResponse(banner);
+      expect(bannerResponses).to.be.an('array').that.is.not.empty;
+      let dataItem = bannerResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'width', 'height', 'ad', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal(banner.body[0].requestId);
+      expect(dataItem.cpm).to.equal(banner.body[0].cpm);
+      expect(dataItem.width).to.equal(banner.body[0].width);
+      expect(dataItem.height).to.equal(banner.body[0].height);
+      expect(dataItem.ad).to.equal(banner.body[0].ad);
+      expect(dataItem.ttl).to.equal(banner.body[0].ttl);
+      expect(dataItem.creativeId).to.equal(banner.body[0].creativeId);
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal(banner.body[0].currency);
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret video response', function () {
+      const video = {
+        body: [{
+          vastUrl: 'test.com',
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let videoResponses = spec.interpretResponse(video);
+      expect(videoResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = videoResponses[0];
+      expect(dataItem).to.have.all.keys('requestId', 'cpm', 'vastUrl', 'ttl', 'creativeId',
+        'netRevenue', 'currency', 'dealId', 'mediaType', 'meta');
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.5);
+      expect(dataItem.vastUrl).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should interpret native response', function () {
+      const native = {
+        body: [{
+          mediaType: 'native',
+          native: {
+            clickUrl: 'test.com',
+            title: 'Test',
+            image: 'test.com',
+            impressionTrackers: ['test.com'],
+          },
+          ttl: 120,
+          cpm: 0.4,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          meta: {
+            advertiserDomains: ['google.com'],
+            advertiserId: 1234
+          }
+        }]
+      };
+      let nativeResponses = spec.interpretResponse(native);
+      expect(nativeResponses).to.be.an('array').that.is.not.empty;
+
+      let dataItem = nativeResponses[0];
+      expect(dataItem).to.have.keys('requestId', 'cpm', 'ttl', 'creativeId', 'netRevenue', 'currency', 'mediaType', 'native', 'meta');
+      expect(dataItem.native).to.have.keys('clickUrl', 'impressionTrackers', 'title', 'image')
+      expect(dataItem.requestId).to.equal('23fhj33i987f');
+      expect(dataItem.cpm).to.equal(0.4);
+      expect(dataItem.native.clickUrl).to.equal('test.com');
+      expect(dataItem.native.title).to.equal('Test');
+      expect(dataItem.native.image).to.equal('test.com');
+      expect(dataItem.native.impressionTrackers).to.be.an('array').that.is.not.empty;
+      expect(dataItem.native.impressionTrackers[0]).to.equal('test.com');
+      expect(dataItem.ttl).to.equal(120);
+      expect(dataItem.creativeId).to.equal('2');
+      expect(dataItem.netRevenue).to.be.true;
+      expect(dataItem.currency).to.equal('USD');
+      expect(dataItem.meta).to.be.an('object').that.has.any.key('advertiserDomains');
+    });
+    it('Should return an empty array if invalid banner response is passed', function () {
+      const invBanner = {
+        body: [{
+          width: 300,
+          cpm: 0.4,
+          ad: 'Test',
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+
+      let serverResponses = spec.interpretResponse(invBanner);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid video response is passed', function () {
+      const invVideo = {
+        body: [{
+          mediaType: 'video',
+          cpm: 0.5,
+          requestId: '23fhj33i987f',
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invVideo);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid native response is passed', function () {
+      const invNative = {
+        body: [{
+          mediaType: 'native',
+          clickUrl: 'test.com',
+          title: 'Test',
+          impressionTrackers: ['test.com'],
+          ttl: 120,
+          requestId: '23fhj33i987f',
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invNative);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+    it('Should return an empty array if invalid response is passed', function () {
+      const invalid = {
+        body: [{
+          ttl: 120,
+          creativeId: '2',
+          netRevenue: true,
+          currency: 'USD',
+          dealId: '1'
+        }]
+      };
+      let serverResponses = spec.interpretResponse(invalid);
+      expect(serverResponses).to.be.an('array').that.is.empty;
+    });
+  });
+
+  describe('getUserSyncs', function() {
+    it('Should return array of objects with proper sync config , include GDPR', function() {
+      const syncData = spec.getUserSyncs({}, {}, {
+        consentString: 'ALL',
+        gdprApplies: true,
+      }, {});
+      expect(syncData).to.be.an('array').which.is.not.empty;
+      expect(syncData[0]).to.be.an('object')
+      expect(syncData[0].type).to.be.a('string')
+      expect(syncData[0].type).to.equal('image')
+      expect(syncData[0].url).to.be.a('string')
+      expect(syncData[0].url).to.equal(`${syncUrl}/image?pbjs=1&gdpr=1&gdpr_consent=ALL&coppa=0`)
+    });
+    it('Should return array of objects with proper sync config , include CCPA', function() {
+      const syncData = spec.getUserSyncs({}, {}, {}, {
+        consentString: '1---'
+      });
+      expect(syncData).to.be.an('array').which.is.not.empty;
+      expect(syncData[0]).to.be.an('object')
+      expect(syncData[0].type).to.be.a('string')
+      expect(syncData[0].type).to.equal('image')
+      expect(syncData[0].url).to.be.a('string')
+      expect(syncData[0].url).to.equal(`${syncUrl}/image?pbjs=1&ccpa_consent=1---&coppa=0`)
+    });
+  });
+});

package/test/spec/modules/rtbhouseBidAdapter_spec.js

@@ -631,10 +631,10 @@ describe('RTBHouseAdapter', () => {
         expect(bids[0].meta.advertiserDomains).to.deep.equal(['rtbhouse.com']);
         expect(bids[0].native).to.deep.equal({
           title: 'Title text',
-          clickUrl: encodeURIComponent('https://example.com'),
+          clickUrl: encodeURI('https://example.com'),
           impressionTrackers: ['https://example.com/imptracker'],
           image: {
-            url: encodeURIComponent('https://example.com/image.jpg'),
+            url: encodeURI('https://example.com/image.jpg'),
             width: 150,
             height: 50
           },

package/test/spec/modules/vidoomyBidAdapter_spec.js

@@ -219,6 +219,55 @@ describe('vidoomyBidAdapter', function() {
         expect(bidRequest.data.bidfloor).to.equal(bidfloor);
       });
     });
+
+    describe('badv, bcat, bapp, btype, battr', function () {
+      const bidderRequestNew = {
+        ...bidderRequest,
+        bcat: ['EX1', 'EX2', 'EX3'],
+        badv: ['site.com'],
+        bapp: ['app.com'],
+        btype: [1, 2, 3],
+        battr: [1, 2, 3]
+      }
+      const request = spec.buildRequests(bidRequests, bidderRequestNew);
+      it('should have badv, bcat, bapp, btype, battr in request', function () {
+        expect(request[0].data).to.include.any.keys('badv');
+        expect(request[0].data).to.include.any.keys('bcat');
+        expect(request[0].data).to.include.any.keys('bapp');
+        expect(request[0].data).to.include.any.keys('btype');
+        expect(request[0].data).to.include.any.keys('battr');
+      })
+
+      it('should have equal badv, bcat, bapp, btype, battr in request', function () {
+        expect(request[0].badv).to.deep.equal(bidderRequest.refererInfo.badv);
+        expect(request[0].bcat).to.deep.equal(bidderRequest.refererInfo.bcat);
+        expect(request[0].bapp).to.deep.equal(bidderRequest.refererInfo.bapp);
+        expect(request[0].btype).to.deep.equal(bidderRequest.refererInfo.btype);
+        expect(request[0].battr).to.deep.equal(bidderRequest.refererInfo.battr);
+      })
+    })
+
+    describe('first party data', function () {
+      const bidderRequest2 = {
+        ...bidderRequest,
+        ortb2: {
+          bcat: ['EX1', 'EX2', 'EX3'],
+          badv: ['site.com'],
+          bapp: ['app.com'],
+          btype: [1, 2, 3],
+          battr: [1, 2, 3]
+        }
+      }
+      const request = spec.buildRequests(bidRequests, bidderRequest2);
+
+      it('should have badv, bcat, bapp, btype, battr in request and equal to bidderRequest.ortb2', function () {
+        expect(request[0].data.bcat).to.deep.equal(bidderRequest2.ortb2.bcat)
+        expect(request[0].data.badv).to.deep.equal(bidderRequest2.ortb2.badv)
+        expect(request[0].data.bapp).to.deep.equal(bidderRequest2.ortb2.bapp);
+        expect(request[0].data.btype).to.deep.equal(bidderRequest2.ortb2.btype);
+        expect(request[0].data.battr).to.deep.equal(bidderRequest2.ortb2.battr);
+      });
+    });
   });
 
   describe('interpretResponse', function () {