generate-bid-browser-signals.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: 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-36
// META: variant=?37-last

"use strict";

// These tests focus on the browserSignals argument passed to generateBid().
// Note that "topLevelSeller" is covered by component auction tests,
// "dataVersion" by trusted signals tests, and cross-origin
// "topWindowHostname" and "seller" are covered by cross origin tests.
//
// Some of these tests use the "uuid" for interest group name, to avoid
// joins/bids from previous tests that failed to clean up after themselves
// from affecting results.

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let expectedBrowserSignals = {
    'topWindowHostname': window.location.hostname,
    'seller': window.location.origin,
    'adComponentsLimit': 40,
    'joinCount': 1,
    'bidCount': 0,
    'multiBidLimit': 1,
    'prevWinsMs': [],
    'forDebuggingOnlySampling': false,
    'viewCounts': {
      'pastHour': 0,
      'pastDay': 0,
      'pastWeek': 0,
      'past30Days': 0,
      'past90Days': 0
    },
    'clickCounts': {
      'pastHour': 0,
      'pastDay': 0,
      'pastWeek': 0,
      'past30Days': 0,
      'past90Days': 0
    }
  };
  let biddingLogicURL = createBiddingScriptURL({
    generateBid:
        `let expectedBrowserSignals = ${JSON.stringify(expectedBrowserSignals)};

          // Can't check this value exactly.
          expectedBrowserSignals.recency = browserSignals.recency;

          // This value may be affected by other recently run tests.
          expectedBrowserSignals.forDebuggingOnlyInCooldownOrLockout =
              browserSignals.forDebuggingOnlyInCooldownOrLockout;

          // Don't check exact values of view/click reports.
          function zeroCounts(object) {
            object.pastHour = 0;
            object.pastDay = 0;
            object.pastWeek = 0;
            object.past30Days = 0;
            object.past90Days = 0;
          }
          zeroCounts(browserSignals.viewCounts);
          zeroCounts(browserSignals.clickCounts);

          // Remove deprecated field, if present.
          delete browserSignals.prevWins;

          if (!deepEquals(browserSignals, expectedBrowserSignals))
             throw "Unexpected browserSignals: " + JSON.stringify(browserSignals);`
  });

  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: biddingLogicURL}});
}, 'Only expected fields present.');

// Creates a bidding script URL that expects the "joinCount" to be
// "expectedJoinCount".
function createJoinCountBiddingScriptURL(expectedJoinCount) {
  return createBiddingScriptURL(
    { generateBid:
        `if (browserSignals.joinCount !== ${expectedJoinCount})
           throw "Unexpected joinCount: " + browserSignals.joinCount;`
    });
}

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: createJoinCountBiddingScriptURL(1)}});

  // Joining again, even with a different script URL, should increase the join count.
  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: createJoinCountBiddingScriptURL(2)}});
}, 'browserSignals.joinCount same joining page.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: createJoinCountBiddingScriptURL(1)}});

  // Attempt to re-join the same interest group from a different top-level origin.
  // The join count should still be persisted.
  await joinCrossOriginInterestGroupInTopLevelWindow(
      test, uuid, OTHER_ORIGIN1, window.location.origin,
      { name: uuid,
        biddingLogicURL: createJoinCountBiddingScriptURL(2)});

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.joinCount different top-level joining origin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: createJoinCountBiddingScriptURL(1)}});

  // Leaving interest group should clear join count.
  await leaveInterestGroup({name: uuid});

  // Check that join count was cleared.
  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test,
      { uuid: uuid,
        interestGroupOverrides: {name: uuid,
                                 biddingLogicURL: createJoinCountBiddingScriptURL(1)}});
}, 'browserSignals.joinCount leave and rejoin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  await runReportTest(
    test, uuid,
    { generateBid:
        `if (browserSignals.recency === undefined)
           throw new Error("Missing recency in browserSignals.")

         if (browserSignals.recency < 0)
           throw new Error("Recency is a negative value.")

         if (browserSignals.recency > 30000)
           throw new Error("Recency is over 30 seconds threshold.")

         if (browserSignals.recency % 100 !== 0)
           throw new Error("Recency is not rounded to multiple of 100 milliseconds.")

         return {'bid': 9,
                 'render': interestGroup.ads[0].renderURL};`,
      reportWin:
        `sendReportTo('${createBidderReportURL(uuid)}');`
    },
    // expectedReportURLs
    [createBidderReportURL(uuid)]
  );
}, 'Check recency in generateBid() is below a certain threshold and rounded ' +
   'to multiple of 100 milliseconds.');

