prebid.js 8.1.0 → 8.2.0

package/test/spec/libraries/cmp/cmpClient_spec.js

@@ -0,0 +1,233 @@
+import {cmpClient} from '../../../../libraries/cmp/cmpClient.js';
+
+describe('cmpClient', () => {
+  function mockWindow(props = {}) {
+    let listeners = [];
+    const win = {
+      addEventListener: sinon.stub().callsFake((evt, listener) => {
+        evt === 'message' && listeners.push(listener)
+      }),
+      postMessage: sinon.stub().callsFake((msg) => {
+        listeners.forEach(ln => ln({data: msg}))
+      }),
+      ...props,
+    };
+    win.top = win.parent?.top || win;
+    return win;
+  }
+
+  it('should return undefined when there is no CMP', () => {
+    expect(cmpClient({apiName: 'missing'}, mockWindow())).to.not.exist;
+  });
+
+  it('should return undefined when parent is inaccessible', () => {
+    const win = mockWindow();
+    win.top = mockWindow();
+    expect(cmpClient({apiName: 'missing'}, win)).to.not.exist;
+  })
+
+  describe('direct access', () => {
+    let mockApiFn;
+    beforeEach(() => {
+      mockApiFn = sinon.stub();
+    })
+    Object.entries({
+      'on same frame': () => mockWindow({mockApiFn}),
+      'on parent frame': () => mockWindow({parent: mockWindow({parent: mockWindow({parent: mockWindow(), mockApiFn})})}),
+    }).forEach(([t, mkWindow]) => {
+      describe(t, () => {
+        let win, mkClient;
+        beforeEach(() => {
+          win = mkWindow();
+          mkClient = (opts) => cmpClient(Object.assign({apiName: 'mockApiFn'}, opts), win)
+        });
+
+        it('should mark client function as direct', () => {
+          expect(mkClient().isDirect).to.equal(true);
+        });
+
+        it('should find and call the CMP api function', () => {
+          mkClient()({command: 'mockCmd'});
+          sinon.assert.calledWith(mockApiFn, 'mockCmd');
+        });
+
+        describe('should return a promise that', () => {
+          let cbResult;
+          beforeEach(() => {
+            cbResult = [];
+            mockApiFn.callsFake((cmd, callback) => {
+              if (typeof callback === 'function') {
+                callback.apply(this, cbResult);
+              }
+              return 'val'
+            })
+          })
+          Object.entries({
+            callback: [sinon.stub(), 'undefined', undefined],
+            'no callback': [undefined, 'api return value', 'val']
+          }).forEach(([t, [callback, tResult, expectedResult]]) => {
+            describe(`when ${t} is provided`, () => {
+              Object.entries({
+                'no success flag': undefined,
+                'success is set': true
+              }).forEach(([t, success]) => {
+                it(`resolves to ${tResult} (${t})`, (done) => {
+                  cbResult = ['cbVal', success];
+                  mkClient()({callback}).then((val) => {
+                    expect(val).to.equal(expectedResult);
+                    done();
+                  })
+                })
+              });
+            })
+          });
+
+          it('rejects to undefined when callback is provided and success = false', () => {
+            cbResult = ['cbVal', false];
+            mkClient()({callback: sinon.stub()}).catch(val => {
+              expect(val).to.equal('cbVal');
+              done();
+            })
+          });
+
+          it('rejects when CMP api throws', (done) => {
+            mockApiFn.reset();
+            const e = new Error();
+            mockApiFn.throws(e);
+            mkClient()({}).catch(val => {
+              expect(val).to.equal(e);
+              done();
+            });
+          })
+        })
+
+        it('should use apiArgs to choose and order the arguments to pass to the API fn', () => {
+          mkClient({apiArgs: ['parameter', 'command']})({
+            command: 'mockCmd',
+            parameter: 'mockParam',
+            callback() {}
+          });
+          sinon.assert.calledWith(mockApiFn, 'mockParam', 'mockCmd');
+        });
+      })
+    })
+  })
+
+  describe('postMessage access', () => {
+    let messenger, win, response;
+    beforeEach(() => {
+      response = {};
+      messenger = sinon.stub().callsFake((msg) => {
+        if (msg.mockApiCall) {
+          win.postMessage({mockApiReturn: {callId: msg.mockApiCall.callId, ...response}});
+        }
+      });
+    });
+
+    function mkClient(options) {
+      return cmpClient(Object.assign({apiName: 'mockApi'}, options), win);
+    }
+
+    Object.entries({
+      'on same frame': () => {
+        win = mockWindow({frames: {mockApiLocator: true}});
+        win.addEventListener('message', (evt) => messenger(evt.data));
+      },
+      'on parent frame': () => {
+        win = mockWindow({parent: mockWindow({frames: {mockApiLocator: true}})})
+        win.parent.addEventListener('message', evt => messenger(evt.data))
+      }
+    }).forEach(([t, setup]) => {
+      describe(t, () => {
+        beforeEach(setup);
+
+        it('should mark client as not direct', () => {
+          expect(mkClient().isDirect).to.equal(false);
+        });
+
+        it('should find and message the CMP frame', () => {
+          mkClient()({command: 'mockCmd', parameter: 'param'});
+          sinon.assert.calledWithMatch(messenger, {
+            mockApiCall: {
+              command: 'mockCmd',
+              parameter: 'param'
+            }
+          })
+        });
+
+        it('should use apiArgs to choose what to include in the message payload', () => {
+          mkClient({apiArgs: ['command']})({
+            command: 'cmd',
+            parameter: 'param'
+          });
+          sinon.assert.calledWithMatch(messenger, sinon.match((arg) => {
+            return arg.mockApiCall.command === 'cmd' &&
+              !arg.mockApiCall.hasOwnProperty('parameter');
+          }))
+        });
+
+        it('should not include callback in the payload, but still run it on response', () => {
+          const cb = sinon.stub();
+          mkClient({apiArgs: ['command', 'callback']})({
+            command: 'cmd',
+            callback: cb
+          });
+          sinon.assert.calledWithMatch(messenger, sinon.match(arg => !arg.mockApiCall.hasOwnProperty('callback')));
+          sinon.assert.called(cb);
+        });
+
+        it('should use callbackArgs to decide what to pass to callback', () => {
+          const cb = sinon.stub();
+          response = {a: 'one', b: 'two'};
+          mkClient({callbackArgs: ['a', 'b']})({callback: cb});
+          sinon.assert.calledWith(cb, 'one', 'two');
+        })
+
+        describe('should return a promise that', () => {
+          beforeEach(() => {
+            response = {returnValue: 'val'}
+          })
+          Object.entries({
+            'callback': [sinon.stub(), 'undefined', undefined],
+            'no callback': [undefined, 'response returnValue', 'val'],
+          }).forEach(([t, [callback, tResult, expectedResult]]) => {
+            describe(`when ${t} is provided`, () => {
+              Object.entries({
+                'no success flag': {},
+                'with success flag': {success: true}
+              }).forEach(([t, resp]) => {
+                it(`resolves to ${tResult} (${t})`, () => {
+                  Object.assign(response, resp);
+                  mkClient()({callback}).then((val) => {
+                    expect(val).to.equal(expectedResult);
+                  })
+                })
+              });
+
+              it(`rejects to ${tResult} when success = false`, (done) => {
+                response.success = false;
+                mkClient()({callback}).catch((err) => {
+                  expect(err).to.equal(expectedResult);
+                  done();
+                });
+              });
+            })
+          });
+        });
+
+        it('should re-use callback for messages with same callId', () => {
+          messenger.reset();
+          let callId;
+          messenger.callsFake((msg) => { if (msg.mockApiCall) callId = msg.mockApiCall.callId });
+          const callback = sinon.stub();
+          mkClient()({callback});
+          expect(callId).to.exist;
+          win.postMessage({mockApiReturn: {callId, returnValue: 'a'}});
+          win.postMessage({mockApiReturn: {callId, returnValue: 'b'}});
+          sinon.assert.calledWith(callback, 'a');
+          sinon.assert.calledWith(callback, 'b');
+        })
+      });
+    });
+  });
+});

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

