gecko-dev/dom/tests/unit/test_Fetch.js

/* Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

Cu.importGlobalProperties(["fetch"]);
const {HttpServer} = ChromeUtils.import("resource://testing-common/httpd.js");

const BinaryInputStream = Components.Constructor("@mozilla.org/binaryinputstream;1",
  "nsIBinaryInputStream", "setInputStream");

var server;

function getBaseUrl() {
  return "http://localhost:" + server.identity.primaryPort;
}

// a way to create some test defaults
function createTestData(testPath) {
  return {
    testPath,
    request: {
      headers: {},
      contentType: "application/json",
    },
    response: {
      headers: {},
      contentType: "application/json",
      body: "{\"Look\": \"Success!\"}",
      status: 200,
      statusText: "OK",
    },
  };
}

// read body and content type information from a request
function readDataFromRequest(aRequest) {
  let requestData = {};
  if (aRequest.method == "POST" || aRequest.method == "PUT") {
    if (aRequest.bodyInputStream) {
      let inputStream = new BinaryInputStream(aRequest.bodyInputStream);
      let bytes = [];
      let available;

      while ((available = inputStream.available()) > 0) {
        Array.prototype.push.apply(bytes, inputStream.readByteArray(available));
      }

      requestData.body = String.fromCharCode.apply(null, bytes);
      requestData.contentType = aRequest.getHeader("Content-Type");
    }
  }
  return requestData;
}

// write status information, content type information and body to a response
function writeDataToResponse(aData, aResponse) {
  aResponse.setStatusLine(null, aData.status, aData.statusText);
  aResponse.setHeader("Content-Type", aData.contentType);
  for (let header in aData.headers) {
    aResponse.setHeader(header, aData.headers[header]);
  }
  aResponse.write(aData.body);
}

// test some GET functionality
add_test(function test_GetData() {
  do_test_pending();

  let testData = createTestData("/getData");

  // set up some headers to test
  let headerNames = ["x-test-header", "x-other-test-header"];
  for (let headerName of headerNames) {
    testData.request.headers[headerName] = "test-value-for-" + headerName;
  }

  server.registerPathHandler(testData.testPath, function(aRequest, aResponse) {
    try {
      // check our request headers made it OK
      for (let headerName of headerNames) {
        Assert.equal(testData.request.headers[headerName],
                     aRequest.getHeader(headerName));
      }

      // send a response
      writeDataToResponse(testData.response, aResponse);
    } catch (e) {
      do_report_unexpected_exception(e);
    }
  });

  // fetch, via GET, with some request headers set
  fetch(getBaseUrl() + testData.testPath, {headers: testData.request.headers})
    .then(function(response) {
    // check response looks as expected
    Assert.ok(response.ok);
    Assert.equal(response.status, testData.response.status);
    Assert.equal(response.statusText, testData.response.statusText);

    // check a response header looks OK:
    Assert.equal(response.headers.get("Content-Type"),
                 testData.response.contentType);

    // ... and again to check header names are case insensitive
    Assert.equal(response.headers.get("content-type"),
                 testData.response.contentType);

    // ensure response.text() returns a promise that resolves appropriately
    response.text().then(function(text) {
      Assert.equal(text, testData.response.body);
      do_test_finished();
      run_next_test();
    });
  }).catch(function(e) {
    do_report_unexpected_exception(e);
    do_test_finished();
    run_next_test();
  });
});

// test a GET with no init
add_test(function test_GetDataNoInit() {
  do_test_pending();

  let testData = createTestData("/getData");

  server.registerPathHandler(testData.testPath, function(aRequest, aResponse) {
    try {
      // send a response
      writeDataToResponse(testData.response, aResponse);
    } catch (e) {
      do_report_unexpected_exception(e);
    }
  });

  fetch(getBaseUrl() + testData.testPath, {headers: testData.request.headers})
    .then(function(response) {
    // check response looks as expected
    Assert.ok(response.ok);
    Assert.equal(response.status, testData.response.status);

    // ensure response.text() returns a promise that resolves appropriately
    response.text().then(function(text) {
      Assert.equal(text, testData.response.body);
      do_test_finished();
      run_next_test();
    });
  }).catch(function(e) {
    do_report_unexpected_exception(e);
    do_test_finished();
    run_next_test();
  });
});

// test some error responses
add_test(function test_get40x() {
  do_test_pending();

  // prepare a response with some 40x error - a 404 will do
  let notFoundData = createTestData("/getNotFound");
  notFoundData.response.status = 404;
  notFoundData.response.statusText = "Not found";
  notFoundData.response.body = null;

  // No need to register a path handler - httpd will return 404 anyway.
  // Fetch, via GET, the resource that doesn't exist
  fetch(getBaseUrl() + notFoundData.testPath).then(function(response) {
    Assert.equal(response.status, 404);
    do_test_finished();
    run_next_test();
  });
});

add_test(function test_get50x() {
  do_test_pending();

  // prepare a response with some server error - a 500 will do
  let serverErrorData = createTestData("/serverError");
  serverErrorData.response.status = 500;
  serverErrorData.response.statusText = "The server broke";
  serverErrorData.response.body = null;

  server.registerPathHandler(serverErrorData.testPath,
                             function(aRequest, aResponse) {
    try {
      // send the error response
      writeDataToResponse(serverErrorData.response, aResponse);
    } catch (e) {
      do_report_unexpected_exception(e);
    }
  });

  // fetch, via GET, the resource that creates a server error
  fetch(getBaseUrl() + serverErrorData.testPath).then(function(response) {
    Assert.equal(response.status, 500);
    do_test_finished();
    run_next_test();
  });
});

// test a failure to connect
add_test(function test_getTestFailedConnect() {
  do_test_pending();
  // try a server that's not there
  fetch("http://localhost:4/should/fail").then(response => {
    do_throw("Request should not succeed");
  }).catch(err => {
    Assert.equal(true, err instanceof TypeError);
    do_test_finished();
    run_next_test();
  });
});

add_test(function test_mozError() {
  do_test_pending();
  // try a server that's not there
  fetch("http://localhost:4/should/fail", { mozErrors: true }).then(response => {
    do_throw("Request should not succeed");
  }).catch(err => {
    Assert.equal(err.result, Cr.NS_ERROR_CONNECTION_REFUSED);
    do_test_finished();
    run_next_test();
  });
});

add_test(function test_request_mozError() {
  do_test_pending();
  // try a server that's not there
  const r = new Request("http://localhost:4/should/fail", { mozErrors: true });
  fetch(r).then(response => {
    do_throw("Request should not succeed");
  }).catch(err => {
    Assert.equal(err.result, Cr.NS_ERROR_CONNECTION_REFUSED);
    do_test_finished();
    run_next_test();
  });
});

// test POSTing some JSON data
add_test(function test_PostJSONData() {
  do_test_pending();

  let testData = createTestData("/postJSONData");
  testData.request.body = "{\"foo\": \"bar\"}";

  server.registerPathHandler(testData.testPath, function(aRequest, aResponse) {
    try {
      let requestData = readDataFromRequest(aRequest);

      // Check the request body is OK
      Assert.equal(requestData.body, testData.request.body);

      // Check the content type is as expected
      Assert.equal(requestData.contentType, testData.request.contentType);

      writeDataToResponse(testData.response, aResponse);
    } catch (e) {
      Assert.ok(false);
    }
  });

  fetch(getBaseUrl() + testData.testPath, {
    method: "POST",
    body: testData.request.body,
    headers: {
      "Content-Type": "application/json",
    },
  }).then(function(aResponse) {
    Assert.ok(aResponse.ok);
    Assert.equal(aResponse.status, testData.response.status);
    Assert.equal(aResponse.statusText, testData.response.statusText);

    do_test_finished();
    run_next_test();
  }).catch(function(e) {
    do_report_unexpected_exception(e);
    do_test_finished();
    run_next_test();
  });
});

// test POSTing some text
add_test(function test_PostTextData() {
  do_test_pending();

  let testData = createTestData("/postTextData");
  testData.request.body = "A plain text body";
  testData.request.contentType = "text/plain";
  let responseHeaderName = "some-response-header";
  testData.response.headers[responseHeaderName] = "some header value";

  server.registerPathHandler(testData.testPath, function(aRequest, aResponse) {
    try {
      let requestData = readDataFromRequest(aRequest);

      // Check the request body is OK
      Assert.equal(requestData.body, testData.request.body);

      // Check the content type is as expected
      Assert.equal(requestData.contentType, testData.request.contentType);

      writeDataToResponse(testData.response, aResponse);
    } catch (e) {
      Assert.ok(false);
    }
  });

  fetch(getBaseUrl() + testData.testPath, {
    method: "POST",
    body: testData.request.body,
    headers: {
      "Content-Type": testData.request.contentType,
    },
  }).then(function(aResponse) {
    Assert.ok(aResponse.ok);
    Assert.equal(aResponse.status, testData.response.status);
    Assert.equal(aResponse.statusText, testData.response.statusText);

    // check the response header is set OK
    Assert.equal(aResponse.headers.get(responseHeaderName),
                 testData.response.headers[responseHeaderName]);

    do_test_finished();
    run_next_test();
  }).catch(function(e) {
    do_report_unexpected_exception(e);
    do_test_finished();
    run_next_test();
  });
});

function run_test() {
  // Set up an HTTP Server
  server = new HttpServer();
  server.start(-1);

  run_next_test();

  registerCleanupFunction(function() {
    server.stop(function() { });
  });
}