prebid.js 8.6.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/freepassBidAdapter_spec.js

@@ -19,6 +19,9 @@ describe('FreePass adapter', function () {
         }
       },
       adUnitCode: 'adunit-code',
+      params: {
+        publisherId: 'publisherIdValue'
+      }
     };
 
     it('should return true when required params found', function () {
@@ -30,6 +33,12 @@ describe('FreePass adapter', function () {
       delete localBid.adUnitCode;
       expect(spec.isBidRequestValid(localBid)).to.equal(false);
     });
+
+    it('should return false when params.publisherId is missing', function () {
+      let localBid = Object.assign({}, bid);
+      delete localBid.params.publisherId;
+      expect(spec.isBidRequestValid(localBid)).to.equal(false);
+    });
   });
 
   describe('buildRequests', function () {
@@ -43,6 +52,10 @@ describe('FreePass adapter', function () {
             'userId': '56c4c789-71ce-46f5-989e-9e543f3d5f96',
             'commonId': 'commonIdValue'
           }
+        },
+        'adUnitCode': 'adunit-code',
+        'params': {
+          'publisherId': 'publisherIdValue'
         }
       }];
       bidderRequest = {};
@@ -108,6 +121,33 @@ describe('FreePass adapter', function () {
       expect(ortbData.device.ext).to.be.an('object');
       expect(ortbData.device.ext.is_accurate_ip).to.equal(0);
     });
+
+    it('it should add publisher related information w/o publisherUrl', function () {
+      const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
+      const ortbData = bidRequest.data;
+      expect(ortbData.site).to.be.an('object');
+      expect(ortbData.site.publisher.id).to.equal('publisherIdValue');
+      // publisher.domain is optional
+      expect(ortbData.site.publisher.domain).to.be.undefined;
+    });
+
+    it('it should add publisher related information w/ publisherUrl', function () {
+      const PUBLISHER_URL = 'publisherUrlValue';
+      let localBidRequests = [Object.assign({}, bidRequests[0])];
+      localBidRequests[0].params.publisherUrl = PUBLISHER_URL;
+      const bidRequest = spec.buildRequests(localBidRequests, bidderRequest);
+      const ortbData = bidRequest.data;
+      expect(ortbData.site).to.be.an('object');
+      expect(ortbData.site.publisher.id).to.equal('publisherIdValue');
+      // publisher.domain is optional. set when given
+      expect(ortbData.site.publisher.domain).to.equal(PUBLISHER_URL);
+    });
+
+    it('it should imp.tagId from adUnitCode', function () {
+      const bidRequest = spec.buildRequests(bidRequests, bidderRequest);
+      const ortbData = bidRequest.data;
+      expect(ortbData.imp[0].tagId).to.equal('adunit-code');
+    });
   });
 
   describe('interpretResponse', function () {
@@ -122,6 +162,10 @@ describe('FreePass adapter', function () {
             'userId': '56c4c789-71ce-46f5-989e-9e543f3d5f96',
             'commonId': 'commonIdValue'
           }
+        },
+        'adUnitCode': 'adunit-code',
+        'params': {
+          'publisherId': 'publisherIdValue'
         }
       }];
       bidderRequest = {};

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/gridBidAdapter_spec.js

@@ -786,6 +786,74 @@ describe('TheMediaGrid Adapter', function () {
       });
     });
 
