prebid.js 7.22.0 → 7.24.0

package/test/spec/ortbConverter/native_spec.js

@@ -0,0 +1,95 @@
+import {fillNativeImp, fillNativeResponse} from '../../../libraries/ortbConverter/processors/native.js';
+import {BANNER, NATIVE} from '../../../src/mediaTypes.js';
+
+describe('pbjs -> ortb native requests', () => {
+  function toNative(bidRequest, context) {
+    const imp = {};
+    fillNativeImp(imp, bidRequest, context);
+    return imp;
+  }
+
+  it('should do nothing if request has no nativeOrtbRequest', () => {
+    expect(toNative({}, {})).to.eql({});
+  });
+
+  it('should set imp.native according to nativeOrtbRequest', () => {
+    const nativeOrtbRequest = {ver: 'version', prop: 'value', assets: [{}]};
+    const imp = toNative({nativeOrtbRequest}, {});
+    expect(imp.native.ver).to.eql('version');
+    expect(JSON.parse(imp.native.request)).to.eql(nativeOrtbRequest);
+  });
+
+  it('should do nothing if context.mediaType is set but is not NATIVE', () => {
+    expect(toNative({nativeOrtbRequest: {ver: 'version'}}, {mediaType: BANNER})).to.eql({})
+  });
+
+  it('should merge context.nativeRequest', () => {
+    const nativeOrtbRequest = {ver: 'version', eventtrackers: [{tracker: 'req'}], assets: [{}]};
+    const nativeDefaults = {eventtrackers: [{tracker: 'default'}], other: 'other'};
+    const imp = toNative({nativeOrtbRequest}, {nativeRequest: nativeDefaults});
+    expect(imp.native.ver).to.eql('version');
+    expect(JSON.parse(imp.native.request)).to.eql({
+      assets: [{}],
+      ver: 'version',
+      eventtrackers: [{tracker: 'req'}],
+      other: 'other'
+    });
+  });
+
+  it('should keep ortb2Imp.native', () => {
+    const imp = {
+      native: {
+        something: 'orother'
+      }
+    }
+    fillNativeImp(imp, {nativeOrtbRequest: {ver: 'version'}}, {});
+    expect(imp.native.something).to.eql('orother')
+  });
+
+  it('should do nothing if there are no assets', () => {
+    const imp = {};
+    fillNativeImp(imp, {nativeOrtbRequest: {assets: []}}, {});
+    expect(imp).to.eql({});
+  })
+});
+
+describe('ortb -> ortb native response', () => {
+  const MOCK_NATIVE_RESPONSE = {
+    property: 'value',
+    assets: [
+      {
+        id: 0
+      }
+    ]
+  }
+  Object.entries({
+    'serialized': JSON.stringify(MOCK_NATIVE_RESPONSE),
+    'an object': MOCK_NATIVE_RESPONSE
+  }).forEach(([t, adm]) => {
+    describe(`when adm is ${t}`, () => {
+      let bid;
+      beforeEach(() => {
+        bid = {adm};
+      })
+      it('should set bidResponse.native', () => {
+        const bidResponse = {
+          mediaType: NATIVE
+        };
+        fillNativeResponse(bidResponse, bid, {});
+        expect(bidResponse.native).to.eql({ortb: MOCK_NATIVE_RESPONSE});
+      });
+    });
+    it('should throw if response has no assets', () => {
+      expect(() => fillNativeResponse({mediaType: NATIVE}, {adm: {...MOCK_NATIVE_RESPONSE, assets: null}}, {})).to.throw;
+    })
+    it('should do nothing if bidResponse.mediaType is not NATIVE', () => {
+      const bidResponse = {
+        mediaType: BANNER
+      };
+      fillNativeResponse(bidResponse, {adm: MOCK_NATIVE_RESPONSE}, {});
+      expect(bidResponse).to.eql({
+        mediaType: BANNER
+      })
+    })
+  })
+});

package/test/spec/ortbConverter/pbjsORTB_spec.js

