prebid.js 7.51.0 → 7.53.0

package/test/spec/modules/uid2IdSystem_spec.js

@@ -1,11 +1,15 @@
+/* eslint-disable no-console */
+
 import {coreStorage, init, setSubmoduleRegistry, requestBidsHook} from 'modules/userId/index.js';
 import {config} from 'src/config.js';
 import * as utils from 'src/utils.js';
 import { uid2IdSubmodule } from 'modules/uid2IdSystem.js';
 import 'src/prebid.js';
+import 'modules/consentManagement.js';
 import { getGlobal } from 'src/prebidGlobal.js';
 import { server } from 'test/mocks/xhr.js';
 import { configureTimerInterceptors } from 'test/mocks/timers.js';
+import { cookieHelpers, runAuction, apiHelpers, setGdprApplies } from './uid2IdSystem_helpers.js';
 import {hook} from 'src/hook.js';
 import {uninstall as uninstallGdprEnforcement} from 'modules/gdprEnforcement.js';
 
@@ -14,72 +18,48 @@ let expect = require('chai').expect;
 const clearTimersAfterEachTest = true;
 const debugOutput = () => {};
 
-const expireCookieDate = 'Thu, 01 Jan 1970 00:00:01 GMT';
-const msIn12Hours = 60 * 60 * 12 * 1000;
 const moduleCookieName = '__uid2_advertising_token';
 const publisherCookieName = '__UID2_SERVER_COOKIE';
 const auctionDelayMs = 10;
-const legacyConfigParams = null;
-const serverCookieConfigParams = { uid2ServerCookie: publisherCookieName }
-const getFutureCookieExpiry = () => new Date(Date.now() + msIn12Hours).toUTCString();
-const setPublisherCookie = (token) => coreStorage.setCookie(publisherCookieName, JSON.stringify(token), getFutureCookieExpiry());
-
-const makePrebidIdentityContainer = (token) => ({uid2: {id: token}});
-const makePrebidConfig = (params = null, extraSettings = {}, debug = false) => ({
-  userSync: { auctionDelay: auctionDelayMs, userIds: [{name: 'uid2', params}] }, debug, ...extraSettings
-});
-
 const initialToken = `initial-advertising-token`;
 const legacyToken = 'legacy-advertising-token';
 const refreshedToken = 'refreshed-advertising-token';
