@api-client/core 0.20.9 → 0.21.0

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

@@ -1,206 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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')
-  })
-})