// Creates a bidding script URL that expects the "bidCount" to be
// "expectedBidCount".
function createBidCountBiddingScriptURL(expectedBidCount) {
  return createBiddingScriptURL(
    { generateBid:
        `if (browserSignals.bidCount !== ${expectedBidCount})
           throw "Unexpected bidCount: " + browserSignals.bidCount;`
    });
}

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Running an auction should not increment "bidCount".
  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)});

  // These auctions would have no winner if the "bidCount" were incremented.
  await runBasicFledgeAuction(test, uuid);
  await runBasicFledgeAuction(test, uuid);
}, 'browserSignals.bidCount not incremented when ad not used.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0) });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Wait for the navigation to trigger reports. "bidCount" should be updated before
  // any reports are sent.
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1) });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Wait for the navigation to trigger reports. "bidCount" should be updated before
  // any reports are sent.
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(2) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented when ad used.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Join an interest group and run an auction and navigate to the winning ad,
  // increasing the bid count to 1.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)});
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Wait for the navigation to trigger reports. "bidCount" should be updated before
  // any reports are sent.
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinCrossOriginInterestGroupInTopLevelWindow(
      test, uuid, OTHER_ORIGIN1, window.location.origin,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount persists across re-join from other top-level origin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Join an interest group and run an auction and navigate to the winning ad,
  // increasing the bid count to 1.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0) });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  // Leaving interest group should clear "bidCount".
  await leaveInterestGroup({name: uuid});

  // Check that bid count was cleared.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)});
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount leave and rejoin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)} );

  // Run two auctions at once, without any navigations.
  // "bidCount" should be 0 for both auctions.
  let fencedFrameConfigs =
      await Promise.all([runBasicFledgeTestExpectingWinner(test, uuid),
                         runBasicFledgeTestExpectingWinner(test, uuid)]);

  // Start navigating to both auction winners.
  createAndNavigateFencedFrame(test, fencedFrameConfigs[0]);
  createAndNavigateFencedFrame(test, fencedFrameConfigs[1]);

  // Wait for navigations to have sent reports (and thus to have updated
  // bid counts).
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  // Check that "bidCount" has increased by 2.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(2) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount two auctions at once.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use a tracker URL for the ad. It won't be successfully loaded, due to missing
  // the fenced frame header, but it should be fetched twice.
  let trackedRenderURL =
      createTrackerURL(window.location.origin, uuid, 'track_get', /*id=*/'ad');
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0),
        ads: [{ renderURL: trackedRenderURL }]
      });

  let fencedFrameConfig = await runBasicFledgeTestExpectingWinner(test, uuid);

  // Start navigating two frames to the winning ad.
  createAndNavigateFencedFrame(test, fencedFrameConfig);
  createAndNavigateFencedFrame(test, fencedFrameConfig);

  // Wait for both navigations to have requested ads (and thus to have updated
  // bid counts).
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       trackedRenderURL,
                                       trackedRenderURL]);

  // Check that "bidCount" has increased by only 1.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented once when winning ad used twice.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let bidderReportURL = createBidderReportURL(uuid, /*id=*/'winner');

  // Join an interest group named "uuid", which will bid 0.1, losing the first auction.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { bid: 0.1, reportWin: `sendReportTo('${createBidderReportURL(uuid, /*id=*/'loser')}')` })
      });

  // Join an interest group with the default name, which will bid 1 and win the first
  // auction, sending a bidder report.
  await joinInterestGroup(
      test, uuid,
      { biddingLogicURL: createBiddingScriptURL(
          { bid: 1, reportWin: `sendReportTo('${bidderReportURL}')` })
      });

  // Run an auction that both bidders participate in. Despite the first interest group
  // losing, its "bidCount" should be incremented.
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Make sure the right bidder won.
  await waitForObservedRequests(uuid, [bidderReportURL, createSellerReportURL(uuid)]);

  // Leave the second interest group (which has the default name).
  await leaveInterestGroup();

  // Re-join the first interest group, with a bidding script that checks its "bidCount".
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1)
      });

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented when another interest group wins.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use default interest group, other than using a unique name. It will make a bid.
  await joinInterestGroup(test, uuid, { name: uuid });
  // Run auction with seller that rejects all bids.
  await runBasicFledgeTestExpectingNoWinner(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(uuid, {scoreAd: `return 0;`})});

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1)
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented when seller rejects bid.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use default interest group, other than using a unique name. It will make a bid.
  await joinInterestGroup(test, uuid, { name: uuid });
  // Run auction with seller that always throws.
  await runBasicFledgeTestExpectingNoWinner(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(uuid, {scoreAd: `throw "a fit";`})});

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1)
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented when seller throws.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Interest group that does not bid.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { generateBid: 'return;' })
      });
  await runBasicFledgeTestExpectingNoWinner(test, uuid);

  // Check that "bidCount" was not incremented.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount not incremented when no bid.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let bidderReportURL = createBidderReportURL(uuid, /*id=*/'winner');

  // Interest group that does not bid.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { generateBid: 'return;' })
      });

  // Join an interest group with the default name, which will bid 1 and win the first
  // auction, sending a bidder report.
  await joinInterestGroup(
      test, uuid,
      { biddingLogicURL: createBiddingScriptURL(
          { bid: 1, reportWin: `sendReportTo('${bidderReportURL}')` })
      });

  // Run an auction that both bidders participate in, and make sure the right bidder won.
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [bidderReportURL, createSellerReportURL(uuid)]);

  // Leave the second interest group (which has the default name).
  await leaveInterestGroup();

  // Re-join the first interest group, with a bidding script that checks its "bidCount".
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(0)
      });

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount not incremented when no bid and another interest group wins.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let bidderReportURL = createBidderReportURL(uuid, /*id=*/'winner');

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { bid: 42, reportWin: `sendReportTo('${createBidderReportURL(uuid, /*id=*/'loser')}')` })
      });

  // Join an interest group with the default name, which will bid 1 and win the first
  // auction, sending a bidder report.
  await joinInterestGroup(
      test, uuid,
      { biddingLogicURL: createBiddingScriptURL(
          { bid: 1, reportWin: `sendReportTo('${bidderReportURL}')` })
      });

  // Run an auction that both bidders participate in. The scoreAd script rejects the
  // first interest group's bid.
  await runBasicFledgeAuctionAndNavigate(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(
          uuid,
          { scoreAd: `if (bid === 42) return -1;`})});
  // Make sure the second interest group won.
  await waitForObservedRequests(uuid, [bidderReportURL]);

  // Leave the second interest group (which has the default name).
  await leaveInterestGroup();

  // Re-join the first interest group, with a bidding script that checks its "bidCount".
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBidCountBiddingScriptURL(1)
      });

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.bidCount incremented when makes largest bid, but seller rejects the bid.');

