third_party/web_platform_tests/fetch/api/request/request-disturbed.html

<!doctype html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Request disturbed</title>
    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
    <meta name="help" href="https://fetch.spec.whatwg.org/#body-mixin">
    <meta name="author" title="Canon Research France" href="https://www.crf.canon.fr">
    <script src="/resources/testharness.js"></script>
    <script src="/resources/testharnessreport.js"></script>
  </head>
  <body>
    <script>
      var initValuesDict = {"method" : "POST",
                            "body" : "Request's body"
      };

      var noBodyConsumed = new Request("");
      var bodyConsumed = new Request("", initValuesDict);

      test(() => {
        assert_equals(noBodyConsumed.body, null, "body's default value is null");
        assert_false(noBodyConsumed.bodyUsed , "bodyUsed is false when request is not disturbed");
        assert_not_equals(bodyConsumed.body, null, "non-null body");
        assert_true(bodyConsumed.body instanceof ReadableStream, "non-null body type");
        assert_false(noBodyConsumed.bodyUsed, "bodyUsed is false when request is not disturbed");
      }, "Request's body: initial state");

      noBodyConsumed.blob();
      bodyConsumed.blob();

      test(function() {
        assert_false(noBodyConsumed.bodyUsed , "bodyUsed is false when request is not disturbed");
        try {
          noBodyConsumed.clone();
        } catch (e) {
          assert_unreached("Can use request not disturbed for creating or cloning request");
        }
      }, "Request without body cannot be disturbed");

      test(function() {
        assert_true(bodyConsumed.bodyUsed , "bodyUsed is true when request is disturbed");
        assert_throws(new TypeError(), function() { bodyConsumed.clone(); });
      }, "Check cloning a disturbed request");

      test(function() {
        assert_true(bodyConsumed.bodyUsed , "bodyUsed is true when request is disturbed");
        assert_throws(new TypeError(), function() { new Request(bodyConsumed); });
      }, "Check creating a new request from a disturbed request");

      promise_test(function() {
        var bodyRequest = new Request("", initValuesDict);
        const originalBody = bodyRequest.body;
        assert_false(bodyRequest.bodyUsed , "bodyUsed is false when request is not disturbed");
        var requestFromRequest = new Request(bodyRequest);
        assert_true(bodyRequest.bodyUsed , "bodyUsed is true when request is disturbed");
        assert_equals(bodyRequest.body, originalBody, "body should not change");
        assert_not_equals(originalBody, undefined, "body should not be undefined");
        assert_not_equals(originalBody, null, "body should not be null");
        assert_not_equals(requestFromRequest.body, originalBody, "new request's body is new");
        return requestFromRequest.text(text => {
          assert_equals(text, "Request's body");
        });
      }, "Input request used for creating new request became disturbed");

      promise_test(() => {
        const bodyRequest = new Request("", initValuesDict);
        const originalBody = bodyRequest.body;
        assert_false(bodyRequest.bodyUsed , "bodyUsed is false when request is not disturbed");
        const requestFromRequest = new Request(bodyRequest, { body : "init body" });
        assert_true(bodyRequest.bodyUsed , "bodyUsed is true when request is disturbed");
        assert_equals(bodyRequest.body, originalBody, "body should not change");
        assert_not_equals(originalBody, undefined, "body should not be undefined");
        assert_not_equals(originalBody, null, "body should not be null");
        assert_not_equals(requestFromRequest.body, originalBody, "new request's body is new");

        return requestFromRequest.text(text => {
          assert_equals(text, "init body");
        });
      }, "Input request used for creating new request became disturbed even if body is not used");

      promise_test(function(test) {
        assert_true(bodyConsumed.bodyUsed , "bodyUsed is true when request is disturbed");
        return promise_rejects(test, new TypeError(), bodyConsumed.blob());
      }, "Check consuming a disturbed request");

      test(function() {
        var req = new Request(URL, {method: 'POST', body: 'hello'});
        assert_false(req.bodyUsed,
                     'Request should not be flagged as used if it has not been ' +
                     'consumed.');
        assert_throws(new TypeError(),
          function() { new Request(req, {method: 'GET'}); },
          'A get request may not have body.');

        assert_false(req.bodyUsed, 'After the GET case');

        assert_throws(new TypeError(),
          function() { new Request(req, {method: 'CONNECT'}); },
          'Request() with a forbidden method must throw.');

        assert_false(req.bodyUsed, 'After the forbidden method case');

        var req2 = new Request(req);
        assert_true(req.bodyUsed,
                    'Request should be flagged as used if it has been consumed.');
      }, 'Request construction failure should not set "bodyUsed"');
    </script>
  </body>
</html>