prebid.js 8.7.0 → 8.8.0

package/test/spec/modules/eids_spec.js

@@ -271,6 +271,39 @@ describe('eids array generation for known sub-modules', function() {
     });
   });
 
+  it('index', function() {
+    const userId = {
+      index: {'id': 'sample_id'}
+    };
+    const newEids = createEidsArray(userId);
+    expect(newEids.length).to.equal(1);
+    expect(newEids[0]).to.deep.equal({
+      source: 'liveintent.indexexchange.com',
+      uids: [{
+        id: 'sample_id',
+        atype: 3
+      }]
+    });
+  });
+
+  it('index with ext', function() {
+    const userId = {
+      index: {'id': 'sample_id', 'ext': {'provider': 'some.provider.com'}}
+    };
+    const newEids = createEidsArray(userId);
+    expect(newEids.length).to.equal(1);
+    expect(newEids[0]).to.deep.equal({
+      source: 'liveintent.indexexchange.com',
+      uids: [{
+        id: 'sample_id',
+        atype: 3,
+        ext: {
+          provider: 'some.provider.com'
+        }
+      }]
+    });
+  });
+
   it('liveIntentId; getValue call and NO ext', function() {
     const userId = {
       lipb: {
@@ -547,6 +580,21 @@ describe('eids array generation for known sub-modules', function() {
     });
   });
 
+  it('operaId', function() {
+    const userId = {
+      operaId: 'some-random-id-value'
+    };
+    const newEids = createEidsArray(userId);
+    expect(newEids.length).to.equal(1);
+    expect(newEids[0]).to.deep.equal({
+      source: 't.adx.opera.com',
+      uids: [{
+        id: 'some-random-id-value',
+        atype: 1
+      }]
+    });
+  });
+
   it('33acrossId', function() {
     const userId = {
       '33acrossId': {

package/test/spec/modules/geoedgeRtdProvider_spec.js

@@ -1,12 +1,13 @@
 import * as utils from '../../../src/utils.js';
+import { loadExternalScript } from '../../../src/adloader.js';
 import * as hook from '../../../src/hook.js'
-import { beforeInit, geoedgeSubmodule, setWrapper, wrapper, htmlPlaceholder, WRAPPER_URL, getClientUrl } from '../../../modules/geoedgeRtdProvider.js';
+import { beforeInit, geoedgeSubmodule, setWrapper, wrapper, htmlPlaceholder, WRAPPER_URL, getClientUrl, getInPageUrl } from '../../../modules/geoedgeRtdProvider.js';
 import { server } from '../../../test/mocks/xhr.js';
 import * as events from '../../../src/events.js';
 import CONSTANTS from '../../../src/constants.json';
 
 let key = '123123123';
-function makeConfig() {
+function makeConfig(gpt) {
   return {
     name: 'geoedge',
     params: {
@@ -15,7 +16,8 @@ function makeConfig() {
       bidders: {
         bidderA: true,
         bidderB: false
-      }
+      },
+      gpt: gpt
     }
   };
 }
@@ -23,6 +25,7 @@ function makeConfig() {
 function mockBid(bidderCode) {
   return {
     'ad': '<creative/>',
+    'adId': '1234',
     'cpm': '1.00',
     'width': 300,
     'height': 250,
@@ -35,6 +38,15 @@ function mockBid(bidderCode) {
   };
 }
 
+function mockMessageFromClient(key) {
+  return {
+    key,
+    impression: true,
+    adId: 1234,
+    type: 'impression'
+  };
+}
+
 let mockWrapper = `<wrapper>${htmlPlaceholder}</wrapper>`;
 
 describe('Geoedge RTD module', function () {
@@ -47,22 +59,11 @@ describe('Geoedge RTD module', function () {
     after(function () {
       submoduleStub.restore();
     });
-    it('should fetch the wrapper', function () {
-      beforeInit();
-      let request = server.requests[0];
-      let isWrapperRequest = request && request.url && request.url && request.url === WRAPPER_URL;
-      expect(isWrapperRequest).to.equal(true);
-    });
     it('should register RTD submodule provider', function () {
+      beforeInit();
       expect(submoduleStub.calledWith('realTimeData', geoedgeSubmodule)).to.equal(true);
     });
   });
-  describe('setWrapper', function () {
-    it('should set the wrapper', function () {
-      setWrapper(mockWrapper);
-      expect(wrapper).to.equal(mockWrapper);
-    });
-  });
   describe('submodule', function () {
     describe('name', function () {
       it('should be geoedge', function () {
@@ -84,35 +85,54 @@ describe('Geoedge RTD module', function () {
         expect(missingParams || missingKey).to.equal(false);
       });
       it('should return true when params are ok', function () {
-        expect(geoedgeSubmodule.init(makeConfig())).to.equal(true);
+        expect(geoedgeSubmodule.init(makeConfig(false))).to.equal(true);
+      });
+      it('should fetch the wrapper', function () {
+        geoedgeSubmodule.init(makeConfig(false));
+        let request = server.requests[0];
+        let isWrapperRequest = request && request.url && request.url && request.url === WRAPPER_URL;
+        expect(isWrapperRequest).to.equal(true);
       });
       it('should preload the client', function () {
         let isLinkPreloadAsScript = arg => arg.tagName === 'LINK' && arg.rel === 'preload' && arg.as === 'script' && arg.href === getClientUrl(key);
         expect(insertElementStub.calledWith(sinon.match(isLinkPreloadAsScript))).to.equal(true);
       });
-      it('should emit billable events with applicable winning bids', function () {
-        let applicableBid = mockBid('bidderA');
-        let nonApplicableBid = mockBid('bidderB');
+      it('should emit billable events with applicable winning bids', function (done) {
         let counter = 0;
         events.on(CONSTANTS.EVENTS.BILLABLE_EVENT, function (event) {
           if (event.vendor === 'geoedge' && event.type === 'impression') {
             counter += 1;
           }
+          expect(counter).to.equal(1);
+          done();
         });
-        events.emit(CONSTANTS.EVENTS.BID_WON, applicableBid);
-        events.emit(CONSTANTS.EVENTS.BID_WON, nonApplicableBid);
-        expect(counter).to.equal(1);
+        window.postMessage(mockMessageFromClient(key), '*');
+      });
+      it('should load the in page code when gpt params is true', function () {
+        geoedgeSubmodule.init(makeConfig(true));
+        let isInPageUrl = arg => arg == getInPageUrl(key);
+        expect(loadExternalScript.calledWith(sinon.match(isInPageUrl))).to.equal(true);
+      });
+      it('should set the window.grumi config object when gpt params is true', function () {
+        let hasGrumiObj = typeof window.grumi === 'object';
+        expect(hasGrumiObj && window.grumi.key === key && window.grumi.fromPrebid).to.equal(true);
+      });
+    });
+    describe('setWrapper', function () {
+      it('should set the wrapper', function () {
+        setWrapper(mockWrapper);
+        expect(wrapper).to.equal(mockWrapper);
       });
     });
     describe('onBidResponseEvent', function () {
       let bidFromA = mockBid('bidderA');
       it('should wrap bid html when bidder is configured', function () {
-        geoedgeSubmodule.onBidResponseEvent(bidFromA, makeConfig());
+        geoedgeSubmodule.onBidResponseEvent(bidFromA, makeConfig(false));
         expect(bidFromA.ad.indexOf('<wrapper>')).to.equal(0);
       });
       it('should not wrap bid html when bidder is not configured', function () {
         let bidFromB = mockBid('bidderB');
-        geoedgeSubmodule.onBidResponseEvent(bidFromB, makeConfig());
+        geoedgeSubmodule.onBidResponseEvent(bidFromB, makeConfig(false));
         expect(bidFromB.ad.indexOf('<wrapper>')).to.equal(-1);
       });
       it('should only muatate the bid ad porperty', function () {

package/test/spec/modules/liveIntentIdMinimalSystem_spec.js

@@ -266,6 +266,11 @@ describe('LiveIntentMinimalId', function() {
     expect(result).to.eql({'lipb': {'lipbid': 'foo', 'nonId': 'foo', 'magnite': 'bar'}, 'magnite': {'id': 'bar', 'ext': {'provider': 'liveintent.com'}}});
   });
 
+  it('should decode an index id to a seperate object when present', function() {
+    const result = liveIntentIdSubmodule.decode({ nonId: 'foo', index: 'bar' });
+    expect(result).to.eql({'lipb': {'lipbid': 'foo', 'nonId': 'foo', 'index': 'bar'}, 'index': {'id': 'bar', 'ext': {'provider': 'liveintent.com'}}});
+  });
+
   it('should allow disabling nonId resolution', function() {
     let callBackSpy = sinon.spy();
     let submoduleCallback = liveIntentIdSubmodule.getId({ params: {

package/test/spec/modules/liveIntentIdSystem_spec.js

@@ -378,6 +378,11 @@ describe('LiveIntentId', function() {
     expect(result).to.eql({'lipb': {'lipbid': 'foo', 'nonId': 'foo', 'magnite': 'bar'}, 'magnite': {'id': 'bar', 'ext': {'provider': 'liveintent.com'}}});
   });
 
+  it('should decode an index id to a seperate object when present', function() {
+    const result = liveIntentIdSubmodule.decode({ nonId: 'foo', index: 'bar' });
+    expect(result).to.eql({'lipb': {'lipbid': 'foo', 'nonId': 'foo', 'index': 'bar'}, 'index': {'id': 'bar', 'ext': {'provider': 'liveintent.com'}}});
+  });
+
   it('should allow disabling nonId resolution', function() {
     let callBackSpy = sinon.spy();
     let submoduleCallback = liveIntentIdSubmodule.getId({ params: {

package/test/spec/modules/nativoBidAdapter_spec.js

@@ -112,7 +112,7 @@ describe('nativoBidAdapterTests', function () {
       bidRequests = [JSON.parse(bidRequestString)]
     })
 
-    it('url should contain query string parameters', function () {
+    it('Request should be POST, with JSON string payload and QS params should be added to the url', function () {
       const request = spec.buildRequests(bidRequests, {
         bidderRequestId: 123456,
         refererInfo: {
@@ -120,6 +120,11 @@ describe('nativoBidAdapterTests', function () {
         },
       })
 
+      expect(request.method).to.equal('POST')
+
+      expect(request.data).to.exist
+      expect(request.data).to.be.a('string')
+
       expect(request.url).to.exist
       expect(request.url).to.be.a('string')
 

package/test/spec/modules/onetagBidAdapter_spec.js

@@ -312,6 +312,75 @@ describe('onetag', function () {
       expect(payload.usPrivacy).to.exist;
       expect(payload.usPrivacy).to.exist.and.to.equal(consentString);
     });
+    it('Should send FPD (ortb2 field)', function () {
+      const firtPartyData = {
+        // this is where the contextual data is placed
+        site: {
+          name: 'example',
+          domain: 'page.example.com',
+          // OpenRTB 2.5 spec / Content Taxonomy
+          cat: ['IAB2'],
+          sectioncat: ['IAB2-2'],
+          pagecat: ['IAB2-2'],
+          page: 'https://page.example.com/here.html',
+          ref: 'https://ref.example.com',
+          keywords: 'power tools, drills',
+          search: 'drill',
+          content: {
+            userrating: '4',
+            data: [{
+              name: 'www.dataprovider1.com', // who resolved the segments
+              ext: {
+                segtax: 7, // taxonomy used to encode the segments
+                cids: ['iris_c73g5jq96mwso4d8']
+              },
+              // the bare minimum are the IDs. These IDs are the ones from the new IAB Content Taxonomy v3
+              segment: [ { id: '687' }, { id: '123' } ]
+            }]
+          },
+          ext: {
+            data: { // fields that aren't part of openrtb 2.6
+              pageType: 'article',
+              category: 'repair'
+            }
+          }
+        },
+        // this is where the user data is placed
+        user: {
+          keywords: 'a,b',
+          data: [{
+            name: 'dataprovider.com',
+            ext: {
+              segtax: 4
+            },
+            segment: [{
+              id: '1'
+            }]
+          }],
+          ext: {
+            data: {
+              registered: true,
+              interests: ['cars']
+            }
+          }
+        },
+        regs: {
+          gpp: 'abc1234',
+          gpp_sid: [7]
+        }
+      };
+      let bidderRequest = {
+        'bidderCode': 'onetag',
+        'auctionId': '1d1a030790a475',
+        'bidderRequestId': '22edbae2733bf6',
+        'timeout': 3000,
+        'ortb2': firtPartyData
+      }
+      let serverRequest = spec.buildRequests([bannerBid], bidderRequest);
+      const payload = JSON.parse(serverRequest.data);
+      expect(payload.ortb2).to.exist;
+      expect(payload.ortb2).to.exist.and.to.deep.equal(firtPartyData);
+    });
   });
   describe('interpretResponse', function () {
     const request = getBannerVideoRequest();

package/test/spec/modules/operaadsIdSystem_spec.js

@@ -0,0 +1,53 @@
+import { operaIdSubmodule } from 'modules/operaadsIdSystem'
+import * as ajaxLib from 'src/ajax.js'
+
+const TEST_ID = 'opera-test-id';
+const operaIdRemoteResponse = { uid: TEST_ID };
+
+describe('operaId submodule properties', () => {
+  it('should expose a "name" property equal to "operaId"', () => {
+    expect(operaIdSubmodule.name).to.equal('operaId');
+  });
+});
+
+function fakeRequest(fn) {
+  const ajaxBuilderStub = sinon.stub(ajaxLib, 'ajaxBuilder').callsFake(() => {
+    return (url, cbObj) => {
+      cbObj.success(JSON.stringify(operaIdRemoteResponse));
+    }
+  });
+  fn();
+  ajaxBuilderStub.restore();
+}
+
+describe('operaId submodule getId', function() {
+  it('request to the fake server to correctly extract test ID', function() {
+    fakeRequest(() => {
+      const moduleIdCallbackResponse = operaIdSubmodule.getId({ params: { pid: 'pub123' } });
+      moduleIdCallbackResponse.callback((id) => {
+        expect(id).to.equal(operaIdRemoteResponse.operaId);
+      });
+    });
+  });
+
+  it('request to the fake server without publiser ID', function() {
+    fakeRequest(() => {
+      const moduleIdCallbackResponse = operaIdSubmodule.getId({ params: {} });
+      expect(moduleIdCallbackResponse).to.equal(undefined);
+    });
+  });
+});
+
+describe('operaId submodule decode', function() {
+  it('should respond with an object containing "operaId" as key with the value', () => {
+    expect(operaIdSubmodule.decode(TEST_ID)).to.deep.equal({
+      operaId: TEST_ID
+    });
+  });
+
+  it('should respond with undefined if the value is not a string or an empty string', () => {
+    [1, 2.0, null, undefined, NaN, [], {}].forEach((value) => {
+      expect(operaIdSubmodule.decode(value)).to.equal(undefined);
+    });
+  });
+});

package/test/spec/modules/oxxionAnalyticsAdapter_spec.js

@@ -167,7 +167,8 @@ describe('Oxxion Analytics', function () {
         'meta': {
           'advertiserDomains': [
             'example.com'
-          ]
+          ],
+	  'demandSource': 'something'
         },
         'renderer': 'something',
         'originalCpm': 25.02521,
@@ -313,13 +314,16 @@ describe('Oxxion Analytics', function () {
       expect(message.auctionEnd[0].bidsReceived[0]).not.to.have.property('ad');
       expect(message.auctionEnd[0].bidsReceived[0]).to.have.property('meta');
       expect(message.auctionEnd[0].bidsReceived[0].meta).to.have.property('advertiserDomains');
+      expect(message.auctionEnd[0].bidsReceived[0].meta).to.have.property('demandSource');
       expect(message.auctionEnd[0].bidsReceived[0]).to.have.property('adId');
       expect(message.auctionEnd[0]).to.have.property('bidderRequests').and.to.have.lengthOf(1);
       expect(message.auctionEnd[0].bidderRequests[0]).to.have.property('gdprConsent');
       expect(message.auctionEnd[0].bidderRequests[0].gdprConsent).not.to.have.property('vendorData');
+      expect(message.auctionEnd[0].bidderRequests[0]).to.have.property('oxxionMode');
     });
 
     it('test bidWon', function() {
+      window.OXXION_MODE = {'abtest': true};
       adapterManager.registerAnalyticsAdapter({
         code: 'oxxion',
         adapter: oxxionAnalytics
@@ -337,6 +341,7 @@ describe('Oxxion Analytics', function () {
       expect(message).not.to.have.property('ad');
       expect(message).to.have.property('adId')
       expect(message).to.have.property('cpmIncrement').and.to.equal(27.4276);
+      expect(message).to.have.property('oxxionMode').and.to.have.property('abtest').and.to.equal(true);
       // sinon.assert.callCount(oxxionAnalytics.track, 1);
     });
   });

package/test/spec/modules/rubiconBidAdapter_spec.js

@@ -1229,6 +1229,30 @@ describe('the rubicon adapter', function () {
             });
           });
 
+          it('should still use single request if other rubicon configs are set after', function () {
+            // set single request to true
+            config.setConfig({ rubicon: { singleRequest: true } });
+
+            // execute some other rubicon setConfig
+            config.setConfig({ rubicon: { netRevenue: true } });
+
+            const bidCopy = utils.deepClone(bidderRequest.bids[0]);
+            bidderRequest.bids.push(bidCopy);
+            bidderRequest.bids.push(bidCopy);
+            bidderRequest.bids.push(bidCopy);
+
+            let serverRequests = spec.buildRequests(bidderRequest.bids, bidderRequest);
+
+            // should have 1 request only
+            expect(serverRequests).that.is.an('array').of.length(1);
+
+            // get the built query
+            let data = parseQuery(serverRequests[0].data);
+
+            // num slots should be 4
+            expect(data.slots).to.equal('4');
+          });
+
           it('should not group bid requests if singleRequest does not equal true', function () {
             config.setConfig({rubicon: {singleRequest: false}});
 

package/test/spec/modules/smartyadsBidAdapter_spec.js

@@ -1,6 +1,7 @@
 import {expect} from 'chai';
 import {spec} from '../../../modules/smartyadsBidAdapter.js';
 import { config } from '../../../src/config.js';
+import {server} from '../../mocks/xhr';
 
 describe('SmartyadsAdapter', function () {
   let bid = {
@@ -14,6 +15,21 @@ describe('SmartyadsAdapter', function () {
     }
   };
 
+  let bidResponse = {
+    width: 300,
+    height: 250,
+    mediaType: 'banner',
+    ad: `<img src='https://dummyimage.com/300x250&text=Test+Mode' width=300 height=250 alt='test mode'>`,
+    requestId: '23fhj33i987f',
+    cpm: 0.1,
+    ttl: 120,
+    creativeId: '123',
+    netRevenue: true,
+    currency: 'USD',
+    dealId: 'HASH',
+    sid: 1234
+  };
+
   describe('isBidRequestValid', function () {
     it('Should return true if there are bidId, params and sourceid parameters present', function () {
       expect(spec.isBidRequestValid(bid)).to.be.true;
@@ -257,4 +273,37 @@ describe('SmartyadsAdapter', function () {
       ]);
     });
   });
+
+  describe('onBidWon', function () {
+    it('should exists', function () {
+      expect(spec.onBidWon).to.exist.and.to.be.a('function');
+    });
+
+    it('should send a valid bid won notice', function () {
+      spec.onBidWon(bidResponse);
+      expect(server.requests.length).to.equal(1);
+    });
+  });
+
+  describe('onTimeout', function () {
+    it('should exists', function () {
+      expect(spec.onTimeout).to.exist.and.to.be.a('function');
+    });
+
+    it('should send a valid bid timeout notice', function () {
+      spec.onTimeout({});
+      expect(server.requests.length).to.equal(1);
+    });
+  });
+
+  describe('onBidderError', function () {
+    it('should exists', function () {
+      expect(spec.onBidderError).to.exist.and.to.be.a('function');
+    });
+
+    it('should send a valid bidder error notice', function () {
+      spec.onBidderError({});
+      expect(server.requests.length).to.equal(1);
+    });
+  });
 });

package/test/spec/modules/snigelBidAdapter_spec.js

@@ -20,6 +20,7 @@ const makeBidRequest = function (overrides) {
 };
 
 const BASE_BIDDER_REQUEST = {
+  auctionId: 'test',
   bidderRequestId: 'test',
   refererInfo: {
     canonicalUrl: 'https://localhost',
@@ -53,8 +54,8 @@ describe('snigelBidAdapter', function () {
     it('should build a single request for every impression and its placement', function () {
       const bidderRequest = Object.assign({}, BASE_BIDDER_REQUEST);
       const bidRequests = [
-        makeBidRequest({bidId: 'a', params: {placement: 'top_leaderboard'}}),
-        makeBidRequest({bidId: 'b', params: {placement: 'bottom_leaderboard'}}),
+        makeBidRequest({bidId: 'a', adUnitCode: 'au_a', params: {placement: 'top_leaderboard'}}),
+        makeBidRequest({bidId: 'b', adUnitCode: 'au_b', params: {placement: 'bottom_leaderboard'}}),
       ];
 
       const request = spec.buildRequests(bidRequests, bidderRequest);
@@ -70,9 +71,9 @@ describe('snigelBidAdapter', function () {
       expect(data).to.have.property('page').and.to.equal('https://localhost');
       expect(data).to.have.property('placements');
       expect(data.placements.length).to.equal(2);
-      expect(data.placements[0].uuid).to.equal('a');
+      expect(data.placements[0].id).to.equal('au_a');
       expect(data.placements[0].name).to.equal('top_leaderboard');
-      expect(data.placements[1].uuid).to.equal('b');
+      expect(data.placements[1].id).to.equal('au_b');
       expect(data.placements[1].name).to.equal('bottom_leaderboard');
     });
 
@@ -127,6 +128,56 @@ describe('snigelBidAdapter', function () {
       const data = JSON.parse(request.data);
       expect(data).to.have.property('coppa').and.to.equal(true);
     });
+
+    it('should forward refresh information', function () {
+      const bidderRequest = Object.assign({}, BASE_BIDDER_REQUEST);
+      const topLeaderboard = makeBidRequest({adUnitCode: 'top_leaderboard'});
+      const bottomLeaderboard = makeBidRequest({adUnitCode: 'bottom_leaderboard'});
+      const sidebar = makeBidRequest({adUnitCode: 'sidebar'});
+
+      // first auction, no refresh
+      let request = spec.buildRequests([topLeaderboard, bottomLeaderboard], bidderRequest);
+      expect(request).to.have.property('data');
+      let data = JSON.parse(request.data);
+      expect(data).to.have.property('placements');
+      expect(data.placements.length).to.equal(2);
+      expect(data.placements[0].id).to.equal('top_leaderboard');
+      expect(data.placements[0].refresh).to.be.undefined;
+      expect(data.placements[1].id).to.equal('bottom_leaderboard');
+      expect(data.placements[1].refresh).to.be.undefined;
+
+      // second auction for top leaderboard, was refreshed
+      request = spec.buildRequests([topLeaderboard, sidebar], bidderRequest);
+      expect(request).to.have.property('data');
+      data = JSON.parse(request.data);
+      expect(data).to.have.property('placements');
+      expect(data.placements.length).to.equal(2);
+      expect(data.placements[0].id).to.equal('top_leaderboard');
+      expect(data.placements[0].refresh).to.not.be.undefined;
+      expect(data.placements[0].refresh.count).to.equal(1);
+      expect(data.placements[0].refresh.time).to.be.greaterThanOrEqual(0);
+      expect(data.placements[1].id).to.equal('sidebar');
+      expect(data.placements[1].refresh).to.be.undefined;
+
+      // third auction, all units refreshed at some point
+      request = spec.buildRequests([topLeaderboard, bottomLeaderboard, sidebar], bidderRequest);
+      expect(request).to.have.property('data');
+      data = JSON.parse(request.data);
+      expect(data).to.have.property('placements');
+      expect(data.placements.length).to.equal(3);
+      expect(data.placements[0].id).to.equal('top_leaderboard');
+      expect(data.placements[0].refresh).to.not.be.undefined;
+      expect(data.placements[0].refresh.count).to.equal(2);
+      expect(data.placements[0].refresh.time).to.be.greaterThanOrEqual(0);
+      expect(data.placements[1].id).to.equal('bottom_leaderboard');
+      expect(data.placements[1].refresh).to.not.be.undefined;
+      expect(data.placements[1].refresh.count).to.equal(1);
+      expect(data.placements[1].refresh.time).to.be.greaterThanOrEqual(0);
+      expect(data.placements[2].id).to.equal('sidebar');
+      expect(data.placements[2].refresh).to.not.be.undefined;
+      expect(data.placements[2].refresh.count).to.equal(1);
+      expect(data.placements[2].refresh.time).to.be.greaterThanOrEqual(0);
+    });
   });
 
   describe('interpretResponse', function () {
@@ -146,7 +197,7 @@ describe('snigelBidAdapter', function () {
           cur: 'USD',
           bids: [
             {
-              uuid: BASE_BID_REQUEST.bidId,
+              id: BASE_BID_REQUEST.adUnitCode,
               price: 0.0575,
               ad: '<html><body><h1>Test Ad</h1></body></html>',
               width: 728,
@@ -160,7 +211,7 @@ describe('snigelBidAdapter', function () {
         },
       };
 
-      const bids = spec.interpretResponse(serverResponse, {});
+      const bids = spec.interpretResponse(serverResponse, {bidderRequest: {bids: [BASE_BID_REQUEST]}});
       expect(bids.length).to.equal(1);
       const bid = bids[0];
       expect(isValid(BASE_BID_REQUEST.adUnitCode, bid)).to.be.true;