mirrors/zotero
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
zotero/test/tests/httpTest.js

375 lines
9.6 KiB
JavaScript
Raw Normal View History

Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
describe("Zotero.HTTP", function () {
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
var server;
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
var httpd;
var port = 16213;
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
var baseURL = `http://127.0.0.1:${port}/`
var testURL = baseURL + 'test.html';
var redirectLocation = baseURL + 'test2.html';
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
function setResponse(response) {
setHTTPResponse(server, baseURL, response, {});
}
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
before(function* () {
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
// Real HTTP server
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
Components.utils.import("resource://zotero-unit/httpd.js");
httpd = new HttpServer();
httpd.start(port);
httpd.registerPathHandler(
'/test.html',
{
handle: function (request, response) {
response.setStatusLine(null, 200, "OK");
response.write("<html><body><p>Test</p><p>Test 2</p></body></html>");
}
}
);
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
httpd.registerPathHandler(
'/redirect',
{
handle: function (request, response) {
response.setHeader('Location', redirectLocation);
response.setStatusLine(null, 301, "Moved Permanently");
response.write(`<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">\n<html><head>\n<title>301 Moved Permanently</title>\n</head><body>\n<h1>Moved Permanently</h1>\n<p>The document has moved <a href="${redirectLocation}">here</a>.</p>\n</body></html>`);
}
}
);
Follow meta redirects and use the final URL when processing documents (#1568)
2018-10-04 02:24:39 +00:00
httpd.registerPathHandler(
'/test-redirect.html',
{
handle: function (request, response) {
response.setHeader("Content-Type", 'text/html', false);
response.setStatusLine(null, 200, "OK");
response.write("<html><head><meta http-equiv=\"refresh\" content=\"2;url=test.html\"/></head><body></body></html>");
}
}
);
Zotero.HTTP.request(): Process headers case insensitively Using the Headers class from the Fetch API. Before, the added test would fail: `_requestInternal()`, not finding a header named `Content-Type` (case sensitive), would set it to `application/x-www-form-urlencoded`. XMLHttpRequest, upon being given both `content-type`: `application/json`) and `Content-Type`: `application/x-www-form-urlencoded`, would helpfully merge the two, producing `content-type`: `application/json, application/x-www-form-urlencoded`. That's obviously not the correct behavior.
2022-12-23 01:47:28 +00:00
httpd.registerPathHandler(
'/requireJSON',
{
handle(request, response) {
if (request.getHeader('Content-Type') == 'application/json') {
response.setStatusLine(null, 200, "OK");
}
else {
response.setStatusLine(null, 400, "Bad Request");
}
response.write('JSON required');
}
}
);
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
});
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
beforeEach(function () {
// Fake XHR, which can be disabled per test with `Zotero.HTTP.mock = null`
Zotero.HTTP.mock = sinon.FakeXMLHttpRequest;
server = sinon.fakeServer.create();
server.autoRespond = true;
});
Make HTTP tests more reliable
2019-12-23 09:29:41 +00:00
afterEach(async function () {
// Allow requests to settle
await Zotero.Promise.delay(50);
});
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
after(function* () {
var defer = new Zotero.Promise.defer();
httpd.stop(() => defer.resolve());
yield defer.promise;
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
Zotero.HTTP.mock = null;
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
});
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
describe("#request()", function () {
it("should succeed with 3xx status if followRedirects is false", async function () {
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
Zotero.HTTP.mock = null;
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
var req = await Zotero.HTTP.request(
'GET',
baseURL + 'redirect',
{
followRedirects: false
}
);
assert.equal(req.status, 301);
assert.equal(req.getResponseHeader('Location'), redirectLocation);
});
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
it("should catch an interrupted connection", async function () {
setResponse({
method: "GET",
url: "empty",
status: 0,
text: ""
})
var e = await getPromiseError(Zotero.HTTP.request("GET", baseURL + "empty"));
assert.ok(e);
assert.equal(e.message, Zotero.getString('sync.error.checkConnection'));
});
it("should provide cancellerReceiver with a callback to cancel a request", async function () {
var timeoutID;
server.autoRespond = false;
server.respondWith(function (req) {
if (req.method == "GET" && req.url == baseURL + "slow") {
req.respond(
200,
{},
"OK"
);
}
});
setTimeout(function () {
cancel();
}, 50);
var e = await getPromiseError(Zotero.HTTP.request(
"GET",
baseURL + "slow",
{
cancellerReceiver: function (f) {
cancel = f;
}
}
));
assert.instanceOf(e, Zotero.HTTP.CancelledException);
server.respond();
});
Zotero.HTTP.request(): Process headers case insensitively Using the Headers class from the Fetch API. Before, the added test would fail: `_requestInternal()`, not finding a header named `Content-Type` (case sensitive), would set it to `application/x-www-form-urlencoded`. XMLHttpRequest, upon being given both `content-type`: `application/json`) and `Content-Type`: `application/x-www-form-urlencoded`, would helpfully merge the two, producing `content-type`: `application/json, application/x-www-form-urlencoded`. That's obviously not the correct behavior.
2022-12-23 01:47:28 +00:00
it("should process headers case insensitively", async function () {
Zotero.HTTP.mock = null;
var req = await Zotero.HTTP.request(
'GET',
baseURL + 'requireJSON',
{
headers: {
'content-type': 'application/json'
}
}
);
assert.equal(req.status, 200);
});
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
describe("Retries", function () {
var spy;
var delayStub;
beforeEach(function () {
delayStub = sinon.stub(Zotero.Promise, "delay").returns(Zotero.Promise.resolve());
});
afterEach(function () {
if (spy) {
spy.restore();
}
delayStub.restore();
});
after(function () {
sinon.restore();
});
it("should retry on 500 error", async function () {
setResponse({
method: "GET",
url: "error",
status: 500,
text: ""
});
spy = sinon.spy(Zotero.HTTP, "_requestInternal");
var e = await getPromiseError(
Zotero.HTTP.request(
"GET",
baseURL + "error",
{
Add additional checks to test for HTTP.request() 5xx retry
2020-12-11 07:04:48 +00:00
errorDelayIntervals: [10, 20, 100],
errorDelayMax: 35
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
}
)
);
assert.instanceOf(e, Zotero.HTTP.UnexpectedStatusException);
Add additional checks to test for HTTP.request() 5xx retry
2020-12-11 07:04:48 +00:00
assert.isTrue(spy.calledThrice);
assert.isTrue(delayStub.calledTwice);
assert.equal(delayStub.args[0][0], 10);
assert.equal(delayStub.args[1][0], 20);
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
});
Fix HTTP.request() 5xx handling with errorDelayMax=0 This was causing delay-less infinite loops for OPTIONS requests to Box, which are returning 502 errors.
2022-08-29 21:35:06 +00:00
it("shouldn't retry on 500 error if errorDelayMax=0", async function () {
setResponse({
method: "GET",
url: "error",
status: 500,
text: ""
});
spy = sinon.spy(Zotero.HTTP, "_requestInternal");
var e = await getPromiseError(
Zotero.HTTP.request(
"GET",
baseURL + "error",
{
errorDelayIntervals: [10, 20, 100],
errorDelayMax: 0
}
)
);
assert.instanceOf(e, Zotero.HTTP.UnexpectedStatusException);
assert.isTrue(spy.calledOnce);
assert.isTrue(delayStub.notCalled);
});
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
it("should provide cancellerReceiver a callback to cancel while waiting to retry a 5xx error", async function () {
delayStub.restore();
setResponse({
method: "GET",
url: "error",
status: 500,
text: ""
});
var cancel;
spy = sinon.spy(Zotero.HTTP, "_requestInternal");
setTimeout(() => {
cancel();
Make Zotero.HTTP retry test a bit more robust
2021-08-27 21:12:28 +00:00
}, 300);
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
var e = await getPromiseError(
Zotero.HTTP.request(
"GET",
baseURL + "error",
{
Make Zotero.HTTP retry test a bit more robust
2021-08-27 21:12:28 +00:00
errorDelayIntervals: [10, 10, 600],
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
cancellerReceiver: function () {
cancel = arguments[0];
}
}
)
);
assert.instanceOf(e, Zotero.HTTP.CancelledException);
Make HTTP tests more reliable
2019-12-23 09:29:41 +00:00
assert.equal(spy.callCount, 3);
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
});
it("should obey Retry-After for 503", function* () {
var called = 0;
server.respond(function (req) {
if (req.method == "GET" && req.url == baseURL + "error") {
if (called < 1) {
req.respond(
503,
{
"Retry-After": "5"
},
""
);
}
else if (called < 2) {
req.respond(
503,
{
"Retry-After": "10"
},
""
);
}
else {
req.respond(
200,
{},
""
);
}
}
called++;
});
spy = sinon.spy(Zotero.HTTP, "_requestInternal");
yield Zotero.HTTP.request("GET", baseURL + "error");
Make HTTP tests more reliable
2019-12-23 09:29:41 +00:00
assert.equal(3, spy.callCount);
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
// DEBUG: Why are these slightly off?
assert.approximately(delayStub.args[0][0], 5 * 1000, 5);
assert.approximately(delayStub.args[1][0], 10 * 1000, 5);
});
Fix incorrect retries if multiple HTTP.request() calls get 500s https://forums.zotero.org/discussion/comment/425814/#Comment_425814 The passed intervals array was modified, so after a request() got a 500, subsequent calls would start with longer delays and eventually start retrying immediately.
2023-01-11 07:07:18 +00:00
it("should start with first interval on new request() call", async function () {
var called = 0;
server.respond(function (req) {
if (req.method == "GET" && req.url.startsWith(baseURL + "error")) {
if (called < 1) {
req.respond(500, {}, "");
}
else {
req.respond(200, {}, "");
}
}
called++;
});
spy = sinon.spy(Zotero.HTTP, "_requestInternal");
var errorDelayIntervals = [20];
await Zotero.HTTP.request("GET", baseURL + "error1", { errorDelayIntervals })
called = 0;
await Zotero.HTTP.request("GET", baseURL + "error2", { errorDelayIntervals }),
assert.equal(4, spy.callCount);
assert.equal(delayStub.args[0][0], 20);
assert.equal(delayStub.args[1][0], 20);
});
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
});
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
});
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
describe("#processDocuments()", function () {
HTTP.request() improvements - Move 5xx retries and connection checking out of the sync API client and into HTTP.request() so that they apply to all requests. 429 handling remains in the API client, since not all callers necessarily want to handle that the same way. Callers can still handle 5xx themselves by including the relevant 5xx status codes in `successCodes` or by passing `errorDelayMax: 0`. - Add `cancellerReceiver` option, which is a callback that receives a function that will cancel the request, whether it's an active request or an automatic delay before a 5xx retry. This also updates Sinon to 7.3.2.
2019-04-23 23:49:48 +00:00
beforeEach(function () {
Zotero.HTTP.mock = null;
});
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
it("should provide a document object", function* () {
var called = false;
yield Zotero.HTTP.processDocuments(
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
testURL,
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
function (doc) {
Add followRedirects: false option to Zotero.HTTP.request() Currently only .status and .getResponseHeader() (for getting 'Location') are available in the returned object, but we could make the body available if necessary.
2018-09-11 05:23:15 +00:00
assert.equal(doc.location.href, testURL);
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
assert.equal(doc.querySelector('p').textContent, 'Test');
var p = doc.evaluate('//p', doc, null, XPathResult.ANY_TYPE, null).iterateNext();
assert.equal(p.textContent, 'Test');
called = true;
}
);
assert.isTrue(called);
});
Follow meta redirects and use the final URL when processing documents (#1568)
2018-10-04 02:24:39 +00:00
it("should follow meta redirect for a document", async function () {
let url1 = `http://127.0.0.1:${port}/test-redirect.html`;
let url2 = `http://127.0.0.1:${port}/test.html`;
let called = false;
await Zotero.HTTP.processDocuments(
url1,
function (doc) {
assert.equal(doc.location.href, url2);
called = true;
}
);
assert.isTrue(called);
});
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
});
fx-compat: Run translation and SingleFile in [hidden] browser And replace loadDocuments().
2023-04-14 15:37:07 +00:00
Preserve capitalization in `Zotero.HTTP.request()` headers (#3002)
2023-02-24 07:15:07 +00:00
describe("CasePreservingHeaders", function () {
describe("#constructor()", function () {
it("should initialize from an iterable or object", function () {
let headers = new Zotero.HTTP.CasePreservingHeaders([['Name', 'value']]);
assert.equal(headers.get('name'), 'value');
headers = new Zotero.HTTP.CasePreservingHeaders({ NAME: 'value' });
assert.equal(headers.get('Name'), 'value');
});
});
describe("#entries()", function () {
it("should iterate through headers with original capitalization", function () {
let headers = new Zotero.HTTP.CasePreservingHeaders({ 'A-Header': 'a value' });
headers.set('FuNkY-Header', 'some other value');
assert.deepEqual(Array.from(headers.entries()), [
['A-Header', 'a value'],
['FuNkY-Header', 'some other value']
]);
});
});
});
Switch to XMLHttpRequest for processDocuments() processDocuments() now uses an XHR 'document' request, wrapped to provide a 'location' property, and uses promises for a simpler call signature (though the old one will continue to work, for existing translators). 'done' and 'exception' can now be handled via promises, and in the translator sandbox an optional noCompleteOnError argument instructs it not to automatically cancel the translation process with an error (e.g., for supplementary materials). Since we do need a hidden browser in some situations (e.g., for saving snapshots), the old hidden-browser-based processDocuments() is still available as Zotero.HTTP.loadDocuments(). This hopefully also fixes various problems with document property access in translation-server.
2017-08-19 10:57:54 +00:00
});
Reference in a new issue Copy permalink