@api-client/core 0.14.10 → 0.15.0

package/tests/unit/models/response_redirect.spec.ts

@@ -0,0 +1,303 @@
+import { test } from '@japa/runner'
+import {
+  ResponseRedirect,
+  IResponseRedirect,
+  Kind as ResponseRedirectKind,
+} from '../../../src/models/ResponseRedirect.js'
+import { HttpResponse, IHttpResponse } from '../../../src/models/HttpResponse.js'
+import { Kind as RequestTimeKind } from '../../../src/models/RequestTime.js'
+import { ResponseRedirect as LegacyRedirect } from '../../../src/models/legacy/request/ArcResponse.js'
+import { HttpResponseKind } from '../../../src/models/kinds.js'
+
+test.group('Models > ResponseRedirect > ResponseRedirect.fromValues()', (group) => {
+  let response: IHttpResponse
+  group.each.setup(() => {
+    response = HttpResponse.fromValues(200, 'OK', 'content-type: text/plain').toJSON()
+  })
+
+  test('sets the kind', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response)
+    assert.equal(result.kind, ResponseRedirectKind)
+  })
+
+  test('sets the url', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response)
+    assert.equal(result.url, 'https://dot.com')
+  })
+
+  test('sets the response', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response)
+    assert.typeOf(result.response, 'object', 'has the response')
+    assert.isTrue(result.response instanceof HttpResponse, 'has the HttpResponse instance')
+  })
+
+  test('sets the default startTime', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response)
+    assert.equal(result.startTime, 0)
+  })
+
+  test('sets the default endTime', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response)
+    assert.equal(result.endTime, 0)
+  })
+
+  test('sets the startTime', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response, 1234)
+    assert.equal(result.startTime, 1234)
+  })
+
+  test('sets the endTime', ({ assert }) => {
+    const result = ResponseRedirect.fromValues('https://dot.com', response, 1234, 5678)
+    assert.equal(result.endTime, 5678)
+  })
+})
+
+test.group('Models > ResponseRedirect > ResponseRedirect.fromLegacy()', (group) => {
+  let schema: LegacyRedirect
+  group.each.setup(() => {
+    schema = {
+      startTime: 1234,
+      endTime: 5678,
+      url: 'https://rdr.com',
+      timings: {
+        blocked: 1,
+        connect: 2,
+        dns: 3,
+        receive: 4,
+        send: 5,
+        wait: 6,
+        ssl: 7,
+      },
+      response: {
+        status: 307,
+        statusText: 'Moved.',
+        headers: 'location: https://rdr.com',
+        payload: 'I am in a different location.',
+      },
+    }
+  })
+
+  test('sets the kind', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.kind, ResponseRedirectKind)
+  })
+
+  test('sets the startTime', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.startTime, schema.startTime)
+  })
+
+  test('sets the default startTime', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete schema.startTime
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.startTime, 0)
+  })
+
+  test('sets the endTime', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.endTime, schema.endTime)
+  })
+
+  test('sets the default endTime', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete schema.endTime
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.endTime, 0)
+  })
+
+  test('sets the url', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.url, schema.url)
+  })
+
+  test('sets the default url', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete schema.url
+    const result = await ResponseRedirect.fromLegacy(schema)
+    assert.equal(result.url, '')
+  })
+
+  test('sets the response', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    const { response } = result
+    assert.typeOf(response, 'object')
+    assert.equal(response!.status, schema.response.status)
+    assert.equal(response!.statusText, schema.response.statusText)
+    assert.equal(response!.headers, schema.response.headers)
+    assert.equal(response!.payload, 'I am in a different location.')
+  })
+
+  test('sets the default response', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete schema.response
+    const result = await ResponseRedirect.fromLegacy(schema)
+    const { response } = result
+    assert.typeOf(response, 'object')
+    assert.equal(response!.status, 0)
+  })
+
+  test('sets the timings', async ({ assert }) => {
+    const result = await ResponseRedirect.fromLegacy(schema)
+    const { timings } = result
+    assert.typeOf(timings, 'object')
+    assert.equal(timings!.blocked, schema.timings!.blocked)
+    assert.equal(timings!.connect, schema.timings!.connect)
+    assert.equal(timings!.dns, schema.timings!.dns)
+    assert.equal(timings!.receive, schema.timings!.receive)
+    assert.equal(timings!.send, schema.timings!.send)
+    assert.equal(timings!.wait, schema.timings!.wait)
+  })
+})
+
+test.group('Models > ResponseRedirect > constructor()', () => {
+  test('creates a default instance', ({ assert }) => {
+    const result = new ResponseRedirect()
+    assert.equal(result.kind, ResponseRedirectKind)
+    assert.equal(result.endTime, 0)
+    assert.equal(result.startTime, 0)
+    assert.equal(result.url, '')
+    assert.equal(result.response!.status, 0)
+  })
+
+  test('creates an instance from the schema', ({ assert }) => {
+    const schema: IResponseRedirect = {
+      kind: ResponseRedirectKind,
+      startTime: 1234,
+      endTime: 5678,
+      url: 'https://dot.com',
+      response: {
+        status: 200,
+        statusText: 'OK',
+      },
+      timings: {
+        blocked: 1,
+        connect: 2,
+        dns: 3,
+        receive: 4,
+        send: 5,
+        wait: 6,
+        ssl: 7,
+      },
+    }
+    const result = new ResponseRedirect(schema)
+    assert.equal(result.kind, ResponseRedirectKind)
+    assert.equal(result.startTime, 1234)
+    assert.equal(result.endTime, 5678)
+    assert.equal(result.url, 'https://dot.com')
+    assert.equal(result.response!.status, 200)
+    assert.equal(result.response!.statusText, 'OK')
+    assert.equal(result.timings!.blocked, schema.timings!.blocked)
+    assert.equal(result.timings!.connect, schema.timings!.connect)
+  })
+
+  test('the timings is optional', ({ assert }) => {
+    const schema: IResponseRedirect = {
+      kind: ResponseRedirectKind,
+      startTime: 1234,
+      endTime: 5678,
+      url: 'https://dot.com',
+      response: {
+        status: 200,
+        statusText: 'OK',
+      },
+    }
+    const result = new ResponseRedirect(schema)
+    assert.isUndefined(result.timings)
+  })
+
+  test('creates an instance from the JSON schema string', ({ assert }) => {
+    const schema: IResponseRedirect = {
+      kind: ResponseRedirectKind,
+      startTime: 1234,
+      endTime: 5678,
+      url: 'https://dot.com',
+      response: {
+        status: 200,
+        statusText: 'OK',
+      },
+    }
+    const result = new ResponseRedirect(JSON.stringify(schema))
+    assert.equal(result.kind, ResponseRedirectKind)
+    assert.equal(result.startTime, 1234)
+    assert.equal(result.endTime, 5678)
+    assert.equal(result.url, 'https://dot.com')
+    assert.equal(result.response!.status, 200)
+    assert.equal(result.response!.statusText, 'OK')
+  })
+})
+
+test.group('Models > ResponseRedirect > toJSON()', (group) => {
+  let schema: IResponseRedirect
+  let instance: ResponseRedirect
+  group.each.setup(() => {
+    schema = {
+      kind: ResponseRedirectKind,
+      startTime: 1234,
+      endTime: 5678,
+      url: 'https://dot.com',
+      response: {
+        kind: HttpResponseKind,
+        status: 200,
+        statusText: 'OK',
+      },
+      timings: {
+        kind: RequestTimeKind, // Added kind for timings as it's likely a typed object
+        blocked: 1,
+        connect: 2,
+        dns: 3,
+        receive: 4,
+        send: 5,
+        wait: 6,
+        ssl: 7,
+      },
+    }
+    instance = new ResponseRedirect(schema)
+  })
+
+  test('serializes the kind', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.equal(result.kind, ResponseRedirectKind)
+  })
+
+  test('serializes the startTime', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.equal(result.startTime, schema.startTime)
+  })
+
+  test('serializes the endTime', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.equal(result.endTime, schema.endTime)
+  })
+
+  test('serializes the url', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.equal(result.url, schema.url)
+  })
+
+  test('serializes the response', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.deepEqual(result.response, schema.response)
+  })
+
+  test('serializes the default response', ({ assert }) => {
+    delete instance.response
+    const result = instance.toJSON()
+    assert.deepEqual(result.response, {
+      kind: HttpResponseKind,
+      status: 0,
+    })
+  })
+
+  test('serializes the timings', ({ assert }) => {
+    const result = instance.toJSON()
+    // Assuming timings in schema also includes kind after serialization by RequestTime model
+    assert.deepEqual(result.timings, schema.timings)
+  })
+
+  test('does not serialize the timings when missing', ({ assert }) => {
+    delete instance.timings
+    const result = instance.toJSON()
+    assert.isUndefined(result.timings)
+  })
+})