+    it('should prioritize pbadslot over adslot', function() {
+      const ortb2Imp = [{
+        ext: {
+          data: {
+            adserver: {
+              adslot: 'adslot'
+            }
+          }
+        }
+      }, {
+        ext: {
+          data: {
+            adserver: {
+              adslot: 'adslot'
+            },
+            pbadslot: 'pbadslot'
+          }
+        }
+      }];
+      const bidRequestsWithOrtb2Imp = bidRequests.slice(0, 2).map((bid, ind) => {
+        return Object.assign({}, bid, ortb2Imp[ind] ? { ortb2Imp: {...bid.ortb2Imp, ...ortb2Imp[ind]} } : {});
+      });
+      const [request] = spec.buildRequests(bidRequestsWithOrtb2Imp, bidderRequest);
+      expect(request.data).to.be.an('string');
+      const payload = parseRequest(request.data);
+      expect(payload.imp[0].ext.gpid).to.equal(ortb2Imp[0].ext.data.adserver.adslot);
+      expect(payload.imp[1].ext.gpid).to.equal(ortb2Imp[1].ext.data.pbadslot);
+    });
+
+    it('should prioritize gpid over pbadslot and adslot', function() {
+      const ortb2Imp = [{
+        ext: {
+          gpid: 'gpid',
+          data: {
+            adserver: {
+              adslot: 'adslot'
+            },
+            pbadslot: 'pbadslot'
+          }
+        }
+      }, {
+        ext: {
+          gpid: 'gpid',
+          data: {
+            adserver: {
+              adslot: 'adslot'
+            }
+          }
+        }
+      }, {
+        ext: {
+          gpid: 'gpid',
+          data: {
+            pbadslot: 'pbadslot'
+          }
+        }
+      }];
+      const bidRequestsWithOrtb2Imp = bidRequests.slice(0, 3).map((bid, ind) => {
+        return Object.assign({}, bid, ortb2Imp[ind] ? { ortb2Imp: {...bid.ortb2Imp, ...ortb2Imp[ind]} } : {});
+      });
+      const [request] = spec.buildRequests(bidRequestsWithOrtb2Imp, bidderRequest);
+      expect(request.data).to.be.an('string');
+      const payload = parseRequest(request.data);
+      expect(payload.imp[0].ext.gpid).to.equal(ortb2Imp[0].ext.gpid);
+      expect(payload.imp[1].ext.gpid).to.equal(ortb2Imp[1].ext.gpid);
+      expect(payload.imp[2].ext.gpid).to.equal(ortb2Imp[2].ext.gpid);
+    });
+
     it('should contain imp[].instl if available', function() {
       const ortb2Imp = [{
         instl: 1

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/medianetBidAdapter_spec.js

@@ -915,24 +915,24 @@ let VALID_BID_REQUEST = [{
       cid: '8CUV090'
     }
   },
-  VALID_PARAMS_AAX = {
-    bidder: 'aax',
+  VALID_PARAMS_TS = {
+    bidder: 'trustedstack',
     params: {
-      cid: 'AAXG123'
+      cid: 'TS012345'
     }
   },
   PARAMS_MISSING = {
     bidder: 'medianet',
   },
-  PARAMS_MISSING_AAX = {
-    bidder: 'aax',
+  PARAMS_MISSING_TS = {
+    bidder: 'trustedstack',
   },
   PARAMS_WITHOUT_CID = {
     bidder: 'medianet',
     params: {}
   },
-  PARAMS_WITHOUT_CID_AAX = {
-    bidder: 'aax',
+  PARAMS_WITHOUT_CID_TS = {
+    bidder: 'trustedstack',
     params: {}
   },
   PARAMS_WITH_INTEGER_CID = {
@@ -941,8 +941,8 @@ let VALID_BID_REQUEST = [{
       cid: 8867587
     }
   },
-  PARAMS_WITH_INTEGER_CID_AAX = {
-    bidder: 'aax',
+  PARAMS_WITH_INTEGER_CID_TS = {
+    bidder: 'trustedstack',
     params: {
       cid: 8867587
     }
@@ -953,8 +953,8 @@ let VALID_BID_REQUEST = [{
       cid: ''
     }
   },
-  PARAMS_WITH_EMPTY_CID_AAX = {
-    bidder: 'aax',
+  PARAMS_WITH_EMPTY_CID_TS = {
+    bidder: 'trustedstack',
     params: {
       cid: ''
     }
@@ -1783,34 +1783,34 @@ describe('Media.net bid adapter', function () {
     });
   });
 
-  describe('isBidRequestValid aax', function () {
+  describe('isBidRequestValid trustedstack', function () {
     it('should accept valid bid params', function () {
-      let isValid = spec.isBidRequestValid(VALID_PARAMS_AAX);
+      let isValid = spec.isBidRequestValid(VALID_PARAMS_TS);
       expect(isValid).to.equal(true);
     });
 
     it('should reject bid if cid is not present', function () {
-      let isValid = spec.isBidRequestValid(PARAMS_WITHOUT_CID_AAX);
+      let isValid = spec.isBidRequestValid(PARAMS_WITHOUT_CID_TS);
       expect(isValid).to.equal(false);
     });
 
     it('should reject bid if cid is not a string', function () {
-      let isValid = spec.isBidRequestValid(PARAMS_WITH_INTEGER_CID_AAX);
+      let isValid = spec.isBidRequestValid(PARAMS_WITH_INTEGER_CID_TS);
       expect(isValid).to.equal(false);
     });
 
     it('should reject bid if cid is a empty string', function () {
-      let isValid = spec.isBidRequestValid(PARAMS_WITH_EMPTY_CID_AAX);
+      let isValid = spec.isBidRequestValid(PARAMS_WITH_EMPTY_CID_TS);
       expect(isValid).to.equal(false);
     });
 
     it('should have missing params', function () {
-      let isValid = spec.isBidRequestValid(PARAMS_MISSING_AAX);
+      let isValid = spec.isBidRequestValid(PARAMS_MISSING_TS);
       expect(isValid).to.equal(false);
     });
   });
 
-  describe('interpretResponse aax', function () {
+  describe('interpretResponse trustedstack', function () {
     it('should not push response if no-bid', function () {
       let validBids = [];
       let bids = spec.interpretResponse(SERVER_RESPONSE_NOBID, []);

package/test/spec/modules/mediasquareBidAdapter_spec.js

@@ -1,5 +1,6 @@
 import {expect} from 'chai';
 import {spec} from 'modules/mediasquareBidAdapter.js';
+import { server } from 'test/mocks/xhr.js';
 
 describe('MediaSquare bid adapter tests', function () {
   var DEFAULT_PARAMS = [{
@@ -208,6 +209,10 @@ describe('MediaSquare bid adapter tests', function () {
     const response = spec.interpretResponse(BID_RESPONSE, request);
     const won = spec.onBidWon(response[0]);
     expect(won).to.equal(true);
+    expect(server.requests.length).to.equal(1);
+    let message = JSON.parse(server.requests[0].requestBody);
+    expect(message).to.have.property('increment').exist;
+    expect(message).to.have.property('increment').and.to.equal('1');
   });
   it('Verifies user sync without cookie in bid response', function () {
     var syncs = spec.getUserSyncs({}, [BID_RESPONSE], DEFAULT_OPTIONS.gdprConsent, DEFAULT_OPTIONS.uspConsent);

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/optidigitalBidAdapter_spec.js

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { spec } from 'modules/optidigitalBidAdapter.js';
+import { spec, resetSync } from 'modules/optidigitalBidAdapter.js';
 import * as utils from 'src/utils.js';
 
 const ENDPOINT = 'https://pbs.optidigital.com/bidder';
@@ -497,6 +497,7 @@ describe('optidigitalAdapterTests', function () {
     let test;
     beforeEach(function () {
       test = sinon.sandbox.create();
+      resetSync();
     });
     afterEach(function() {
       test.restore();
@@ -508,16 +509,22 @@ describe('optidigitalAdapterTests', function () {
       }]);
     });
 
-    it('should return appropriate URL', function() {
+    it('should return appropriate URL with GDPR equals to 1 and GDPR consent', function() {
       expect(spec.getUserSyncs({ iframeEnabled: true }, {}, {gdprApplies: true, consentString: 'foo'}, undefined)).to.deep.equal([{
         type: 'iframe', url: `${syncurlIframe}&gdpr=1&gdpr_consent=foo`
       }]);
+    });
+    it('should return appropriate URL with GDPR equals to 0 and GDPR consent', function() {
       expect(spec.getUserSyncs({ iframeEnabled: true }, {}, {gdprApplies: false, consentString: 'foo'}, undefined)).to.deep.equal([{
         type: 'iframe', url: `${syncurlIframe}&gdpr=0&gdpr_consent=foo`
       }]);
+    });
+    it('should return appropriate URL with GDPR equals to 1 and no consent', function() {
       expect(spec.getUserSyncs({ iframeEnabled: true }, {}, {gdprApplies: true, consentString: undefined}, undefined)).to.deep.equal([{
         type: 'iframe', url: `${syncurlIframe}&gdpr=1&gdpr_consent=`
       }]);
+    });
+    it('should return appropriate URL with GDPR equals to 1, GDPR consent and CCPA consent', function() {
       expect(spec.getUserSyncs({ iframeEnabled: true }, {}, {gdprApplies: true, consentString: 'foo'}, {consentString: 'fooUsp'})).to.deep.equal([{
         type: 'iframe', url: `${syncurlIframe}&gdpr=1&gdpr_consent=foo&ccpa_consent=fooUsp`
       }]);