private-aggregation.https.window.js

// 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: script=third_party/cbor-js/cbor.js
// META: timeout=long
// META: variant=?1-5
// META: variant=?6-10
// META: variant=?11-15
// META: variant=?16-20

'use strict;'

// To better isolate from private aggregation tests run in parallel,
// don't use the usual origin here.
const MAIN_ORIGIN = OTHER_ORIGIN1;
const ALT_ORIGIN = OTHER_ORIGIN4;

const MAIN_PATH = '/.well-known/private-aggregation/report-protected-audience';
const DEBUG_PATH =
    '/.well-known/private-aggregation/debug/report-protected-audience';

const ADDITIONAL_BID_PUBLIC_KEY =
    '11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=';

const enableDebugMode = 'privateAggregation.enableDebugMode();';

// The next 3 methods are for interfacing with the test handler for
// Private Aggregation reports; adopted wholesale from Chrome-specific
// wpt_internal/private-aggregation/resources/utils.js
const resetReports = url => {
  url = `${url}?clear_stash=true`;
  const options = {
    method: 'POST',
    mode: 'no-cors',
  };
  return fetch(url, options);
};

const delay = ms => new Promise(resolve => step_timeout(resolve, ms));

async function pollReports(path, wait_for = 1, timeout = 5000 /*ms*/) {
  const targetUrl = new URL(path, MAIN_ORIGIN);
  const endTime = performance.now() + timeout;
  const outReports = [];

  do {
    const response = await fetch(targetUrl);
    assert_true(response.ok, 'pollReports() fetch response should be OK.');
    const reports = await response.json();
    outReports.push(...reports);
    if (outReports.length >= wait_for) {
      break;
    }
    await delay(/*ms=*/ 100);
  } while (performance.now() < endTime);

  return outReports.length ? outReports : null;
};

function decodeBase64(inStr) {
  let strBytes = atob(inStr);
  let arrBytes = new Uint8Array(strBytes.length);
  for (let i = 0; i < strBytes.length; ++i) {
    arrBytes[i] = strBytes.codePointAt(i);
  }
  return arrBytes.buffer;
}

function byteArrayToBigInt(inArray) {
  let out = 0n;
  for (let byte of inArray) {
    out = out * 256n + BigInt(byte);
  }
  return out;
}

async function getDebugSamples(path) {
  const debugReports = await pollReports(path);

  let samplesDict = new Map();

  // Extract samples for debug reports, and aggregate them, so we are not
  // reliant on how aggregation happens.
  for (let jsonReport of debugReports) {
    let report = JSON.parse(jsonReport);
    for (let payload of report.aggregation_service_payloads) {
      let decoded = CBOR.decode(decodeBase64(payload.debug_cleartext_payload));
      assert_equals(decoded.operation, 'histogram');
      for (let sample of decoded.data) {
        let convertedSample = {
          bucket: byteArrayToBigInt(sample.bucket),
          value: byteArrayToBigInt(sample.value)
        };
        if (convertedSample.value !== 0n) {
          let oldCount = 0n;
          if (samplesDict.has(convertedSample.bucket)) {
            oldCount = samplesDict.get(convertedSample.bucket);
          }

          samplesDict.set(
              convertedSample.bucket, oldCount + convertedSample.value);
        }
      }
    }
  }

  return samplesDict;
}

function stringifySamples(samplesDict) {
  let samplesArray = [];
  for (let [bucket, value] of samplesDict.entries()) {
    // Stringify these so we can use assert_array_equals on them.
    samplesArray.push(bucket + ' => ' + value);
  }
  samplesArray.sort();
  return samplesArray;
}

function maybeDelay(delayParam) {
  if (delayParam) {
    return `&pipe=trickle(d${delayParam / 1000})`
  } else {
    return '';
  }
}