// Creates a bidding script URL that expects "prevWinsMs" to be
// "expectedPrevWinsMs". All times in "expectedPrevWinsMs" must be 0.
//
// "adIndex" is the index of the ad to use in the bid.
function createPrevWinsMsBiddingScriptURL(expectedPrevWinsMs, adIndex = 0) {
  return createBiddingScriptURL(
    { generateBid:
        `for (let i = 0; i < browserSignals.prevWinsMs.length; i++) {
           // Check age is in a reasonable range.
           if (browserSignals.prevWinsMs[i][0] < 0 ||
               browserSignals.prevWinsMs[i][0] > 30000) {
             throw "Unexpected prevWinsMs time: " + JSON.stringify(browserSignals.prevWinsMs);
           }

           // Set age to 0.
           browserSignals.prevWinsMs[i][0] = 0;

           // Remove obsolete field, if present.
           delete browserSignals.prevWinsMs[i][1].render_url;
         }
         if (!deepEquals(browserSignals.prevWinsMs, ${JSON.stringify(expectedPrevWinsMs)}))
           throw "Unexpected prevWinsMs: " + JSON.stringify(browserSignals.prevWinsMs);

           return {
             bid: 1,
             render: interestGroup.ads[${adIndex}].renderURL
         };`
    });
}

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Running an auction should not increment "prevWinsMs".
  await joinGroupAndRunBasicFledgeTestExpectingWinner(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])});

  // These auctions would have no winner if the "prevWinsMs" were incremented.
  await runBasicFledgeAuction(test, uuid);
  await runBasicFledgeAuction(test, uuid);
}, 'browserSignals.prevWinsMs not affected when ad not used.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([]) });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Wait for the navigation to trigger reports. "prevWinsMs" should be updated before
  // any reports are sent.
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [[0, {renderURL: createRenderURL(uuid)}]]) });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  // Wait for the navigation to trigger reports. "prevWinsMs" should be updated before
  // any reports are sent.
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [ [0, {renderURL: createRenderURL(uuid)}],
              [0, {renderURL: createRenderURL(uuid)}]]) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs, no metadata.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const ads = [ {renderURL: createRenderURL(uuid, 0), metadata: null},
                {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]},
                {renderURL: createRenderURL(uuid, 2)} ];

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([], /*adIndex=*/0),
        ads: ads });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [[0, {renderURL: createRenderURL(uuid, 0), metadata: null}]],
            /*adIndex=*/1),
        ads: ads });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [ [0, {renderURL: createRenderURL(uuid, 0), metadata: null}],
              [0, {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]}] ],
            /*adIndex=*/2),
        ads: ads });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [ [0, {renderURL: createRenderURL(uuid, 0), metadata: null}],
              [0, {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]}],
              [0, {renderURL: createRenderURL(uuid, 2)}] ]),
        ads: ads });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs, with metadata.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const ads = [ {renderURL: createRenderURL(uuid, 0), metadata: null},
                {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]},
                {renderURL: createRenderURL(uuid, 2)} ];

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([]),
        ads: [{renderURL: createRenderURL(uuid, 0), metadata: null}] });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [[0, {renderURL: createRenderURL(uuid, 0), metadata: null}]]),
        ads: [{renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]}] });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [ [0, {renderURL: createRenderURL(uuid, 0), metadata: null}],
              [0, {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]}] ]),
        ads: [{renderURL: createRenderURL(uuid, 2)}] });
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [ [0, {renderURL: createRenderURL(uuid, 0), metadata: null}],
              [0, {renderURL: createRenderURL(uuid, 1), metadata: ['1', 2, {3: 4}]}],
              [0, {renderURL: createRenderURL(uuid, 2)}] ]) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs, different set of ads for each bid.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Join an interest group and run an auction and navigate to the winning ad,
  // which should be logged in "prevWinsMs".
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])});
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  await joinCrossOriginInterestGroupInTopLevelWindow(
      test, uuid, OTHER_ORIGIN1, window.location.origin,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
            [[0, {renderURL: createRenderURL(uuid)}]]) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs persists across re-join from other top-level origin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Join an interest group and run an auction and navigate to the winning ad,
  // which should be logged in "prevWinsMs".
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])});
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);

  // Leaving interest group should clear "prevWinsMs".
  await leaveInterestGroup({name: uuid});

  // Check that bid count was cleared.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])});
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs leave and rejoin.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });

  // Run two auctions at once, without any navigations.
  // "prevWinsMs" should be empty for both auctions.
  let fencedFrameConfigs =
      await Promise.all([runBasicFledgeTestExpectingWinner(test, uuid),
                         runBasicFledgeTestExpectingWinner(test, uuid)]);

  // Start navigating to both auction winners.
  createAndNavigateFencedFrame(test, fencedFrameConfigs[0]);
  createAndNavigateFencedFrame(test, fencedFrameConfigs[1]);

  // Wait for navigations to have sent reports (and thus to have updated
  // "prevWinsMs").
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       createSellerReportURL(uuid)]);

  // Check that "prevWinsMs" has two URLs.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
          [[0, {renderURL: createRenderURL(uuid)}],
           [0, {renderURL: createRenderURL(uuid)}]])
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs two auctions at once.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use a tracker URL for the ad. It won't be successfully loaded, due to missing
  // the fenced frame header, but it should be fetched twice.
  let trackedRenderURL =
      createTrackerURL(window.location.origin, uuid, 'track_get', /*id=*/'ad');
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([]),
        ads: [{ renderURL: trackedRenderURL }]
      });

  let fencedFrameConfig = await runBasicFledgeTestExpectingWinner(test, uuid);

  // Start navigating two frames to the winning ad.
  createAndNavigateFencedFrame(test, fencedFrameConfig);
  createAndNavigateFencedFrame(test, fencedFrameConfig);

  // Wait for both navigations to have requested ads (and thus to have updated
  // "prevWinsMs").
  await waitForObservedRequests(uuid, [createSellerReportURL(uuid),
                                       trackedRenderURL,
                                       trackedRenderURL]);

  // Check that "prevWins" has only a single win.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL(
          [[0, {renderURL: trackedRenderURL}]]) });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs has only one win when winning ad used twice.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let bidderReportURL = createBidderReportURL(uuid, /*id=*/'winner');

  // Join an interest group named "uuid", which will bid 0.1, losing the first auction.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { bid: 0.1, reportWin: `sendReportTo('${createBidderReportURL(uuid, /*id=*/'loser')}')` })
      });

  // Join an interest group with the default name, which will bid 1 and win the first
  // auction, sending a bidder report.
  await joinInterestGroup(
      test, uuid,
      { biddingLogicURL: createBiddingScriptURL(
          { bid: 1, reportWin: `sendReportTo('${bidderReportURL}')` })
      });

  // Run an auction that both bidders participate in, and make sure the right bidder won.
  await runBasicFledgeAuctionAndNavigate(test, uuid);
  await waitForObservedRequests(uuid, [bidderReportURL, createSellerReportURL(uuid)]);

  // Leave the second interest group (which has the default name).
  await leaveInterestGroup();

  // Re-join the first interest group, with a bidding script that expects prevWinsMs to
  // be empty.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs not updated when another interest group wins.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use default interest group, other than using a unique name. It will make a bid.
  await joinInterestGroup(test, uuid, { name: uuid });
  // Run auction with seller that rejects all bids.
  await runBasicFledgeTestExpectingNoWinner(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(uuid, {scoreAd: `return 0;`})});

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs not updated when seller rejects bid.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Use default interest group, other than using a unique name. It will make a bid.
  await joinInterestGroup(test, uuid, { name: uuid });
  // Run auction with seller that always throws.
  await runBasicFledgeTestExpectingNoWinner(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(uuid, {scoreAd: `throw "a fit";`})});

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs not updated when seller throws.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Interest group that does not bid.
  await joinInterestGroup(
    test, uuid,
    { name: uuid,
      biddingLogicURL: createBiddingScriptURL(
        { generateBid: 'return;' })
    });
  await runBasicFledgeTestExpectingNoWinner(test, uuid);

  // Check that "prevWinsMs" was not modified.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });
  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs not updated when no bid.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  let bidderReportURL = createBidderReportURL(uuid, /*id=*/'winner');

  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createBiddingScriptURL(
          { bid: 42, reportWin: `sendReportTo('${createBidderReportURL(uuid, /*id=*/'loser')}')` })
      });

  // Join an interest group with the default name, which will bid 1 and win the first
  // auction, sending a bidder report.
  await joinInterestGroup(
      test, uuid,
      { biddingLogicURL: createBiddingScriptURL(
          { bid: 1, reportWin: `sendReportTo('${bidderReportURL}')` })
      });

  // Run an auction that both bidders participate in. The scoreAd script returns a low
  // score for the first interest group's bid.
  await runBasicFledgeAuctionAndNavigate(
      test, uuid,
      { decisionLogicURL: createDecisionScriptURL(
          uuid,
          { scoreAd: `if (bid === 42) return 0.1;`})});
  // Make sure the second interest group won.
  await waitForObservedRequests(uuid, [bidderReportURL]);

  // Leave the second interest group (which has the default name).
  await leaveInterestGroup();

  // Re-join the first interest group, with a bidding script that expects prevWinsMs to
  // be empty.
  await joinInterestGroup(
      test, uuid,
      { name: uuid,
        biddingLogicURL: createPrevWinsMsBiddingScriptURL([])
      });

  await runBasicFledgeTestExpectingWinner(test, uuid);
}, 'browserSignals.prevWinsMs not updated when makes largest bid, but another interest group wins.');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);

  // Join an interest group with a WASM helper that exposes a single "increment" method,
  // and make sure that method can be invoked and behaves as expected.
  await joinGroupAndRunBasicFledgeTestExpectingWinner(
    test,
    { uuid: uuid,
      interestGroupOverrides: {
          biddingWasmHelperURL: `${RESOURCE_PATH}wasm-helper.py`,
          biddingLogicURL: createBiddingScriptURL(
            { generateBid:
                `if (!browserSignals.wasmHelper)
                   throw "No WASM helper";

                 let instance = new WebAssembly.Instance(browserSignals.wasmHelper);
                 if (!instance)
                   throw "Couldn't create WASM Instance";

                 if (!deepEquals(Object.keys(instance.exports), ["increment"]))
                   throw "Unexpected exports: " + JSON.stringify(instance.exports);

                 if (instance.exports.increment(1) !== 2)
                   throw "Unexpected increment result: " + instance.exports.increment(1);` })
      }
    });
}, 'browserSignals.wasmHelper.');


