prebid.js 7.22.0 → 7.24.0

package/test/spec/ortbConverter/composer_spec.js

@@ -0,0 +1,69 @@
+import {compose} from '../../../libraries/ortbConverter/lib/composer.js';
+
+describe('compose', () => {
+  it('runs each component in order of priority', () => {
+    const order = [];
+    const components = {
+      first: {
+        fn: sinon.stub().callsFake(() => order.push(1)),
+      },
+      second: {
+        fn: sinon.stub().callsFake(() => order.push(2)),
+        priority: 10
+      },
+      third: {
+        fn: sinon.stub().callsFake(() => order.push(3)),
+        priority: 5
+      }
+    };
+    compose(components)();
+    expect(order).to.eql([2, 3, 1]);
+  });
+
+  it('passes parameters to each component', () => {
+    const components = {
+      first: {
+        fn: sinon.stub()
+      },
+      second: {
+        fn: sinon.stub()
+      }
+    };
+    compose(components)('one', 'two');
+    Object.values(components).forEach(comp => {
+      sinon.assert.calledWith(comp.fn, 'one', 'two')
+    })
+  })
+
+  it('respects overrides', () => {
+    const components = {
+      first: {
+        fn: sinon.stub()
+      },
+      second: {
+        fn: sinon.stub()
+      }
+    };
+    const overrides = {
+      second: sinon.stub()
+    }
+    compose(components, overrides)('one', 'two');
+    sinon.assert.calledWith(overrides.second, components.second.fn, 'one', 'two')
+  })
+
+  it('disables components when override is false', () => {
+    const components = {
+      first: {
+        fn: sinon.stub(),
+      },
+      second: {
+        fn: sinon.stub()
+      }
+    };
+    const overrides = {
+      second: false
+    };
+    compose(components, overrides)('one', 'two');
+    sinon.assert.notCalled(components.second.fn);
+  })
+});

package/test/spec/ortbConverter/converter_spec.js