package/tests/unit/models/sent_request.spec.ts

@@ -0,0 +1,206 @@
+import { test } from '@japa/runner'
+import { SentRequest, ISentRequest, IBaseSentRequest } from '../../../src/models/SentRequest.js'
+import { Kind as HttpRequestKind } from '../../../src/models/HttpRequest.js'
+import { TransportRequest as LegacyTransportRequest } from '../../../src/models/legacy/request/ArcRequest.js'
+
+test.group('Models > SentRequest > SentRequest.fromBaseValues()', (group) => {
+  let base: IBaseSentRequest
+  group.each.setup(() => {
+    base = {
+      startTime: 1234,
+      url: 'https://dot.com',
+      endTime: 5678,
+      headers: 'x-test: true',
+      httpMessage: 'GET / HTTP 1/1\n\n',
+      method: 'GET',
+      payload: 'test',
+    }
+  })
+
+  test('sets the kind', ({ assert }) => {
+    const result = SentRequest.fromBaseValues(base)
+    assert.equal(result.kind, HttpRequestKind)
+  })
+
+  // Note: The original test had a duplicate "sets the kind" test. I'm keeping one.
+  // If the second was intended to test something else, it should be adjusted.
+
+  test('sets the httpMessage', ({ assert }) => {
+    const result = SentRequest.fromBaseValues(base)
+    assert.equal(result.httpMessage, base.httpMessage)
+  })
+
+  test('sets the startTime', ({ assert }) => {
+    const result = SentRequest.fromBaseValues(base)
+    assert.equal(result.startTime, base.startTime)
+  })
+
+  test('sets the endTime', ({ assert }) => {
+    const result = SentRequest.fromBaseValues(base)
+    assert.equal(result.endTime, base.endTime)
+  })
+})
+
+test.group('Models > SentRequest > SentRequest.fromLegacy()', (group) => {
+  let base: LegacyTransportRequest
+  group.each.setup(() => {
+    base = {
+      startTime: 1234,
+      url: 'https://dot.com',
+      endTime: 5678,
+      httpMessage: 'GET / HTTP 1/1\n\n',
+      method: 'GET',
+      headers: 'x-test: true',
+      payload: 'test',
+    }
+  })
+
+  test('sets the kind', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.kind, HttpRequestKind)
+  })
+
+  test('sets the url', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.url, base.url)
+  })
+
+  test('sets the default url when missing', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete base.url
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.url, '')
+  })
+
+  test('sets the startTime', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.startTime, base.startTime)
+  })
+
+  test('sets the default startTime', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete base.startTime
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.startTime, 0)
+  })
+
+  test('sets the endTime', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.endTime, base.endTime)
+  })
+
+  test('sets the default endTime when missing', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete base.endTime
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.endTime, 0)
+  })
+
+  test('sets the httpMessage', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.httpMessage, base.httpMessage)
+  })
+
+  test('does not set the httpMessage when missing', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete base.httpMessage
+    const result = await SentRequest.fromLegacy(base)
+    assert.isUndefined(result.httpMessage)
+  })
+
+  test('sets the method', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.method, base.method)
+  })
+
+  test('sets the default method when missing', async ({ assert }) => {
+    // @ts-expect-error Used in testing
+    delete base.method
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.method, 'GET')
+  })
+
+  test('sets the headers', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.headers, base.headers)
+  })
+
+  test('does not set the headers when missing', async ({ assert }) => {
+    delete base.headers
+    const result = await SentRequest.fromLegacy(base)
+    assert.isUndefined(result.headers)
+  })
+
+  test('sets the payload', async ({ assert }) => {
+    const result = await SentRequest.fromLegacy(base)
+    assert.equal(result.payload, 'test')
+  })
+
+  test('does not set the payload when missing', async ({ assert }) => {
+    delete base.payload
+    const result = await SentRequest.fromLegacy(base)
+    assert.isUndefined(result.payload)
+  })
+})
+
+test.group('Models > SentRequest > constructor()', () => {
+  test('creates a default instance', ({ assert }) => {
+    const result = new SentRequest()
+    assert.equal(result.kind, HttpRequestKind)
+    assert.equal(result.url, '')
+    assert.equal(result.startTime, 0)
+  })
+
+  test('creates an instance from schema', ({ assert }) => {
+    const schema: ISentRequest = {
+      kind: HttpRequestKind,
+      startTime: 1234,
+      url: 'https://dot.com',
+      endTime: 56789,
+      httpMessage: 'GET / HTTP 1/1\n\n',
+      method: 'GET',
+      headers: 'x-test: true',
+      payload: 'test',
+    }
+    const result = new SentRequest(schema)
+    assert.deepEqual(result.toJSON(), schema)
+  })
+
+  test('creates an instance from a JSON schema string', ({ assert }) => {
+    const schema: ISentRequest = {
+      kind: HttpRequestKind,
+      startTime: 1234,
+      url: 'https://dot.com',
+      endTime: 56789,
+      httpMessage: 'GET / HTTP 1/1\n\n',
+      method: 'GET',
+      headers: 'x-test: true',
+      payload: 'test',
+    }
+    const result = new SentRequest(JSON.stringify(schema))
+    assert.deepEqual(result.toJSON(), schema)
+  })
+})
+
+test.group('Models > SentRequest > toJSON()', (group) => {
+  let schema: ISentRequest
+  let instance: SentRequest
+  group.each.setup(() => {
+    schema = {
+      kind: HttpRequestKind,
+      startTime: 1234,
+      url: 'https://dot.com',
+      endTime: 56789,
+      httpMessage: 'GET / HTTP 1/1\n\n',
+      method: 'GET',
+      headers: 'x-test: true',
+      payload: 'test',
+    }
+    instance = new SentRequest(schema)
+  })
+
+  test('serializes all properties from schema', ({ assert }) => {
+    const result = instance.toJSON()
+    assert.deepEqual(result, schema)
+  })
+})