// Generates 0 or 1 clicks, dependent on `produceAttributionSrc` &
// `produceUserAction`, and `numViews` views for `igOwner`, provided by
// `viewClickProvider`.
async function generateViewsAndClicks(
    test, uuid, viewClickProvider, igOwner, numViews, produceAttributionSrc,
    produceUserAction) {
  let iframe = await createIframe(test, viewClickProvider);
  let script = `
    // We use a wrapper iframe here so the original remains in communication.
    let frame = document.createElement('iframe');
    document.body.appendChild(frame);
    let frameDocument = frame.contentDocument;
    let a = frameDocument.createElement('a');
    a.href = '${RESOURCE_PATH}/record-click.py?' +
        'eligible_origin=${igOwner}&num_views=${numViews}';
    if (${produceAttributionSrc}) {
      a.attributionSrc = '';
    }
    a.target = '_self';
    a.appendChild(frameDocument.createTextNode('Click me'));
    frameDocument.body.appendChild(a);

    if (${produceUserAction}) {
      // Note: test_driver.click() seems to not work well with Chrome's
      // content_shell; while .bless() does... unreliably.
      // headless_shell/chrome path seems to work reliably. User activation
      // is used sparingly to work around content_shell flakiness.
      await test_driver.bless('User-initiated click', () => { a.click() });
    } else {
      a.click();
    }
  `;

  await runInFrame(test, iframe, script);
}