@@ -0,0 +1,67 @@
+import {
+  DEFAULT,
+  PBS,
+  PROCESSOR_TYPES,
+  processorRegistry,
+  REQUEST
+} from '../../../src/pbjsORTB.js';
+
+describe('pbjsORTB register / get processors', () => {
+  let registerOrtbProcessor, getProcessors;
+  beforeEach(() => {
+    ({registerOrtbProcessor, getProcessors} = processorRegistry());
+  })
+  PROCESSOR_TYPES.forEach(type => {
+    it(`can get and set ${type} processors`, () => {
+      const proc = function () {};
+      registerOrtbProcessor({
+        type,
+        name: 'test',
+        fn: proc
+      });
+      expect(getProcessors(DEFAULT)).to.eql({
+        [type]: {
+          test: {
+            priority: 0,
+            fn: proc
+          }
+        }
+      });
+    });
+  });
+
+  it('throws on wrong type', () => {
+    expect(() => registerOrtbProcessor({
+      type: 'incorrect',
+      name: 'test',
+      fn: function () {}
+    })).to.throw();
+  });
+
+  it('can set priority', () => {
+    const proc = function () {};
+    registerOrtbProcessor({type: REQUEST, name: 'test', fn: proc, priority: 10});
+    expect(getProcessors(DEFAULT)).to.eql({
+      [REQUEST]: {
+        test: {
+          priority: 10,
+          fn: proc
+        }
+      }
+    })
+  });
+
+  it('can assign processors to specific dialects', () => {
+    const proc = function () {};
+    registerOrtbProcessor({type: REQUEST, name: 'test', fn: proc, dialects: [PBS]});
+    expect(getProcessors(DEFAULT)).to.eql({});
+    expect(getProcessors(PBS)).to.eql({
+      [REQUEST]: {
+        test: {
+          priority: 0,
+          fn: proc
+        }
+      }
+    })
+  });
+});

package/test/spec/ortbConverter/pbsExtensions/aliases_spec.js

@@ -0,0 +1,57 @@
+import {setRequestExtPrebidAliases} from '../../../../libraries/pbsExtensions/processors/aliases.js';
+
+describe('PBS - ortb ext.prebid.aliases', () => {
+  let aliasRegistry, bidderRegistry;
+
+  function setAliases(bidderRequest) {
+    const req = {}
+    setRequestExtPrebidAliases(req, bidderRequest, {}, {
+      am: {
+        bidderRegistry,
+        aliasRegistry
+      }
+    });
+    return req;
+  }
+
+  beforeEach(() => {
+    aliasRegistry = {};
+    bidderRegistry = {};
+  })
+
+  describe('has no effect if', () => {
+    it('bidder is not an alias', () => {
+      expect(setAliases({bidderCode: 'not-an-alias'})).to.eql({});
+    });
+
+    it('bidder sets skipPbsAliasing', () => {
+      aliasRegistry['alias'] = 'bidder';
+      bidderRegistry['alias'] = {
+        getSpec() {
+          return {
+            skipPbsAliasing: true
+          }
+        }
+      };
+      expect(setAliases({bidderCode: 'alias'})).to.eql({});
+    });
+  });
+
+  it('sets ext.prebid.aliases.BIDDER', () => {
+    aliasRegistry['alias'] = 'bidder';
+    bidderRegistry['alias'] = {
+      getSpec() {
+        return {}
+      }
+    };
+    expect(setAliases({bidderCode: 'alias'})).to.eql({
+      ext: {
+        prebid: {
+          aliases: {
+            alias: 'bidder'
+          }
+        }
+      }
+    })
+  });
+})

package/test/spec/ortbConverter/pbsExtensions/params_spec.js

@@ -0,0 +1,96 @@
+import {setImpBidParams} from '../../../../libraries/pbsExtensions/processors/params.js';
+
+describe('pbjs -> ortb bid params to imp[].ext.prebid.BIDDER', () => {
+  let bidderRegistry, index, adUnit;
+  beforeEach(() => {
+    bidderRegistry = {};
+    adUnit = {code: 'mockAdUnit'};
+    index = {
+      getAdUnit() {
+        return adUnit;
+      }
+    }
+  });
+
+  function setParams(bidRequest, context, deps = {}) {
+    const imp = {};
+    setImpBidParams(imp, bidRequest, context, Object.assign({bidderRegistry, index}, deps))
+    return imp;
+  }
+
+  it('sets params in ext.prebid.bidder.BIDDER', () => {
+    expect(setParams({bidder: 'mockBidder', params: {a: 'param'}})).to.eql({
+      ext: {
+        prebid: {
+          bidder: {
+            mockBidder: {
+              a: 'param'
+            }
+          }
+        }
+      }
+    })
+  });
+
+  it('has no effect if bidRequest has no params', () => {
+    expect(setParams({bidder: 'mockBidder'})).to.eql({});
+  })
+
+  describe('when adapter provides transformBidParams', () => {
+    let transform, bidderRequest;
+    beforeEach(() => {
+      bidderRequest = {bidderCode: 'mockBidder'};
+      transform = sinon.stub().callsFake((p) => Object.assign({transformed: true}, p));
+      bidderRegistry.mockBidder = {
+        getSpec() {
+          return {
+            transformBidParams: transform
+          }
+        }
+      }
+    })
+
+    it('runs params through transform', () => {
+      expect(setParams({bidder: 'mockBidder', params: {a: 'param'}}, {bidderRequest})).to.eql({
+        ext: {
+          prebid: {
+            bidder: {
+              mockBidder: {
+                a: 'param',
+                transformed: true
+              }
+            }
+          }
+        }
+      });
+    });
+
+    it('runs through transform even if bid has no params', () => {
+      expect(setParams({bidder: 'mockBidder'}, {bidderRequest})).to.eql({
+        ext: {
+          prebid: {
+            bidder: {
+              mockBidder: {
+                transformed: true
+              }
+            }
+          }
+        }
+      })
+    })
+
+    it('by default, passes adUnit from index, bidderRequest from context', () => {
+      const params = {a: 'param'};
+      setParams({bidder: 'mockBidder', params}, {bidderRequest});
+      sinon.assert.calledWith(transform, params, true, adUnit, [bidderRequest])
+    });
+
+    it('uses provided adUnit, bidderRequests', () => {
+      const adUnit = {code: 'other-ad-unit'};
+      const bidderRequests = [{bidderCode: 'one'}, {bidderCode: 'two'}];
+      const params = {a: 'param'};
+      setParams({bidder: 'mockBidder', params}, {}, {adUnit, bidderRequests});
+      sinon.assert.calledWith(transform, params, true, adUnit, bidderRequests);
+    })
+  });
+});

