prebid.js 7.51.0 → 7.53.0

package/test/spec/activities/allowActivites_spec.js

@@ -0,0 +1,138 @@
+import {config} from 'src/config.js';
+import {ruleRegistry} from '../../../src/activities/rules.js';
+import {updateRulesFromConfig} from '../../../modules/allowActivities.js';
+import {activityParams} from '../../../src/activities/activityParams.js';
+
+describe('allowActivities config', () => {
+  const MODULE_TYPE = 'test'
+  const MODULE_NAME = 'testMod';
+  const ACTIVITY = 'testActivity';
+
+  let isAllowed, params;
+
+  beforeEach(() => {
+    let registerRule;
+    [registerRule, isAllowed] = ruleRegistry();
+    updateRulesFromConfig(registerRule);
+    params = activityParams(MODULE_TYPE, MODULE_NAME)
+  });
+
+  afterEach(() => {
+    config.resetConfig();
+  });
+
+  function setupActivityConfig(cfg) {
+    config.setConfig({
+      allowActivities: {
+        [ACTIVITY]: cfg
+      }
+    })
+  }
+
+  describe('default = false', () => {
+    it('should deny activites with no other rules', () => {
+      setupActivityConfig({
+        default: false
+      })
+      expect(isAllowed(ACTIVITY, {})).to.be.false;
+    });
+    it('should not deny activities that are explicitly allowed', () => {
+      setupActivityConfig({
+        default: false,
+        rules: [
+          {
+            condition({componentName}) {
+              return componentName === MODULE_NAME
+            },
+            allow: true
+          }
+        ]
+      })
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    });
+    it('should be removable by a config update', () => {
+      setupActivityConfig({
+        default: false
+      });
+      setupActivityConfig({});
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    })
+  });
+
+  describe('rules', () => {
+    it('are tested for their condition', () => {
+      setupActivityConfig({
+        rules: [{
+          condition({flag}) { return flag },
+          allow: false
+        }]
+      });
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+      params.flag = true;
+      expect(isAllowed(ACTIVITY, params)).to.be.false;
+    });
+
+    it('always apply if they have no condition', () => {
+      setupActivityConfig({
+        rules: [{allow: false}]
+      });
+      expect(isAllowed(ACTIVITY, params)).to.be.false;
+    });
+
+    it('do not choke when the condition throws', () => {
+      setupActivityConfig({
+        rules: [{
+          condition() {
+            throw new Error()
+          },
+          allow: true
+        }]
+      });
+      expect(isAllowed(ACTIVITY, params)).to.be.false;
+    });
+
+    it('does not pass private (underscored) parameters to condition', () => {
+      setupActivityConfig({
+        rules: [{
+          condition({_priv}) { return _priv },
+          allow: false
+        }]
+      });
+      params._priv = true;
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    })
+
+    it('are evaluated in order of priority', () => {
+      setupActivityConfig({
+        rules: [{
+          priority: 1000,
+          allow: false
+        }, {
+          priority: 100,
+          allow: true
+        }]
+      });
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    });
+
+    it('can be set with priority 0', () => {
+      setupActivityConfig({
+        rules: [{
+          allow: false
+        }, {
+          priority: 0,
+          allow: true
+        }]
+      });
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    })
+
+    it('can be reset with a config update', () => {
+      setupActivityConfig({
+        allow: false
+      });
+      config.setConfig({allowActivities: {}});
+      expect(isAllowed(ACTIVITY, params)).to.be.true;
+    });
+  });
+});

package/test/spec/activities/objectGuard_spec.js