// Keep running a basic auction with an interest group in
// `interestGroupOverrides` until it succeeds; joining and leaving the
// IG every time to bypass caching which is permitted to provide stale
// view/click counts.
async function keepTryingAuctionUntilWinBypassCaching(
    test, uuid, interestGroupOverrides) {
  while (true) {
    await joinInterestGroup(test, uuid, interestGroupOverrides);
    let result = await runBasicFledgeAuction(test, uuid);
    if (result !== null) {  // Got a winner.
      break;
    }
    await leaveInterestGroup(interestGroupOverrides);
  }
}

// Like keepTryingAuctionUntilWinBypassCaching but for auctions with
// cross-origin interest group, owned by `igOwner`.
async function crossOriginKeepTryingAuctionUntilWinBypassCaching(
    test, uuid, igOwner, interestGroupOverrides) {
  while (true) {
    await joinCrossOriginInterestGroup(
        test, uuid, igOwner, interestGroupOverrides);
    const auctionConfigOverrides = {interestGroupBuyers: [igOwner]};
    let result =
        await runBasicFledgeAuction(test, uuid, auctionConfigOverrides);
    if (result !== null) {  // Got a winner.
      break;
    }
    await leaveCrossOriginInterestGroup(
        test, uuid, igOwner, interestGroupOverrides);
  }
}