@@ -0,0 +1,283 @@
+import {ortbConverter} from '../../../libraries/ortbConverter/converter.js';
+import {BID_RESPONSE, IMP, REQUEST, RESPONSE} from '../../../src/pbjsORTB.js';
+
+describe('pbjs-ortb converter', () => {
+  const MOCK_BIDDER_REQUEST = {
+    id: 'bidderRequest',
+    bids: [
+      {
+        id: 111
+      },
+      {
+        id: 112
+      }
+    ]
+  }
+
+  const MOCK_ORTB_RESPONSE = {
+    id: 'response',
+    seatbid: [
+      {
+        seat: 'mockBidder1',
+        bid: [
+          {
+            impid: 'imp0'
+          },
+          {
+            impid: 'imp1'
+          }
+        ]
+      },
+      {
+        seat: 'mockBidder2',
+        bid: [
+          {
+            impid: 'imp1'
+          }
+        ]
+      }
+    ]
+  }
+
+  let processors, reqCnt, impCnt;
+
+  beforeEach(() => {
+    reqCnt = 0;
+    impCnt = 0;
+    processors = {
+      [REQUEST]: {
+        req: {
+          fn(ortbRequest, bidderRequest, context) {
+            ortbRequest.id = `req${reqCnt++}`;
+            if (context.ctx) {
+              ortbRequest.ctx = context.ctx;
+            }
+          }
+        }
+      },
+      [IMP]: {
+        imp: {
+          fn(imp, bidRequest, context) {
+            imp.id = `imp${impCnt++}`;
+            imp.bidId = bidRequest.id;
+            if (context.ctx) {
+              imp.ctx = context.ctx;
+            }
+            if (context.reqContext?.ctx) {
+              imp.reqCtx = context.reqContext?.ctx;
+            }
+          }
+        }
+      },
+      [BID_RESPONSE]: {
+        resp: {
+          fn(bidResponse, bid, context) {
+            bidResponse.impid = bid.impid;
+            bidResponse.bidId = context.imp.bidId;
+            if (context.ctx) {
+              bidResponse.ctx = context.ctx;
+            }
+            if (context.reqContext?.ctx) {
+              bidResponse.reqCtx = context.reqContext?.ctx;
+            }
+          }
+        }
+      },
+      [RESPONSE]: {
+        resp: {
+          fn(response, ortbResponse, context) {
+            response.marker = true;
+            if (context.ctx) {
+              response.ctx = context.ctx;
+            }
+          }
+        }
+      }
+    }
+  });
+
+  function makeConverter(options = {}) {
+    options = Object.assign({
+      processors: () => processors
+    }, options);
+    return ortbConverter(options);
+  }
+
+  it('runs each processor', () => {
+    const cvt = makeConverter();
+    const request = cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST});
+    expect(request).to.eql({
+      id: 'req0',
+      imp: [
+        {id: 'imp0', bidId: 111},
+        {id: 'imp1', bidId: 112}
+      ]
+    });
+    const response = cvt.fromORTB({request, response: MOCK_ORTB_RESPONSE});
+    expect(response.bids).to.eql([{
+      impid: 'imp0',
+      bidId: 111
+    }, {
+      impid: 'imp1',
+      bidId: 112
+    }, {
+      impid: 'imp1',
+      bidId: 112
+    }]);
+    expect(response.marker).to.be.true;
+  });
+
+  it('fromORTB throws if request was not produced by the same converter', () => {
+    expect(() => {
+      makeConverter().fromORTB({
+        request: {
+          imp: [
+            {
+              id: 'imp0'
+            }
+          ]
+        },
+        response: MOCK_ORTB_RESPONSE
+      })
+    }).to.throw();
+  });
+
+  it('gives precedence to the bidRequests argument over bidderRequest.bids', () => {
+    expect(makeConverter().toORTB({bidderRequest: MOCK_BIDDER_REQUEST, bidRequests: [MOCK_BIDDER_REQUEST.bids[0]]})).to.eql({
+      id: 'req0',
+      imp: [
+        {
+          id: 'imp0',
+          bidId: 111
+        }
+      ]
+    })
+  });
+
+  it('passes context to every processor', () => {
+    const cvt = makeConverter();
+    const request = cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}});
+    expect(request.ctx).to.equal('context');
+    request.imp.forEach(imp => expect(imp.ctx).to.equal('context'));
+    const response = cvt.fromORTB({request, response: MOCK_ORTB_RESPONSE});
+    expect(response.ctx).to.eql('context');
+    response.bids.forEach(bidResponse => expect(bidResponse.ctx).to.equal('context'));
+  });
+
+  it('passes request context to imp and bidResponse processors', () => {
+    const cvt = makeConverter();
+    const request = cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}});
+    expect(request.imp[0].reqCtx).to.eql('context');
+    const response = cvt.fromORTB({request, response: MOCK_ORTB_RESPONSE});
+    expect(response.bids[0].reqCtx).to.eql('context');
+  });
+
+  it('allows overriding of imp building with `imp`', () => {
+    const cvt = makeConverter({
+      imp: function (buildImp, bidRequest, context) {
+        return Object.assign({
+          extraArg: bidRequest.id,
+          extraCtx: context.ctx
+        }, buildImp(bidRequest, context));
+      }
+    });
+    const request = cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}});
+    expect(request.imp.length).to.eql(2);
+    request.imp.forEach(imp => {
+      expect(imp.extraArg).to.eql(imp.bidId);
+      expect(imp.extraCtx).to.eql('context');
+    })
+  });
+
+  it('allows filtering imps with `imp`', () => {
+    const cvt = makeConverter({
+      imp(buildImp, bidRequest, context) {
+        if (bidRequest.id === 112) {
+          return buildImp(bidRequest, context);
+        }
+      }
+    });
+    expect(cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST}).imp.length).to.eql(1);
+  });
+
+  it('does not include imps that have no id', () => {
+    const cvt = makeConverter({
+      imp(buildImp, bidRequest, context) {
+        const imp = buildImp(bidRequest, context);
+        delete imp.id;
+        return imp;
+      }
+    });
+    expect(cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST}).imp.length).to.eql(0);
+  })
+
+  it('allows overriding of response building with bidResponse', () => {
+    const cvt = makeConverter({
+      bidResponse(buildResponse, bid, context) {
+        return Object.assign({
+          extraArg: context.bidRequest.id,
+          extraCtx: context.ctx
+        }, buildResponse(bid, context));
+      }
+    });
+    const response = cvt.fromORTB({
+      response: MOCK_ORTB_RESPONSE,
+      request: cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}})
+    });
+
+    expect(response.bids.length).to.equal(3);
+    response.bids.forEach(response => {
+      expect(response.extraArg).to.eql(response.bidId);
+      expect(response.extraCtx).to.eql('context');
+    });
+  });
+
+  it('allows filtering of responses with `bidResponse`', () => {
+    const cvt = makeConverter({
+      bidResponse(buildBidResponse, bid, context) {
+        if (context.seatbid.seat === 'mockBidder1' && context.imp.id === 'imp0') {
+          return buildBidResponse(bid, context);
+        }
+      }
+    });
+    expect(cvt.fromORTB({
+      request: cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST}),
+      response: MOCK_ORTB_RESPONSE
+    }).bids.length).to.equal(1);
+  });
+
+  it('allows overriding of request building with `request`', () => {
+    const cvt = makeConverter({
+      request(buildRequest, imps, bidderRequest, context) {
+        return {
+          request: buildRequest(imps, bidderRequest, context),
+          extraArg: bidderRequest.id,
+          extraCtx: context.ctx
+        }
+      }
+    });
+    const req = cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}});
+    expect(req.extraArg).to.equal(MOCK_BIDDER_REQUEST.id);
+    expect(req.extraCtx).to.equal('context');
+    expect(req.request.imp.length).to.equal(2);
+  });
+
+  it('allows overriding of response building with `response`', () => {
+    const cvt = makeConverter({
+      response(buildResponse, bidResponses, ortbResponse, context) {
+        return {
+          response: buildResponse(bidResponses, ortbResponse, context),
+          extraArg: ortbResponse.id,
+          extraCtx: context.ctx
+        }
+      }
+    });
+    const resp = cvt.fromORTB({
+      request: cvt.toORTB({bidderRequest: MOCK_BIDDER_REQUEST, context: {ctx: 'context'}}),
+      response: MOCK_ORTB_RESPONSE,
+    });
+    expect(resp.extraArg).to.equal(MOCK_ORTB_RESPONSE.id);
+    expect(resp.extraCtx).to.equal('context');
+    expect(resp.response.bids.length).to.equal(3);
+  })
+})