@@ -0,0 +1,144 @@
+import {objectGuard, writeProtectRule} from '../../../libraries/objectGuard/objectGuard.js';
+
+describe('objectGuard', () => {
+  describe('read rule', () => {
+    let rule, applies;
+    beforeEach(() => {
+      applies = true;
+      rule = {
+        paths: ['foo', 'outer.inner.foo'],
+        name: 'testRule',
+        applies: sinon.stub().callsFake(() => applies),
+        get(val) { return `repl${val}` },
+      }
+    })
+    it('can prevent top level read access', () => {
+      const {obj} = objectGuard([rule])({'foo': 1, 'other': 2});
+      expect(obj).to.eql({
+        foo: 'repl1',
+        other: 2
+      });
+    });
+
+    it('does not choke if a guarded property is missing', () => {
+      const {obj} = objectGuard([rule])({});
+      expect(obj.foo).to.not.exist;
+    });
+
+    it('does not prevent access if applies returns false', () => {
+      applies = false;
+      const {obj} = objectGuard([rule])({foo: 1});
+      expect(obj).to.eql({
+        foo: 1
+      });
+    })
+
+    it('can prevent nested property access', () => {
+      const {obj} = objectGuard([rule])({
+        other: 0,
+        outer: {
+          foo: 1,
+          inner: {
+            foo: 2
+          },
+          bar: {
+            foo: 3
+          }
+        }
+      });
+      expect(obj).to.eql({
+        other: 0,
+        outer: {
+          foo: 1,
+          inner: {
+            foo: 'repl2',
+          },
+          bar: {
+            foo: 3
+          }
+        }
+      })
+    });
+
+    it('does not call applies more than once', () => {
+      JSON.stringify(objectGuard([rule])({
+        foo: 0,
+        outer: {
+          inner: {
+            foo: 1
+          }
+        }
+      }).obj);
+      expect(rule.applies.callCount).to.equal(1);
+    })
+  });
+
+  describe('write protection', () => {
+    let applies, rule;
+
+    beforeEach(() => {
+      applies = true;
+      rule = writeProtectRule({
+        paths: ['foo', 'bar', 'outer.inner.foo', 'outer.inner.bar'],
+        applies: sinon.stub().callsFake(() => applies)
+      });
+    });
+
+    it('should undo top-level writes', () => {
+      const obj = {bar: {nested: 'val'}, other: 'val'};
+      const guard = objectGuard([rule])(obj);
+      guard.obj.foo = 'denied';
+      guard.obj.bar.nested = 'denied';
+      guard.obj.bar.other = 'denied';
+      guard.obj.other = 'allowed';
+      guard.verify();
+      expect(obj).to.eql({bar: {nested: 'val'}, other: 'allowed'});
+    });
+
+    it('should undo top-level deletes', () => {
+      const obj = {foo: {nested: 'val'}, bar: 'val'};
+      const guard = objectGuard([rule])(obj);
+      delete guard.obj.foo.nested;
+      delete guard.obj.bar;
+      guard.verify();
+      expect(obj).to.eql({foo: {nested: 'val'}, bar: 'val'});
+    })
+
+    it('should undo nested writes', () => {
+      const obj = {outer: {inner: {bar: {nested: 'val'}, other: 'val'}}};
+      const guard = objectGuard([rule])(obj);
+      guard.obj.outer.inner.bar.other = 'denied';
+      guard.obj.outer.inner.bar.nested = 'denied';
+      guard.obj.outer.inner.foo = 'denied';
+      guard.obj.outer.inner.other = 'allowed';
+      guard.verify();
+      expect(obj).to.eql({
+        outer: {
+          inner: {
+            bar: {
+              nested: 'val'
+            },
+            other: 'allowed'
+          }
+        }
+      })
+    });
+
+    it('should undo nested deletes', () => {
+      const obj = {outer: {inner: {foo: {nested: 'val'}, bar: 'val'}}};
+      const guard = objectGuard([rule])(obj);
+      delete guard.obj.outer.inner.foo.nested;
+      delete guard.obj.outer.inner.bar;
+      guard.verify();
+      expect(obj).to.eql({outer: {inner: {foo: {nested: 'val'}, bar: 'val'}}})
+    });
+
+    it('should work on null properties', () => {
+      const obj = {foo: null};
+      const guard = objectGuard([rule])(obj);
+      guard.obj.foo = 'denied';
+      guard.verify();
+      expect(obj).to.eql({foo: null});
+    });
+  });
+});

package/test/spec/activities/ortbGuard_spec.js

