Quelle  test_XHR_timeout.js

/* eslint-disable mozilla/no-comparison-or-assignment-inside-ok */

/* Notes:
   - All times are expressed in milliseconds in this test suite.
   - Test harness code is at the end of this file.
   - We generate only one request at a time, to avoid overloading the HTTP
   request handlers.
 */

var inWorker = false;
try {
  inWorker = !(self instanceof Window);
} catch (e) {
  inWorker = true;
}

function message(data) {
  if (inWorker) {
    self.postMessage(data);
  } else {
    self.postMessage(data, "*");
  }
}

function is(got, expected, msg) {
  var obj = {};
  obj.type = "is";
  obj.got = got;
  obj.expected = expected;
  obj.msg = msg;

  message(obj);
}

function ok(bool, msg) {
  var obj = {};
  obj.type = "ok";
  obj.bool = bool;
  obj.msg = msg;

  message(obj);
}

/**
 * Generate and track results from a XMLHttpRequest with regards to timeouts.
 *
 * @param {string} id         The test description.
 * @param {number} timeLimit  The initial setting for the request timeout.
 * @param {number} resetAfter (Optional) The time after sending the request, to
 *                            reset the timeout.
 * @param {number} resetTo    (Optional) The delay to reset the timeout to.
 *
 * Note: The actual testing takes place in handleEvent(event).
 * The requests are generated in startXHR().
 *
 * Note: If resetAfter and resetTo are omitted, only the initial timeout setting
 * applies.
 *
 * @class
 * @implements DOMEventListener
 */
function RequestTracker(async, id, timeLimit /*[, resetAfter, resetTo]*/) {
  this.async = async;
  this.id = id;
  this.timeLimit = timeLimit;

  if (arguments.length > 3) {
    this.mustReset = true;
    this.resetAfter = arguments[3];
    this.resetTo = arguments[4];
  }

  this.hasFired = false;
}
RequestTracker.prototype = {
  /**
   * Start the XMLHttpRequest!
   */
  startXHR() {
    var req = new XMLHttpRequest();
    this.request = req;
    req.open("GET", "file_XHR_timeout.sjs", this.async);
    var me = this;
    function handleEvent(e) {
      return me.handleEvent(e);
    }
    req.onerror = handleEvent;
    req.onload = handleEvent;
    req.onabort = handleEvent;
    req.ontimeout = handleEvent;

    req.timeout = this.timeLimit;

    if (this.mustReset) {
      var resetTo = this.resetTo;
      self.setTimeout(function () {
        req.timeout = resetTo;
      }, this.resetAfter);
    }

    var gotException;
    var expectTimeoutException =
      !this.async && inWorker && this.timeLimit > 0 && this.timeLimit < 3000;

    try {
      req.send(null);
    } catch (e) {
      gotException = e;
      if (expectTimeoutException) {
        ok(e.name == "TimeoutError", "Should be a TimeoutError");
      }
    }

    if (gotException && !expectTimeoutException) {
      ok(false, `expected no exception, got ${gotException}`);
    } else if (!gotException && expectTimeoutException) {
      ok(false, "expected timeout exception");
    }
  },

  /**
   * Get a message describing this test.
   *
   * @returns {string} The test description.
   */
  getMessage() {
    var rv = this.id + ", ";
    if (this.mustReset) {
      rv += "original timeout at " + this.timeLimit + ", ";
      rv += "reset at " + this.resetAfter + " to " + this.resetTo;
    } else {
      rv += "timeout scheduled at " + this.timeLimit;
    }
    return rv;
  },

  /**
   * Check the event received, and if it's the right (and only) one we get.
   *
   * @param {DOMProgressEvent} evt An event of type "load" or "timeout".
   */
  handleEvent(evt) {
    if (this.hasFired) {
      ok(false, "Only one event should fire: " + this.getMessage());
      return;
    }
    this.hasFired = true;

    var type = evt.type,
      expectedType;
    // The XHR responds after 2500 milliseconds with a load event.
    var timeLimit =
      this.mustReset && this.resetAfter < Math.min(2500, this.timeLimit)
        ? this.resetTo
        : this.timeLimit;
    if (timeLimit == 0 || timeLimit >= 2500) {
      expectedType = "load";
    } else {
      expectedType = "timeout";
    }
    is(type, expectedType, this.getMessage());
    TestCounter.testComplete();
  },
};

/**
 * Generate and track XMLHttpRequests which will have abort() called on.
 *
 * @param shouldAbort {Boolean} True if we should call abort at all.
 * @param abortDelay  {Number}  The time in ms to wait before calling abort().
 */