package/test/spec/ortbConverter/currency_spec.js

@@ -0,0 +1,40 @@
+import {config} from 'src/config.js';
+import {setOrtbCurrency} from '../../../modules/currency.js';
+
+describe('pbjs -> ortb currency', () => {
+  before(() => {
+    config.resetConfig();
+  });
+
+  afterEach(() => {
+    config.resetConfig();
+  });
+
+  it('does not set cur by default', () => {
+    const req = {};
+    setOrtbCurrency(req, {}, {});
+    expect(req).to.eql({});
+  });
+
+  it('sets currency based on config', () => {
+    config.setConfig({
+      currency: {
+        adServerCurrency: 'EUR'
+      }
+    });
+    const req = {};
+    setOrtbCurrency(req, {}, {});
+    expect(req.cur).to.eql(['EUR']);
+  });
+
+  it('sets currency based on context', () => {
+    config.setConfig({
+      currency: {
+        adServerCurrency: 'EUR'
+      }
+    });
+    const req = {};
+    setOrtbCurrency(req, {}, {currency: 'JPY'});
+    expect(req.cur).to.eql(['JPY']);
+  })
+});

package/test/spec/ortbConverter/default_processors_spec.js

@@ -0,0 +1,61 @@
+import {setDevice, setSite} from '../../../libraries/ortbConverter/processors/default.js';
+
+describe('setDevice', () => {
+  it('sets device.w,  h, dnt, language, ua', () => {
+    const req = {};
+    setDevice(req);
+    ['h', 'w', 'dnt', 'language', 'ua'].forEach(prop => expect(req.device[prop]).to.exist)
+  });
+
+  it('does not override FPD', () => {
+    const req = {
+      device: {
+        w: 'w',
+        h: 'h',
+        ext: {}
+      }
+    };
+    setDevice(req);
+    sinon.assert.match(req.device, {
+      w: 'w',
+      h: 'h',
+      ext: {}
+    })
+  });
+});
+
+describe('setSite', () => {
+  const refererInfo = {
+    page: 'page.com',
+    ref: 'ref.com',
+    domain: 'domain.com'
+  };
+
+  it('sets site, domain, ref from refererInfo', () => {
+    const req = {
+      site: {
+        ext: {}
+      }
+    };
+    setSite(req, {refererInfo});
+    sinon.assert.match(req.site, refererInfo);
+    expect(req.site.ext).to.eql({});
+  });
+
+  it('does not override FPD', () => {
+    const req = {
+      site: {
+        ref: 'other ref'
+      }
+    }
+    setSite(req, {refererInfo});
+    expect(req.site.ref).to.eql('other ref');
+    ['domain', 'page'].forEach(prop => expect(req.site[prop]).to.eql(refererInfo[prop]));
+  });
+
+  it('does not set null properties from refererInfo', () => {
+    const req = {};
+    setSite(req, {refererInfo: {...refererInfo, ref: null}});
+    expect(req.site.ref).to.not.exist;
+  });
+});