function createIgOverrides(nameAndBid, fragments, originOverride = null) {
  let originToUse = originOverride ? originOverride : MAIN_ORIGIN;
  return {
    name: nameAndBid,
    biddingLogicURL: createBiddingScriptURL({
                       origin: originToUse,
                       generateBid:
                           enableDebugMode + fragments.generateBidFragment,
                       reportWin: enableDebugMode + fragments.reportWinFragment,
                       bid: nameAndBid,
                       allowComponentAuction: true
                     }) +
        maybeDelay(fragments.bidderDelayFactor ?
                       fragments.bidderDelayFactor * nameAndBid :
                       null)
  };
}

function expectAndConsume(samplesDict, bucket, val) {
  assert_equals(samplesDict.get(bucket), val, 'sample in bucket ' + bucket);
  samplesDict.delete(bucket);
}

function createAuctionConfigOverrides(
    uuid, fragments, moreAuctionConfigOverrides = {}) {
  return {
    decisionLogicURL:
        createDecisionScriptURL(uuid, {
          origin: MAIN_ORIGIN,
          scoreAd: enableDebugMode + fragments.scoreAdFragment,
          reportResult: enableDebugMode + fragments.reportResultFragment
        }) +
        maybeDelay(fragments.sellerDelay),
    seller: MAIN_ORIGIN,
    interestGroupBuyers: [MAIN_ORIGIN],
    ...moreAuctionConfigOverrides
  };
}

