[FLEDGE] Split up runs of /trusted-scoring-signals.https.sub.window.html

These WPT tests are timing out.  It looks like the issue is test
duration, rather than a hangs, so split the test into "variants"
using the "META: variant=?..." WPT feature and the subsetTest()
helper to make mutliple runs that each only execute some of the
tests.

Bug: 1481290
Change-Id: Ib716ad53b4c563329854ddcd548820fe9721f735
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4858926
Reviewed-by: Maks Orlovich <morlovich@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1196034}

fledge/tentative/resources/fledge-util.js

@@ -353,8 +353,6 @@ async function runReportTest(test, uuid, codeToInsert, expectedReportURLs,
   await joinInterestGroup(test, uuid, interestGroupOverrides);
   await runBasicFledgeAuctionAndNavigate(
       test, uuid,
-    {
-      decisionLogicURL: createDecisionScriptURL(
-                              uuid, decisionScriptURLParams) });
+      { decisionLogicURL: createDecisionScriptURL(uuid, decisionScriptURLParams) });
   await waitForObservedRequests(uuid, expectedReportURLs);
 }

fledge/tentative/trusted-scoring-signals.https.sub.window.js

@@ -1,7 +1,13 @@
 // META: script=/resources/testdriver.js
 // META: script=/common/utils.js
 // META: script=resources/fledge-util.js
+// META: script=/common/subset-tests.js
 // META: timeout=long
+// META: variant=?1-10
+// META: variant=?11-20
+// META: variant=?21-30
+// META: variant=?31-40
+// META: variant=?41-last
 
 "use strict";
 
@@ -81,7 +87,7 @@ function createScoringSignalsRenderUrlWithBody(uuid, responseBody) {
 // Tests where no renderURL value is received for the passed in renderURL.
 /////////////////////////////////////////////////////////////////////////////
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const decisionLogicScriptUrl = createDecisionScriptURL(
       uuid,
@@ -93,79 +99,79 @@ promise_test(async test => {
       });
 }, 'No trustedScoringSignalsURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'close-connection');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       'trustedScoringSignals === null');
 }, 'Trusted scoring signals closes the connection without sending anything.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'http-error');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response is HTTP 404 error.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'no-content-type');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response has no content-type.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'wrong-content-type');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response has wrong content-type.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'ad-auction-not-allowed');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response does not allow FLEDGE.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'bad-ad-auction-allowed');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response has wrong Ad-Auction-Allowed header.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'no-ad-auction-allow');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response has no Ad-Auction-Allowed header.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
       uuid, /*responseBody=*/'');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response has no body.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
       uuid, /*responseBody=*/'Not JSON');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response is not JSON.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
       uuid, /*responseBody=*/'[]');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response is a JSON array.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
       uuid, /*responseBody=*/'{JSON_keys_need_quotes: 1}');
   await runTrustedScoringSignalsTest(test, uuid, renderURL, 'trustedScoringSignals === null');
 }, 'Trusted scoring signals response is invalid JSON object.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
       uuid, /*responseBody=*/'{}');
@@ -174,15 +180,15 @@ promise_test(async test => {
       `trustedScoringSignals.renderURL["${renderURL}"] === null`);
 }, 'Trusted scoring signals response has no renderURL object.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'no-value');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       `trustedScoringSignals.renderURL["${renderURL}"] === null`);
 }, 'Trusted scoring signals response has no renderURLs.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'wrong-url');
   await runTrustedScoringSignalsTest(
@@ -195,23 +201,23 @@ promise_test(async test => {
 // Tests where renderURL value is received for the passed in renderURL.
 /////////////////////////////////////////////////////////////////////////////
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'null-value');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       `trustedScoringSignals.renderURL["${renderURL}"] === null`);
 }, 'Trusted scoring signals response has null value for renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'num-value');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       `trustedScoringSignals.renderURL["${renderURL}"] === 1`);
 }, 'Trusted scoring signals response has a number value for renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null,
       /*signalsParam=*/'string-value');
@@ -220,15 +226,15 @@ promise_test(async test => {
       `trustedScoringSignals.renderURL["${renderURL}"] === "1"`);
 }, 'Trusted scoring signals response has a string value for renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'array-value');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       `JSON.stringify(trustedScoringSignals.renderURL["${renderURL}"]) === '[1,"foo",null]'`);
 }, 'Trusted scoring signals response has an array value for renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'object-value');
   await runTrustedScoringSignalsTest(
@@ -238,15 +244,15 @@ promise_test(async test => {
        JSON.stringify(trustedScoringSignals.renderURL["${renderURL}"]["c"]) === '["d"]'`);
 }, 'Trusted scoring signals response has an object value for renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'+%20 \x00?,3#&');
   await runTrustedScoringSignalsTest(
       test, uuid, renderURL,
       `trustedScoringSignals.renderURL["${renderURL}"] === "default value"`);
 }, 'Trusted scoring signals with escaped renderURL.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'hostname');
   await runTrustedScoringSignalsTest(
@@ -261,7 +267,7 @@ promise_test(async test => {
 // render URLs from two different IGs, though that's the case this is trying to test -
 // browsers are not required to support batching, and even if they do, joining any two
 // particular requests may be racy.
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL1 = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'num-value');
   const renderURL2 = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'string-value');
@@ -298,111 +304,111 @@ promise_test(async test => {
 // Data-Version tests
 /////////////////////////////////////////////////////////////////////////////
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid);
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has no Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:3');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === 3');
 }, 'Trusted scoring signals response has valid Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:0');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === 0');
 }, 'Trusted scoring signals response has min Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:4294967295');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === 4294967295');
 }, 'Trusted scoring signals response has max Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:4294967296');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has too large Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:03');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has data-version with leading 0.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:-1');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has negative Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:1.3');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has decimal in Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:2 2');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has space in Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:0x4');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has hex Data-Version.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:3,replace-body:');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has data-version and empty body.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:3,replace-body:[]');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has data-version and JSON array body.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:3,replace-body:{} {}');
   await runTrustedScoringSignalsDataVersionTest(
       test, uuid, renderURL,
       'browserSignals.dataVersion === undefined');
 }, 'Trusted scoring signals response has data-version and double JSON object body.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, 'data-version:3,replace-body:{}');
   await runTrustedScoringSignalsDataVersionTest(
@@ -414,7 +420,7 @@ promise_test(async test => {
 // Trusted scoring signals + component ad tests.
 /////////////////////////////////////////////////////////////////////////////
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'close-connection');
   const componentURL = createRenderURL(uuid, /*script=*/null);
@@ -429,7 +435,7 @@ promise_test(async test => {
       });
 }, 'Component ads trusted scoring signals, server closes the connection without sending anything.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'num-value');
   // This should not be sent. If it is, it will take precedence over the "num-value" parameter
@@ -444,7 +450,7 @@ promise_test(async test => {
       { adComponents: [{ renderURL: componentURL }] });
 }, 'Trusted scoring signals request without component ads in bid.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createScoringSignalsRenderUrlWithBody(
     uuid, /*responseBody=*/'{}');
@@ -463,7 +469,7 @@ promise_test(async test => {
       });
 }, 'Component ads trusted scoring signals trusted scoring signals response is empty JSON object.');
 
-promise_test(async test => {
+subsetTest(promise_test, async test => {
   const uuid = generateUuid(test);
   const renderURL = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'hostname');
   const componentURL1 = createRenderURL(uuid, /*script=*/null, /*signalsParam=*/'null-value');