package/test/spec/ortbConverter/gdpr_spec.js

@@ -0,0 +1,38 @@
+import {setOrtbAdditionalConsent, setOrtbGdpr} from '../../../modules/consentManagement.js';
+
+describe('pbjs - ortb gpdr', () => {
+  it('sets gdpr properties from bidderRequest', () => {
+    const req = {};
+    setOrtbGdpr(req, {gdprConsent: {gdprApplies: true, consentString: 'consent'}});
+    expect(req.regs.ext.gdpr).to.eql(1);
+    expect(req.user.ext.consent).to.eql('consent');
+  });
+
+  it('does not set it if missing', () => {
+    const req = {};
+    setOrtbGdpr(req, {});
+    expect(req).to.eql({});
+  });
+
+  it('sets user.ext.consent, but not regs.ext.gdpr, if gpdrApplies is not a boolean', () => {
+    const req = {};
+    setOrtbGdpr(req, {
+      gdprConsent: {consentString: 'mock-consent'}
+    });
+    expect(req).to.eql({
+      user: {
+        ext: {
+          consent: 'mock-consent'
+        }
+      }
+    })
+  });
+});
+
+describe('pbjs -> ortb addtlConsent', () => {
+  it('sets ConsentedProvidersSettings', () => {
+    const req = {};
+    setOrtbAdditionalConsent(req, {gdprConsent: {addtlConsent: 'tl'}});
+    expect(req.user.ext.ConsentedProvidersSettings.consented_providers).to.eql('tl');
+  });
+})

package/test/spec/ortbConverter/mediaTypes_spec.js