-const makeUid2Token = (token = initialToken, shouldRefresh = false, expired = false) => ({
-  advertising_token: token,
-  refresh_token: 'fake-refresh-token',
-  identity_expires: expired ? Date.now() - 1000 : Date.now() + 60 * 60 * 1000,
-  refresh_from: shouldRefresh ? Date.now() - 1000 : Date.now() + 60 * 1000,
-  refresh_expires: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
-  refresh_response_key: 'wR5t6HKMfJ2r4J7fEGX9Gw==',
+
+const legacyConfigParams = {storage: null};
+const serverCookieConfigParams = { uid2ServerCookie: publisherCookieName };
+const newServerCookieConfigParams = { uid2Cookie: publisherCookieName };
+
+const makeUid2IdentityContainer = (token) => ({uid2: {id: token}});
+let useLocalStorage = false;
+const makePrebidConfig = (params = null, extraSettings = {}, debug = false) => ({
+  userSync: { auctionDelay: auctionDelayMs, userIds: [{name: 'uid2', params: {storage: useLocalStorage ? 'localStorage' : 'cookie', ...params}}] }, debug, ...extraSettings
 });
-const expectInitialToken = (bid) => expect(bid?.userId ?? {}).to.deep.include(makePrebidIdentityContainer(initialToken));
-const expectRefreshedToken = (bid) => expect(bid?.userId ?? {}).to.deep.include(makePrebidIdentityContainer(refreshedToken));
+
+const getFromAppropriateStorage = () => {
+  if (useLocalStorage) return coreStorage.getDataFromLocalStorage(moduleCookieName);
+  else return coreStorage.getCookie(moduleCookieName);
+}
+
+const expectToken = (bid, token) => expect(bid?.userId ?? {}).to.deep.include(makeUid2IdentityContainer(token));
+const expectLegacyToken = (bid) => expect(bid.userId).to.deep.include(makeUid2IdentityContainer(legacyToken));
 const expectNoIdentity = (bid) => expect(bid).to.not.haveOwnProperty('userId');
-const expectGlobalToHaveRefreshedIdentity = () => expect(getGlobal().getUserIds()).to.deep.include(makePrebidIdentityContainer(refreshedToken));
+const expectGlobalToHaveToken = (token) => expect(getGlobal().getUserIds()).to.deep.include(makeUid2IdentityContainer(token));
 const expectGlobalToHaveNoUid2 = () => expect(getGlobal().getUserIds()).to.not.haveOwnProperty('uid2');
-const expectLegacyToken = (bid) => expect(bid.userId).to.deep.include(makePrebidIdentityContainer(legacyToken));
-const expectNoLegacyToken = (bid) => expect(bid.userId).to.not.deep.include(makePrebidIdentityContainer(legacyToken));
-const expectModuleCookieEmptyOrMissing = () => expect(coreStorage.getCookie(moduleCookieName)).to.be.null;
-const expectModuleCookieToContain = (initialIdentity, latestIdentity) => {
-  const cookie = JSON.parse(coreStorage.getCookie(moduleCookieName));
+const expectNoLegacyToken = (bid) => expect(bid.userId).to.not.deep.include(makeUid2IdentityContainer(legacyToken));
+const expectModuleStorageEmptyOrMissing = () => expect(getFromAppropriateStorage()).to.be.null;
+const expectModuleStorageToContain = (initialIdentity, latestIdentity) => {
+  const cookie = JSON.parse(getFromAppropriateStorage());
   if (initialIdentity) expect(cookie.originalToken.advertising_token).to.equal(initialIdentity);
   if (latestIdentity) expect(cookie.latestToken.advertising_token).to.equal(latestIdentity);
 }
 
 const apiUrl = 'https://prod.uidapi.com/v2/token/refresh';
 const headers = { 'Content-Type': 'application/json' };
-const makeSuccessResponseBody = () => btoa(JSON.stringify({ status: 'success', body: { ...makeUid2Token(), advertising_token: refreshedToken } }));
+const makeSuccessResponseBody = () => btoa(JSON.stringify({ status: 'success', body: { ...apiHelpers.makeTokenResponse(initialToken), advertising_token: refreshedToken } }));
 const configureUid2Response = (httpStatus, response) => server.respondWith('POST', apiUrl, (xhr) => xhr.respond(httpStatus, headers, response));
 const configureUid2ApiSuccessResponse = () => configureUid2Response(200, makeSuccessResponseBody());
 const configureUid2ApiFailResponse = () => configureUid2Response(500, 'Error');
 
-const respondAfterDelay = (delay) => new Promise((resolve) => setTimeout(() => {
-  server.respond();
-  setTimeout(() => resolve());
-}, delay));
-
-const runAuction = async () => {
-  const adUnits = [{
-    code: 'adUnit-code',
-    mediaTypes: {banner: {}, native: {}},
-    sizes: [[300, 200], [300, 600]],
-    bids: [{bidder: 'sampleBidder', params: {placementId: 'banner-only-bidder'}}]
-  }];
-  return new Promise(function(resolve) {
-    requestBidsHook(function() {
-      resolve(adUnits[0].bids[0]);
-    }, {adUnits});
-  });
-}
-
 // Runs the provided test twice - once with a successful API mock, once with one which returns a server error
 const testApiSuccessAndFailure = (act, testDescription, failTestDescription, only = false) => {
   const testFn = only ? it.only : it;
@@ -92,6 +72,26 @@ const testApiSuccessAndFailure = (act, testDescription, failTestDescription, onl
     await act(false);
   });
 }
+
+const testCookieAndLocalStorage = (description, test, only = false) => {
+  const describeFn = only ? describe.only : describe;
+  describeFn(`Using cookies: ${description}`, async function() {
+    before(function() {
+      useLocalStorage = false;
+    });
+    await test();
+  });
+  describeFn(`Using local storage: ${description}`, async function() {
+    before(function() {
+      useLocalStorage = true;
+    });
+    after(function() {
+      useLocalStorage = false;
+    });
+    await test();
+  });
+};
+
 describe(`UID2 module`, function () {
   let suiteSandbox, testSandbox, timerSpy, fullTestTitle, restoreSubtleToUndefined = false;
   before(function () {
@@ -141,21 +141,21 @@ describe(`UID2 module`, function () {
         await timerSpy.waitAllActiveTimers();
       }
     }
-    coreStorage.setCookie(moduleCookieName, '', expireCookieDate);
-    coreStorage.setCookie(publisherCookieName, '', expireCookieDate);
+    cookieHelpers.clearCookies(moduleCookieName, publisherCookieName);
+    coreStorage.removeDataFromLocalStorage(moduleCookieName);
 
     debugOutput('----------------- END TEST ------------------');
   });
 
   describe('Configuration', function() {
     it('When no baseUrl is provided in config, the module calls the production endpoint', function() {
-      const uid2Token = makeUid2Token(initialToken, true, true);
+      const uid2Token = apiHelpers.makeTokenResponse(initialToken, true, true);
       config.setConfig(makePrebidConfig({uid2Token}));
       expect(server.requests[0]?.url).to.have.string('https://prod.uidapi.com/');
     });
 
     it('When a baseUrl is provided in config, the module calls the provided endpoint', function() {
-      const uid2Token = makeUid2Token(initialToken, true, true);
+      const uid2Token = apiHelpers.makeTokenResponse(initialToken, true, true);
       config.setConfig(makePrebidConfig({uid2Token, uid2ApiBase: 'https://operator-integ.uidapi.com'}));
       expect(server.requests[0]?.url).to.have.string('https://operator-integ.uidapi.com/');
     });
@@ -170,14 +170,25 @@ describe(`UID2 module`, function () {
     expectLegacyToken(bid);
   });
 
+  it('When a legacy value is provided directly in configuration but GDPR applies, it is not passed on', async function() {
+    const valueConfig = makePrebidConfig();
+    setGdprApplies();
+    valueConfig.userSync.userIds[0].value = {uid2: {id: legacyToken}}
+    config.setConfig(valueConfig);
+    const bid = await runAuction();
+
+    expectNoIdentity(bid);
+  });
+
   // These tests cover 'legacy' cookies - i.e. cookies set with just the uid2 advertising token, which was how some previous integrations worked.
   // Some users might still have this cookie, and the module should use that token if a newer one isn't provided.
   // This should cover older integrations where the server is setting this legacy cookie and expecting the module to pass it on.
   describe('When a legacy cookie exists', function () {
     // Creates a test which sets the legacy cookie, configures the UID2 module with provided params, runs an
-    const createLegacyTest = function(params, bidAssertions) {
+    const createLegacyTest = function(params, bidAssertions, addConsent = false) {
       return async function() {
-        coreStorage.setCookie(moduleCookieName, legacyToken, getFutureCookieExpiry());
+        coreStorage.setCookie(moduleCookieName, legacyToken, cookieHelpers.getFutureCookieExpiry());
+        if (addConsent) setGdprApplies();
         config.setConfig(makePrebidConfig(params));
 
         const bid = await runAuction();
@@ -189,120 +200,154 @@ describe(`UID2 module`, function () {
       createLegacyTest(legacyConfigParams, [expectLegacyToken]));
     it('and a server cookie config is used without a valid server cookie, it should provide the legacy cookie',
       createLegacyTest(serverCookieConfigParams, [expectLegacyToken]));
+    it('and a server cookie is used with a valid server cookie configured using the new param name, it should provide the server cookie',
+      async function() { cookieHelpers.setPublisherCookie(publisherCookieName, apiHelpers.makeTokenResponse(initialToken)); await createLegacyTest(serverCookieConfigParams, [(bid) => expectToken(bid, initialToken), expectNoLegacyToken])(); });
     it('and a server cookie is used with a valid server cookie, it should provide the server cookie',
-      async function() { setPublisherCookie(makeUid2Token()); await createLegacyTest(serverCookieConfigParams, [expectInitialToken, expectNoLegacyToken])(); });
+      async function() { cookieHelpers.setPublisherCookie(publisherCookieName, apiHelpers.makeTokenResponse(initialToken)); await createLegacyTest(newServerCookieConfigParams, [(bid) => expectToken(bid, initialToken), expectNoLegacyToken])(); });
     it('and a token is provided in config, it should provide the config token',
-      createLegacyTest({uid2Token: makeUid2Token()}, [expectInitialToken, expectNoLegacyToken]));
+      createLegacyTest({uid2Token: apiHelpers.makeTokenResponse(initialToken)}, [(bid) => expectToken(bid, initialToken), expectNoLegacyToken]));
+    it('and GDPR applies, no identity should be provided to the auction',
+      createLegacyTest(legacyConfigParams, [expectNoIdentity], true));
+    it('and GDPR applies, when getId is called directly it provides no identity', () => {
+      coreStorage.setCookie(moduleCookieName, legacyToken, cookieHelpers.getFutureCookieExpiry());
+      const consentConfig = setGdprApplies();
+      let configObj = makePrebidConfig(legacyConfigParams);
+      const result = uid2IdSubmodule.getId(configObj.userSync.userIds[0], consentConfig.consentData);
+      expect(result?.id).to.not.exist;
+    });
+
+    it('multiple runs do not change the value', async function() {
+      coreStorage.setCookie(moduleCookieName, legacyToken, cookieHelpers.getFutureCookieExpiry());
+      config.setConfig(makePrebidConfig(legacyConfigParams));
+
+      const bid = await runAuction();
+
+      console.log('Storage', coreStorage.getDataFromLocalStorage(moduleCookieName));
+      init(config);
+      setSubmoduleRegistry([uid2IdSubmodule]);
+      config.setConfig(makePrebidConfig(legacyConfigParams));
+      const bid2 = await runAuction();
+
+      expect(bid.userId.uid2.id).to.equal(bid2.userId.uid2.id);
+    });
   });
 
   // This setup runs all of the functional tests with both types of config - the full token response in params, or a server cookie with the cookie name provided
   let scenarios = [
     {
       name: 'Token provided in config call',
-      setConfig: (token, extraConfig = {}) => config.setConfig(makePrebidConfig({uid2Token: token}, extraConfig)),
+      setConfig: (token, extraConfig = {}) => {
+        const gen = makePrebidConfig({uid2Token: token}, extraConfig);
+        console.log('GENERATED CONFIG', gen.userSync.userIds[0].params);
+        return config.setConfig(gen);
+      },
     },
     {
       name: 'Token provided in server-set cookie',
       setConfig: (token, extraConfig) => {
-        setPublisherCookie(token);
+        cookieHelpers.setPublisherCookie(publisherCookieName, token);
         config.setConfig(makePrebidConfig(serverCookieConfigParams, extraConfig));
       },
     }
   ]
 
   scenarios.forEach(function(scenario) {
-    describe(scenario.name, function() {
+    testCookieAndLocalStorage(scenario.name, function() {
       describe(`When an expired token which can be refreshed is provided`, function() {
         describe('When the refresh is available in time', function() {
           testApiSuccessAndFailure(async function(apiSucceeds) {
-            scenario.setConfig(makeUid2Token(initialToken, true, true));
-            respondAfterDelay(auctionDelayMs / 10);
+            scenario.setConfig(apiHelpers.makeTokenResponse(initialToken, true, true));
+            apiHelpers.respondAfterDelay(auctionDelayMs / 10);
             const bid = await runAuction();
 
-            if (apiSucceeds) expectRefreshedToken(bid);
+            if (apiSucceeds) expectToken(bid, refreshedToken);
             else expectNoIdentity(bid);
           }, 'it should be used in the auction', 'the auction should have no uid2');
 
           testApiSuccessAndFailure(async function(apiSucceeds) {
-            scenario.setConfig(makeUid2Token(initialToken, true, true));
-            respondAfterDelay(auctionDelayMs / 10);
+            scenario.setConfig(apiHelpers.makeTokenResponse(initialToken, true, true));
+            apiHelpers.respondAfterDelay(auctionDelayMs / 10);
 
             await runAuction();
             if (apiSucceeds) {
-              expectModuleCookieToContain(initialToken, refreshedToken);
+              expectModuleStorageToContain(initialToken, refreshedToken);
             } else {
-              expectModuleCookieEmptyOrMissing();
+              expectModuleStorageEmptyOrMissing();
             }
-          }, 'the refreshed token should be stored in the module cookie', 'the module cookie should not be set');
+          }, 'the refreshed token should be stored in the module storage', 'the module storage should not be set');
         });
         describe(`when the response doesn't arrive before the auction timer`, function() {
           testApiSuccessAndFailure(async function() {
-            scenario.setConfig(makeUid2Token(initialToken, true, true));
+            scenario.setConfig(apiHelpers.makeTokenResponse(initialToken, true, true));
             const bid = await runAuction();
             expectNoIdentity(bid);
           }, 'it should run the auction');
 
           testApiSuccessAndFailure(async function(apiSucceeds) {
-            scenario.setConfig(makeUid2Token(initialToken, true, true));
-            const promise = respondAfterDelay(auctionDelayMs * 2);
+            scenario.setConfig(apiHelpers.makeTokenResponse(initialToken, true, true));
+            const promise = apiHelpers.respondAfterDelay(auctionDelayMs * 2);
 
             const bid = await runAuction();
             expectNoIdentity(bid);
             expectGlobalToHaveNoUid2();
             await promise;
-            if (apiSucceeds) expectGlobalToHaveRefreshedIdentity();
+            if (apiSucceeds) expectGlobalToHaveToken(refreshedToken);
             else expectGlobalToHaveNoUid2();
           }, 'it should update the userId after the auction', 'there should be no global identity');
         })
         describe('and there is a refreshed token in the module cookie', function() {
           it('the refreshed value from the cookie is used', async function() {
-            const initialIdentity = makeUid2Token(initialToken, true, true);
-            const refreshedIdentity = makeUid2Token(refreshedToken);
+            const initialIdentity = apiHelpers.makeTokenResponse(initialToken, true, true);
+            const refreshedIdentity = apiHelpers.makeTokenResponse(refreshedToken);
             const moduleCookie = {originalToken: initialIdentity, latestToken: refreshedIdentity};
-            coreStorage.setCookie(moduleCookieName, JSON.stringify(moduleCookie), getFutureCookieExpiry());
+            coreStorage.setCookie(moduleCookieName, JSON.stringify(moduleCookie), cookieHelpers.getFutureCookieExpiry());
             scenario.setConfig(initialIdentity);
 
             const bid = await runAuction();
-            expectRefreshedToken(bid);
+            expectToken(bid, refreshedToken);
           });
         })
       });
 
       describe(`When a current token is provided`, function() {
-        beforeEach(function() {
-          scenario.setConfig(makeUid2Token());
-        });
-
         it('it should use the token in the auction', async function() {
+          scenario.setConfig(apiHelpers.makeTokenResponse(initialToken));
           const bid = await runAuction();
-          expectInitialToken(bid);
+          expectToken(bid, initialToken);
         });
+
+        it('and GDPR applies, the token should not be used', async function() {
+          setGdprApplies();
+          scenario.setConfig(apiHelpers.makeTokenResponse(initialToken));
+          const bid = await runAuction();
+          expectNoIdentity(bid);
+        })
       });
 
       describe(`When a current token which should be refreshed is provided, and the auction is set to run immediately`, function() {
         beforeEach(function() {
-          scenario.setConfig(makeUid2Token(initialToken, true), {auctionDelay: 0, syncDelay: 1});
+          scenario.setConfig(apiHelpers.makeTokenResponse(initialToken, true), {auctionDelay: 0, syncDelay: 1});
         });
         testApiSuccessAndFailure(async function() {
-          respondAfterDelay(10);
+          apiHelpers.respondAfterDelay(10);
           const bid = await runAuction();
-          expectInitialToken(bid);
+          expectToken(bid, initialToken);
         }, 'it should not be refreshed before the auction runs');
 
         testApiSuccessAndFailure(async function(success) {
-          const promise = respondAfterDelay(1);
+          const promise = apiHelpers.respondAfterDelay(1);
           await runAuction();
           await promise;
           if (success) {
-            expectModuleCookieToContain(initialToken, refreshedToken);
+            expectModuleStorageToContain(initialToken, refreshedToken);
           } else {
-            expectModuleCookieToContain(initialToken, initialToken);
+            expectModuleStorageToContain(initialToken, initialToken);
           }
         }, 'the refreshed token should be stored in the module cookie after the auction runs', 'the module cookie should only have the original token');
 
         it('it should use the current token in the auction', async function() {
           const bid = await runAuction();
-          expectInitialToken(bid);
+          expectToken(bid, initialToken);
         });
       });
     });

package/test/spec/modules/undertoneBidAdapter_spec.js

@@ -41,7 +41,9 @@ const videoBidReq = [{
   },
   mediaTypes: {video: {
     context: 'outstream',
-    playerSize: [640, 480]
+    playerSize: [640, 480],
+    placement: 1,
+    plcmt: 1
   }},
   sizes: [[300, 250], [300, 600]],
   bidId: '263be71e91dd9d',
@@ -184,6 +186,31 @@ const bidderReqCcpaAndGdpr = {
   uspConsent: 'NY12'
 };
 
+const bidderReqGpp = {
+  refererInfo: {
+    topmostLocation: 'http://prebid.org/dev-docs/bidder-adaptor.html'
+  },
+  gppConsent: {
+    gppString: 'DBACNYA~CPXxRfAPXxRfAAfKABENB-CgAAAAAAAAAAYgAAAAAAAA~1YNN',
+    applicableSections: [7]
+  }
+};
+
+const bidderReqFullGppCcpaGdpr = {
+  refererInfo: {
+    topmostLocation: 'http://prebid.org/dev-docs/bidder-adaptor.html'
+  },
+  gppConsent: {
+    gppString: 'DBACNYA~CPXxRfAPXxRfAAfKABENB-CgAAAAAAAAAAYgAAAAAAAA~1YNN',
+    applicableSections: [7]
+  },
+  gdprConsent: {
+    gdprApplies: true,
+    consentString: 'gdprConsent'
+  },
+  uspConsent: '1YNN'
+};
+
 const validBidRes = {
   ad: '<div>Hello</div>',
   publisherId: 12345,
@@ -381,6 +408,31 @@ describe('Undertone Adapter', () => {
       expect(request.url).to.equal(REQ_URL);
       expect(request.method).to.equal('POST');
     });
+    it(`should have gppConsent fields`, function () {
+      const request = spec.buildRequests(bidReq, bidderReqGpp);
+      const domainStart = bidderReq.refererInfo.topmostLocation.indexOf('//');
+      const domainEnd = bidderReq.refererInfo.topmostLocation.indexOf('/', domainStart + 2);
+      const domain = bidderReq.refererInfo.topmostLocation.substring(domainStart + 2, domainEnd);
+      const gppStr = bidderReqGpp.gppConsent.gppString;
+      const gppSid = bidderReqGpp.gppConsent.applicableSections;
+      const REQ_URL = `${URL}?pid=${bidReq[0].params.publisherId}&domain=${domain}&gpp=${gppStr}&gpp_sid=${gppSid}`;
+      expect(request.url).to.equal(REQ_URL);
+      expect(request.method).to.equal('POST');
+    });
+    it(`should have gpp, ccpa and gdpr fields`, function () {
+      const request = spec.buildRequests(bidReq, bidderReqFullGppCcpaGdpr);
+      const domainStart = bidderReq.refererInfo.topmostLocation.indexOf('//');
+      const domainEnd = bidderReq.refererInfo.topmostLocation.indexOf('/', domainStart + 2);
+      const domain = bidderReq.refererInfo.topmostLocation.substring(domainStart + 2, domainEnd);
+      const gppStr = bidderReqFullGppCcpaGdpr.gppConsent.gppString;
+      const gppSid = bidderReqFullGppCcpaGdpr.gppConsent.applicableSections;
+      const ccpa = bidderReqFullGppCcpaGdpr.uspConsent;
+      const gdpr = bidderReqFullGppCcpaGdpr.gdprConsent.gdprApplies ? 1 : 0;
+      const gdprStr = bidderReqFullGppCcpaGdpr.gdprConsent.consentString;
+      const REQ_URL = `${URL}?pid=${bidReq[0].params.publisherId}&domain=${domain}&gdpr=${gdpr}&gdprstr=${gdprStr}&ccpa=${ccpa}&gpp=${gppStr}&gpp_sid=${gppSid}`;
+      expect(request.url).to.equal(REQ_URL);
+      expect(request.method).to.equal('POST');
+    });
     it('should have all relevant fields', function () {
       const request = spec.buildRequests(bidReq, bidderReq);
       const bid1 = JSON.parse(request.data)['x-ut-hb-params'][0];
@@ -409,10 +461,14 @@ describe('Undertone Adapter', () => {
       expect(bidVideo.video.playbackMethod).to.equal(2);
       expect(bidVideo.video.maxDuration).to.equal(30);
       expect(bidVideo.video.skippable).to.equal(true);
+      expect(bidVideo.video.placement).to.equal(1);
+      expect(bidVideo.video.plcmt).to.equal(1);
 
       expect(bidVideo2.video.skippable).to.equal(null);
       expect(bidVideo2.video.maxDuration).to.equal(null);
       expect(bidVideo2.video.playbackMethod).to.equal(null);
+      expect(bidVideo2.video.placement).to.equal(null);
+      expect(bidVideo2.video.plcmt).to.equal(null);
     });
     it('should send all userIds data to server', function () {
       const request = spec.buildRequests(bidReqUserIds, bidderReq);