function AbortedRequest(shouldAbort, abortDelay) {
  this.shouldAbort = shouldAbort;
  this.abortDelay = abortDelay;
  this.hasFired = false;
}
AbortedRequest.prototype = {
  /**
   * Start the XMLHttpRequest!
   */
  startXHR() {
    var req = new XMLHttpRequest();
    this.request = req;
    req.open("GET", "file_XHR_timeout.sjs");
    var me = this;
    function handleEvent(e) {
      return me.handleEvent(e);
    }
    req.onerror = handleEvent;
    req.onload = handleEvent;
    req.onabort = handleEvent;
    req.ontimeout = handleEvent;

    req.timeout = 2000;
    var _this = this;

    function abortReq() {
      req.abort();
    }

    if (!this.shouldAbort) {
      self.setTimeout(function () {
        try {
          _this.noEventsFired();
        } catch (e) {
          ok(false, "Unexpected error: " + e);
          TestCounter.testComplete();
        }
      }, 5000);
    } else {
      // Abort events can only be triggered on sent requests.
      req.send();
      if (this.abortDelay == -1) {
        abortReq();
      } else {
        self.setTimeout(abortReq, this.abortDelay);
      }
    }
  },

  /**
   * Ensure that no events fired at all, especially not our timeout event.
   */
  noEventsFired() {
    ok(
      !this.hasFired,
      "No events should fire for an unsent, unaborted request"
    );
    // We're done; if timeout hasn't fired by now, it never will.
    TestCounter.testComplete();
  },

  /**
   * Get a message describing this test.
   *
   * @returns {string} The test description.
   */
  getMessage() {
    return "time to abort is " + this.abortDelay + ", timeout set at 2000";
  },

  /**
   * Check the event received, and if it's the right (and only) one we get.
   *
   * @param {DOMProgressEvent} evt An event of type "load" or "timeout".
   */
  handleEvent(evt) {
    if (this.hasFired) {
      ok(false, "Only abort event should fire: " + this.getMessage());
      return;
    }
    this.hasFired = true;

    var expectedEvent = this.abortDelay >= 2000 ? "timeout" : "abort";
    is(evt.type, expectedEvent, this.getMessage());
    TestCounter.testComplete();
  },
};

var SyncRequestSettingTimeoutAfterOpen = {
  startXHR() {
    var pass = false;
    var req = new XMLHttpRequest();
    req.open("GET", "file_XHR_timeout.sjs", false);
    try {
      req.timeout = 1000;
    } catch (e) {
      pass = true;
    }
    ok(pass, "Synchronous XHR must not allow a timeout to be set");
    TestCounter.testComplete();
  },
};

var SyncRequestSettingTimeoutBeforeOpen = {
  startXHR() {
    var pass = false;
    var req = new XMLHttpRequest();
    req.timeout = 1000;
    try {
      req.open("GET", "file_XHR_timeout.sjs", false);
    } catch (e) {
      pass = true;
    }
    ok(pass, "Synchronous XHR must not allow a timeout to be set");
    TestCounter.testComplete();
  },
};

var TestRequests = [
  // Simple timeouts.
  new RequestTracker(true, "no time out scheduled, load fires normally", 0),
  new RequestTracker(true, "load fires normally", 5000),
  new RequestTracker(true, "timeout hit before load", 1500),

  // Timeouts reset after a certain delay.
  new RequestTracker(
    true,
    "load fires normally with no timeout set, twice",
    0,
    2000,
    0
  ),
  new RequestTracker(
    true,
    "load fires normally with same timeout set twice",
    5000,
    2000,
    5000
  ),
  new RequestTracker(
    true,
    "timeout fires normally with same timeout set twice",
    1500,
    750,
    1500
  ),

  new RequestTracker(
    true,
    "timeout disabled after initially set",
    5000,
    2000,
    0
  ),
  new RequestTracker(
    true,
    "timeout overrides load after a delay",
    5000,
    1000,
    1500
  ),
  new RequestTracker(
    true,
    "timeout enabled after initially disabled",
    0,
    2000,
    5000
  ),

  new RequestTracker(
    true,
    "timeout set to expiring value after load fires",
    5000,
    4000,
    1000
  ),
  new RequestTracker(
    true,
    "timeout set to expired value before load fires",
    5000,
    2000,
    1000
  ),
  new RequestTracker(
    true,
    "timeout set to non-expiring value after timeout fires",
    1000,
    2000,
    5000
  ),

  // Aborted requests.
  new AbortedRequest(false),
  new AbortedRequest(true, -1),
  new AbortedRequest(true, 5000),
];

var MainThreadTestRequests = [
  new AbortedRequest(true, 0),
  new AbortedRequest(true, 1000),

  // Synchronous requests.
  SyncRequestSettingTimeoutAfterOpen,
  SyncRequestSettingTimeoutBeforeOpen,
];

var WorkerThreadTestRequests = [
  // Simple timeouts.
  new RequestTracker(false, "no time out scheduled, load fires normally", 0),
  new RequestTracker(false, "load fires normally", 5000),
  new RequestTracker(false, "timeout hit before load", 1500),

  // Reset timeouts don't make much sense with a sync request ...
];

if (inWorker) {
  TestRequests = TestRequests.concat(WorkerThreadTestRequests);
} else {
  TestRequests = TestRequests.concat(MainThreadTestRequests);
}

// This code controls moving from one test to another.
var TestCounter = {
  testComplete() {
    // Allow for the possibility there are other events coming.
    self.setTimeout(function () {
      TestCounter.next();
    }, 5000);
  },

  next() {
    var test = TestRequests.shift();

    if (test) {
      test.startXHR();
    } else {
      message("done");
    }
  },
};

self.addEventListener("message", function (event) {
  if (event.data == "start") {
    TestCounter.next();
  }
});