| // 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. |