// Runs an auction with numGroups interest groups, "1" and "2", etc., with
// fragments.generateBidFragment/fragments.reportWinFragment/
// fragments.scoreAdFragment/fragments.reportResultFragment
// expected to make some Private Aggregation contributions.
// Returns the collected samples.
async function runPrivateAggregationTest(
    test, uuid, fragments, numGroups = 2, moreAuctionConfigOverrides = {}) {
  await resetReports(MAIN_ORIGIN + MAIN_PATH);
  await resetReports(MAIN_ORIGIN + DEBUG_PATH);

  for (let i = 1; i <= numGroups; ++i) {
    await joinCrossOriginInterestGroup(
        test, uuid, MAIN_ORIGIN, createIgOverrides(i, fragments));
  }

  const auctionConfigOverrides =
      createAuctionConfigOverrides(uuid, fragments, moreAuctionConfigOverrides);

  await runBasicFledgeAuctionAndNavigate(test, uuid, auctionConfigOverrides);
  return await getDebugSamples(DEBUG_PATH);
}

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogram({ bucket: 1n, value: 2 });`,

    reportWinFragment:
        `privateAggregation.contributeToHistogram({ bucket: 2n, value: 3 });`,

    scoreAdFragment:
        `privateAggregation.contributeToHistogram({ bucket: 3n, value: 4 });`,

    reportResultFragment:
        `privateAggregation.contributeToHistogram({ bucket: 4n, value: 5 });`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments);
  assert_array_equals(
      stringifySamples(samples),
      [
        '1 => 4',  // doubled since it's reported twice.
        '2 => 3',
        '3 => 8',  // doubled since it's reported twice.
        '4 => 5'
      ]);
}, 'Basic contributions');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 1n, value: 2 });`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 2n, value: 3 });`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 3n, value: 4 });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 4n, value: 5 });`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments);
  assert_array_equals(
      stringifySamples(samples),
      [
        '1 => 4',  // doubled since it's reported twice.
        '2 => 3',
        '3 => 8',  // doubled since it's reported twice.
        '4 => 5'
      ]);
}, 'reserved.always');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.win',
          { bucket: 1n, value: interestGroup.name });`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.win',
          { bucket: 2n, value: 3 });`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.win',
          { bucket: 3n, value: bid });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.win',
          { bucket: 4n, value: 5 });`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments);
  assert_array_equals(
      stringifySamples(samples),
      [
        '1 => 2',  // winning IG name
        '2 => 3',
        '3 => 2',  // winning bid
        '4 => 5'
      ]);
}, 'reserved.win');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.loss',
          { bucket: 1n, value: interestGroup.name });`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.loss',
          { bucket: 2n, value: 3 });`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.loss',
          { bucket: 3n, value: bid });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.loss',
          { bucket: 4n, value: 5 });`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments);

  // No reserved.loss from reporting since they only run for winners.
  assert_array_equals(
      stringifySamples(samples),
      [
        '1 => 1',  // losing IG name
        '3 => 1',  // losing bid
      ]);
}, 'reserved.loss');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 1n, value: interestGroup.name });`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 2n, value: 3 });`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 3n, value: bid });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 4n, value: 5 });`
  };

  const samples =
      stringifySamples(await runPrivateAggregationTest(test, uuid, fragments));

  // No reserved.once from reporting since it throws an exception.
  // bidder/scorer just pick one.
  assert_equals(samples.length, 2, 'samples array length');
  assert_in_array(samples[0], ['1 => 1', '1 => 2'], 'samples[0]');
  assert_in_array(samples[1], ['3 => 1', '3 => 2'], 'samples[1]');
}, 'reserved.once');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 1n, value: 1 });`,

    reportWinFragment: `
      try {
        privateAggregation.contributeToHistogramOnEvent(
            'reserved.once',
            { bucket: 2n, value: 2 });
      } catch (e) {
        privateAggregation.contributeToHistogramOnEvent(
            'reserved.always',
            { bucket: 2n, value: (e instanceof TypeError ? 3 : 4) });
      }`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 3n, value: 4 });`,

    reportResultFragment: `
      try {
        privateAggregation.contributeToHistogramOnEvent(
            'reserved.once',
            { bucket: 4n, value: 5 });
      } catch (e) {
        privateAggregation.contributeToHistogramOnEvent(
            'reserved.always',
            { bucket: 4n, value: (e instanceof TypeError ? 6 : 7) });
      }`
  };

  const samples =
      stringifySamples(await runPrivateAggregationTest(test, uuid, fragments));

  assert_array_equals(samples, [
    '1 => 1',
    '2 => 3',
    '3 => 4',
    '4 => 6',
  ]);
}, 'no reserved.once in reporting');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  await resetReports(ALT_ORIGIN + DEBUG_PATH);
  await resetReports(ALT_ORIGIN + MAIN_PATH);

  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'average-code-fetch-time', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'average-code-fetch-time', offset: 100000n},
              value: 1});`,

    bidderDelayFactor: 200,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'average-code-fetch-time', offset: 200000n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'average-code-fetch-time', offset: 300000n},
              value: 1});`,

    sellerDelay: 500
  };

  const altFragments = {
    generateBidFragment: fragments.generateBidFragment,
    bidderDelayFactor: 1000
  };

  await joinCrossOriginInterestGroup(
      test, uuid, ALT_ORIGIN, createIgOverrides('1', altFragments, ALT_ORIGIN));
  const auctionConfigOverrides = {
    interestGroupBuyers: [MAIN_ORIGIN, ALT_ORIGIN]
  };

  const samples = await runPrivateAggregationTest(
      test, uuid, fragments, 3, auctionConfigOverrides);

  let generateBidVal = -1;
  let reportWinVal = -1;
  let scoreAdVal = -1;
  let reportResultVal = -1;
  assert_equals(samples.size, 4, 'main domain samples');

  for (let [bucket, val] of samples.entries()) {
    assert_equals(val, 1n, 'bucket val');
    if (0n <= bucket && bucket < 100000n) {
      generateBidVal = Number(bucket - 0n);
    } else if (100000n <= bucket && bucket < 200000n) {
      reportWinVal = Number(bucket - 100000n);
    } else if (200000n <= bucket && bucket < 300000n) {
      scoreAdVal = Number(bucket - 200000n);
    } else if (300000n <= bucket && bucket < 400000n) {
      reportResultVal = Number(bucket - 300000n);
    } else {
      assert_unreached('Unexpected bucket number ' + bucket);
    }
  }

  assert_greater_than_equal(generateBidVal, 400, 'generateBid code fetch time');
  assert_greater_than_equal(reportWinVal, 600, 'reportWin code fetch time');
  assert_greater_than_equal(scoreAdVal, 500, 'scoreAd code fetch time');
  assert_greater_than_equal(
      reportResultVal, 500, 'reportResult code fetch time');

  let otherSamples = await getDebugSamples(ALT_ORIGIN + DEBUG_PATH);
  assert_equals(otherSamples.size, 1, 'alt domain samples');
  let otherGenerateBidVal = -1;
  for (let [bucket, val] of otherSamples.entries()) {
    assert_equals(val, 1n, 'other bucket val');
    if (0n <= bucket && bucket < 100000n) {
      otherGenerateBidVal = Number(bucket - 0n);
    } else {
      assert_unreached('Unexpected other bucket number ' + bucket);
    }
  }
  assert_greater_than_equal(
      otherGenerateBidVal, 1000, 'other generateBid code fetch time');
}, 'average-code-fetch-time');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'percent-scripts-timeout', offset: 0n},
              value: 1});
      if (interestGroup.name === '1') {
        while (true) {}
      }
      `,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'percent-scripts-timeout', offset: 200n},
              value: 1});
      while(true) {}`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'percent-scripts-timeout', offset: 400n},
              value: 1});
      if (bid == 2) {
        while (true) {}
      }
      `,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'percent-scripts-timeout', offset: 600n},
              value: 1});`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments, 3);

  let expected = [
    '33 => 1',   // 33% of generateBid  (base bucket 0)
    '300 => 1',  // 100% of reportWin   (base bucket 200)
    '450 => 1',  // 50% of scoreAd      (base bucket 400)
    '600 => 1',  // 0% of reportResult  (base bucket 600)
  ].sort();

  assert_array_equals(stringifySamples(samples), expected);
}, 'percent-scripts-timeout');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  await resetReports(ALT_ORIGIN + DEBUG_PATH);
  await resetReports(ALT_ORIGIN + MAIN_PATH);

  const ADDITIONAL_BID_PUBLIC_KEY =
      '11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=';

  // Join a negative group, one without ads.
  // These shouldn't count towards participant number.
  await joinNegativeInterestGroup(
      test, MAIN_ORIGIN, 'some negative group', ADDITIONAL_BID_PUBLIC_KEY);
  await joinCrossOriginInterestGroup(test, uuid, MAIN_ORIGIN, {ads: []});

  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'participating-ig-count', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'participating-ig-count', offset: 200n},
              value: 1});`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'participating-ig-count', offset: 400n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'participating-ig-count', offset: 600n},
              value: 1});`
  };

  // ... and a different participant should get their own samples.
  await joinCrossOriginInterestGroup(
      test, uuid, ALT_ORIGIN, createIgOverrides('1', fragments, ALT_ORIGIN));
  await joinCrossOriginInterestGroup(
      test, uuid, ALT_ORIGIN, createIgOverrides('2', fragments, ALT_ORIGIN));
  const auctionConfigOverrides = {
    interestGroupBuyers: [MAIN_ORIGIN, ALT_ORIGIN]
  };

  const samples = await runPrivateAggregationTest(
      test, uuid, fragments, 5, auctionConfigOverrides);

  let expected = [
    '5 => 1',    // 5 in generateBid  (base bucket 0)
    '205 => 1',  // 5 in reportWin    (base bucket 200)
    '400 => 1',  // 0 in scoreAd      (base bucket 400)
    '600 => 1',  // 0 in reportResult (base bucket 600)
  ].sort();

  assert_array_equals(stringifySamples(samples), expected);

  let otherSamples = await getDebugSamples(ALT_ORIGIN + DEBUG_PATH);
  assert_array_equals(stringifySamples(otherSamples), ['2 => 1']);
}, 'participating-ig-count');


subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {
                  baseValue: 'percent-igs-cumulative-timeout',
                  offset: 0n
              },
              value: 1});
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {
                  baseValue: 'cumulative-buyer-time',
                  offset: 10000n
              },
              value: 1});
      setBid({bid: interestGroup.name, render: interestGroup.ads[0].renderURL});
      while (true) {}
      `,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {
                  baseValue: 'percent-igs-cumulative-timeout',
                  offset: 200n
              },
              value: 1});
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {
                  baseValue: 'cumulative-buyer-time',
                  offset: 20000n
              },
              value: 1});
      `,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {
                  baseValue: 'percent-igs-cumulative-timeout',
                  offset: 400n
              },
              value: 1});
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {
                  baseValue: 'cumulative-buyer-time',
                  offset: 40000n
              },
              value: 1});
      `,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {
                  baseValue: 'percent-igs-cumulative-timeout',
                  offset: 600n
              },
              value: 1});
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {
                  baseValue: 'cumulative-buyer-time',
                  offset: 60000n
              },
              value: 1});`
  };

  const auctionConfigOverrides = {
    perBuyerTimeouts: {
      '*': 500  // max.
    },
    perBuyerCumulativeTimeouts: {'*': 2000}
  };

  const samples = await runPrivateAggregationTest(
      test, uuid, fragments, 15, auctionConfigOverrides);

  // Timeout is reported as 3000 (limit + 1000) for generateBid
  // and reportWin, as 0 for the seller methods.
  expectAndConsume(samples, 13000n, 1n);  // base is 10,000
  expectAndConsume(samples, 23000n, 1n);
  expectAndConsume(samples, 40000n, 1n);
  expectAndConsume(samples, 60000n, 1n);

  // percent time is 0 on the seller side.
  expectAndConsume(samples, 400n, 1n);
  expectAndConsume(samples, 600n, 1n);

  assert_equals(samples.size, 2, 'buyer samples');

  let percentGenerateBid = -1;
  let percentReportWin = -1;

  for (let [bucket, val] of samples.entries()) {
    assert_equals(val, 1n, 'bucket val');
    if (0n <= bucket && bucket <= 110n) {
      percentGenerateBid = bucket;
    } else if (200n <= bucket && bucket <= 310n) {
      percentReportWin = bucket - 200n;
    } else {
      assert_unreached('Unexpected bucket number ' + bucket);
    }
  }

  assert_equals(
      percentGenerateBid, percentReportWin,
      'same % in generateBid and reportWin');

  // This assumes that at least some time out; which may not be guaranteed with
  // sufficient level of parallelism. At any rate, the denominator is 15,
  // however, so only some percentages are possible.
  assert_in_array(
      percentGenerateBid,
      [6n, 13n, 20n, 26n, 33n, 40n, 46n, 53n, 60n, 66n, 73n, 80n, 86n, 93n],
      'percent timeout is as expected');
}, 'percent-igs-cumulative-timeout, and cumulative-buyer-time when hit');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 200n},
              value: 1});`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 400n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 600n},
              value: 1});`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments, 5);

  // 0s for all the bases.
  let expected = ['0 => 1', '200 => 1', '400 => 1', '600 => 1'].sort();

  assert_array_equals(stringifySamples(samples), expected);
}, 'cumulative-buyer-time when not configured');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 10000n},
              value: 1});`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 20000n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: 'cumulative-buyer-time', offset: 30000n},
              value: 1});`
  };

  const auctionConfigOverrides = {perBuyerCumulativeTimeouts: {'*': 4000}};

  const samples = await runPrivateAggregationTest(
      test, uuid, fragments, 5, auctionConfigOverrides);

  // Sellers stuff is just 0s (so 1 to the base bucket offset).
  expectAndConsume(samples, 20000n, 1n);
  expectAndConsume(samples, 30000n, 1n);

  assert_equals(samples.size, 2, 'buyer samples');

  let timeGenerateBid = -1;
  let timeReportWin = -1;

  for (let [bucket, val] of samples.entries()) {
    assert_equals(val, 1n, 'bucket val');
    if (0n <= bucket && bucket <= 5000n) {
      timeGenerateBid = bucket;
    } else if (10000n <= bucket && bucket <= 15000n) {
      timeReportWin = bucket - 10000n;
    } else {
      assert_unreached('Unexpected bucket number');
    }
  }

  assert_equals(
      timeGenerateBid, timeReportWin, 'same time in generateBid and reportWin');

  // This assume this takes more than 0ms to run; it's not really required to
  // be the case, but feels like a realistic assumption that makes the test
  // more useful.
  assert_true(
      1n <= timeGenerateBid && timeGenerateBid <= 4000n,
      'time ' + timeGenerateBid + ' is reasonable and non-zero');
}, 'cumulative-buyer-time when configured');


async function testStorageQuotaMetric(test, name) {
  const uuid = generateUuid(test);
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: '${name}', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: '${name}', offset: 10000n},
              value: 1});`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: '${name}', offset: 20000n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: '${name}', offset: 30000n},
              value: 1});`
  };

  const samples = await runPrivateAggregationTest(test, uuid, fragments, 5);

  // Sellers stuff is just 0s (so 1 to the base bucket offset).
  expectAndConsume(samples, 20000n, 1n);
  expectAndConsume(samples, 30000n, 1n);

  assert_equals(samples.size, 2, 'buyer samples');

  let generateBidVal = -1;
  let reportWinVal = -1;

  for (let [bucket, val] of samples.entries()) {
    assert_equals(val, 1n, 'bucket val');
    if (0n <= bucket && bucket < 10000n) {
      generateBidVal = Number(bucket);
    } else if (10000n <= bucket && bucket <= 20000n) {
      reportWinVal = Number(bucket - 10000n);
    } else {
      assert_unreached('Unexpected bucket number ' + bucket);
    }
  }

  assert_equals(
      generateBidVal, reportWinVal, 'same value in generateBid and reportWin');

  // We don't know what the impls quota is, or even how much we are using,
  // but at least make sure it's in range.
  assert_between_inclusive(
      generateBidVal, 0, 110, 'reported percent value is in expected range');
}

subsetTest(promise_test, async test => {
  await testStorageQuotaMetric(test, 'percent-regular-ig-count-quota-used');
}, 'percent-regular-ig-count-quota-used');

subsetTest(promise_test, async test => {
  await testStorageQuotaMetric(test, 'percent-negative-ig-count-quota-used');
}, 'percent-negative-ig-count-quota-used');

subsetTest(promise_test, async test => {
  await testStorageQuotaMetric(test, 'percent-ig-storage-quota-used');
}, 'percent-ig-storage-quota-used');


async function testStorageUsageMetric(test, name, min) {
  const uuid = generateUuid(test);
  const spacing = 1000000000n;
  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: '${name}', offset: 0n},
              value: 1});`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: '${name}', offset: ${spacing}n},
              value: 1});`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once', {
              bucket: {baseValue: '${name}', offset: 2n * ${spacing}n},
              value: 1});`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always', {
              bucket: {baseValue: '${name}', offset: 3n * ${spacing}n},
              value: 1});`
  };

  await joinNegativeInterestGroup(
      test, MAIN_ORIGIN, 'some negative group', ADDITIONAL_BID_PUBLIC_KEY);
  await joinNegativeInterestGroup(
      test, MAIN_ORIGIN, 'some negative group 2', ADDITIONAL_BID_PUBLIC_KEY);
  await joinCrossOriginInterestGroup(
      test, uuid, MAIN_ORIGIN,
      {ads: [], name: 'Big group w/o ads'.padEnd(50000)});

  const samples = await runPrivateAggregationTest(test, uuid, fragments, 5);

  // Sellers stuff is just 0s (so 1 to the base bucket offset).
  expectAndConsume(samples, 2n * spacing, 1n);
  expectAndConsume(samples, 3n * spacing, 1n);

  assert_equals(samples.size, 2, 'buyer samples');

  let generateBidVal = -1;
  let reportWinVal = -1;

  for (let [bucket, val] of samples.entries()) {
    assert_equals(val, 1n, 'bucket val');
    if (0n <= bucket && bucket < spacing) {
      generateBidVal = bucket;
    } else if (spacing <= bucket && bucket < 2n * spacing) {
      reportWinVal = bucket - spacing;
    } else {
      assert_unreached('Unexpected bucket number ' + bucket);
    }
  }

  assert_equals(
      generateBidVal, reportWinVal, 'same value in generateBid and reportWin');

  assert_true(
      generateBidVal >= BigInt(min),
      'reported value should be at least ' + min + ' but is ' + generateBidVal);
}

subsetTest(promise_test, async test => {
  // 5 regular Igs + one ad less.
  await testStorageUsageMetric(test, 'regular-igs-count', 6);
}, 'regular-igs-count');

subsetTest(promise_test, async test => {
  // 2 negative IGs
  await testStorageUsageMetric(test, 'negative-igs-count', 2);
}, 'negative-igs-count');

subsetTest(promise_test, async test => {
  // The big group has a 50,000 character name
  await testStorageUsageMetric(test, 'ig-storage-used', 50000);
}, 'ig-storage-used');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  await resetReports(MAIN_ORIGIN + MAIN_PATH);
  await resetReports(MAIN_ORIGIN + DEBUG_PATH);
  await resetReports(ALT_ORIGIN + MAIN_PATH);
  await resetReports(ALT_ORIGIN + DEBUG_PATH);

  const fragments = {
    generateBidFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 1n, value: 2 });`,

    reportWinFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 2n, value: 3 });`,

    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 3n, value: 4 });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 4n, value: 5 });`
  };

  // 4 IGs in main origin, 2 in alt origin.
  for (let i = 1; i <= 4; ++i) {
    await joinCrossOriginInterestGroup(
        test, uuid, MAIN_ORIGIN, createIgOverrides(i, fragments));
  }

  for (let i = 1; i <= 2; ++i) {
    await joinCrossOriginInterestGroup(
        test, uuid, ALT_ORIGIN, createIgOverrides(i, fragments, ALT_ORIGIN));
  }

  // Both groups in component auction 1, only alt group in component auction 2.
  const subAuction1 = createAuctionConfigOverrides(
      uuid, fragments, {interestGroupBuyers: [MAIN_ORIGIN, ALT_ORIGIN]});
  const subAuction2 = createAuctionConfigOverrides(
      uuid, fragments, {interestGroupBuyers: [ALT_ORIGIN]});

  const topFragments = {
    scoreAdFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.once',
          { bucket: 5n, value: 6 });`,

    reportResultFragment: `
      privateAggregation.contributeToHistogramOnEvent(
          'reserved.always',
          { bucket: 6n, value: 7 });`
  };
  const mainAuction = createAuctionConfigOverrides(
      uuid, topFragments,
      {interestGroupBuyers: [], componentAuctions: [subAuction1, subAuction2]});

  await runBasicFledgeAuctionAndNavigate(test, uuid, mainAuction);
  let samples = await getDebugSamples(DEBUG_PATH);
  let otherSamples = await getDebugSamples(ALT_ORIGIN + DEBUG_PATH);
  let expected = [
    '1 => 2',  // generateBid only in first component, so happens 1.
    '2 => 3',  // reportWin once.
    '3 => 8',  // Once per each component auction (out of total 6 scored).
    '4 => 5',  // component reportResult once.
    '5 => 6',  // top-level scoreAd once.
    '6 => 7',  // top-level reportResult.
  ].sort();
  let otherExpected = [
    '1 => 4',  // generateBid in each components, so twice, out of 4 executions.
  ].sort();
  assert_array_equals(stringifySamples(samples), expected);
  assert_array_equals(stringifySamples(otherSamples), otherExpected);
}, 'report.once in a component auction');