20240517

node_modules/xhr/test/index.js

@@ -0,0 +1,378 @@
+var window = require("global/window")
+var test = require("tape")
+var forEach = require("for-each")
+
+var xhr = require("../index.js")
+
+test("constructs and calls callback without throwing", { timeout: 500 }, function(assert) {
+    xhr({}, function(err, resp, body) {
+        assert.ok(true, "got here")
+        assert.end()
+    })
+})
+
+test("[func] Can GET a url (cross-domain)", { timeout: 2000 }, function(assert) {
+    xhr({
+        uri: "http://www.mocky.io/v2/55a02cb72651260b1a94f024",
+        useXDR: true
+    }, function(err, resp, body) {
+        assert.ifError(err, "no err")
+        assert.equal(resp.statusCode, 200)
+        assert.equal(typeof resp.rawRequest, "object")
+        assert.notEqual(resp.body.length, 0)
+        assert.equal(resp.body, '{"a":1}')
+        assert.notEqual(body.length, 0)
+        assert.end()
+    })
+})
+
+test("[func] Returns http error responses like npm's request (cross-domain)", { timeout: 2000 }, function(assert) {
+    if (!window.XDomainRequest) {
+        xhr({
+            uri: "http://www.mocky.io/v2/55a02d63265126221a94f025",
+        }, function(err, resp, body) {
+            assert.ifError(err, "no err")
+            assert.equal(resp.statusCode, 404)
+            assert.equal(typeof resp.rawRequest, "object")
+            assert.end()
+        })
+    } else {
+        assert.end();
+    }
+})
+
+test("[func] Request to domain with not allowed cross-domain", { timeout: 2000 }, function(assert) {
+    xhr({
+        uri: "http://www.mocky.io/v2/57bb70c21000002f175850bd",
+    }, function(err, resp, body) {
+        assert.ok(err instanceof Error, "should return error")
+        assert.equal(resp.statusCode, 0)
+        assert.equal(typeof resp.rawRequest, "object")
+        assert.end()
+    })
+})
+
+test("[func] Returns a falsy body for 2xx responses", { timeout: 500 }, function(assert) {
+  assert.plan(8)
+    xhr({
+        uri: "/mock/no-content/200"
+    }, function(err, resp, body) {
+        assert.notOk(body, "body should be falsy")
+        assert.equal(resp.statusCode, 200)
+    })
+    xhr({
+        uri: "/mock/no-content/201"
+    }, function(err, resp, body) {
+        assert.notOk(body, "body should be falsy")
+        assert.equal(resp.statusCode, 201)
+    })
+    xhr({
+        uri: "/mock/no-content/204"
+    }, function(err, resp, body) {
+        assert.notOk(body, "body should be falsy")
+        assert.equal(resp.statusCode, 204)
+    })
+    xhr({
+        uri: "/mock/no-content/205"
+    }, function(err, resp, body) {
+        assert.notOk(body, "body should be falsy")
+        assert.equal(resp.statusCode, 205)
+    })
+
+})
+
+test("[func] Calls the callback at most once even if error is thrown issue #127", { timeout: 500 }, function(assert) {
+    //double call happened in chrome
+    var count = 0;
+    setTimeout(function() {
+        assert.ok(count <= 1, "expected at most one call")
+        assert.end()
+    }, 100)
+    try {
+        xhr({
+            uri: "instanterror://foo"
+        }, function(err, resp, body) {
+            count++;
+            throw Error("dummy error")
+        })
+    } catch(e){}
+})
+
+test("[func] Times out to an error ", { timeout: 500 }, function(assert) {
+    xhr({
+        timeout: 1,
+        uri: "/mock/timeout"
+    }, function(err, resp, body) {
+        assert.ok(err instanceof Error, "should return error")
+        assert.equal(err.message, "XMLHttpRequest timeout")
+        assert.equal(err.code, "ETIMEDOUT")
+        assert.equal(resp.statusCode, 0)
+        assert.end()
+    })
+})
+
+test("withCredentials option", { timeout: 500 }, function(assert) {
+    if (!window.XDomainRequest) {
+        var req = xhr({}, function() {})
+        assert.ok(!req.withCredentials,
+            "withCredentials not true"
+        )
+        req = xhr({
+            withCredentials: true
+        }, function() {})
+        assert.ok(
+            req.withCredentials,
+            "withCredentials set to true"
+        )
+    }
+    assert.end()
+})
+
+test("withCredentials ignored when using synchronous requests", { timeout: 500 }, function(assert) {
+    if (!window.XDomainRequest) {
+        var req = xhr({
+            withCredentials: true,
+            sync: true
+        }, function() {})
+        assert.ok(!req.withCredentials,
+            "sync overrides withCredentials"
+        )
+    }
+    assert.end()
+})
+
+test("XDR usage (run on IE8 or 9)", { timeout: 500 }, function(assert) {
+    var req = xhr({
+        useXDR: true,
+        uri: window.location.href,
+    }, function() {})
+
+    assert.ok(!window.XDomainRequest || window.XDomainRequest === req.constructor,
+        "Uses XDR when told to"
+    )
+
+
+    if (!!window.XDomainRequest) {
+        assert.throws(function() {
+            xhr({
+                useXDR: true,
+                uri: window.location.href,
+                headers: {
+                    "foo": "bar"
+                }
+            }, function() {})
+        }, true, "Throws when trying to send headers with XDR")
+    }
+    assert.end()
+})
+
+test("handles errorFunc call with no arguments provided", { timeout: 500 }, function(assert) {
+    var req = xhr({}, function(err) {
+        assert.ok(err instanceof Error, "callback should get an error")
+        assert.equal(err.message, "Unknown XMLHttpRequest Error", "error message incorrect")
+    })
+    assert.doesNotThrow(function() {
+        req.onerror()
+    }, "should not throw when error handler called without arguments")
+    assert.end()
+
+})
+
+test("constructs and calls callback without throwing", { timeout: 500 }, function(assert) {
+    assert.throws(function() {
+        xhr({})
+    }, "callback is not optional")
+    assert.end()
+})
+
+if (!window.XDomainRequest) {
+    var methods = ["get", "put", "post", "patch"]
+} else {
+    var methods = ["get", "post"]
+}
+
+test("[func] xhr[method] get, put, post, patch", { timeout: 500 }, function(assert) {
+    var i = 0
+
+    forEach(methods, function(method) {
+        xhr[method]({
+            uri: "/mock/200ok"
+        }, function(err, resp, body) {
+            i++
+            assert.ifError(err, "no err")
+            assert.equal(resp.statusCode, 200)
+            assert.equal(resp.method, method.toUpperCase())
+            if (i === methods.length) assert.end()
+        })
+    })
+})
+
+test("xhr[method] get, put, post, patch with url shorthands", { timeout: 500 }, function(assert) {
+    var i = 0
+    forEach(methods, function(method) {
+        var req = xhr[method]("/some-test", function() {})
+        i++
+        assert.equal(req.method, method.toUpperCase())
+
+        if (i === methods.length) assert.end()
+    })
+})
+
+test("[func] sends options.body as json body when options.json === true", { timeout: 500 }, function(assert) {
+    xhr.post("/mock/echo", {
+        json: true,
+        body: {
+            foo: "bar"
+        }
+    }, function(err, resp, body) {
+        assert.equal(resp.rawRequest.headers["Content-Type"], "application/json")
+        assert.deepEqual(body, {
+            foo: "bar"
+        })
+        assert.end()
+    })
+})
+
+test("[func] doesn't freak out when json option is false", { timeout: 500 }, function(assert) {
+    xhr.post("/mock/echo", {
+        json: false,
+        body: "{\"a\":1}"
+    }, function(err, resp, body) {
+        assert.notEqual(resp.rawRequest.headers["Content-Type"], "application/json")
+        assert.equal(body, "{\"a\":1}")
+        assert.end()
+    })
+})
+
+test("[func] sends options.json as body when it's not a boolean", { timeout: 500 }, function(assert) {
+    xhr.post("/mock/echo", {
+        json: {
+            foo: "bar"
+        }
+    }, function(err, resp, body) {
+        assert.equal(resp.rawRequest.headers["Content-Type"], "application/json")
+        assert.deepEqual(body, {
+            foo: "bar"
+        })
+        assert.end()
+    })
+})
+
+test("xhr[method] get, put, post, patch with url shorthands and options", { timeout: 500 }, function(assert) {
+    var i = 0
+    forEach(methods, function(method) {
+        var req = xhr[method]("/some-test", {
+            headers: {
+                foo: 'bar'
+            }
+        }, function(err, resp, body) {
+            i++
+            assert.equal(resp.rawRequest.headers.foo, 'bar')
+            assert.equal(resp.method, method.toUpperCase())
+
+            if (i === methods.length) assert.end()
+        })
+    })
+})
+if (!window.XDomainRequest) {
+    test("[func] xhr.head", function(assert) {
+        xhr.head({
+            uri: "/mock/200ok",
+        }, function(err, resp, body) {
+            assert.ifError(err, "no err")
+            assert.equal(resp.statusCode, 200)
+            assert.equal(resp.method, "HEAD")
+            assert.notOk(resp.body)
+            assert.end()
+        })
+    })
+
+    test("xhr.head url shorthand", { timeout: 500 }, function(assert) {
+        xhr.head("/mock/200ok", function(err, resp, body) {
+            assert.equal(resp.method, "HEAD")
+            assert.end()
+        })
+    })
+
+    test("[func] xhr.del", { timeout: 500 }, function(assert) {
+        xhr.del({
+            uri: "/mock/200ok"
+        }, function(err, resp, body) {
+            assert.ifError(err, "no err")
+            assert.equal(resp.statusCode, 200)
+            assert.equal(resp.method, "DELETE")
+            assert.end()
+        })
+    })
+
+    test("xhr.del url shorthand", { timeout: 500 }, function(assert) {
+        xhr.del("/mock/200ok", function(err, resp, body) {
+            assert.equal(resp.method, "DELETE")
+            assert.end()
+        })
+    })
+}
+test("url signature without object", { timeout: 500 }, function(assert) {
+    xhr("/some-test", function(err, resp, body) {
+        assert.equal(resp.url, '/some-test')
+        assert.end()
+    })
+})
+
+test("url signature with object", { timeout: 500 }, function(assert) {
+    xhr("/some-test", {
+        headers: {
+            "foo": "bar"
+        }
+    }, function(err, resp, body) {
+        assert.equal(resp.url, '/some-test')
+        assert.equal(resp.rawRequest.headers.foo, 'bar')
+        assert.end()
+    })
+})
+
+test("aborting XHR immediately prevents callback from being called", { timeout: 500 }, function(assert) {
+    var req = xhr({ uri: "/mock/200ok" }, function(err, response) {
+        assert.fail('this callback should not be called');
+    });
+    req.abort();
+    setTimeout(function() {
+        assert.end()
+    }, 2)
+})
+
+test("aborting XHR asynchronously still prevents callback from being called", { timeout: 500 }, function(assert) {
+    var req = xhr({ uri: "/mock/timeout" }, function(err, response) {
+        assert.fail('this callback should not be called');
+    });
+    setTimeout(function() {
+        req.abort();
+    }, 0)
+    setTimeout(function() {
+        assert.end()
+    }, 2)
+})
+
+test("XHR can be overridden", { timeout: 500 }, function(assert) {
+    var xhrs = 0
+    var noop = function() {}
+    var fakeXHR = function() {
+        xhrs++
+        this.open = this.send = noop
+    }
+    var xdrs = 0
+    var fakeXDR = function() {
+        xdrs++
+        this.open = this.send = noop
+    }
+    xhr.XMLHttpRequest = fakeXHR
+    xhr({}, function() {})
+    assert.equal(xhrs, 1, "created the custom XHR")
+
+    xhr.XDomainRequest = fakeXDR
+    xhr({
+        useXDR: true
+    }, function() {});
+    assert.equal(xdrs, 1, "created the custom XDR")
+    assert.end()
+})

node_modules/xhr/test/mock-server.js

@@ -0,0 +1,18 @@
+module.exports = function(req, res) {
+    console.log('mock:', req.url)
+    if (req.url === '/mock/200ok') {
+        res.statusCode = 200
+        res.end('')
+    } else if (req.url.substr(0,16) === '/mock/no-content') {
+        res.statusCode = parseInt(req.url.substring(17), 10)
+        res.end('')
+    } else if (req.url === '/mock/echo') {
+        res.statusCode = 200
+        req.pipe(res)
+    } else if (req.url === '/mock/timeout') {
+        setTimeout(function() {
+            res.statusCode = 200
+            res.end()
+        }, 100)
+    }
+}