@api-client/core 0.10.13 → 0.11.0

package/tests/unit/runtime/http-engine/redirects.spec.ts

@@ -0,0 +1,219 @@
+import { test } from '@japa/runner'
+import {
+  ISentRequest,
+  IResponse,
+  Response,
+  DummyLogger,
+  CoreEngine,
+  IHttpRequest,
+  HttpEngineOptions,
+  ResponseRedirect,
+  IResponseRedirect,
+  HttpResponse,
+} from '../../../../src/index.js'
+
+const logger = new DummyLogger()
+
+test.group('Absolute redirects', (group) => {
+  let opts: HttpEngineOptions
+  let baseRequest: IHttpRequest
+
+  group.each.setup((ctx) => {
+    opts = {
+      logger,
+    }
+    baseRequest = {
+      url: `http://localhost:${ctx.context.httpConfig.httpPort}/v1/redirect/absolute/2?test=true`,
+      method: 'GET',
+    }
+  })
+
+  test('redirects to an absolute URL', async ({ assert }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    assert.typeOf(log.redirects!, 'array', 'has the redirects')
+    assert.lengthOf(log.redirects!, 2, 'has both redirects')
+  })
+
+  test('has the redirects data', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    const redirects = log.redirects!.map((i) => new ResponseRedirect(i))
+    const rdr1 = redirects[0]!
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/redirect/absolute/1?test=true`
+    assert.equal(rdr1.url, location, 'has the redirect URL')
+    assert.typeOf(rdr1.startTime, 'number', 'has the startTime property')
+    assert.typeOf(rdr1.endTime, 'number', 'has the endTime property')
+    assert.typeOf(rdr1.timings, 'object', 'has the timings property')
+    assert.typeOf(rdr1.response, 'object', 'has the response property')
+
+    const rsp = rdr1.response!
+    assert.equal(rsp.status, 302, 'has the status code')
+    assert.equal(rsp.statusText, 'Found', 'has the status text')
+    assert.typeOf(rsp.headers, 'string', 'has the headers')
+
+    const body = (await rsp.readPayload('buffer')) as Buffer
+    const parsed = JSON.parse(body.toString('utf8'))
+    assert.equal(parsed.location, location, 'has the payload')
+  })
+
+  test('has the final response', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+
+    const transport = log.request as ISentRequest
+    const response = log.response as IResponse
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/get?test=true`
+    assert.equal(transport.url, location, 'transport request has the final URL')
+    assert.equal(response.status, 200, 'has the status code')
+  })
+})
+
+test.group('Relative redirects - relative path', (group) => {
+  let baseRequest: IHttpRequest
+  let opts: HttpEngineOptions
+
+  group.each.setup((ctx) => {
+    opts = {
+      logger,
+    }
+    baseRequest = {
+      url: `http://localhost:${ctx.context.httpConfig.httpPort}/v1/redirect/relative/2?test=true`,
+      method: 'GET',
+    }
+  })
+
+  test('redirects to a relative URL', async ({ assert }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    assert.typeOf(log.redirects!, 'array', 'has the redirects')
+    assert.lengthOf(log.redirects!, 2, 'has both redirects')
+  })
+
+  test('has the redirects data', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+
+    const log = await request.send()
+    const redirects = log.redirects!.map((i) => new ResponseRedirect(i))
+    const rdr1 = redirects[0]!
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/redirect/relative/1?test=true`
+    assert.equal(rdr1.url, location, 'has the redirect URL')
+    assert.typeOf(rdr1.startTime, 'number', 'has the startTime property')
+    assert.typeOf(rdr1.endTime, 'number', 'has the endTime property')
+    assert.typeOf(rdr1.timings, 'object', 'has the timings property')
+    assert.typeOf(rdr1.response, 'object', 'has the response property')
+
+    const rsp = rdr1.response!
+    assert.equal(rsp.status, 302, 'has the status code')
+    assert.equal(rsp.statusText, 'Found', 'has the status text')
+    assert.typeOf(rsp.headers, 'string', 'has the headers')
+
+    const body = (await rsp.readPayload('buffer')) as Buffer
+    const parsed = JSON.parse(body.toString('utf8'))
+    assert.equal(parsed.location, '../relative/1?test=true', 'has the payload')
+  })
+
+  test('has the final response', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+
+    const transport = log.request as ISentRequest
+    const response = log.response as IResponse
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/get?test=true`
+    assert.equal(transport.url, location, 'transport request has the final URL')
+    assert.equal(response.status, 200, 'has the status code')
+  })
+})
+
+test.group('Relative redirects - root path', (group) => {
+  let baseRequest: IHttpRequest
+  let opts: HttpEngineOptions
+
+  group.each.setup((ctx) => {
+    opts = {
+      logger,
+    }
+    baseRequest = {
+      url: `http://localhost:${ctx.context.httpConfig.httpPort}/v1/redirect/relative-root/2?test=true`,
+      method: 'GET',
+    }
+  })
+
+  test('redirects to a relative URL', async ({ assert }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    assert.typeOf(log.redirects!, 'array', 'has the redirects')
+    assert.lengthOf(log.redirects!, 2, 'has both redirects')
+  })
+
+  test('has the redirects data', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    const redirects = log.redirects!.map((i) => new ResponseRedirect(i))
+    const rdr1 = redirects[0]!
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/redirect/relative/1?test=true`
+    assert.equal(rdr1.url, location, 'has the redirect URL')
+    assert.typeOf(rdr1.startTime, 'number', 'has the startTime property')
+    assert.typeOf(rdr1.endTime, 'number', 'has the endTime property')
+    assert.typeOf(rdr1.timings, 'object', 'has the timings property')
+    assert.typeOf(rdr1.response, 'object', 'has the response property')
+
+    const rsp = rdr1.response!
+    assert.equal(rsp.status, 302, 'has the status code')
+    assert.equal(rsp.statusText, 'Found', 'has the status text')
+    assert.typeOf(rsp.headers, 'string', 'has the headers')
+
+    const body = (await rsp.readPayload('buffer')) as Buffer
+    const parsed = JSON.parse(body.toString('utf8'))
+    assert.equal(parsed.location, '/v1/redirect/relative/1?test=true', 'has the payload')
+  })
+
+  test('has the final response', async ({ assert, httpConfig }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+
+    const transport = log.request as ISentRequest
+    const response = log.response as IResponse
+
+    const location = `http://localhost:${httpConfig.httpPort}/v1/get?test=true`
+    assert.equal(transport.url, location, 'transport request has the final URL')
+    assert.equal(response.status, 200, 'has the status code')
+  })
+})
+
+test.group('Cookies', (group) => {
+  let baseRequest: IHttpRequest
+  let opts: HttpEngineOptions
+
+  group.each.setup((ctx) => {
+    opts = {
+      logger,
+    }
+    baseRequest = {
+      url: `http://localhost:${ctx.context.httpConfig.httpPort}/v1/redirect/cookies/2`,
+      method: 'GET',
+    }
+  })
+
+  test('supports cookies between redirects', async ({ assert }) => {
+    const request = new CoreEngine(baseRequest, opts)
+    const log = await request.send()
+    const list = log.redirects as IResponseRedirect[]
+    const redirects = list.map((i) => new ResponseRedirect(i))
+    const response = new Response(log.response as IResponse)
+    const payload = (await response.readPayloadAsString()) as string
+    const body = JSON.parse(payload)
+
+    assert.equal(body.headers.cookie, 'redirect-1=true', 'the final response has a cookie set with the last redirect')
+
+    const [, r2] = redirects
+    const rPayload = (await (r2.response as HttpResponse).readPayloadAsString()) as string
+    const rBody = JSON.parse(rPayload)
+    assert.equal(rBody.headers.cookie, 'redirect-1=true', 'the redirect #2 has the cookie')
+  })
+})