@@ -0,0 +1,140 @@
+import {ortb2FragmentsGuardFactory, ortb2GuardFactory} from '../../../libraries/objectGuard/ortbGuard.js';
+import {ACTIVITY_PARAM_COMPONENT_NAME, ACTIVITY_PARAM_COMPONENT_TYPE} from '../../../src/activities/params.js';
+import {
+  ACTIVITY_ENRICH_EIDS, ACTIVITY_ENRICH_UFPD,
+  ACTIVITY_TRANSMIT_EIDS,
+  ACTIVITY_TRANSMIT_UFPD
+} from '../../../src/activities/activities.js';
+import {activityParams} from '../../../src/activities/activityParams.js';
+import {deepAccess, deepClone, deepSetValue, mergeDeep} from '../../../src/utils.js';
+import {ORTB_EIDS_PATHS, ORTB_UFPD_PATHS} from '../../../src/activities/redactor.js';
+import {objectGuard, writeProtectRule} from '../../../libraries/objectGuard/objectGuard.js';
+
+describe('ortb2Guard', () => {
+  const MOD_TYPE = 'test';
+  const MOD_NAME = 'mock';
+  let isAllowed, ortb2Guard;
+  beforeEach(() => {
+    isAllowed = sinon.stub();
+    ortb2Guard = ortb2GuardFactory(function (activity, params) {
+      if (params[ACTIVITY_PARAM_COMPONENT_TYPE] === MOD_TYPE && params[ACTIVITY_PARAM_COMPONENT_NAME] === MOD_NAME) {
+        return isAllowed(activity)
+      } else {
+        throw new Error('wrong component')
+      }
+    })
+  });
+
+  function testAllowDeny(transmitActivity, enrichActivity, fn) {
+    Object.entries({
+      allowed: true,
+      denied: false
+    }).forEach(([t, allowed]) => {
+      describe(`when '${enrichActivity}' is ${t}`, () => {
+        beforeEach(() => {
+          isAllowed.callsFake((activity) => {
+            if (activity === transmitActivity) return true;
+            if (activity === enrichActivity) return allowed;
+            throw new Error('wrong activity');
+          })
+        });
+        fn(allowed);
+      })
+    })
+  }
+
+  function testPropertiesAreProtected(properties, allowed) {
+    properties.forEach(prop => {
+      it(`should ${allowed ? 'keep' : 'undo'} additions to ${prop}`, () => {
+        const orig = [{n: 'orig'}];
+        const ortb2 = {};
+        deepSetValue(ortb2, prop, deepClone(orig));
+        const guard = ortb2Guard(ortb2, activityParams(MOD_TYPE, MOD_NAME));
+        const mod = {};
+        const insert = [{n: 'new'}];
+        deepSetValue(mod, prop, insert);
+        mergeDeep(guard.obj, mod);
+        guard.verify();
+        const actual = deepAccess(ortb2, prop);
+        if (allowed) {
+          expect(actual).to.eql(orig.concat(insert))
+        } else {
+          expect(actual).to.eql(orig);
+        }
+      });
+
+      it(`should ${allowed ? 'keep' : 'undo'} modifications to ${prop}`, () => {
+        const orig = [{n: 'orig'}];
+        const ortb2 = {};
+        deepSetValue(ortb2, prop, orig);
+        const guard = ortb2Guard(ortb2, activityParams(MOD_TYPE, MOD_NAME));
+        deepSetValue(guard.obj, `${prop}.0.n`, 'new');
+        guard.verify();
+        const actual = deepAccess(ortb2, prop);
+        if (allowed) {
+          expect(actual).to.eql([{n: 'new'}]);
+        } else {
+          expect(actual).to.eql([{n: 'orig'}]);
+        }
+      });
+    })
+  }
+
+  testAllowDeny(ACTIVITY_TRANSMIT_EIDS, ACTIVITY_ENRICH_EIDS, (allowed) => {
+    testPropertiesAreProtected(ORTB_EIDS_PATHS, allowed);
+  });
+
+  testAllowDeny(ACTIVITY_TRANSMIT_UFPD, ACTIVITY_ENRICH_UFPD, (allowed) => {
+    testPropertiesAreProtected(ORTB_UFPD_PATHS, allowed);
+  });
+});
+
+describe('ortb2FragmentsGuard', () => {
+  let guardFragments
+  beforeEach(() => {
+    const testGuard = objectGuard([
+      writeProtectRule({
+        paths: ['foo'],
+        applies: () => true,
+        name: 'testRule'
+      })
+    ])
+    guardFragments = ortb2FragmentsGuardFactory(testGuard);
+  });
+
+  it('should undo changes to global FPD', () => {
+    const fragments = {
+      global: {
+        foo: {inner: 'val'}
+      }
+    }
+    const guard = guardFragments(fragments);
+    guard.obj.global.foo = 'other';
+    guard.verify();
+    expect(fragments.global.foo).to.eql({inner: 'val'});
+  });
+
+  it('should undo changes to bidder FPD', () => {
+    const fragments = {
+      bidder: {
+        A: {
+          foo: 'val'
+        }
+      }
+    };
+    const guard = guardFragments(fragments);
+    guard.obj.bidder.A.foo = 'denied';
+    guard.verify();
+    expect(fragments.bidder.A).to.eql({foo: 'val'});
+  });
+
+  it('should undo changes to bidder FPD that was not initially there', () => {
+    const fragments = {
+      bidder: {}
+    };
+    const guard = guardFragments(fragments);
+    guard.obj.bidder.A = {foo: 'denied', other: 'allowed'};
+    guard.verify();
+    expect(fragments.bidder.A).to.eql({other: 'allowed'});
+  });
+})

package/test/spec/activities/params_spec.js

@@ -0,0 +1,25 @@
+import {
+  ACTIVITY_PARAM_ADAPTER_CODE,
+  ACTIVITY_PARAM_COMPONENT, ACTIVITY_PARAM_COMPONENT_NAME,
+  ACTIVITY_PARAM_COMPONENT_TYPE
+} from '../../../src/activities/params.js';
+import adapterManager from '../../../src/adapterManager.js';
+import {MODULE_TYPE_BIDDER} from '../../../src/activities/modules.js';
+import {activityParams} from '../../../src/activities/activityParams.js';
+
+describe('activityParams', () => {
+  it('fills out component params', () => {
+    sinon.assert.match(activityParams('bidder', 'mockBidder', {foo: 'bar'}), {
+      [ACTIVITY_PARAM_COMPONENT]: 'bidder.mockBidder',
+      [ACTIVITY_PARAM_COMPONENT_TYPE]: 'bidder',
+      [ACTIVITY_PARAM_COMPONENT_NAME]: 'mockBidder',
+      foo: 'bar'
+    })
+  });
+
+  it('fills out adapterCode', () => {
+    adapterManager.registerBidAdapter({callBids: sinon.stub(), getSpec: sinon.stub().returns({})}, 'mockBidder')
+    adapterManager.aliasBidAdapter('mockBidder', 'mockAlias');
+    expect(activityParams(MODULE_TYPE_BIDDER, 'mockAlias')[ACTIVITY_PARAM_ADAPTER_CODE]).to.equal('mockBidder');
+  });
+});