summaryrefslogtreecommitdiffstats
path: root/test/node-fetch/request.js
diff options
context:
space:
mode:
Diffstat (limited to 'test/node-fetch/request.js')
-rw-r--r--test/node-fetch/request.js281
1 files changed, 281 insertions, 0 deletions
diff --git a/test/node-fetch/request.js b/test/node-fetch/request.js
new file mode 100644
index 0000000..2d29d51
--- /dev/null
+++ b/test/node-fetch/request.js
@@ -0,0 +1,281 @@
+const stream = require('stream')
+const http = require('http')
+
+const chai = require('chai')
+const { Blob } = require('buffer')
+
+const Request = require('../../lib/fetch/request.js').Request
+const TestServer = require('./utils/server.js')
+
+const { expect } = chai
+
+describe('Request', () => {
+ const local = new TestServer()
+ let base
+
+ before(async () => {
+ await local.start()
+ base = `http://${local.hostname}:${local.port}/`
+ })
+
+ after(async () => {
+ return local.stop()
+ })
+
+ it('should have attributes conforming to Web IDL', () => {
+ const request = new Request('http://github.com/')
+ const enumerableProperties = []
+ for (const property in request) {
+ enumerableProperties.push(property)
+ }
+
+ for (const toCheck of [
+ 'body',
+ 'bodyUsed',
+ 'arrayBuffer',
+ 'blob',
+ 'json',
+ 'text',
+ 'method',
+ 'url',
+ 'headers',
+ 'redirect',
+ 'clone',
+ 'signal'
+ ]) {
+ expect(enumerableProperties).to.contain(toCheck)
+ }
+
+ // for (const toCheck of [
+ // 'body', 'bodyUsed', 'method', 'url', 'headers', 'redirect', 'signal'
+ // ]) {
+ // expect(() => {
+ // request[toCheck] = 'abc'
+ // }).to.throw()
+ // }
+ })
+
+ // it('should support wrapping Request instance', () => {
+ // const url = `${base}hello`
+
+ // const form = new FormData()
+ // form.append('a', '1')
+ // const { signal } = new AbortController()
+
+ // const r1 = new Request(url, {
+ // method: 'POST',
+ // follow: 1,
+ // body: form,
+ // signal
+ // })
+ // const r2 = new Request(r1, {
+ // follow: 2
+ // })
+
+ // expect(r2.url).to.equal(url)
+ // expect(r2.method).to.equal('POST')
+ // expect(r2.signal).to.equal(signal)
+ // // Note that we didn't clone the body
+ // expect(r2.body).to.equal(form)
+ // expect(r1.follow).to.equal(1)
+ // expect(r2.follow).to.equal(2)
+ // expect(r1.counter).to.equal(0)
+ // expect(r2.counter).to.equal(0)
+ // })
+
+ xit('should override signal on derived Request instances', () => {
+ const parentAbortController = new AbortController()
+ const derivedAbortController = new AbortController()
+ const parentRequest = new Request(`${base}hello`, {
+ signal: parentAbortController.signal
+ })
+ const derivedRequest = new Request(parentRequest, {
+ signal: derivedAbortController.signal
+ })
+ expect(parentRequest.signal).to.equal(parentAbortController.signal)
+ expect(derivedRequest.signal).to.equal(derivedAbortController.signal)
+ })
+
+ xit('should allow removing signal on derived Request instances', () => {
+ const parentAbortController = new AbortController()
+ const parentRequest = new Request(`${base}hello`, {
+ signal: parentAbortController.signal
+ })
+ const derivedRequest = new Request(parentRequest, {
+ signal: null
+ })
+ expect(parentRequest.signal).to.equal(parentAbortController.signal)
+ expect(derivedRequest.signal).to.equal(null)
+ })
+
+ it('should throw error with GET/HEAD requests with body', () => {
+ expect(() => new Request(base, { body: '' }))
+ .to.throw(TypeError)
+ expect(() => new Request(base, { body: 'a' }))
+ .to.throw(TypeError)
+ expect(() => new Request(base, { body: '', method: 'HEAD' }))
+ .to.throw(TypeError)
+ expect(() => new Request(base, { body: 'a', method: 'HEAD' }))
+ .to.throw(TypeError)
+ expect(() => new Request(base, { body: 'a', method: 'get' }))
+ .to.throw(TypeError)
+ expect(() => new Request(base, { body: 'a', method: 'head' }))
+ .to.throw(TypeError)
+ })
+
+ it('should default to null as body', () => {
+ const request = new Request(base)
+ expect(request.body).to.equal(null)
+ return request.text().then(result => expect(result).to.equal(''))
+ })
+
+ it('should support parsing headers', () => {
+ const url = base
+ const request = new Request(url, {
+ headers: {
+ a: '1'
+ }
+ })
+ expect(request.url).to.equal(url)
+ expect(request.headers.get('a')).to.equal('1')
+ })
+
+ it('should support arrayBuffer() method', () => {
+ const url = base
+ const request = new Request(url, {
+ method: 'POST',
+ body: 'a=1'
+ })
+ expect(request.url).to.equal(url)
+ return request.arrayBuffer().then(result => {
+ expect(result).to.be.an.instanceOf(ArrayBuffer)
+ const string = String.fromCharCode.apply(null, new Uint8Array(result))
+ expect(string).to.equal('a=1')
+ })
+ })
+
+ it('should support text() method', () => {
+ const url = base
+ const request = new Request(url, {
+ method: 'POST',
+ body: 'a=1'
+ })
+ expect(request.url).to.equal(url)
+ return request.text().then(result => {
+ expect(result).to.equal('a=1')
+ })
+ })
+
+ it('should support json() method', () => {
+ const url = base
+ const request = new Request(url, {
+ method: 'POST',
+ body: '{"a":1}'
+ })
+ expect(request.url).to.equal(url)
+ return request.json().then(result => {
+ expect(result.a).to.equal(1)
+ })
+ })
+
+ it('should support blob() method', () => {
+ const url = base
+ const request = new Request(url, {
+ method: 'POST',
+ body: Buffer.from('a=1')
+ })
+ expect(request.url).to.equal(url)
+ return request.blob().then(result => {
+ expect(result).to.be.an.instanceOf(Blob)
+ expect(result.size).to.equal(3)
+ expect(result.type).to.equal('')
+ })
+ })
+
+ it('should support clone() method', () => {
+ const url = base
+ const body = stream.Readable.from('a=1')
+ const agent = new http.Agent()
+ const { signal } = new AbortController()
+ const request = new Request(url, {
+ body,
+ method: 'POST',
+ redirect: 'manual',
+ headers: {
+ b: '2'
+ },
+ follow: 3,
+ compress: false,
+ agent,
+ signal,
+ duplex: 'half'
+ })
+ const cl = request.clone()
+ expect(cl.url).to.equal(url)
+ expect(cl.method).to.equal('POST')
+ expect(cl.redirect).to.equal('manual')
+ expect(cl.headers.get('b')).to.equal('2')
+ expect(cl.method).to.equal('POST')
+ // Clone body shouldn't be the same body
+ expect(cl.body).to.not.equal(body)
+ return Promise.all([cl.text(), request.text()]).then(results => {
+ expect(results[0]).to.equal('a=1')
+ expect(results[1]).to.equal('a=1')
+ })
+ })
+
+ it('should support ArrayBuffer as body', () => {
+ const encoder = new TextEncoder()
+ const body = encoder.encode('a=12345678901234').buffer
+ const request = new Request(base, {
+ method: 'POST',
+ body
+ })
+ new Uint8Array(body)[0] = 0
+ return request.text().then(result => {
+ expect(result).to.equal('a=12345678901234')
+ })
+ })
+
+ it('should support Uint8Array as body', () => {
+ const encoder = new TextEncoder()
+ const fullbuffer = encoder.encode('a=12345678901234').buffer
+ const body = new Uint8Array(fullbuffer, 2, 9)
+ const request = new Request(base, {
+ method: 'POST',
+ body
+ })
+ body[0] = 0
+ return request.text().then(result => {
+ expect(result).to.equal('123456789')
+ })
+ })
+
+ it('should support BigUint64Array as body', () => {
+ const encoder = new TextEncoder()
+ const fullbuffer = encoder.encode('a=12345678901234').buffer
+ const body = new BigUint64Array(fullbuffer, 8, 1)
+ const request = new Request(base, {
+ method: 'POST',
+ body
+ })
+ body[0] = 0n
+ return request.text().then(result => {
+ expect(result).to.equal('78901234')
+ })
+ })
+
+ it('should support DataView as body', () => {
+ const encoder = new TextEncoder()
+ const fullbuffer = encoder.encode('a=12345678901234').buffer
+ const body = new Uint8Array(fullbuffer, 2, 9)
+ const request = new Request(base, {
+ method: 'POST',
+ body
+ })
+ body[0] = 0
+ return request.text().then(result => {
+ expect(result).to.equal('123456789')
+ })
+ })
+})
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 00:07:40 +0000