package/tests/unit/runtime/http-engine/request_utils.spec.ts

@@ -0,0 +1,175 @@
+import { test } from '@japa/runner'
+import { IHttpRequest, Headers, HttpResponse, ResponseRedirect } from '../../../../src/index.js'
+import * as RequestUtils from '../../../../src/runtime/http-engine/RequestUtils.js'
+
+const requests: IHttpRequest[] = [
+  {
+    url: `http://localhost:1234/api/endpoint?query=param`,
+    method: 'POST',
+    headers: 'content-type: text/plain',
+    payload: {
+      type: 'buffer',
+      data: [...Buffer.from([0x74, 0x65, 0x73, 0x74, 0x0a, 0x74, 0x65, 0x73, 0x74])],
+    },
+  },
+  {
+    url: `http://localhost:1234/api/endpoint?query=param`,
+    method: 'GET',
+    headers: 'Host: test.com',
+  },
+]
+
+test.group('getPort()', () => {
+  test('returns a number when a number is passed', ({ assert }) => {
+    const result = RequestUtils.getPort(20)
+    assert.equal(result, 20)
+  })
+
+  test('returns a number when the argument is a string', ({ assert }) => {
+    const result = RequestUtils.getPort('20')
+    assert.equal(result, 20)
+  })
+
+  test('returns 443 port from the protocol', ({ assert }) => {
+    const result = RequestUtils.getPort(0, 'https:')
+    assert.equal(result, 443)
+  })
+
+  test('returns 80 port from the protocol', ({ assert }) => {
+    // @ts-expect-error Used in testing
+    const result = RequestUtils.getPort(undefined, 'http:')
+    assert.equal(result, 80)
+  })
+})
+
+test.group('getHostHeader()', () => {
+  test('returns host with SSL port', ({ assert }) => {
+    const result = RequestUtils.getHostHeader('https://domain.com/path')
+    assert.equal(result, 'domain.com')
+  })
+
+  test('returns host with http port', ({ assert }) => {
+    const result = RequestUtils.getHostHeader('http://domain.com/path')
+    assert.equal(result, 'domain.com')
+  })
+
+  test('respects an existing port', ({ assert }) => {
+    const result = RequestUtils.getHostHeader('https://domain.com:123/path')
+    assert.equal(result, 'domain.com:123')
+  })
+})
+
+test.group('_addContentLength()', (group) => {
+  let headers: Headers
+  group.each.setup(() => {
+    headers = new Headers()
+  })
+
+  test('adds the content length header', ({ assert }) => {
+    const b = Buffer.from([0x74, 0x65, 0x73, 0x74, 0x0a, 0x74, 0x65, 0x73, 0x74])
+    RequestUtils.addContentLength(requests[0].method as string, b, headers)
+    assert.equal(headers.get('content-length'), '9')
+  })
+
+  test('does nothing for GET requests', ({ assert }) => {
+    // @ts-expect-error Used in testing
+    RequestUtils.addContentLength(requests[1].method as string, undefined, headers)
+    assert.isFalse(headers.has('content-length'))
+  })
+})
+
+test.group('redirectOptions()', () => {
+  ;[300, 304, 305].forEach((code) => {
+    test(`does not set redirect flag for ${code}`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'GET')
+      assert.isFalse(result.redirect)
+    })
+
+    test(`does not set forceGet flag for ${code}`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'GET')
+      assert.isFalse(result.forceGet)
+    })
+  })
+  ;[301, 302, 307].forEach((code) => {
+    test(`Redirects ${code} for HEAD method`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'HEAD')
+      assert.isTrue(result.redirect)
+    })
+
+    test(`Redirects ${code} for GET method`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'GET')
+      assert.isTrue(result.redirect)
+    })
+
+    test(`Do not redirects ${code} for other method`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'POST')
+      assert.isFalse(result.redirect)
+    })
+
+    test(`Do not set forceGet for ${code} status`, ({ assert }) => {
+      const result = RequestUtils.redirectOptions(code, 'GET')
+      assert.isFalse(result.forceGet)
+    })
+  })
+
+  test(`Adds redirect location`, ({ assert }) => {
+    const result = RequestUtils.redirectOptions(301, 'GET', 'domain.com')
+    assert.equal(result.location, 'domain.com')
+  })
+
+  test('Sets forceGet for 303 status', ({ assert }) => {
+    const result = RequestUtils.redirectOptions(303, 'GET')
+    assert.isTrue(result.forceGet)
+  })
+})
+
+test.group('isRedirectLoop()', () => {
+  const url = 'https://domain.com'
+  test('returns false when no redirects', ({ assert }) => {
+    // @ts-expect-error Used in testing
+    const result = RequestUtils.isRedirectLoop(url, undefined)
+    assert.isFalse(result)
+  })
+
+  test('returns false when redirects is empty', ({ assert }) => {
+    const result = RequestUtils.isRedirectLoop(url, [])
+    assert.isFalse(result)
+  })
+
+  test('returns false when url is not on the list', ({ assert }) => {
+    const response = HttpResponse.fromValues(200)
+    const redirect = ResponseRedirect.fromValues('other.com', response)
+    const result = RequestUtils.isRedirectLoop(url, [redirect])
+    assert.isFalse(result)
+  })
+
+  test('returns true when url is on the list', ({ assert }) => {
+    const response = HttpResponse.fromValues(200)
+    const redirect = ResponseRedirect.fromValues(url, response)
+    const result = RequestUtils.isRedirectLoop(url, [redirect])
+    assert.isTrue(result)
+  })
+})
+
+test.group('getRedirectLocation()', () => {
+  test('returns the same valid url', ({ assert }) => {
+    const url = 'https://domain.com/path?a=b'
+    const result = RequestUtils.getRedirectLocation(url, '')
+    assert.equal(result, url)
+  })
+
+  test('Resolves relative URL', ({ assert }) => {
+    const url = '/path?a=b'
+    const base = 'https://domain.com/other'
+    const compare = 'https://domain.com/path?a=b'
+    const result = RequestUtils.getRedirectLocation(url, base)
+    assert.equal(result, compare)
+  })
+
+  test('Returns undefined for unknown state', ({ assert }) => {
+    const url = '/path?a=b'
+    const base = '/other'
+    const result = RequestUtils.getRedirectLocation(url, base)
+    assert.isUndefined(result)
+  })
+})