@@ -0,0 +1,67 @@
+import {ORTB_MTYPES, setResponseMediaType} from '../../../libraries/ortbConverter/processors/mediaType.js';
+import {BANNER} from '../../../src/mediaTypes.js';
+import {extPrebidMediaType} from '../../../libraries/pbsExtensions/processors/mediaType.js';
+
+function testMtype(processor) {
+  describe('respects 2.6 mtype', () => {
+    Object.entries(ORTB_MTYPES).forEach(([mtype, pbtype]) => {
+      it(`${mtype} -> ${pbtype}`, () => {
+        const resp = {};
+        processor(resp, {
+          mtype: parseInt(mtype, 10)
+        }, {});
+        expect(resp.mediaType).to.eql(pbtype);
+      });
+    });
+  });
+}
+
+describe('ortb -> pbjs mediaType conversion', () => {
+  testMtype(setResponseMediaType);
+  it('throws if mtype is missing', () => {
+    expect(() => {
+      setResponseMediaType({}, {});
+    }).to.throw();
+  });
+
+  it('respects pre-set bidResponse.mediaType', () => {
+    const resp = {mediaType: 'video'};
+    setResponseMediaType(resp, {mtype: 1});
+    expect(resp.mediaType).to.eql('video');
+  });
+
+  it('gives precedence to context.mediaType', () => {
+    const resp = {};
+    setResponseMediaType(resp, {mtype: 1}, {mediaType: 'video'});
+    expect(resp.mediaType).to.eql('video')
+  })
+});
+
+describe('ortb -> pbjs mediaType conversion based on ext.prebid.type', () => {
+  testMtype(extPrebidMediaType);
+  describe('respects ext.prebid.type', () => {
+    Object.values(ORTB_MTYPES).forEach(mediaType => {
+      const response = {};
+      extPrebidMediaType(response, {
+        ext: {
+          prebid: {
+            type: mediaType
+          }
+        }
+      }, {});
+      expect(response.mediaType).to.eql(mediaType);
+    });
+  });
+
+  it('defaults to banner', () => {
+    const response = {};
+    extPrebidMediaType(response, {}, {});
+    expect(response.mediaType).to.eql(BANNER);
+  });
+
+  it('gives precedence to context.mediaType', () => {
+    const response = {};
+    extPrebidMediaType(response, {ext: {prebid: {type: 'banner'}}}, {mediaType: 'video'});
+    expect(response.mediaType).to.eql('video');
+  })
+});

package/test/spec/ortbConverter/mergeProcessors_spec.js

@@ -0,0 +1,59 @@
+import {mergeProcessors} from '../../../libraries/ortbConverter/lib/mergeProcessors.js';
+import {BID_RESPONSE, IMP, REQUEST, RESPONSE} from '../../../src/pbjsORTB.js';
+
+describe('mergeProcessors', () => {
+  it('can merge', () => {
+    const result = mergeProcessors({
+      [REQUEST]: {
+        first: {
+          priority: 0,
+          fn: 'first'
+        }
+      },
+      [RESPONSE]: {
+        second: {
+          priority: 1,
+          fn: 'second'
+        }
+      }
+    }, {
+      [REQUEST]: {
+        first: {
+          fn: 'overriden'
+        }
+      },
+      [IMP]: {
+        third: {
+          fn: 'third'
+        }
+      }
+    }, {
+      [IMP]: {
+        third: {
+          priority: 3,
+          fn: 'overridden'
+        }
+      }
+    });
+    expect(result).to.eql({
+      [REQUEST]: {
+        first: {
+          fn: 'overriden'
+        }
+      },
+      [IMP]: {
+        third: {
+          priority: 3,
+          fn: 'overridden'
+        },
+      },
+      [RESPONSE]: {
+        second: {
+          priority: 1,
+          fn: 'second'
+        }
+      },
+      [BID_RESPONSE]: {}
+    });
+  });
+});

package/test/spec/ortbConverter/multibid_spec.js

@@ -0,0 +1,35 @@
+import {config} from 'src/config.js';
+import {setOrtbExtPrebidMultibid} from '../../../modules/multibid/index.js';
+
+describe('pbjs - ortb ext.prebid.multibid', () => {
+  before(() => {
+    config.resetConfig();
+  });
+  afterEach(() => {
+    config.resetConfig();
+  });
+
+  it('sets ext.prebid.multibid according to config', () => {
+    config.setConfig({
+      multibid: [
+        {
+          bidder: 'A',
+          maxBids: 2
+        },
+        {
+          bidder: 'B',
+          maxBids: 3
+        }
+      ]
+    });
+    const req = {};
+    setOrtbExtPrebidMultibid(req);
+    expect(req.ext.prebid.multibid).to.eql([{bidder: 'A', maxbids: 2}, {bidder: 'B', maxbids: 3}]);
+  });
+
+  it('does not set it if not configured', () => {
+    const req = {};
+    setOrtbExtPrebidMultibid(req);
+    expect(req).to.eql({});
+  })
+});