package/test/spec/ortbConverter/pbsExtensions/video_spec.js

@@ -0,0 +1,52 @@
+import {setBidResponseVideoCache} from '../../../../libraries/pbsExtensions/processors/video.js';
+
+describe('pbjs - ortb videoCacheKey based on ext.prebid', () => {
+  const EXT_PREBID_CACHE = {
+    ext: {
+      prebid: {
+        cache: {
+          vastXml: {
+            cacheId: 'id',
+            url: 'url'
+          }
+        }
+      }
+    }
+  }
+
+  function setCache(bid) {
+    const bidResponse = {mediaType: 'video'};
+    setBidResponseVideoCache(bidResponse, bid);
+    return bidResponse;
+  }
+
+  it('has no effect if mediaType is not video', () => {
+    const resp = {mediaType: 'banner'};
+    setBidResponseVideoCache(resp, EXT_PREBID_CACHE);
+    expect(resp).to.eql({mediaType: 'banner'});
+  });
+
+  it('sets videoCacheKey, vastUrl from ext.prebid.cache.vastXml', () => {
+    sinon.assert.match(setCache(EXT_PREBID_CACHE), {
+      videoCacheKey: 'id',
+      vastUrl: 'url'
+    });
+  });
+
+  it('sets videoCacheKey, vastUrl from ext.prebid.targeting', () => {
+    sinon.assert.match(setCache({
+      ext: {
+        prebid: {
+          targeting: {
+            hb_uuid: 'id',
+            hb_cache_host: 'host',
+            hb_cache_path: '/path'
+          }
+        }
+      }
+    }), {
+      vastUrl: 'https://host/path?uuid=id',
+      videoCacheKey: 'id'
+    })
+  });
+});

package/test/spec/ortbConverter/priceFloors_spec.js