// Generates `numViews` views and 0 or 1 clicks based on `produceAttributionSrc`
// and `produceUserAction`, by `viewClickProvider` available to `igOwner`, then
// creates an interest group for `igOwner` with given
// `viewAndClickCountsProviders`, and runs an auction
// to make sure the events are eventually available.
async function testClickiness(
    test, igOwner, viewClickProvider, numViews, produceAttributionSrc,
    produceUserAction, viewAndClickCountsProviders = undefined) {
  const uuid = generateUuid(test);

  await generateViewsAndClicks(
      test, uuid, viewClickProvider, igOwner, numViews, produceAttributionSrc,
      produceUserAction);

  // For clicks to be recorded, both attributionsrc attribution must exist
  // and a user action must be used. If we don't expect clicks, we can expect
  // that the number is exactly 0 since re-running the test won't break that.
  //
  // This is relying on all tests using Ad-Auction-Record-Event using distinct
  // `viewClickProvider`s.
  let clicksBadTest =
      produceAttributionSrc && produceUserAction ? '< 1' : ' !== 0';

  let viewsBadTest = (numViews > 0) ? `< ${numViews}` : ' !== 0';

  // Join an IG to read view/click info back. We use a UUID for a name to make
  // sure nothing old is cached, since view/clicks are permitted to be a bit
  // stale.
  let interestGroupOverrides = {
    owner: igOwner,
    name: uuid,
    biddingLogicURL: createBiddingScriptURL({
      origin: igOwner,
      generateBid: `
        // We should see at least one click and numViews views the test injects.
        if (browserSignals.clickCounts.pastHour ${clicksBadTest} ||
            browserSignals.clickCounts.pastDay ${clicksBadTest} ||
            browserSignals.clickCounts.pastWeek ${clicksBadTest} ||
            browserSignals.clickCounts.past30Days ${clicksBadTest} ||
            browserSignals.clickCounts.past90Days ${clicksBadTest} ||
            browserSignals.viewCounts.pastHour ${viewsBadTest} ||
            browserSignals.viewCounts.pastDay ${viewsBadTest} ||
            browserSignals.viewCounts.pastWeek ${viewsBadTest} ||
            browserSignals.viewCounts.past30Days ${viewsBadTest} ||
            browserSignals.viewCounts.past90Days ${viewsBadTest}) {
          return -1;
        }
    `
    })
  };

  if (viewAndClickCountsProviders) {
    interestGroupOverrides.viewAndClickCountsProviders =
        viewAndClickCountsProviders;
  }

  await crossOriginKeepTryingAuctionUntilWinBypassCaching(
      test, uuid, igOwner, interestGroupOverrides);
}

