tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

send-report-to.https.window.js (5042B)

      1 // META: script=/resources/testdriver.js
      2 // META: script=/resources/testdriver-vendor.js
      3 // META: script=/common/utils.js
      4 // META: script=resources/fledge-util.sub.js
      5 // META: script=/common/subset-tests.js
      6 // META: timeout=long
      7 // META: variant=?1-5
      8 // META: variant=?6-last
      9 
     10 "use strict";
     11 
     12 subsetTest(promise_test, async test => {
     13  const uuid = generateUuid(test);
     14  await runReportTest(
     15      test, uuid,
     16      { reportResult:
     17          `sendReportTo('${createSellerReportURL(uuid)}');`,
     18        reportWinSuccessCondition:
     19          'sellerSignals === null',
     20        reportWin:
     21          `sendReportTo('${createBidderReportURL(uuid)}');` },
     22      // expectedReportURLs:
     23      [createSellerReportURL(uuid), createBidderReportURL(uuid)]
     24  );
     25 }, 'Both send reports, seller passes nothing to bidder.');
     26 
     27 subsetTest(promise_test, async test => {
     28  const uuid = generateUuid(test);
     29  await runReportTest(
     30      test, uuid,
     31      { reportResult:
     32          `sendReportTo('${createSellerReportURL(uuid)}');`,
     33        reportWin:
     34          '' },
     35      // expectedReportURLs:
     36      [createSellerReportURL(uuid)]
     37  );
     38 }, 'Only seller sends a report');
     39 
     40 subsetTest(promise_test, async test => {
     41  const uuid = generateUuid(test);
     42  await runReportTest(
     43      test, uuid,
     44      { reportResult:
     45          `sendReportTo('${createSellerReportURL(uuid)}');`,
     46        reportWin:
     47          'throw new Error("Very serious exception")' },
     48      // expectedReportURLs:
     49      [createSellerReportURL(uuid)]
     50  );
     51 }, 'Only seller sends a report, bidder throws an exception');
     52 
     53 subsetTest(promise_test, async test => {
     54  const uuid = generateUuid(test);
     55  await runReportTest(
     56      test, uuid,
     57      { reportResult:
     58          `sendReportTo('${createSellerReportURL(uuid)}');` },
     59      // expectedReportURLs:
     60      [createSellerReportURL(uuid)]
     61  );
     62 }, 'Only seller sends a report, bidder has no reportWin() method');
     63 
     64 subsetTest(promise_test, async test => {
     65  const uuid = generateUuid(test);
     66  await runReportTest(
     67      test, uuid,
     68      { reportResult:
     69          '',
     70        reportWinSuccessCondition:
     71          'sellerSignals === null',
     72        reportWin:
     73          `sendReportTo('${createBidderReportURL(uuid)}');` },
     74      // expectedReportURLs:
     75      [createBidderReportURL(uuid)]
     76  );
     77 }, 'Only bidder sends a report');
     78 
     79 subsetTest(promise_test, async test => {
     80  const uuid = generateUuid(test);
     81  await runReportTest(
     82      test, uuid,
     83      { reportResult:
     84          'return "foo";',
     85        reportWinSuccessCondition:
     86          'sellerSignals === "foo"',
     87        reportWin:
     88          `sendReportTo('${createBidderReportURL(uuid)}');` },
     89      // expectedReportURLs:
     90      [createBidderReportURL(uuid)]
     91  );
     92 }, 'Only bidder sends a report, seller passes a message to bidder');
     93 
     94 subsetTest(promise_test, async test => {
     95  const uuid = generateUuid(test);
     96  await runReportTest(
     97      test, uuid,
     98      { reportResult:
     99          'throw new Error("Very serious exception")',
    100        reportWinSuccessCondition:
    101          'sellerSignals === null',
    102        reportWin:
    103          `sendReportTo('${createBidderReportURL(uuid)}');` },
    104      // expectedReportURLs:
    105      [createBidderReportURL(uuid)]
    106  );
    107 }, 'Only bidder sends a report, seller throws an exception');
    108 
    109 subsetTest(promise_test, async test => {
    110  const uuid = generateUuid(test);
    111  await runReportTest(
    112      test, uuid,
    113      { reportWinSuccessCondition:
    114          'sellerSignals === null',
    115        reportWin:
    116          `sendReportTo('${createBidderReportURL(uuid)}');` },
    117      // expectedReportURLs:
    118      [createBidderReportURL(uuid)]
    119  );
    120 }, 'Only bidder sends a report, seller has no reportResult() method');
    121 
    122 subsetTest(promise_test, async test => {
    123  const uuid = generateUuid(test);
    124  await runReportTest(
    125      test, uuid,
    126      { reportResult:
    127          `sendReportTo('${createSellerReportURL(uuid)}');
    128           sendReportTo('${createSellerReportURL(uuid)}');
    129           return 5;`,
    130        reportWinSuccessCondition:
    131          'sellerSignals === null',
    132        reportWin:
    133          `sendReportTo('${createBidderReportURL(uuid)}');` },
    134      // expectedReportURLs:
    135      [createBidderReportURL(uuid)]
    136  );
    137 }, 'Seller calls sendReportTo() twice, which throws an exception.');
    138 
    139 subsetTest(promise_test, async test => {
    140  const uuid = generateUuid(test);
    141  await runReportTest(
    142      test, uuid,
    143      { reportResult:
    144          `sendReportTo('${createSellerReportURL(uuid)}');`,
    145        reportWin:
    146          `sendReportTo('${createBidderReportURL(uuid)}');
    147           sendReportTo('${createBidderReportURL(uuid)}');` },
    148      // expectedReportURLs:
    149      [createSellerReportURL(uuid)]
    150  );
    151  // Seller reports may be sent before bidder reports, since reportWin()
    152  // takes output from reportResult() as input. Wait to make sure the
    153  // bidder report URL really is not being requested.
    154  await new Promise(resolve => test.step_timeout(resolve, 200));
    155  await waitForObservedRequests(uuid, [createSellerReportURL(uuid)]);
    156 }, 'Bidder calls sendReportTo() twice, which throws an exception.');