@@ -0,0 +1,143 @@
+import {config} from 'src/config.js';
+import {setOrtbExtPrebidFloors, setOrtbImpBidFloor} from '../../../modules/priceFloors.js';
+import 'src/prebid.js';
+
+describe('pbjs - ortb imp floor params', () => {
+  before(() => {
+    config.resetConfig();
+  });
+
+  afterEach(() => {
+    config.resetConfig();
+  });
+
+  Object.entries({
+    'has no getFloor': {},
+    'has getFloor that throws': {
+      getFloor: sinon.stub().callsFake(() => { throw new Error() }),
+    },
+    'returns invalid floor': {
+      getFloor: sinon.stub().callsFake(() => ({floor: NaN, currency: null}))
+    }
+  }).forEach(([t, req]) => {
+    it(`has no effect if bid ${t}`, () => {
+      const imp = {};
+      setOrtbImpBidFloor(imp, {}, {});
+      expect(imp).to.eql({});
+    })
+  })
+
+  it('sets bidfoor and bidfloorcur according to getFloor', () => {
+    const imp = {};
+    const req = {
+      getFloor() {
+        return {
+          currency: 'EUR',
+          floor: '1.23'
+        }
+      }
+    };
+    setOrtbImpBidFloor(imp, req, {});
+    expect(imp).to.eql({
+      bidfloor: 1.23,
+      bidfloorcur: 'EUR'
+    })
+  });
+
+  Object.entries({
+    'missing currency': {floor: 1.23},
+    'missing floor': {currency: 'USD'},
+    'not a number': {floor: 'abc', currency: 'USD'}
+  }).forEach(([t, floor]) => {
+    it(`should not set bidfloor if floor is ${t}`, () => {
+      const imp = {};
+      const req = {
+        getFloor: () => floor
+      }
+      setOrtbImpBidFloor(imp, req, {});
+      expect(imp).to.eql({});
+    })
+  })
+
+  describe('asks for floor in currency', () => {
+    let req;
+    beforeEach(() => {
+      req = {
+        getFloor(opts) {
+          return {
+            floor: 1.23,
+            currency: opts.currency
+          }
+        }
+      }
+    })
+
+    it('from context.currency', () => {
+      const imp = {};
+      setOrtbImpBidFloor(imp, req, {currency: 'JPY'});
+      config.setConfig({
+        currency: {
+          adServerCurrency: 'EUR'
+        }
+      })
+      expect(imp.bidfloorcur).to.eql('JPY');
+    });
+
+    it('from config', () => {
+      const imp = {};
+      config.setConfig({
+        currency: {
+          adServerCurrency: 'EUR'
+        }
+      });
+      setOrtbImpBidFloor(imp, req, {});
+      expect(imp.bidfloorcur).to.eql('EUR');
+    });
+
+    it('defaults to USD', () => {
+      const imp = {};
+      setOrtbImpBidFloor(imp, req, {});
+      expect(imp.bidfloorcur).to.eql('USD');
+    })
+  });
+
+  it('asks for specific mediaType if context.mediaType is set', () => {
+    let reqMediaType;
+    const req = {
+      getFloor(opts) {
+        reqMediaType = opts.mediaType;
+      }
+    }
+    setOrtbImpBidFloor({}, req, {mediaType: 'banner'});
+    expect(reqMediaType).to.eql('banner');
+  })
+});
+
+describe('setOrtbExtPrebidFloors', () => {
+  before(() => {
+    config.setConfig({floors: {}});
+  })
+  after(() => {
+    config.setConfig({floors: {enabled: false}});
+  });
+
+  it('should set ext.prebid.floors.enabled to false', () => {
+    const req = {};
+    setOrtbExtPrebidFloors(req);
+    expect(req.ext.prebid.floors.enabled).to.equal(false);
+  })
+
+  it('should respect fpd', () => {
+    const req = {
+      ext: {
+        prebid: {
+          floors: {
+            enabled: true
+          }
+        }
+      }
+    }
+    setOrtbExtPrebidFloors(req);
+    expect(req.ext.prebid.floors.enabled).to.equal(true);
+  })
+})

package/test/spec/ortbConverter/schain_spec.js

@@ -0,0 +1,33 @@
+import {setOrtbSourceExtSchain} from '../../../modules/schain.js';
+
+describe('pbjs - ortb source.ext.schain', () => {
+  it('sets schain from request', () => {
+    const req = {};
+    setOrtbSourceExtSchain(req, {}, {
+      bidRequests: [{schain: {s: 'chain'}}]
+    });
+    expect(req.source.ext.schain).to.eql({s: 'chain'});
+  });
+
+  it('does not set it if missing', () => {
+    const req = {};
+    setOrtbSourceExtSchain(req, {}, {bidRequests: [{}]});
+    expect(req).to.eql({});
+  })
+
+  it('does not set it if already in request', () => {
+    const req = {
+      source: {
+        ext: {
+          schain: {s: 'chain'}
+        }
+      }
+    }
+    setOrtbSourceExtSchain(req, {}, {
+      bidRequests: [{
+        schain: {other: 'chain'}
+      }]
+    });
+    expect(req.source.ext.schain).to.eql({s: 'chain'});
+  })
+});

package/test/spec/ortbConverter/userId_spec.js

@@ -0,0 +1,21 @@
+import {setOrtbUserExtEids} from '../../../modules/userId/index.js';
+
+describe('pbjs - ortb user eids', () => {
+  it('sets user.ext.eids from request', () => {
+    const req = {};
+    setOrtbUserExtEids(req, {}, {
+      bidRequests: [
+        {
+          userIdAsEids: {e: 'id'}
+        }
+      ]
+    });
+    expect(req.user.ext.eids).to.eql({e: 'id'});
+  });
+
+  it('has no effect if requests have no eids', () => {
+    const req = {};
+    setOrtbUserExtEids(req, {}, [{}]);
+    expect(req).to.eql({});
+  })
+})

package/test/spec/ortbConverter/usp_spec.js

@@ -0,0 +1,15 @@
+import {setOrtbUsp} from '../../../modules/consentManagementUsp.js';
+
+describe('pbjs - ortb usp', () => {
+  it('sets regs.ext.us_privacy from bidderRequest', () => {
+    const req = {};
+    setOrtbUsp(req, {uspConsent: '1NN'});
+    expect(req.regs.ext.us_privacy).to.eql('1NN');
+  });
+
+  it('does not set if missing', () => {
+    const req = {};
+    setOrtbUsp(req, {});
+    expect(req).to.eql({});
+  });
+})