subsetTest(promise_test, async test => {
  const IG_OWNER = OTHER_ORIGIN5;
  const VIEW_CLICK_PROVIDER = OTHER_ORIGIN6;
  await testClickiness(
      test, IG_OWNER, VIEW_CLICK_PROVIDER, /*numViews=*/ 2,
      /*produceAttributionSrc=*/ true,
      /*produceUserAction=*/ true, [VIEW_CLICK_PROVIDER]);
}, 'browserSignals for clickiness.');

subsetTest(promise_test, async test => {
  const IG_OWNER = OTHER_ORIGIN5;
  const VIEW_CLICK_PROVIDER = OTHER_ORIGIN5;

  await testClickiness(
      test, IG_OWNER, VIEW_CLICK_PROVIDER, /*numViews=*/ 4,
      /*produceAttributionSrc=*/ false,
      /*produceUserAction=*/ false);
}, 'IG owner is default clickiness provider if nothing is specified');

subsetTest(promise_test, async test => {
  const IG_OWNER = OTHER_ORIGIN4;
  const VIEW_CLICK_PROVIDER = OTHER_ORIGIN4;

  await testClickiness(
      test, IG_OWNER, VIEW_CLICK_PROVIDER, /*numViews=*/ 6,
      /*produceAttributionSrc=*/ true,
      /*produceUserAction=*/ true, []);
}, 'IG owner is default clickiness provider if empty list provided');

