This module allows to “intercept” bids and replace their contents with arbitrary data for the purposes of testing and development.
Bids intercepted in this way are never seen by bid adapters or their backend SSPs, but they are nonetheless injected into the auction as if they originated from them.
For convenience, debugging
configuration is persisted to the browser’s session storage, so that you may type pbjs.setConfig({debugging: ...})
in the console and reload the page to immediately see the effects. This means that you need to remember to deactivate debuggging (or clear session storage) when you are done.
The following will intercept all bids for the ad unit with code “test-div”, and replace them with mocks that have cpm: 10
:
pbjs.setConfig({
debugging: {
enabled: true,
intercept: [
{
when: {
// intercept all bids that have adUnitCode === 'test-div'
adUnitCode: 'test-div',
},
then: {
// mock their response with sane defaults and `cpm: 10`
cpm: 10
}
},
]
}
});
intercept
is a list of objects each containing the following:
Property | Type | Required? | Description |
---|---|---|---|
when |
Function or Object | yes | Match rule - decides which bids should be intercepted by this rule |
then |
Function or Object | no | Replace rule - decides the contents of the bids that are intercepted by this rule |
options |
Object | no | Rule options |
Rules are evaluated on each bid in the order they are provided: the first one that has a matching when
definition takes the bid out of the normal auction flow and replaces it according to its then
definition.
The match rule can be provided as a function that takes the bid request as its only argument and returns true
if the bid should be intercepted, false
otherwise. The example above could be written as:
pbjs.setConfig({
debugging: {
enabled: true,
intercept: [
{
when: (bidRequest) => bidRequest.adUnitCode === 'test-div',
then: {
cpm: 10
}
}
]
}
})
Alternatively, the rule can be expressed as an object, and it matches if for each key
-value
pair:
bidRequest[key] === value
, orvalue
is a function and value(bidRequest[key])
is true
, orvalue
is a regular expression and it matches bidRequest[key]
.To illustrate, these definitions are equivalent:
{
when: {
adUnitCode: 'test-div'
}
};
{
when: {
adUnitCode: (code) => code === 'test-div'
}
};
{
when: {
adUnitCode: /^test-div$/
}
};
The replace rule can be provided as a function that takes the bid request as its only argument and returns an object with the desired response properties. The first example above could be written as:
pbjs.setConfig({
debugging: {
enabled: true,
intercept: [
{
when: {
adUnitCode: 'test-div',
},
then: (bidRequest) => ({cpm: 10})
},
]
}
});
Alternatively, the rule can be expressed as an object, and its key
-value
pairs will appear in the response as follows:
value
is a function, then bidResponse[key]
will be set to value(bidRequest)
;bidResponse[key]
will be set to value
.To illustrate, the following definitions are equivalent:
{
then: {
cpm: 10
}
};
{
then: {
cpm: (bidRequest) => 10
}
}
Property | Type | Default value | Description |
---|---|---|---|
delay |
Number | 0 | Delay (in milliseconds) before intercepted bids are injected into the auction. Can be used to simulate network latency. |