mozilla-central/testing/web-platform/tests/fledge/tentative/currency.https.window.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

// META: script=/resources/testdriver.js
// META: script=/resources/testdriver-vendor.js
// META: script=/common/utils.js
// META: script=resources/fledge-util.sub.js
// META: script=/common/subset-tests.js
// META: timeout=long
// META: variant=?1-4
// META: variant=?5-8
// META: variant=?9-12
// META: variant=?13-16
// META: variant=?17-20
// META: variant=?21-24
// META: variant=?25-28
// META: variant=?29-32
// META: variant=?33-last
'use strict;'
const ORIGIN = window.location.origin;
// The tests in this file focus on calls to runAdAuction involving currency
// handling.
// Joins an interest group that bids 9USD on window.location.origin, and one
// that bids 10CAD on OTHER_ORIGIN1, each with a reportWin() report.
async function joinTwoCurrencyGroups(test, uuid) {
const reportWinURL = createBidderReportURL(uuid, 'USD');
const biddingURL = createBiddingScriptURL(
{bidCurrency: 'USD', reportWin: `sendReportTo('${reportWinURL}')`});
await joinInterestGroup(test, uuid, {biddingLogicURL: biddingURL});
const otherReportWinURL = createBidderReportURL(uuid, 'CAD', OTHER_ORIGIN1);
const otherBiddingURL = createBiddingScriptURL({
origin: OTHER_ORIGIN1,
bid: 10,
bidCurrency: 'CAD',
reportWin: `sendReportTo('${otherReportWinURL}')`
});
await joinCrossOriginInterestGroup(
test, uuid, OTHER_ORIGIN1, {biddingLogicURL: otherBiddingURL});
}
function createBiddingScriptURLWithCurrency(uuid, currency) {
return createBiddingScriptURL({
bidCurrency: currency,
allowComponentAuction: true,
reportWin: `
sendReportTo('${createBidderReportURL(uuid, /*id=*/ '')}' +
browserSignals.bid + browserSignals.bidCurrency);`,
});
}
// Creates a component-auction eligible bidding script returning a bid `bid` in
// currency `currency`. It provides a reporting handler that logs bid and
// highestScoringOtherBid along with their currencies.
function createBiddingScriptURLForHighestScoringOther(uuid, bid, currency) {
return createBiddingScriptURL({
bid: bid,
bidCurrency: currency,
allowComponentAuction: true,
generateBid: `
forDebuggingOnly.reportAdAuctionWin(
'${createBidderReportURL(uuid, /*id=*/ 'dbg_')}' +
'\${winningBid}\${winningBidCurrency}_' +
'\${highestScoringOtherBid}\${highestScoringOtherBidCurrency}');`,
reportWin: `
sendReportTo(
'${createBidderReportURL(uuid, /*id=*/ '')}' +
browserSignals.bid + browserSignals.bidCurrency +
'_' + browserSignals.highestScoringOtherBid +
browserSignals.highestScoringOtherBidCurrency);`,
});
}
function createDecisionURLExpectCurrency(uuid, currencyInScore) {
return createDecisionScriptURL(uuid, {
scoreAd: `
if (browserSignals.bidCurrency !== '${currencyInScore}')
throw 'Wrong currency';`,
reportResult: `
sendReportTo('${createSellerReportURL(uuid, /*id=*/ '')}' +
browserSignals.bid + browserSignals.bidCurrency);`,
});
}
// Creates a component-auction seller script, which by default just scores
// bid * 2, but the `conversion` argument can be used to customize bid
// modification and currenct conversion.
//
// The script provides a reporting handler that logs bid and
// highestScoringOtherBid along with their currencies as well as `suffix`.
function createDecisionURLForHighestScoringOther(
uuid, conversion = '', suffix = '') {
return createDecisionScriptURL(uuid, {
scoreAd: `
forDebuggingOnly.reportAdAuctionWin(
'${createSellerReportURL(uuid, /*id=*/ 'dbg_')}' + '${suffix}' +
'\${winningBid}\${winningBidCurrency}_' +
'\${highestScoringOtherBid}\${highestScoringOtherBidCurrency}');
let converted = undefined;
let modified = undefined;
let modifiedCurrency = undefined;
${conversion}
return {desirability: 2 * bid,
incomingBidInSellerCurrency: converted,
bid: modified,
bidCurrency: modifiedCurrency,
allowComponentAuction: true};
`,
reportResult: `
sendReportTo(
'${createSellerReportURL(uuid, /*id=*/ '')}' + '${suffix}' +
browserSignals.bid + browserSignals.bidCurrency +
'_' + browserSignals.highestScoringOtherBid +
browserSignals.highestScoringOtherBidCurrency);`,
});
}
// Joins groups for 9USD and 10USD, with reporting including
// highestScoringOtherBid.
async function joinTwoGroupsForHighestScoringOther(test, uuid) {
await joinInterestGroup(test, uuid, {
name: 'group-9USD',
biddingLogicURL:
createBiddingScriptURLForHighestScoringOther(uuid, /*bid=*/ 9, 'USD')
});
await joinInterestGroup(test, uuid, {
name: 'group-10USD',
biddingLogicURL:
createBiddingScriptURLForHighestScoringOther(uuid, /*bid=*/ 10, 'USD')
});
}
async function runCurrencyComponentAuction(test, uuid, params = {}) {
let auctionConfigOverrides = {
interestGroupBuyers: [],
decisionLogicURL: createDecisionScriptURL(uuid, {
reportResult: `
sendReportTo('${createSellerReportURL(uuid, 'top_')}' +
browserSignals.bid + browserSignals.bidCurrency)`,
...params.topLevelSellerScriptParamsOverride
}),
componentAuctions: [{
seller: ORIGIN,
decisionLogicURL: createDecisionScriptURL(uuid, {
reportResult: `
sendReportTo('${createSellerReportURL(uuid, 'component_')}' +
browserSignals.bid + browserSignals.bidCurrency)`,
...params.componentSellerScriptParamsOverride
}),
interestGroupBuyers: [ORIGIN],
...params.componentAuctionConfigOverrides
}],
...params.topLevelAuctionConfigOverrides
};
return await runBasicFledgeAuction(test, uuid, auctionConfigOverrides);
}
// Runs a component auction with reporting scripts that report bid and
// highestScoringOtherBid, along with their currencies.
//
// Customization points in `params` are:
// componentAuctionConfigOverrides, topLevelAuctionConfigOverrides:
// edit auctionConfig for given auction level.
//
// topLevelConversion and componentConversion:
// Permit customizing how the scoring function does currency conversiona and
// bid modification. See createDecisionURLForHighestScoringOther().
async function runCurrencyComponentAuctionForHighestScoringOther(
test, uuid, params = {}) {
let auctionConfigOverrides = {
interestGroupBuyers: [],
decisionLogicURL: createDecisionURLForHighestScoringOther(
uuid, params.topLevelConversion || '', 'top_'),
componentAuctions: [{
seller: ORIGIN,
decisionLogicURL: createDecisionURLForHighestScoringOther(
uuid, params.componentConversion || '', 'component_'),
interestGroupBuyers: [ORIGIN],
...params.componentAuctionConfigOverrides
}],
...params.topLevelAuctionConfigOverrides
};
return await runBasicFledgeAuction(test, uuid, auctionConfigOverrides);
}
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURL({bidCurrency: 'usd'})});
await runBasicFledgeTestExpectingNoWinner(test, uuid);
}, 'Returning bid with invalid currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
await runBasicFledgeAuctionAndNavigate(
test, uuid,
{decisionLogicURL: createDecisionURLExpectCurrency(uuid, 'USD')});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '9???'), createBidderReportURL(uuid, '9???')
]);
}, 'Returning bid with currency, configuration w/o currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, undefined)});
await runBasicFledgeAuctionAndNavigate(test, uuid, {
perBuyerCurrencies: {'*': 'USD'},
decisionLogicURL: createDecisionURLExpectCurrency(uuid, '???')
});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '9USD'), createBidderReportURL(uuid, '9USD')
]);
}, 'Returning bid w/o currency, configuration w/currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
await runBasicFledgeAuctionAndNavigate(test, uuid, {
perBuyerCurrencies: {'*': 'USD'},
decisionLogicURL: createDecisionURLExpectCurrency(uuid, 'USD')
});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '9USD'), createBidderReportURL(uuid, '9USD')
]);
}, 'Returning bid w/currency, configuration w/matching currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURL({bidCurrency: 'USD'})});
await runBasicFledgeTestExpectingNoWinner(
test, uuid, {perBuyerCurrencies: {'*': 'CAD'}});
}, 'Returning bid w/currency, configuration w/different currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoCurrencyGroups(test, uuid);
let auctionConfigOverrides = {
interestGroupBuyers: [ORIGIN, OTHER_ORIGIN1],
perBuyerCurrencies: {}
};
auctionConfigOverrides.perBuyerCurrencies['*'] = 'USD';
auctionConfigOverrides.perBuyerCurrencies[OTHER_ORIGIN1] = 'CAD';
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
// Since the scoring script doesn't actually look at the currencies,
// We expect 10CAD to win because 10 > 9
await waitForObservedRequests(uuid, [
createBidderReportURL(uuid, 'CAD', OTHER_ORIGIN1),
createSellerReportURL(uuid)
]);
}, 'Different currencies for different origins, all match.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoCurrencyGroups(test, uuid);
let auctionConfigOverrides = {
interestGroupBuyers: [ORIGIN, OTHER_ORIGIN1],
perBuyerCurrencies: {}
};
auctionConfigOverrides.perBuyerCurrencies[ORIGIN] = 'USD';
auctionConfigOverrides.perBuyerCurrencies[OTHER_ORIGIN1] = 'EUR';
await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
// Since the configuration for CAD script expects EUR only the USD bid goes
// through.
await waitForObservedRequests(
uuid, [createBidderReportURL(uuid, 'USD'), createSellerReportURL(uuid)]);
}, 'Different currencies for different origins, USD one matches.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoCurrencyGroups(test, uuid);
let auctionConfigOverrides = {
interestGroupBuyers: [ORIGIN, OTHER_ORIGIN1],
perBuyerCurrencies: {}
};
auctionConfigOverrides.perBuyerCurrencies['*'] = 'EUR';
}, 'Different currencies for different origins, none match.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'USD')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
// While scoring sees the original currency tag, reporting currency tags are
// config-based.
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_9???'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- no currency restriction.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'USD'},
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'USD')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
// Because component's sellerCurrency is USD, the bid it makes is seen to be
// in dollars by top-level reporting. That doesn't affect reporting in its
// own auction.
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_9USD'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- component sellerCurrency matches bid.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'EUR'},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid, bidCurrency: 'EUR'}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'EUR')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
// Because component's sellerCurrency is USD, the bid it makes is seen to be
// in dollars by top-level reporting. That doesn't affect reporting in its
// own auction.
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_13.5EUR'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- component scoreAd modifies bid into its sellerCurrency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'EUR'},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
// scoreAd sees what's actually passed in.
if (browserSignals.bidCurrency !== '???')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_13.5EUR'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- component scoreAd modifies bid, no explicit currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides:
{sellerCurrency: 'EUR', perBuyerCurrencies: {'*': 'USD'}},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
// scoreAd sees what's actually passed in.
if (browserSignals.bidCurrency !== '???')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_13.5EUR'),
createSellerReportURL(uuid, 'component_9USD'),
createBidderReportURL(uuid, '9USD')
]);
}, 'Multi-seller auction --- component scoreAd modifies bid, bidder has bidCurrency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {perBuyerCurrencies: {'*': 'USD'}},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
// scoreAd sees what's actually passed in.
if (browserSignals.bidCurrency !== '???')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_13.5???'),
createSellerReportURL(uuid, 'component_9USD'),
createBidderReportURL(uuid, '9USD')
]);
}, 'Multi-seller auction --- only bidder currency specified.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {perBuyerCurrencies: {'*': 'USD'}},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid, bidCurrency: 'CAD'}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
// scoreAd sees what's actually passed in.
if (browserSignals.bidCurrency !== 'CAD')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_13.5???'),
createSellerReportURL(uuid, 'component_9USD'),
createBidderReportURL(uuid, '9USD')
]);
}, 'Multi-seller auction --- only bidder currency in config, component uses explicit currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(test, uuid, {
biddingLogicURL:
createBiddingScriptURLWithCurrency(uuid, /*bidCurrency=*/ undefined)
});
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'CAD'},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
incomingBidInSellerCurrency: 12345}
`
},
topLevelSellerScriptParamsOverride: {
scoreAd: `
// scoreAd sees what's actually passed in.
if (bid !== 9)
throw 'Wrong bid';
if (browserSignals.bidCurrency !== '???')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_9CAD'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- incomingBidInSellerCurrency does not go to top-level; component sellerCurrency does.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let result = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'EUR'},
componentSellerScriptParamsOverride: {
scoreAd: `
return {desirability: 2 * bid, allowComponentAuction: true,
bid: 1.5 * bid, bidCurrency: 'CAD'}
`
}
});
expectNoWinner(result);
}, 'Multi-seller auction --- component scoreAd modifies bid to wrong currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let topLevelConfigOverride = {perBuyerCurrencies: {}};
topLevelConfigOverride.perBuyerCurrencies[ORIGIN] = 'USD';
let config = await runCurrencyComponentAuction(test, uuid, {
topLevelAuctionConfigOverrides: topLevelConfigOverride,
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'USD')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
// Because component is constrained by perBuyerCurrencies for it on top-level
// to USD, the bid it makes is seen to be in dollars by top-level reporting.
// That doesn't affect reporting in its own auction.
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_9USD'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- top-level perBuyerCurrencies matches bid.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let topLevelConfigOverride = {perBuyerCurrencies: {}};
topLevelConfigOverride.perBuyerCurrencies[ORIGIN] = 'USD';
let config = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'USD'},
topLevelAuctionConfigOverrides: topLevelConfigOverride,
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'USD')
throw 'Wrong currency';`
}
});
expectSuccess(config);
createAndNavigateFencedFrame(test, config);
// Because component is constrained by perBuyerCurrencies for it on top-level
// to USD, the bid it makes is seen to be in dollars by top-level reporting.
// That doesn't affect reporting in its own auction.
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_9USD'),
createSellerReportURL(uuid, 'component_9???'),
createBidderReportURL(uuid, '9???')
]);
}, 'Multi-seller auction --- consistent sellerConfig and top-level perBuyerCurrencies.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let topLevelConfigOverride = {perBuyerCurrencies: {}};
topLevelConfigOverride.perBuyerCurrencies[ORIGIN] = 'EUR';
let result = await runCurrencyComponentAuction(test, uuid, {
componentAuctionConfigOverrides: {sellerCurrency: 'USD'},
topLevelAuctionConfigOverrides: topLevelConfigOverride,
topLevelSellerScriptParamsOverride: {
scoreAd: `
if (browserSignals.bidCurrency !== 'USD')
throw 'Wrong currency';`
}
});
expectNoWinner(result);
}, 'Multi-seller auction --- inconsistent sellerConfig and top-level perBuyerCurrencies.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let topLevelConfigOverride = {perBuyerCurrencies: {}};
topLevelConfigOverride.perBuyerCurrencies[ORIGIN] = 'EUR';
let result = await runCurrencyComponentAuction(
test, uuid, {componentAuctionConfigOverrides: topLevelConfigOverride});
expectNoWinner(result);
}, 'Multi-seller auction --- top-level perBuyerCurrencies different from bid.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
let result = await runCurrencyComponentAuction(
test, uuid, {componentAuctionConfigOverrides: {sellerCurrency: 'EUR'}});
expectNoWinner(result);
}, 'Multi-seller auction --- component sellerCurrency different from bid.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(test, uuid);
await runBasicFledgeTestExpectingNoWinner(test, uuid, {
decisionLogicURL: createDecisionScriptURL(uuid, {
scoreAd: `
return {desirability: 2 * bid,
incomingBidInSellerCurrency: 5* bid}
`
})
});
}, 'Trying to use incomingBidInSellerCurrency w/o sellerCurrency set.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(test, uuid);
await runBasicFledgeTestExpectingWinner(test, uuid, {
decisionLogicURL: createDecisionScriptURL(uuid, {
scoreAd: `
return {desirability: 2 * bid,
incomingBidInSellerCurrency: 5* bid}
`,
}),
sellerCurrency: 'USD'
});
}, 'Trying to use incomingBidInSellerCurrency w/sellerCurrency set.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
await runBasicFledgeTestExpectingNoWinner(test, uuid, {
decisionLogicURL: createDecisionScriptURL(uuid, {
scoreAd: `
return {desirability: 2 * bid,
incomingBidInSellerCurrency: 5* bid}
`
}),
sellerCurrency: 'USD'
});
}, 'Trying to use incomingBidInSellerCurrency to change bid already in that currency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinInterestGroup(
test, uuid,
{biddingLogicURL: createBiddingScriptURLWithCurrency(uuid, 'USD')});
await runBasicFledgeTestExpectingWinner(test, uuid, {
decisionLogicURL: createDecisionScriptURL(uuid, {
scoreAd: `
return {desirability: 2 * bid,
incomingBidInSellerCurrency: bid}
`
}),
sellerCurrency: 'USD'
});
}, 'incomingBidInSellerCurrency repeating value of bid already in that currency is OK.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
await runBasicFledgeAuctionAndNavigate(
test, uuid,
{decisionLogicURL: createDecisionURLForHighestScoringOther(uuid)});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '10???_9???'),
createBidderReportURL(uuid, '10???_9???'),
// w/o sellerCurrency set, forDebuggingOnly reports original values and ???
// as tags.
createSellerReportURL(uuid, 'dbg_10???_9???'),
createBidderReportURL(uuid, 'dbg_10???_9???')
]);
}, 'Converted currency use with no sellerCurrency set.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
await runBasicFledgeAuctionAndNavigate(test, uuid, {
decisionLogicURL: createDecisionURLForHighestScoringOther(uuid),
sellerCurrency: 'USD'
});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '10???_9USD'),
createBidderReportURL(uuid, '10???_9USD'),
// w/sellerCurrency set, forDebuggingOnly reports converted bids +
// sellerCurrency.
createSellerReportURL(uuid, 'dbg_10USD_9USD'),
createBidderReportURL(uuid, 'dbg_10USD_9USD')
]);
}, 'Converted currency use with sellerCurrency set matching.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
await runBasicFledgeAuctionAndNavigate(test, uuid, {
decisionLogicURL: createDecisionURLForHighestScoringOther(uuid),
sellerCurrency: 'EUR'
});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '10???_0EUR'),
createBidderReportURL(uuid, '10???_0EUR'),
// sellerCurrency set, and no bid available in it: get 0s.
createSellerReportURL(uuid, 'dbg_0EUR_0EUR'),
createBidderReportURL(uuid, 'dbg_0EUR_0EUR')
]);
}, 'Converted currency use with sellerCurrency different, no conversion.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
await runBasicFledgeAuctionAndNavigate(test, uuid, {
decisionLogicURL:
createDecisionURLForHighestScoringOther(uuid, 'converted = 3 * bid'),
sellerCurrency: 'EUR'
});
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, '10???_27EUR'),
createBidderReportURL(uuid, '10???_27EUR'),
// sellerCurrency set, converted bids.
createSellerReportURL(uuid, 'dbg_30EUR_27EUR'),
createBidderReportURL(uuid, 'dbg_30EUR_27EUR')
]);
}, 'Converted currency use with sellerCurrency different, conversion.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
let result =
await runCurrencyComponentAuctionForHighestScoringOther(test, uuid, {
componentConversion: `
modified = bid + 1;
modifiedCurrency = 'EUR';`,
componentAuctionConfigOverrides: {sellerCurrency: 'EUR'}
});
expectSuccess(result);
createAndNavigateFencedFrame(test, result);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_11EUR_0???'),
createSellerReportURL(uuid, 'component_10???_0EUR'),
createBidderReportURL(uuid, '10???_0EUR'),
// forDebuggingOnly info w/sellerCurrency set relies on conversion;
// but sellerCurrency is on component auction only.
createBidderReportURL(uuid, 'dbg_0EUR_0EUR'),
createSellerReportURL(uuid, 'dbg_component_0EUR_0EUR'),
createSellerReportURL(uuid, 'dbg_top_11???_0???'),
]);
}, 'Modified bid does not act in place of incomingBidInSellerCurrency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
let result =
await runCurrencyComponentAuctionForHighestScoringOther(test, uuid, {
componentConversion: `
modified = bid + 1;
modifiedCurrency = 'EUR';
converted = bid - 1;`,
componentAuctionConfigOverrides: {sellerCurrency: 'EUR'}
});
expectSuccess(result);
createAndNavigateFencedFrame(test, result);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_11EUR_0???'),
createSellerReportURL(uuid, 'component_10???_8EUR'),
createBidderReportURL(uuid, '10???_8EUR'),
// Debug at component shows converted; top-level has no sellerCurrency,
// so shows modified.
createBidderReportURL(uuid, 'dbg_9EUR_8EUR'),
createSellerReportURL(uuid, 'dbg_component_9EUR_8EUR'),
createSellerReportURL(uuid, 'dbg_top_11???_0???'),
]);
}, 'Both modified bid and incomingBidInSellerCurrency.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
let result =
await runCurrencyComponentAuctionForHighestScoringOther(test, uuid, {
componentConversion: `
modified = bid + 1;
modifiedCurrency = 'CAD';`,
topLevelAuctionConfigOverrides: {sellerCurrency: 'EUR'},
topLevelConversion: `converted = 3 * bid;`,
});
expectSuccess(result);
createAndNavigateFencedFrame(test, result);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_11???_0???'),
createSellerReportURL(uuid, 'component_10???_9???'),
createBidderReportURL(uuid, '10???_9???'),
// No sellerCurrency at component; debug at top-level shows the result of
// conversion.
createBidderReportURL(uuid, 'dbg_10???_9???'),
createSellerReportURL(uuid, 'dbg_component_10???_9???'),
createSellerReportURL(uuid, 'dbg_top_33EUR_0???'),
]);
}, 'incomingBidInSellerCurrency at top-level trying to convert is OK.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
let result =
await runCurrencyComponentAuctionForHighestScoringOther(test, uuid, {
componentConversion: `
modified = bid + 1;
modifiedCurrency = 'EUR';`,
topLevelAuctionConfigOverrides: {sellerCurrency: 'EUR'},
topLevelConversion: `converted = 3 * bid;`,
});
// Tried to change a bid that was already in EUR.
expectNoWinner(result);
}, 'incomingBidInSellerCurrency at top-level trying to change bid is not OK.');
subsetTest(promise_test, async test => {
const uuid = generateUuid(test);
await joinTwoGroupsForHighestScoringOther(test, uuid);
let result =
await runCurrencyComponentAuctionForHighestScoringOther(test, uuid, {
componentConversion: `
modified = bid + 1;
modifiedCurrency = 'EUR';`,
topLevelAuctionConfigOverrides: {sellerCurrency: 'EUR'},
topLevelConversion: `converted = bid;`,
});
// Changing the bid to itself when it was already in right currency is OK.
expectSuccess(result);
createAndNavigateFencedFrame(test, result);
await waitForObservedRequests(uuid, [
createSellerReportURL(uuid, 'top_11???_0???'),
createSellerReportURL(uuid, 'component_10???_9???'),
createBidderReportURL(uuid, '10???_9???'),
// No sellerCurrency at component; debug at top-level shows the result of
// no-op conversion.
createBidderReportURL(uuid, 'dbg_10???_9???'),
createSellerReportURL(uuid, 'dbg_component_10???_9???'),
createSellerReportURL(uuid, 'dbg_top_11EUR_0???'),
]);
}, 'incomingBidInSellerCurrency at top-level doing a no-op conversion OK.');
// TODO: PrivateAggregation. It follows the same rules as
// highestScoringOtherBid, but is actually visible at top-level.