subsetTest(promise_test, async test => {
  const IG_OWNER = OTHER_ORIGIN3;
  const VIEW_CLICK_PROVIDER = OTHER_ORIGIN3;

  await testClickiness(
      test, IG_OWNER, VIEW_CLICK_PROVIDER, /*numViews=*/ 0,
      /*produceAttributionSrc=*/ true,
      /*produceUserAction=*/ true, []);
}, 'browserSignals for clickiness --- just a click');

subsetTest(promise_test, async test => {
  const IG_OWNER = OTHER_ORIGIN2;
  const VIEW_CLICK_PROVIDER = OTHER_ORIGIN2;

  await testClickiness(
      test, IG_OWNER, VIEW_CLICK_PROVIDER, /*numViews=*/ 1,
      /*produceAttributionSrc=*/ true,
      /*produceUserAction=*/ false, [VIEW_CLICK_PROVIDER]);
}, 'browserSignals for clickiness --- no click report w/o user action');

subsetTest(promise_test, async test => {
  const uuid = generateUuid(test);
  const IG_OWNER = window.location.origin;
  const VIEW_CLICK_PROVIDER1 = OTHER_ORIGIN1;
  const VIEW_CLICK_PROVIDER2 = window.location.origin;

  // From provider 1 have click, no views.
  // From provider 2 have views, no clicks;
  await generateViewsAndClicks(
      test, uuid, VIEW_CLICK_PROVIDER1, IG_OWNER,
      /*numViews=*/ 0, /*produceAttributionSrc=*/ true,
      /*produceUserAction=*/ true);
  await generateViewsAndClicks(
      test, uuid, VIEW_CLICK_PROVIDER2, IG_OWNER,
      /*numViews=*/ 2, /*produceAttributionSrc=*/ false,
      /*produceUserAction=*/ false);

  // Create an IG that subscribes only to provider 2 --- it should only see
  // the views.
  let interestGroupOverrides = {
    name: uuid,
    viewAndClickCountsProviders: [VIEW_CLICK_PROVIDER2],
    biddingLogicURL: createBiddingScriptURL({
      generateBid: `
        if (browserSignals.clickCounts.pastHour !== 0 ||
            browserSignals.viewCounts.pastHour < 2) {
          throw JSON.stringify(browserSignals);
        }
    `
    })
  };

  await keepTryingAuctionUntilWinBypassCaching(
      test, uuid, interestGroupOverrides);

  // Now see that subscribing only to 1 provides only the click.
  interestGroupOverrides = {
    name: uuid,
    viewAndClickCountsProviders: [VIEW_CLICK_PROVIDER1],
    biddingLogicURL: createBiddingScriptURL({
      generateBid: `
        if (browserSignals.clickCounts.pastHour < 1 ||
            browserSignals.viewCounts.pastHour !== 0) {
          throw JSON.stringify(browserSignals);
        }
    `
    })
  };

  await keepTryingAuctionUntilWinBypassCaching(
      test, uuid, interestGroupOverrides);

  // Now subscribe to both.
  interestGroupOverrides = {
    name: uuid,
    viewAndClickCountsProviders: [VIEW_CLICK_PROVIDER1, VIEW_CLICK_PROVIDER2],
    biddingLogicURL: createBiddingScriptURL({
      generateBid: `
        if (browserSignals.clickCounts.pastHour < 1 ||
            browserSignals.viewCounts.pastHour < 2) {
          throw JSON.stringify(browserSignals);
        }
    `
    })
  };

  await keepTryingAuctionUntilWinBypassCaching(
      test, uuid, interestGroupOverrides);
}, 'browserSignals for clickiness --- viewAndClickCountsProviders works.');