prebid.js 9.26.0 → 9.28.0

package/test/spec/creative/nativeRenderer_spec.js

@@ -34,10 +34,16 @@ describe('Native creative renderer', () => {
       });
     });
     describe('otherwise, calls replacer', () => {
-      let replacer;
+      let replacer, frame;
       beforeEach(() => {
         replacer = sinon.stub().returns('markup');
+        frame = document.createElement('iframe');
+        document.body.appendChild(frame);
+        win.document = frame.contentDocument;
       });
+      afterEach(() => {
+        document.body.removeChild(frame);
+      })
       it('with adTemplate, if present', () => {
         return getAdMarkup('123', {adTemplate: 'tpl'}, replacer, win).then((result) => {
           expect(result).to.eql('markup');
@@ -45,7 +51,7 @@ describe('Native creative renderer', () => {
         });
       });
       it('with document body otherwise', () => {
-        win.document = {body: {innerHTML: 'body'}};
+        win.document.body.innerHTML = 'body'
         return getAdMarkup('123', {}, replacer, win).then((result) => {
           expect(result).to.eql('markup');
           sinon.assert.calledWith(replacer, 'body');
@@ -186,26 +192,29 @@ describe('Native creative renderer', () => {
   });
 
   describe('render', () => {
-    let getMarkup, sendMessage, adId, nativeData, exc;
+    let getMarkup, sendMessage, adId, nativeData, exc, frame;
     beforeEach(() => {
       adId = '123';
       nativeData = {}
       getMarkup = sinon.stub();
       sendMessage = sinon.stub()
       exc = sinon.stub();
-      win.document = {
-        querySelectorAll() { return [] },
-        body: {}
-      }
+      frame = document.createElement('iframe');
+      document.body.appendChild(frame);
+      win.document = frame.contentDocument;
     });
 
+    afterEach(() => {
+      document.body.removeChild(frame);
+    })
+
     function runRender() {
       return render({adId, native: nativeData}, {sendMessage, exc}, win, getMarkup)
     }
 
     it('replaces placeholders in head, if present', () => {
       getMarkup.returns(Promise.resolve(''))
-      win.document.head = {innerHTML: '##hb_native_asset_id_1##'};
+      win.document.head.innerHTML = '##hb_native_asset_id_1##';
       nativeData.ortb = {
         assets: [
           {id: 1, data: {value: 'repl'}}
@@ -216,6 +225,14 @@ describe('Native creative renderer', () => {
       })
     });
 
+    it('does not replace iframes with srcdoc that contain "renderer"', () => {
+      win.document.head.innerHTML = win.document.body.innerHTML = '<iframe srcdoc="renderer"></iframe>';
+      getMarkup.returns(Promise.resolve(''))
+      return runRender().then(() => {
+        expect(Array.from(win.document.querySelectorAll('iframe[srcdoc="renderer"]')).length).to.eql(2);
+      })
+    })
+
     it('drops markup on body, and fires imp trackers', () => {
       getMarkup.returns(Promise.resolve('markup'));
       return runRender().then(() => {
@@ -246,9 +263,27 @@ describe('Native creative renderer', () => {
 
     describe('requests resize', () => {
       beforeEach(() => {
+        const mkNode = () => {
+          const node = {
+            innerHTML: '',
+            childNodes: [],
+            insertAdjacentHTML: () => {},
+            style: {},
+            querySelectorAll: () => [],
+            cloneNode: () => node
+          };
+          return node;
+        }
+        win.document = {
+          head: mkNode(),
+          body: Object.assign(mkNode(), {
+            offsetHeight: 123,
+            offsetWidth: 321
+          }),
+          querySelectorAll: () => [],
+          style: {}
+        };
         getMarkup.returns(Promise.resolve('markup'));
-        win.document.body.offsetHeight = 123;
-        win.document.body.offsetWidth = 321;
       });
 
       it('immediately, if document is loaded', () => {

package/test/spec/libraries/mspa/activityControls_spec.js

@@ -45,6 +45,13 @@ describe('Consent interpretation', () => {
       expect(isBasicConsentDenied(mkConsent({
         KnownChildSensitiveDataConsents: [0, null]
       }))).to.be.false;
+    });
+
+    it('should deny when Version = 2 & childconsent[3] is 1', () => {
+      expect(isBasicConsentDenied(mkConsent({
+        Version: 2,
+        KnownChildSensitiveDataConsents: [null, null, 1]
+      }))).to.be.true;
     })
   });
 
@@ -84,13 +91,60 @@ describe('Consent interpretation', () => {
       expect(result).to.equal(false);
     });
     Object.entries({
-      'health information': 2,
-      'biometric data': 6,
-    }).forEach(([t, flagNo]) => {
-      it(`'should be true (consent denied to add ufpd) if no consent to process ${t}'`, () => {
-        const consent = mkConsent();
-        consent.SensitiveDataProcessing[flagNo] = 1;
-        expect(isTransmitUfpdConsentDenied(consent)).to.be.true;
+      'health information': {
+        flagNo: 2,
+        consents: {
+          1: true,
+          2: false
+        },
+        versions: [1, 2]
+      },
+      'biometric data': {
+        flagNo: 6,
+        consents: {
+          1: true,
+          2: true
+        },
+        versions: [1, 2]
+      },
+      'consumer health data': {
+        flagNo: 12,
+        consents: {
+          1: true,
+          2: false
+        },
+        versions: [2]
+      },
+      'status as transgender': {
+        flagNo: 15,
+        consents: {
+          1: true,
+          2: true,
+        },
+        versions: [2]
+      }
+
+    }).forEach(([t, {flagNo, consents, versions}]) => {
+      describe(t, () => {
+        Object.entries(consents).forEach(([flagValue, shouldBeDenied]) => {
+          const flagDescription = ({
+            1: 'denied',
+            2: 'given'
+          })[flagValue]
+          describe(`consent is ${flagValue} (${flagDescription})`, () => {
+            let consent;
+            beforeEach(() => {
+              consent = mkConsent();
+              consent.SensitiveDataProcessing[flagNo] = parseInt(flagValue, 10);
+            });
+            versions.forEach(version => {
+              it(`should ${shouldBeDenied ? 'deny' : 'allow'} (version ${version})`, () => {
+                consent.Version = version;
+                expect(isTransmitUfpdConsentDenied(consent)).to.eql(shouldBeDenied);
+              })
+            })
+          })
+        })
       })
     });
 
@@ -181,8 +235,8 @@ describe('mspaRule', () => {
       expect(mkRule()().allow).to.equal(false);
     });
 
-    it('should deny when consent is using version != 1', () => {
-      consent = {Version: 2};
+    it('should deny when consent is using version other than 1/2', () => {
+      consent = {Version: 3};
       expect(mkRule()().allow).to.equal(false);
     })
 

package/test/spec/modules/33acrossIdSystem_spec.js

@@ -21,7 +21,7 @@ describe('33acrossIdSystem', () => {
   });
 
   describe('getId', () => {
-    it('should call endpoint and handle valid response', () => {
+    it('should call endpoint', () => {
       const completeCallback = sinon.spy();
 
       const { callback } = thirtyThreeAcrossIdSubmodule.getId({
@@ -50,7 +50,71 @@ describe('33acrossIdSystem', () => {
       const regExp = new RegExp('https://lexicon.33across.com/v1/envelope\\?pid=12345&gdpr=\\d&src=pbjs&ver=$prebid.version$');
 
       expect(request.url).to.match(regExp);
-      expect(completeCallback.calledOnceWithExactly('foo')).to.be.true;
+    });
+
+    context('when there\'s a successful response containing an ID', () => {
+      it('should execute the callback and pass the ID', () => {
+        const completeCallback = sinon.spy();
+
+        const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+          params: {
+            pid: '12345'
+          }
+        });
+
+        callback(completeCallback);
+
+        const [request] = server.requests;
+
+        request.respond(200, {
+          'Content-Type': 'application/json'
+        }, JSON.stringify({
+          succeeded: true,
+          data: {
+            envelope: 'foo'
+          },
+          expires: 1645667805067
+        }));
+
+        expect(completeCallback.calledOnceWithExactly('foo')).to.be.true;
+      });
+
+      it('should NOT wipe any stored hashed email', () => {
+        const completeCallback = () => {};
+
+        const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+          params: {
+            pid: '12345'
+          },
+          enabledStorageTypes: [ 'html5' ],
+          storage: {}
+        });
+
+        callback(completeCallback);
+
+        const [request] = server.requests;
+
+        const removeDataFromLocalStorage = sinon.stub(storage, 'removeDataFromLocalStorage');
+        const setCookie = sinon.stub(storage, 'setCookie');
+        sinon.stub(domainUtils, 'domainOverride').returns('foo.com');
+
+        request.respond(200, {
+          'Content-Type': 'application/json'
+        }, JSON.stringify({
+          succeeded: true,
+          data: {
+            envelope: 'foo'
+          },
+          expires: 1645667805067
+        }));
+
+        expect(removeDataFromLocalStorage.calledWithExactly('33acrossIdHm')).to.be.false;
+        expect(setCookie.calledWithExactly('33acrossIdHm', '', sinon.match.string, 'Lax', 'foo.com')).to.be.false;
+
+        removeDataFromLocalStorage.restore();
+        setCookie.restore();
+        domainUtils.domainOverride.restore();
+      });
     });
 
     const additionalOptions = {
@@ -931,9 +995,194 @@ describe('33acrossIdSystem', () => {
 
         storage.getDataFromLocalStorage.restore();
       });
+
+      context('and the enabled storage types include "html5"', () => {
+        it('should store the hashed email in local storage', () => {
+          const completeCallback = () => {};
+
+          const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+            params: {
+              pid: '12345',
+              hem: '33acrossIdHmValue+'
+            },
+            enabledStorageTypes: [ 'html5' ],
+            storage: {}
+          });
+
+          callback(completeCallback);
+
+          const [request] = server.requests;
+
+          const setDataInLocalStorage = sinon.stub(storage, 'setDataInLocalStorage');
+
+          request.respond(200, {
+            'Content-Type': 'application/json'
+          }, JSON.stringify({
+            succeeded: true,
+            data: {
+              envelope: 'foo',
+              fp: 'bar'
+            },
+            expires: 1645667805067
+          }));
+
+          expect(setDataInLocalStorage.calledWithExactly('33acrossIdHm', '33acrossIdHmValue+')).to.be.true;
+
+          setDataInLocalStorage.restore();
+        });
+      });
+
+      context('and the enabled storage types include "cookie"', () => {
+        it('should store the hashed email in a cookie', () => {
+          const completeCallback = () => {};
+
+          const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+            params: {
+              pid: '12345',
+              hem: '33acrossIdHmValue+'
+            },
+            enabledStorageTypes: [ 'cookie' ],
+            storage: { expires: 30 }
+          });
+
+          callback(completeCallback);
+
+          const [request] = server.requests;
+
+          const setCookie = sinon.stub(storage, 'setCookie');
+          sinon.stub(domainUtils, 'domainOverride').returns('foo.com');
+
+          request.respond(200, {
+            'Content-Type': 'application/json'
+          }, JSON.stringify({
+            succeeded: true,
+            data: {
+              envelope: 'foo',
+              fp: 'bar'
+            },
+            expires: 1645667805067
+          }));
+
+          expect(setCookie.calledWithExactly('33acrossIdHm', '33acrossIdHmValue+', sinon.match.string, 'Lax', 'foo.com')).to.be.true;
+
+          setCookie.restore();
+          domainUtils.domainOverride.restore();
+        });
+      });
     });
 
     context('when a hashed email is NOT provided via configuration options', () => {
+      context('but it\'s provided via global 33across object', () => {
+        beforeEach(() => {
+          window._33across = {
+            hem: {
+              sha256: 'fake-sha256-hashed-email+'
+            }
+          }
+        });
+
+        afterEach(() => {
+          delete window._33across;
+        });
+
+        it('should call endpoint with the hashed email included', () => {
+          const completeCallback = () => {};
+          const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+            params: {
+              pid: '12345'
+              // No hashed email via config option.
+            },
+            enabledStorageTypes: [ 'html5' ],
+            storage: {}
+          });
+
+          // Prioritizes the hashed email given via global object over the one stored in LS.
+          sinon.stub(storage, 'getDataFromLocalStorage')
+            .withArgs('33acrossIdHm')
+            .returns('33acrossIdHmValueLS');
+
+          callback(completeCallback);
+
+          const [request] = server.requests;
+
+          expect(request.url).to.contain('sha256=fake-sha256-hashed-email%2B');
+
+          storage.getDataFromLocalStorage.restore();
+        });
+
+        context('and the enabled storage types include "html5"', () => {
+          it('should store the hashed email in local storage', () => {
+            const completeCallback = () => {};
+
+            const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+              params: {
+                pid: '12345'
+              },
+              enabledStorageTypes: [ 'html5' ],
+              storage: {}
+            });
+
+            callback(completeCallback);
+
+            const [request] = server.requests;
+
+            const setDataInLocalStorage = sinon.stub(storage, 'setDataInLocalStorage');
+
+            request.respond(200, {
+              'Content-Type': 'application/json'
+            }, JSON.stringify({
+              succeeded: true,
+              data: {
+                envelope: 'foo',
+                fp: 'bar'
+              },
+              expires: 1645667805067
+            }));
+
+            expect(setDataInLocalStorage.calledWithExactly('33acrossIdHm', 'fake-sha256-hashed-email+')).to.be.true;
+
+            setDataInLocalStorage.restore();
+          });
+        });
+
+        context('and the enabled storage types include "cookie"', () => {
+          it('should store the hashed email in a cookie', () => {
+            const completeCallback = () => {};
+
+            const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+              params: {
+                pid: '12345'
+              },
+              enabledStorageTypes: [ 'cookie' ],
+              storage: { expires: 30 }
+            });
+
+            callback(completeCallback);
+
+            const [request] = server.requests;
+
+            const setCookie = sinon.stub(storage, 'setCookie');
+            sinon.stub(domainUtils, 'domainOverride').returns('foo.com');
+
+            request.respond(200, {
+              'Content-Type': 'application/json'
+            }, JSON.stringify({
+              succeeded: true,
+              data: {
+                envelope: 'foo',
+                fp: 'bar'
+              },
+              expires: 1645667805067
+            }));
+
+            expect(setCookie.calledWithExactly('33acrossIdHm', 'fake-sha256-hashed-email+', sinon.match.string, 'Lax', 'foo.com')).to.be.true;
+
+            setCookie.restore();
+            domainUtils.domainOverride.restore();
+          });
+        });
+      });
+
       context('but it\'s provided via local storage', () => {
         it('should call endpoint with the hashed email included', () => {
           const completeCallback = () => {};
@@ -1205,6 +1454,43 @@ describe('33acrossIdSystem', () => {
 
         expect(completeCallback.calledOnceWithExactly(undefined)).to.be.true;
       });
+
+      it('should wipe any stored hashed email', () => {
+        const completeCallback = () => {};
+
+        const { callback } = thirtyThreeAcrossIdSubmodule.getId({
+          params: {
+            pid: '12345'
+          },
+          enabledStorageTypes: [ 'html5' ],
+          storage: {}
+        });
+
+        callback(completeCallback);
+
+        const [request] = server.requests;
+
+        const removeDataFromLocalStorage = sinon.stub(storage, 'removeDataFromLocalStorage');
+        const setCookie = sinon.stub(storage, 'setCookie');
+        sinon.stub(domainUtils, 'domainOverride').returns('foo.com');
+
+        request.respond(200, {
+          'Content-Type': 'application/json'
+        }, JSON.stringify({
+          succeeded: true,
+          data: {
+            // no envelope field
+          },
+          expires: 1645667805067
+        }));
+
+        expect(removeDataFromLocalStorage.calledWithExactly('33acrossIdHm')).to.be.true;
+        expect(setCookie.calledWithExactly('33acrossIdHm', '', sinon.match.string, 'Lax', 'foo.com')).to.be.true;
+
+        removeDataFromLocalStorage.restore();
+        setCookie.restore();
+        domainUtils.domainOverride.restore();
+      });
     });
 
     context('when the server returns an error status code', () => {

package/test/spec/modules/acuityadsBidAdapter_spec.js

@@ -191,6 +191,55 @@ describe('AcuityAdsBidAdapter', function () {
       }
     });
 
+    it('Returns valid endpoints', function () {
+      const bids = [
+        {
+          bidId: getUniqueIdentifierStr(),
+          bidder: bidder,
+          mediaTypes: {
+            [BANNER]: {
+              sizes: [[300, 250]]
+            }
+          },
+          params: {
+            endpointId: 'testBanner',
+          },
+          userIdAsEids
+        }
+      ];
+
+      let serverRequest = spec.buildRequests(bids, bidderRequest);
+
+      const { placements } = serverRequest.data;
+      for (let i = 0, len = placements.length; i < len; i++) {
+        const placement = placements[i];
+        expect(placement.endpointId).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('network');
+        expect(placement.eids).to.exist.and.to.be.deep.equal(userIdAsEids);
+
+        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);