package/tests/unit/models/server.spec.ts

@@ -0,0 +1,195 @@
+import { test } from '@japa/runner'
+import { Server, IServer, Kind as ServerKind } from '../../../src/models/Server.js'
+import { Property } from '../../../src/models/Property.js'
+
+test.group('Models > Server > Server.fromUri()', () => {
+  test('sets the kind', ({ assert }) => {
+    const result = Server.fromUri('https://dot.com')
+    assert.equal(result.kind, ServerKind)
+  })
+
+  test('sets the uri', ({ assert }) => {
+    const result = Server.fromUri('https://dot.com')
+    assert.equal(result.uri, 'https://dot.com')
+  })
+})
+
+test.group('Models > Server > constructor()', () => {
+  test('creates an empty Server', ({ assert }) => {
+    const result = new Server()
+    assert.equal(result.kind, ServerKind)
+    assert.equal(result.uri, '')
+    assert.isUndefined(result.description)
+    assert.isUndefined(result.protocol)
+    assert.isUndefined(result.basePath)
+  })
+
+  test('creates a Server from the schema values', ({ assert }) => {
+    const schema: IServer = {
+      kind: ServerKind,
+      uri: 'dot.com',
+      description: 'a desc',
+      protocol: 'https:',
+      basePath: '/api',
+    }
+    const result = new Server(schema)
+    assert.equal(result.kind, ServerKind)
+    assert.equal(result.uri, 'dot.com')
+    assert.equal(result.description, 'a desc')
+    assert.equal(result.protocol, 'https:')
+    assert.equal(result.basePath, '/api')
+  })
+
+  test('creates a Server from the JSON schema string', ({ assert }) => {
+    const schema: IServer = {
+      kind: ServerKind,
+      uri: 'dot.com',
+      description: 'a desc',
+      protocol: 'https:',
+      basePath: '/api',
+    }
+    const result = new Server(JSON.stringify(schema))
+    assert.equal(result.kind, ServerKind)
+    assert.equal(result.uri, 'dot.com')
+    assert.equal(result.description, 'a desc')
+    assert.equal(result.protocol, 'https:')
+    assert.equal(result.basePath, '/api')
+  })
+
+  test('throws when invalid schema', ({ assert }) => {
+    assert.throws(() => {
+      new Server(
+        JSON.stringify({
+          name: 'a name', // Invalid, Server expects 'uri' not 'name' for primary identifier
+        })
+      )
+    })
+  })
+})
+
+test.group('Models > Server > toJSON()', (group) => {
+  let server: Server
+  group.each.setup(() => {
+    server = new Server()
+  })
+
+  test('serializes the kind', ({ assert }) => {
+    const result = server.toJSON()
+    assert.equal(result.kind, ServerKind)
+  })
+
+  test('serializes the uri', ({ assert }) => {
+    server.uri = 'dot.com'
+    const result = server.toJSON()
+    assert.equal(result.uri, 'dot.com')
+  })
+
+  test('serializes the description', ({ assert }) => {
+    server.description = 'a description'
+    const result = server.toJSON()
+    assert.equal(result.description, 'a description')
+  })
+
+  test('does not serialize description when missing', ({ assert }) => {
+    const result = server.toJSON()
+    assert.isUndefined(result.description)
+  })
+
+  test('serializes the protocol', ({ assert }) => {
+    server.protocol = 'a protocol'
+    const result = server.toJSON()
+    assert.equal(result.protocol, 'a protocol')
+  })
+
+  test('does not serialize protocol when missing', ({ assert }) => {
+    const result = server.toJSON()
+    assert.isUndefined(result.protocol)
+  })
+
+  test('serializes the basePath', ({ assert }) => {
+    server.basePath = 'a basePath'
+    const result = server.toJSON()
+    assert.equal(result.basePath, 'a basePath')
+  })
+
+  test('does not serialize basePath when missing', ({ assert }) => {
+    const result = server.toJSON()
+    assert.isUndefined(result.basePath)
+  })
+})
+
+test.group('Models > Server > readUri()', () => {
+  test('returns empty string when no data', ({ assert }) => {
+    const info = new Server()
+    const result = info.readUri()
+    assert.equal(result, '')
+  })
+
+  test('returns the uri value', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'dot.com'
+    const result = info.readUri()
+    assert.equal(result, 'dot.com')
+  })
+
+  test('adds the protocol when missing', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'dot.com'
+    info.protocol = 'http:'
+    const result = info.readUri()
+    assert.equal(result, 'http://dot.com')
+  })
+
+  test('ignores the protocol when not missing', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'https://dot.com'
+    info.protocol = 'http:'
+    const result = info.readUri()
+    assert.equal(result, 'https://dot.com')
+  })
+
+  test('adds the base path', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'dot.com'
+    info.basePath = '/api'
+    const result = info.readUri()
+    assert.equal(result, 'dot.com/api')
+  })
+
+  test('clears the base uri before adding the base path', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'dot.com/'
+    info.basePath = '/api'
+    const result = info.readUri()
+    assert.equal(result, 'dot.com/api')
+  })
+
+  test('normalizes the base path', ({ assert }) => {
+    const info = new Server()
+    info.uri = 'dot.com'
+    info.basePath = 'api'
+    const result = info.readUri()
+    assert.equal(result, 'dot.com/api')
+  })
+
+  test('evaluates the uri when no variables', ({ assert }) => {
+    const info = Server.fromUri('https://api.com')
+    const p1 = Property.String('a', 'b')
+    const result = info.readUri([p1])
+    assert.equal(result, 'https://api.com')
+  })
+
+  test('evaluates the uri', ({ assert }) => {
+    const info = Server.fromUri('https://{a}.com')
+    const p1 = Property.String('a', 'b')
+    const result = info.readUri([p1])
+    assert.equal(result, 'https://b.com')
+  })
+
+  test('evaluates the uri when no property', ({ assert }) => {
+    const info = Server.fromUri('https://{a}.com')
+    const p1 = Property.String('c', 'b')
+    const result = info.readUri([p1])
+    assert.equal(result, 'https://{a}.com')
+  })
+})