1012 lines
44 KiB
JavaScript
1012 lines
44 KiB
JavaScript
// META: script=/resources/testdriver.js
|
|
// META: script=/resources/testdriver-vendor.js
|
|
// META: script=/common/utils.js
|
|
// META: script=/common/subset-tests.js
|
|
// META: script=resources/fledge-util.sub.js
|
|
// META: timeout=long
|
|
// META: variant=?1-5
|
|
// META: variant=?6-10
|
|
// META: variant=?11-15
|
|
// META: variant=?16-20
|
|
// META: variant=?21-25
|
|
// META: variant=?26-30
|
|
// META: variant=?31-35
|
|
// META: variant=?36-40
|
|
// META: variant=?41-45
|
|
// META: variant=?46-50
|
|
// META: variant=?51-55
|
|
// META: variant=?56-60
|
|
// META: variant=?61-65
|
|
// META: variant=?66-70
|
|
// META: variant=?71-75
|
|
// META: variant=?76-last
|
|
|
|
"use strict";
|
|
|
|
// These tests focus on trustedBiddingSignals: Requesting them, handling network
|
|
// errors, handling the keys portion of the response, and passing keys to
|
|
// worklet scripts, and handling the Data-Version header
|
|
//
|
|
// Because of request batching, left over interest groups from
|
|
// other tests may result in tests that request TRUSTED_BIDDING_SIGNALS_URL
|
|
// with certain special keys failing, if interest groups with names other than
|
|
// the default one are not successfully left after previously run tests.
|
|
|
|
// Helper for trusted bidding signals test. Runs an auction, and fails the
|
|
// test if there's no winner. "generateBidCheck" is an expression that should
|
|
// be true when evaluated in generateBid(). "interestGroupOverrides" is a
|
|
// set of overridden fields added to the default interestGroup when joining it,
|
|
// allowing trusted bidding signals keys and URL to be set, in addition to other
|
|
// fields.
|
|
async function runTrustedBiddingSignalsTest(
|
|
test, generateBidCheck, interestGroupOverrides = {}, auctionConfigOverrides = {}, uuidOverride = null) {
|
|
interestGroupOverrides.biddingLogicURL =
|
|
createBiddingScriptURL({
|
|
allowComponentAuction: true,
|
|
generateBid: `if (!(${generateBidCheck})) return false;` });
|
|
let testConfig = {
|
|
interestGroupOverrides: interestGroupOverrides,
|
|
auctionConfigOverrides: auctionConfigOverrides
|
|
};
|
|
if (uuidOverride)
|
|
testConfig.uuid = uuidOverride;
|
|
await joinGroupAndRunBasicFledgeTestExpectingWinner(test, testConfig);
|
|
}
|
|
|
|
// Much like runTrustedBiddingSignalsTest, but runs auctions through reporting
|
|
// as well, and evaluates `check` both in generateBid() and reportWin(). Also
|
|
// makes sure browserSignals.dataVersion is undefined in scoreAd() and
|
|
// reportResult().
|
|
async function runTrustedBiddingSignalsDataVersionTest(
|
|
test, check, interestGroupOverrides = {}) {
|
|
const uuid = generateUuid(test);
|
|
interestGroupOverrides.biddingLogicURL =
|
|
createBiddingScriptURL({
|
|
generateBid:
|
|
`if (!(${check})) return false;`,
|
|
reportWin:
|
|
`if (!(${check}))
|
|
sendReportTo('${createBidderReportURL(uuid, 'error')}');
|
|
else
|
|
sendReportTo('${createBidderReportURL(uuid)}');` });
|
|
await joinInterestGroup(test, uuid, interestGroupOverrides);
|
|
|
|
const auctionConfigOverrides = {
|
|
decisionLogicURL: createDecisionScriptURL(
|
|
uuid,
|
|
{ scoreAd:
|
|
`if (browserSignals.dataVersion !== undefined)
|
|
return false;`,
|
|
reportResult:
|
|
`if (browserSignals.dataVersion !== undefined)
|
|
sendReportTo('${createSellerReportURL(uuid, 'error')}')
|
|
sendReportTo('${createSellerReportURL(uuid)}')`, })
|
|
}
|
|
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
|
|
await waitForObservedRequests(
|
|
uuid, [createBidderReportURL(uuid), createSellerReportURL(uuid)]);
|
|
}
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(test, 'trustedBiddingSignals === null');
|
|
}, 'No trustedBiddingSignalsKeys or trustedBiddingSignalsURL.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['numValue'] });
|
|
}, 'trustedBiddingSignalsKeys but no trustedBiddingSignalsURL.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'trustedBiddingSignalsURL without trustedBiddingSignalsKeys.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['close-connection'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'trustedBiddingSignalsURL closes the connection without sending anything.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['http-error'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response is HTTP 404 error.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['no-content-type'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no content-type.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['wrong-content-type'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has wrong content-type.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['ad-auction-not-allowed'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response does not allow fledge.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['bad-ad-auction-allowed'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has wrong Ad-Auction-Allowed header.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['no-ad-auction-allow'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no Ad-Auction-Allowed header.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['replace-body:'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no body.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['replace-body:Not JSON'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response is not JSON.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['replace-body:[]'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response is a JSON array.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals === null',
|
|
{ trustedBiddingSignalsKeys: ['replace-body:{JSON_keys_need_quotes: 1}'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response in invalid JSON object.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals["replace-body:{}"] === null',
|
|
{ trustedBiddingSignalsKeys: ['replace-body:{}'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no keys object.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, `trustedBiddingSignals['replace-body:{"keys":{}}'] === null`,
|
|
{ trustedBiddingSignalsKeys: ['replace-body:{"keys":{}}'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no keys.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["0"] === null &&
|
|
trustedBiddingSignals["1"] === null &&
|
|
trustedBiddingSignals["2"] === null &&
|
|
trustedBiddingSignals["length"] === null`,
|
|
{ trustedBiddingSignalsKeys:
|
|
['replace-body:{"keys":[1,2,3]}', "0", "1", "2", "length"],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response keys is incorrectly an array.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["wrong-value"] === null &&
|
|
trustedBiddingSignals["another-value"] === undefined`,
|
|
{ trustedBiddingSignalsKeys: ['wrong-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has key not in trustedBiddingSignalsKeys.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals["null-value"] === null',
|
|
{ trustedBiddingSignalsKeys: ['null-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has null value for key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals["num-value"] === 1',
|
|
{ trustedBiddingSignalsKeys: ['num-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has a number value for key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test, 'trustedBiddingSignals["string-value"] === "1"',
|
|
{ trustedBiddingSignalsKeys: ['string-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has string value for key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`JSON.stringify(trustedBiddingSignals["array-value"]) === '[1,"foo",null]'`,
|
|
{ trustedBiddingSignalsKeys: ['array-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has array value for key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`Object.keys(trustedBiddingSignals["object-value"]).length === 2 &&
|
|
trustedBiddingSignals["object-value"]["a"] === "b" &&
|
|
JSON.stringify(trustedBiddingSignals["object-value"]["c"]) === '["d"]'`,
|
|
{ trustedBiddingSignalsKeys: ['object-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has object value for key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'trustedBiddingSignals[""] === "default value"',
|
|
{ trustedBiddingSignalsKeys: [''],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives empty string key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`Object.keys(trustedBiddingSignals).length === 6 &&
|
|
trustedBiddingSignals["wrong-value"] === null &&
|
|
trustedBiddingSignals["null-value"] === null &&
|
|
trustedBiddingSignals["num-value"] === 1 &&
|
|
trustedBiddingSignals["string-value"] === "1" &&
|
|
JSON.stringify(trustedBiddingSignals["array-value"]) === '[1,"foo",null]' &&
|
|
trustedBiddingSignals[""] === "default value"`,
|
|
{ trustedBiddingSignalsKeys: ['wrong-value', 'null-value', 'num-value',
|
|
'string-value', 'array-value', ''],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has multiple keys.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'trustedBiddingSignals["+%20 \x00?,3#&"] === "default value"',
|
|
{ trustedBiddingSignalsKeys: ['+%20 \x00?,3#&'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives escaped key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'trustedBiddingSignals["\x00"] === "default value"',
|
|
{ trustedBiddingSignalsKeys: ['\x00'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives null key.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["interest-group-names"] === '["${DEFAULT_INTEREST_GROUP_NAME}"]'`,
|
|
{ trustedBiddingSignalsKeys: ['interest-group-names'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives interest group name.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
// Interest group names is a JSONified list of JSONified names, so the
|
|
// null ends up being escaped twice.
|
|
`trustedBiddingSignals["interest-group-names"] === '["+%20 \\\\u0000?,3#&"]'`,
|
|
{ name: '+%20 \x00?,3#&',
|
|
trustedBiddingSignalsKeys: ['interest-group-names'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives escaped interest group name.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["interest-group-names"] === '[""]'`,
|
|
{ name: '',
|
|
trustedBiddingSignalsKeys: ['interest-group-names'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives empty interest group name.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["hostname"] === "${window.location.hostname}"`,
|
|
{ trustedBiddingSignalsKeys: ['hostname'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals receives hostname field.');
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Cross-origin trusted bidding signals tests
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals === null &&
|
|
!('dataVersion' in browserSignals) &&
|
|
crossOriginTrustedBiddingSignals['${OTHER_ORIGIN1}']['num-value'] === 1 &&
|
|
browserSignals.crossOriginDataVersion === 4`,
|
|
{ name: 'data-version',
|
|
trustedBiddingSignalsKeys: ['num-value', 'cors'],
|
|
trustedBiddingSignalsURL: CROSS_ORIGIN_TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Basic cross-origin trusted bidding signals');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals === null &&
|
|
!('dataVersion' in browserSignals) &&
|
|
crossOriginTrustedBiddingSignals === null &&
|
|
!('crossOriginDataVersion' in browserSignals)`,
|
|
{ name: 'data-version',
|
|
trustedBiddingSignalsKeys: ['num-value'],
|
|
trustedBiddingSignalsURL: CROSS_ORIGIN_TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Cross-origin trusted bidding signals w/o CORS authorization');
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Data-Version tests
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['num-value'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has no Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === 3',
|
|
{ trustedBiddingSignalsKeys: ['data-version:3'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has numeric Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === 0',
|
|
{ trustedBiddingSignalsKeys: ['data-version:0'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has min Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === 4294967295',
|
|
{ trustedBiddingSignalsKeys: ['data-version:4294967295'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has max Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:4294967296'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has too large Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:03'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has Data-Version with leading 0.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:-1'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has negative Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:1.3'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has decimal in Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:2 2'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has space in Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:0x4'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has hex Data-Version.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === 4',
|
|
{ name: 'data-version',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has Data-Version and no trustedBiddingSignalsKeys.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:3', 'replace-body:'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response with Data-Version and empty body.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:3', 'replace-body:[]'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response with Data-Version and JSON array body.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === undefined',
|
|
{ trustedBiddingSignalsKeys: ['data-version:3', 'replace-body:{} {}'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response with Data-Version and double JSON object body.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsDataVersionTest(
|
|
test,
|
|
'browserSignals.dataVersion === 3',
|
|
{ trustedBiddingSignalsKeys: ['data-version:3', 'replace-body:{"keys":5}'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response with Data-Version and invalid keys entry');
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// trustedBiddingSignalsSlotSizeMode tests
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
async function runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
expectedSlotSize,
|
|
expectedAllSlotsRequestedSizes,
|
|
trustedBiddingSignalsSlotSizeMode = null,
|
|
auctionConfigOverrides = {},
|
|
uuidOverride = null) {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
`trustedBiddingSignals["slotSize"] ===
|
|
${JSON.stringify(expectedSlotSize)} &&
|
|
trustedBiddingSignals["allSlotsRequestedSizes"] ===
|
|
${JSON.stringify(expectedAllSlotsRequestedSizes)}`,
|
|
{ trustedBiddingSignalsKeys: ['slotSize', 'allSlotsRequestedSizes'],
|
|
trustedBiddingSignalsSlotSizeMode: trustedBiddingSignalsSlotSizeMode,
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL},
|
|
auctionConfigOverrides,
|
|
uuidOverride);
|
|
}
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found');
|
|
}, 'Null trustedBiddingSignalsSlotSizeMode, no sizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'not-a-real-mode');
|
|
}, 'Unknown trustedBiddingSignalsSlotSizeMode, no sizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'none');
|
|
}, 'none trustedBiddingSignalsSlotSizeMode, no sizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size');
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, no sizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size');
|
|
}, 'all-slots-requested-sizes trustedBiddingSignalsSlotSizeMode, no sizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'none',
|
|
{requestedSize: {width:'10', height:'20'}});
|
|
}, 'none trustedBiddingSignalsSlotSizeMode, requestedSize in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/null,
|
|
{requestedSize: {width:'10', height:'20'}});
|
|
}, 'Null trustedBiddingSignalsSlotSizeMode, requestedSize in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'not-a-real-mode',
|
|
{requestedSize: {width:'10', height:'20'}});
|
|
}, 'Unknown trustedBiddingSignalsSlotSizeMode, requestedSize in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'10px,20px',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{requestedSize: {width:'10', height:'20'}});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, requestedSize in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'all-slots-requested-sizes',
|
|
{requestedSize: {width:'10', height:'20'}});
|
|
}, 'all-slots-requested-sizes trustedBiddingSignalsSlotSizeMode, requestedSize in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'none',
|
|
{allSlotsRequestedSizes: [{width:10, height:20}]});
|
|
}, 'none trustedBiddingSignalsSlotSizeMode, allSlotsRequestedSizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/null,
|
|
{allSlotsRequestedSizes: [{width:'10', height:'20'}]});
|
|
}, 'Null trustedBiddingSignalsSlotSizeMode, allSlotsRequestedSizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'not-a-real-mode',
|
|
{allSlotsRequestedSizes: [{width:'10', height:'20'}]});
|
|
}, 'Unknown trustedBiddingSignalsSlotSizeMode, allSlotsRequestedSizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{allSlotsRequestedSizes: [{width:'10', height:'20'}]});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, allSlotsRequestedSizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'10px,20px',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'all-slots-requested-sizes',
|
|
{allSlotsRequestedSizes: [{width:'10', height:'20'}]});
|
|
}, 'all-slots-requested-sizes trustedBiddingSignalsSlotSizeMode, allSlotsRequestedSizes in AuctionConfig');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'10px,20px',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{requestedSize: {width:'10px', height:'20px'}});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, explicit pixel units');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'80sw,12.5sh',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{requestedSize: {width:'80sw', height:'12.50sh'}});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, screen size units');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'80sh,12.5sw',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{requestedSize: {width:'80sh', height:'12.5sw'}});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, flipped screen size units');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'10px,25sh',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
{requestedSize: {width:'10', height:'25sh'}});
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode, mixed pixel and screen width units');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'10px,20px,25sw,20px,22px,80sh',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'all-slots-requested-sizes',
|
|
{ allSlotsRequestedSizes: [ {width:'10', height:'20'},
|
|
{width:'25sw', height:'20px'},
|
|
{width:'22', height:'80sh'}]});
|
|
}, 'all-slots-requested-sizes trustedBiddingSignalsSlotSizeMode, multiple unit types');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
const uuid = generateUuid(test);
|
|
|
|
let group1ReportURL = createBidderReportURL(uuid, /*id=*/'none')
|
|
let group2ReportURL = createBidderReportURL(uuid, /*id=*/'slot-size')
|
|
let group3ReportURL = createBidderReportURL(uuid, /*id=*/'all-slots-requested-sizes')
|
|
|
|
// The simplest way to make sure interest groups with different modes all receive
|
|
// the right sizes is to have interest groups that modify their bids based on ad
|
|
// size sent to the trusted server.
|
|
await Promise.all(
|
|
[ joinInterestGroup(
|
|
test, uuid,
|
|
{ name: 'group 1',
|
|
trustedBiddingSignalsKeys: ['slotSize', 'allSlotsRequestedSizes'],
|
|
trustedBiddingSignalsSlotSizeMode: 'none',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{ generateBid:
|
|
`if (trustedBiddingSignals["slotSize"] !== "not-found" ||
|
|
trustedBiddingSignals["allSlotsRequestedSizes"] !== "not-found") {
|
|
throw "unexpected trustedBiddingSignals";
|
|
}
|
|
return {bid: 5, render: interestGroup.ads[0].renderURL};`,
|
|
reportWin: `sendReportTo("${group1ReportURL}");`})}),
|
|
joinInterestGroup(
|
|
test, uuid,
|
|
{ name: 'group 2',
|
|
trustedBiddingSignalsKeys: ['slotSize', 'allSlotsRequestedSizes'],
|
|
trustedBiddingSignalsSlotSizeMode: 'slot-size',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{ generateBid:
|
|
`if (trustedBiddingSignals["slotSize"] === "not-found" ||
|
|
trustedBiddingSignals["allSlotsRequestedSizes"] !== "not-found") {
|
|
throw "unexpected trustedBiddingSignals";
|
|
}
|
|
// Group 3 bids using the first digit of the first dimension.
|
|
return { bid: trustedBiddingSignals["slotSize"].substr(0, 1),
|
|
render: interestGroup.ads[0].renderURL};`,
|
|
reportWin: `sendReportTo("${group2ReportURL}");`})}),
|
|
joinInterestGroup(
|
|
test, uuid,
|
|
{ name: 'group 3',
|
|
trustedBiddingSignalsKeys: ['slotSize', 'allSlotsRequestedSizes'],
|
|
trustedBiddingSignalsSlotSizeMode: 'all-slots-requested-sizes',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{ generateBid:
|
|
`if (trustedBiddingSignals["slotSize"] !== "not-found" ||
|
|
trustedBiddingSignals["allSlotsRequestedSizes"] === "not-found") {
|
|
throw "unexpected trustedBiddingSignals";
|
|
}
|
|
// Group 3 bids using the second digit of the first dimension.
|
|
return { bid: trustedBiddingSignals["allSlotsRequestedSizes"].substr(1, 1),
|
|
render: interestGroup.ads[0].renderURL};`,
|
|
reportWin: `sendReportTo("${group3ReportURL}");`})}),
|
|
]
|
|
);
|
|
|
|
let auctionConfigOverrides = {
|
|
// Disable the default seller reporting, for simplicity.
|
|
decisionLogicURL: createDecisionScriptURL(uuid, { reportResult: '' }),
|
|
// Default sizes start with a "11", so groups 2 and 3 will start with a bid
|
|
// of 1 and lose.
|
|
requestedSize: {width:'11', height:'20'},
|
|
allSlotsRequestedSizes: [{width:'11', height:'20'}]
|
|
};
|
|
|
|
// Group 1 wins the first auction.
|
|
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
|
|
await waitForObservedRequests(uuid, [group1ReportURL]);
|
|
|
|
// Group2 should bid "6" in the second auction, and win it.
|
|
auctionConfigOverrides.requestedSize = {width:'61', height:'20'};
|
|
auctionConfigOverrides.allSlotsRequestedSizes = [{width:'61', height:'20'}];
|
|
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
|
|
await waitForObservedRequests(uuid, [group1ReportURL, group2ReportURL]);
|
|
|
|
// Group3 should bid "7" in the third auction, and win it.
|
|
auctionConfigOverrides.requestedSize = {width:'67', height:'20'};
|
|
auctionConfigOverrides.allSlotsRequestedSizes = [{width:'67', height:'20'}];
|
|
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
|
|
await waitForObservedRequests(uuid, [group1ReportURL, group2ReportURL, group3ReportURL]);
|
|
}, 'Mixed trustedBiddingSignalsSlotSizeModes in a single auction');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
const uuid = generateUuid(test);
|
|
let componentAuctionConfig = {
|
|
seller: window.location.origin,
|
|
decisionLogicURL: createDecisionScriptURL(uuid),
|
|
interestGroupBuyers: [window.location.origin],
|
|
requestedSize: {width:'10', height:'20'}
|
|
};
|
|
|
|
let auctionConfigOverrides = {
|
|
interestGroupBuyers: [],
|
|
componentAuctions: [componentAuctionConfig],
|
|
requestedSize: {width:'22', height:'33'}
|
|
}
|
|
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
// Dimensions from the component auction should be used.
|
|
/*expectedSlotSize=*/'10px,20px',
|
|
/*expectedAllSlotsRequestedSizes=*/'not-found',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'slot-size',
|
|
auctionConfigOverrides,
|
|
uuid);
|
|
}, 'slot-size trustedBiddingSignalsSlotSizeMode in a component auction');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
const uuid = generateUuid(test);
|
|
let componentAuctionConfig = {
|
|
seller: window.location.origin,
|
|
decisionLogicURL: createDecisionScriptURL(uuid),
|
|
interestGroupBuyers: [window.location.origin],
|
|
allSlotsRequestedSizes: [{width:'11', height:'22'}, {width:'12', height:'23'}]
|
|
};
|
|
|
|
let auctionConfigOverrides = {
|
|
interestGroupBuyers: [],
|
|
componentAuctions: [componentAuctionConfig],
|
|
allSlotsRequestedSizes: [{width:'10', height:'20'}]
|
|
}
|
|
|
|
await runTrustedBiddingSignalsSlotSizeTest(
|
|
test,
|
|
// Dimensions from the component auction should be used.
|
|
/*expectedSlotSize=*/'not-found',
|
|
/*expectedAllSlotsRequestedSizes=*/'11px,22px,12px,23px',
|
|
/*trustedBiddingSignalsSlotSizeMode=*/'all-slots-requested-sizes',
|
|
auctionConfigOverrides,
|
|
uuid);
|
|
}, 'all-slots-requested-sizes trustedBiddingSignalsSlotSizeMode in a component auction');
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// maxTrustedBiddingSignalsURLLength tests
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// To detect whether two signals are fetched together or separately, the trusted bidding signals
|
|
// Python server will return the request URL as the signal value if the request URL contains the
|
|
// string url in its query parameters.
|
|
|
|
// Trusted bidding signals can be retrieved when `maxTrustedBiddingSignalsURLLength` is set to 0,
|
|
// which means infinite length limit.
|
|
subsetTest(promise_test, async test => {
|
|
const name = 'group';
|
|
const expect_queries = 'keys=interest-group-names,url&interestGroupNames=group';
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
// Check returned signal contains expected queries to ensure the URL is not truncated.
|
|
` trustedBiddingSignals["interest-group-names"] === '["${name}"]' &&
|
|
trustedBiddingSignals["url"].includes("${expect_queries}") `,
|
|
{
|
|
name: name,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 0
|
|
});
|
|
}, 'Trusted bidding signals request works with a URL length limit set to 0.');
|
|
|
|
// Trusted bidding signals can be retrieved when `maxTrustedBiddingSignalsURLLength` is set to
|
|
// a non-zero value smaller than the length of the request URL. It also tests that multiple
|
|
// bidding keys from the same interest group will not be separated even the full URL length is
|
|
// larger than the limit.
|
|
subsetTest(promise_test, async test => {
|
|
const name = 'group';
|
|
const expect_queries = 'keys=interest-group-names,url&interestGroupNames=group';
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
// Check returned signal contains expected queries to ensure the URL is not truncated.
|
|
` trustedBiddingSignals["interest-group-names"] === '["${name}"]' &&
|
|
trustedBiddingSignals["url"].includes("${expect_queries}") `,
|
|
{
|
|
name: name,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 1
|
|
});
|
|
}, 'Trusted bidding signals request works with a URL length limit smaller than the URL length.');
|
|
|
|
// Trusted bidding signals can be retrieved when `maxTrustedBiddingSignalsURLLength` is set to
|
|
// a value larger than the length of the request URL.
|
|
subsetTest(promise_test, async test => {
|
|
const name = 'group';
|
|
const expect_queries = 'keys=interest-group-names,url&interestGroupNames=group';
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
// Check returned signal contains expected queries to ensure the URL is not truncated.
|
|
` trustedBiddingSignals["interest-group-names"] === '["${name}"]' &&
|
|
trustedBiddingSignals["url"].includes("${expect_queries}") `,
|
|
{
|
|
name: name,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 1000
|
|
});
|
|
}, 'Trusted bidding signals request works with a URL length limit larger than the URL length.');
|
|
|
|
// Test whether an oversized trusted bidding signals request URL, generated from two interest
|
|
// groups, will be split into two parts when `maxTrustedBiddingSignalsURLLength` is set to a
|
|
// value larger than a single URL length and smaller than the combined URL length. A request
|
|
// URL from a single interest group contains about 188 characters, while a request URL from
|
|
// two interest groups contains about 216 characters.
|
|
subsetTest(promise_test, async test => {
|
|
const uuid = generateUuid(test);
|
|
const name1 = 'extraordinarilyLongNameGroup1';
|
|
const name2 = 'extraordinarilyLongNameGroup2';
|
|
|
|
await Promise.all(
|
|
[ joinInterestGroup(
|
|
test, uuid,
|
|
{
|
|
name: name1,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 200,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{
|
|
// Return 0 as bid to force the second interest group to win. This interest group
|
|
// is considered as fetching trusted bidding signals by itself if the winner's
|
|
// URL length passes the limit check.
|
|
generateBid:
|
|
`return { bid: 0, render: interestGroup.ads[0].renderURL };`
|
|
})
|
|
}),
|
|
joinInterestGroup(
|
|
test, uuid,
|
|
{
|
|
name: name2,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 200,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{
|
|
generateBid:
|
|
`if (trustedBiddingSignals["interest-group-names"] !== '["${name2}"]' ||
|
|
trustedBiddingSignals["url"].includes("${name1}")) {
|
|
throw "unexpected trustedBiddingSignals";
|
|
}
|
|
return { bid: 10, render: interestGroup.ads[0].renderURL };`})
|
|
})
|
|
]
|
|
);
|
|
await runBasicFledgeTestExpectingWinner(test, uuid);
|
|
}, 'Trusted bidding signals splits the request if the combined URL length exceeds the limit of regular value.');
|
|
|
|
// Test whether an oversized trusted bidding signals request URL, generated from two interest
|
|
// groups, will be split into two parts when `maxTrustedBiddingSignalsURLLength` is set to a
|
|
// value smaller than a single URL length.
|
|
subsetTest(promise_test, async test => {
|
|
const uuid = generateUuid(test);
|
|
const name1 = 'extraordinaryLongNameGroup1';
|
|
const name2 = 'extraordinaryLongNameGroup2';
|
|
|
|
await Promise.all(
|
|
[ joinInterestGroup(
|
|
test, uuid,
|
|
{
|
|
name: name1,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 1,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{
|
|
generateBid:
|
|
`return { bid: 0, render: interestGroup.ads[0].renderURL };`
|
|
})
|
|
}),
|
|
joinInterestGroup(
|
|
test, uuid,
|
|
{
|
|
name: name2,
|
|
trustedBiddingSignalsKeys: ['interest-group-names', 'url'],
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL,
|
|
maxTrustedBiddingSignalsURLLength: 1,
|
|
biddingLogicURL: createBiddingScriptURL(
|
|
{
|
|
generateBid:
|
|
`if (trustedBiddingSignals["interest-group-names"] !== '["${name2}"]' ||
|
|
trustedBiddingSignals["url"].includes("${name1}")) {
|
|
throw "unexpected trustedBiddingSignals";
|
|
}
|
|
return { bid: 10, render: interestGroup.ads[0].renderURL };`})
|
|
})
|
|
]
|
|
);
|
|
await runBasicFledgeTestExpectingWinner(test, uuid);
|
|
}, 'Trusted bidding signals splits the request if the combined URL length exceeds the limit of small value.');
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// updateIfOlderThanMs tests
|
|
//
|
|
// NOTE: Due to the lack of mock time in wpt, these test just exercise the code
|
|
// paths and ensure that no crash occurs -- they don't otherwise verify
|
|
// behavior.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'true',
|
|
{ name: 'use-update-if-older-than-ms',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has updateIfOlderThanMs > 10 min.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'true',
|
|
{ name: 'use-update-if-older-than-ms-small',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has updateIfOlderThanMs == 1 ms.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'true',
|
|
{ name: 'use-update-if-older-than-ms-zero',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has updateIfOlderThanMs == 0 ms.');
|
|
|
|
subsetTest(promise_test, async test => {
|
|
await runTrustedBiddingSignalsTest(
|
|
test,
|
|
'true',
|
|
{ name: 'use-update-if-older-than-ms-negative',
|
|
trustedBiddingSignalsURL: TRUSTED_BIDDING_SIGNALS_URL });
|
|
}, 'Trusted bidding signals response has updateIfOlderThanMs == -1 ms.');
|