tor-browser

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

test_transport_bulk.js (4393B)

      1 /* Any copyright is dedicated to the Public Domain.
      2   http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 "use strict";
      5 
      6 var { FileUtils } = ChromeUtils.importESModule(
      7  "resource://gre/modules/FileUtils.sys.mjs"
      8 );
      9 
     10 function run_test() {
     11  initTestDevToolsServer();
     12 
     13  add_task(async function () {
     14    await test_bulk_transfer_transport(socket_transport);
     15    await test_bulk_transfer_transport(local_transport);
     16    DevToolsServer.destroy();
     17  });
     18 
     19  run_next_test();
     20 }
     21 
     22 /*** Tests ***/
     23 
     24 /**
     25 * This tests a one-way bulk transfer at the transport layer.
     26 */
     27 var test_bulk_transfer_transport = async function (transportFactory) {
     28  info("Starting bulk transfer test at " + new Date().toTimeString());
     29 
     30  let clientResolve;
     31  const clientDeferred = new Promise(resolve => {
     32    clientResolve = resolve;
     33  });
     34 
     35  let serverResolve;
     36  const serverDeferred = new Promise(resolve => {
     37    serverResolve = resolve;
     38  });
     39 
     40  // Ensure test files are not present from a failed run
     41  cleanup_files();
     42  const reallyLong = really_long();
     43  writeTestTempFile("bulk-input", reallyLong);
     44 
     45  Assert.equal(Object.keys(DevToolsServer._connections).length, 0);
     46 
     47  const transport = await transportFactory();
     48 
     49  // Sending from client to server
     50  function write_data({ copyFrom }) {
     51    NetUtil.asyncFetch(
     52      {
     53        uri: NetUtil.newURI(getTestTempFile("bulk-input")),
     54        loadUsingSystemPrincipal: true,
     55      },
     56      function (input) {
     57        copyFrom(input).then(() => {
     58          input.close();
     59        });
     60      }
     61    );
     62  }
     63 
     64  // Receiving on server from client
     65  function on_bulk_packet({ actor, type, length, copyTo }) {
     66    Assert.equal(actor, "root");
     67    Assert.equal(type, "file-stream");
     68    Assert.equal(length, reallyLong.length);
     69 
     70    const outputFile = getTestTempFile("bulk-output", true);
     71    outputFile.create(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("666", 8));
     72 
     73    const output = FileUtils.openSafeFileOutputStream(outputFile);
     74 
     75    copyTo(output)
     76      .then(() => {
     77        FileUtils.closeSafeFileOutputStream(output);
     78        return verify();
     79      })
     80      .then(() => {
     81        // It's now safe to close
     82        transport.hooks.onTransportClosed = () => {
     83          clientResolve();
     84        };
     85        transport.close();
     86      });
     87  }
     88 
     89  // Client
     90  transport.hooks = {
     91    onPacket(packet) {
     92      // We've received the initial start up packet
     93      Assert.equal(packet.from, "root");
     94 
     95      // Server
     96      Assert.equal(Object.keys(DevToolsServer._connections).length, 1);
     97      info(Object.keys(DevToolsServer._connections));
     98      for (const connId in DevToolsServer._connections) {
     99        DevToolsServer._connections[connId].onBulkPacket = on_bulk_packet;
    100      }
    101 
    102      DevToolsServer.on("connectionchange", type => {
    103        if (type === "closed") {
    104          serverResolve();
    105        }
    106      });
    107 
    108      transport
    109        .startBulkSend({
    110          actor: "root",
    111          type: "file-stream",
    112          length: reallyLong.length,
    113        })
    114        .then(write_data);
    115    },
    116 
    117    onTransportClosed() {
    118      do_throw("Transport closed before we expected");
    119    },
    120  };
    121 
    122  transport.ready();
    123 
    124  return Promise.all([clientDeferred, serverDeferred]);
    125 };
    126 
    127 /*** Test Utils ***/
    128 
    129 function verify() {
    130  const reallyLong = really_long();
    131 
    132  const inputFile = getTestTempFile("bulk-input");
    133  const outputFile = getTestTempFile("bulk-output");
    134 
    135  Assert.equal(inputFile.fileSize, reallyLong.length);
    136  Assert.equal(outputFile.fileSize, reallyLong.length);
    137 
    138  // Ensure output file contents actually match
    139  return new Promise(resolve => {
    140    NetUtil.asyncFetch(
    141      {
    142        uri: NetUtil.newURI(getTestTempFile("bulk-output")),
    143        loadUsingSystemPrincipal: true,
    144      },
    145      input => {
    146        const outputData = NetUtil.readInputStreamToString(
    147          input,
    148          reallyLong.length
    149        );
    150        // Avoid Assert.strictEqual here so we don't log the contents
    151        // eslint-disable-next-line mozilla/no-comparison-or-assignment-inside-ok
    152        Assert.ok(outputData === reallyLong);
    153        input.close();
    154        resolve();
    155      }
    156    );
    157  }).then(cleanup_files);
    158 }
    159 
    160 function cleanup_files() {
    161  const inputFile = getTestTempFile("bulk-input", true);
    162  if (inputFile.exists()) {
    163    inputFile.remove(false);
    164  }
    165 
    166  const outputFile = getTestTempFile("bulk-output", true);
    167  if (outputFile.exists()) {
    168    outputFile.remove(false);
    169  }
    170 }