@@ -0,0 +1,315 @@
+import {mspaRule, setupRules, isTransmitUfpdConsentDenied, isTransmitGeoConsentDenied, isBasicConsentDenied, isSensitiveNoticeMissing, isConsentDenied} from '../../../../libraries/mspa/activityControls.js';
+import {ruleRegistry} from '../../../../src/activities/rules.js';
+describe('isBasicConsentDenied', () => {
+  const cd = {
+    // not covered, opt in to targeted, sale, and share, all notices given, opt into precise geo
+    Gpc: 0,
+    KnownChildSensitiveDataConsents: [0, 0],
+    MspaCoveredTransaction: 2,
+    MspaOptOutOptionMode: 0,
+    MspaServiceProviderMode: 0,
+    PersonalDataConsents: 0,
+    SaleOptOut: 2,
+    SaleOptOutNotice: 1,
+    SensitiveDataLimitUseNotice: 1,
+    SensitiveDataProcessing: [0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0],
+    SensitiveDataProcessingOptOutNotice: 1,
+    SharingNotice: 1,
+    SharingOptOut: 2,
+    SharingOptOutNotice: 1,
+    TargetedAdvertisingOptOut: 2,
+    TargetedAdvertisingOptOutNotice: 1,
+    Version: 1
+  };
+  it('should be false (basic consent conditions pass) with variety of notice and opt in', () => {
+    const result = isBasicConsentDenied(cd);
+    expect(result).to.equal(false);
+  });
+  it('should be true (basic consent conditions do not pass) with personal data consent set to true (invalid state)', () => {
+    cd.PersonalDataConsents = 2;
+    const result = isBasicConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.PersonalDataConsents = 0;
+  });
+  it('should be true (basic consent conditions do not pass) with sensitive opt in but no notice', () => {
+    cd.SensitiveDataLimitUseNotice = 0;
+    const result = isBasicConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataLimitUseNotice = 1;
+  });
+})
+describe('isSensitiveNoticeMissing', () => {
+  const cd = {
+    // not covered, opt in to targeted, sale, and share, all notices given, opt into precise geo
+    Gpc: 0,
+    KnownChildSensitiveDataConsents: [0, 0],
+    MspaCoveredTransaction: 2,
+    MspaOptOutOptionMode: 0,
+    MspaServiceProviderMode: 0,
+    PersonalDataConsents: 0,
+    SaleOptOut: 2,
+    SaleOptOutNotice: 1,
+    SensitiveDataLimitUseNotice: 1,
+    SensitiveDataProcessing: [0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0],
+    SensitiveDataProcessingOptOutNotice: 1,
+    SharingNotice: 1,
+    SharingOptOut: 2,
+    SharingOptOutNotice: 1,
+    TargetedAdvertisingOptOut: 2,
+    TargetedAdvertisingOptOutNotice: 1,
+    Version: 1
+  };
+  it('should be false (sensitive notice is given or not needed) with variety of notice and opt in', () => {
+    const result = isSensitiveNoticeMissing(cd);
+    expect(result).to.equal(false);
+  });
+  it('should be true (sensitive notice is missing) with variety of notice and opt in', () => {
+    cd.SensitiveDataLimitUseNotice = 2;
+    const result = isSensitiveNoticeMissing(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataLimitUseNotice = 1;
+  });
+})
+describe('isConsentDenied', () => {
+  const cd = {
+    // not covered, opt in to targeted, sale, and share, all notices given, opt into precise geo
+    Gpc: 0,
+    KnownChildSensitiveDataConsents: [0, 0],
+    MspaCoveredTransaction: 2,
+    MspaOptOutOptionMode: 0,
+    MspaServiceProviderMode: 0,
+    PersonalDataConsents: 0,
+    SaleOptOut: 2,
+    SaleOptOutNotice: 1,
+    SensitiveDataLimitUseNotice: 1,
+    SensitiveDataProcessing: [0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0],
+    SensitiveDataProcessingOptOutNotice: 1,
+    SharingNotice: 1,
+    SharingOptOut: 2,
+    SharingOptOutNotice: 1,
+    TargetedAdvertisingOptOut: 2,
+    TargetedAdvertisingOptOutNotice: 1,
+    Version: 1
+  };
+  it('should be false (consent given personalized ads / sale / share) with variety of notice and opt in', () => {
+    const result = isConsentDenied(cd);
+    expect(result).to.equal(false);
+  });
+  it('should be true (no consent) on opt out of targeted ads via TargetedAdvertisingOptOut', () => {
+    cd.TargetedAdvertisingOptOut = 1;
+    const result = isConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.TargetedAdvertisingOptOut = 2;
+  });
+  it('should be true (no consent) on opt out of targeted ads via no TargetedAdvertisingOptOutNotice', () => {
+    cd.TargetedAdvertisingOptOutNotice = 2;
+    const result = isConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.TargetedAdvertisingOptOutNotice = 1;
+  });
+  it('should be true (no consent) if TargetedAdvertisingOptOutNotice is 0 and TargetedAdvertisingOptOut is 2', () => {
+    cd.TargetedAdvertisingOptOutNotice = 0;
+    const result = isConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.TargetedAdvertisingOptOutNotice = 1;
+  });
+})
+describe('isTransmitUfpdConsentDenied', () => {
+  const cd = {
+    // not covered, opt in to targeted, sale, and share, all notices given, opt into precise geo
+    Gpc: 0,
+    KnownChildSensitiveDataConsents: [0, 0],
+    MspaCoveredTransaction: 2,
+    MspaOptOutOptionMode: 0,
+    MspaServiceProviderMode: 0,
+    PersonalDataConsents: 0,
+    SaleOptOut: 2,
+    SaleOptOutNotice: 1,
+    SensitiveDataLimitUseNotice: 1,
+    SensitiveDataProcessing: [0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0],
+    SensitiveDataProcessingOptOutNotice: 1,
+    SharingNotice: 1,
+    SharingOptOut: 2,
+    SharingOptOutNotice: 1,
+    TargetedAdvertisingOptOut: 2,
+    TargetedAdvertisingOptOutNotice: 1,
+    Version: 1
+  };
+  it('should be false (consent given to add ufpd) with variety of notice and opt in', () => {
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(false);
+  });
+  it('should be true (consent denied to add ufpd) if no consent to process health information', () => {
+    cd.SensitiveDataProcessing[2] = 1;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataProcessing[2] = 0;
+  });
+  it('should be true (consent denied to add ufpd) with consent to process biometric data, as this should not be on openrtb', () => {
+    cd.SensitiveDataProcessing[6] = 1;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataProcessing[6] = 1;
+  });
+  it('should be true (consent denied to add ufpd) without sharing notice', () => {
+    cd.SharingNotice = 2;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SharingNotice = 1;
+  });
+  it('should be true (consent denied to add ufpd) with sale opt out', () => {
+    cd.SaleOptOut = 1;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SaleOptOut = 2;
+  });
+  it('should be true (consent denied to add ufpd) without targeted ads opt out', () => {
+    cd.TargetedAdvertisingOptOut = 1;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.TargetedAdvertisingOptOut = 2;
+  });
+  it('should be true (consent denied to add ufpd) with missing sensitive data limit notice', () => {
+    cd.SensitiveDataLimitUseNotice = 2;
+    const result = isTransmitUfpdConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataLimitUseNotice = 1;
+  });
+})
+
+describe('isTransmitGeoConsentDenied', () => {
+  const cd = {
+    // not covered, opt out of geo
+    Gpc: 0,
+    KnownChildSensitiveDataConsents: [0, 0],
+    MspaCoveredTransaction: 2,
+    MspaOptOutOptionMode: 0,
+    MspaServiceProviderMode: 0,
+    PersonalDataConsents: 0,
+    SaleOptOut: 2,
+    SaleOptOutNotice: 1,
+    SensitiveDataLimitUseNotice: 1,
+    SensitiveDataProcessing: [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+    SensitiveDataProcessingOptOutNotice: 1,
+    SharingNotice: 1,
+    SharingOptOut: 2,
+    SharingOptOutNotice: 1,
+    TargetedAdvertisingOptOut: 2,
+    TargetedAdvertisingOptOutNotice: 1,
+    Version: 1
+  };
+  it('should be true (consent denied to add precise geo) -- sensitive flag denied', () => {
+    const result = isTransmitGeoConsentDenied(cd);
+    expect(result).to.equal(true);
+  });
+  it('should be true (consent denied to add precise geo) -- sensitive data limit usage not given', () => {
+    cd.SensitiveDataLimitUseNotice = 0;
+    const result = isTransmitGeoConsentDenied(cd);
+    expect(result).to.equal(true);
+    cd.SensitiveDataLimitUseNotice = 1;
+  });
+  it('should be false (consent given to add precise geo) -- sensitive position 8 (index 7) is true', () => {
+    cd.SensitiveDataProcessing[7] = 2;
+    const result = isTransmitGeoConsentDenied(cd);
+    expect(result).to.equal(false);
+    cd.SensitiveDataProcessing[7] = 1;
+  });
+})
+
+describe('mspaRule', () => {
+  it('does not apply if SID is not applicable', () => {
+    const rule = mspaRule([1, 2], () => null, () => true, () => [3, 4]);
+    expect(rule()).to.not.exist;
+  });
+
+  it('does not apply when no SID is applicable', () => {
+    const rule = mspaRule([1], () => null, () => true, () => []);
+    expect(rule()).to.not.exist;
+  });
+
+  describe('when SID is applicable', () => {
+    let consent, denies;
+    function mkRule() {
+      return mspaRule([1, 2], () => consent, denies, () => [2])
+    }
+
+    beforeEach(() => {
+      consent = null;
+      denies = sinon.stub();
+    });
+
+    it('should deny when no consent is available', () => {
+      expect(mkRule()().allow).to.equal(false);
+    });
+
+    Object.entries({
+      'denies': true,
+      'allows': false
+    }).forEach(([t, denied]) => {
+      it(`should check if deny fn ${t}`, () => {
+        denies.returns(denied);
+        consent = {mock: 'value'};
+        const result = mkRule()();
+        sinon.assert.calledWith(denies, consent);
+        if (denied) {
+          expect(result.allow).to.equal(false);
+        } else {
+          expect(result).to.not.exist;
+        }
+      })
+    })
+  })
+});
+
+describe('setupRules', () => {
+  let rules, registerRule, isAllowed, consent;
+  beforeEach(() => {
+    rules = {
+      mockActivity: sinon.stub().returns(true)
+    };
+    ([registerRule, isAllowed] = ruleRegistry());
+    consent = {
+      applicableSections: [1],
+      sectionData: {
+        mockApi: {
+          mock: 'consent'
+        }
+      }
+    };
+  });
+
+  function runSetup(api, sids, normalize) {
+    return setupRules(api, sids, normalize, rules, registerRule, () => consent)
+  }
+
+  it('should use section data for the given api', () => {
+    runSetup('mockApi', [1]);
+    expect(isAllowed('mockActivity', {})).to.equal(false);
+    sinon.assert.calledWith(rules.mockActivity, {mock: 'consent'})
+  });
+
+  it('should not choke when no consent data is available', () => {
+    consent = null;
+    runSetup('mockApi', [1]);
+    expect(isAllowed('mockActivity', {})).to.equal(true);
+  });
+
+  it('should check applicableSections against given SIDs', () => {
+    runSetup('mockApi', [2]);
+    expect(isAllowed('mockActivity', {})).to.equal(true);
+  });
+
+  it('should pass consent through normalizeConsent', () => {
+    const normalize = sinon.stub().returns({normalized: 'consent'})
+    runSetup('mockApi', [1], normalize);
+    expect(isAllowed('mockActivity', {})).to.equal(false);
+    sinon.assert.calledWith(normalize, {mock: 'consent'});
+    sinon.assert.calledWith(rules.mockActivity, {normalized: 'consent'});
+  });
+
+  it('should return a function that unregisters activity controls', () => {
+    const dereg = runSetup('mockApi', [1]);
+    dereg();
+    expect(isAllowed('mockActivity', {})).to.equal(true);
+  });
+})

package/test/spec/modules/admanBidAdapter_spec.js

@@ -106,8 +106,11 @@ describe('AdmanAdapter', function () {
       let placements = data['placements'];
       for (let i = 0; i < placements.length; i++) {
         let placement = placements[i];
-        expect(placement).to.have.all.keys('placementId', 'eids', 'bidId', 'traffic', 'sizes', 'schain', 'bidFloor');
+        expect(placement).to.have.all.keys('placementId', 'eids', 'bidId', 'traffic', 'sizes', 'schain', 'bidFloor', 'ext');
         expect(placement.schain).to.be.an('object')
+        expect(placement.ext).to.be.an('object')
+        expect(placement.ext).to.have.key('tid')
+        expect(placement.ext.tid).to.equal(bidBanner.transactionId);
         expect(placement.placementId).to.be.a('number');
         expect(placement.bidId).to.be.a('string');
         expect(placement.traffic).to.be.a('string');
@@ -132,7 +135,10 @@ describe('AdmanAdapter', function () {
         let placement = placements[i];
         expect(placement).to.have.all.keys('placementId', 'eids', 'bidId', 'traffic', 'schain', 'bidFloor',
           'playerSize', 'minduration', 'maxduration', 'mimes', 'protocols', 'startdelay', 'placement', 'skip',
-          'skipafter', 'minbitrate', 'maxbitrate', 'delivery', 'playbackmethod', 'api', 'linearity');
+          'skipafter', 'minbitrate', 'maxbitrate', 'delivery', 'playbackmethod', 'api', 'linearity', 'ext');
+        expect(placement.ext).to.be.an('object')
+        expect(placement.ext).to.have.key('tid')
+        expect(placement.ext.tid).to.equal(bidBanner.transactionId);
         expect(placement.schain).to.be.an('object')
         expect(placement.placementId).to.be.a('number');
         expect(placement.bidId).to.be.a('string');

package/test/spec/modules/adqueryBidAdapter_spec.js

@@ -80,7 +80,11 @@ describe('adqueryBidAdapter', function () {
   })
 
   describe('buildRequests', function () {
-    let req = spec.buildRequests([ bidRequest ], { refererInfo: { } })[0]
+    let req;
+    beforeEach(() => {
+      req = spec.buildRequests([ bidRequest ], { refererInfo: { } })[0]
+    })
+
     let rdata
 
     it('should return request object', function () {