@api-client/core 0.14.9 → 0.15.0

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

@@ -0,0 +1,183 @@
+import { test } from '@japa/runner'
+import { HttpResponse } from '../../../src/models/HttpResponse.js'
+import { ErrorResponse, IErrorResponse } from '../../../src/models/ErrorResponse.js'
+import { ErrorResponse as LegacyErrorResponse } from '../../../src/models/legacy/request/ArcResponse.js'
+import { HttpResponseKind } from '../../../src/models/kinds.js'
+import { ISerializedError } from '../../../src/models/SerializableError.js'
+
+test.group('Models > ErrorResponse > Initialization > Default response initialization', () => {
+  test('initializes a default project', ({ assert }) => {
+    const result = new ErrorResponse()
+    assert.equal(result.kind, HttpResponseKind, 'sets the kind property')
+    assert.equal(result.status, 0, 'sets the status property')
+    assert.equal(result.error.message, 'Unknown error', 'sets the error')
+    assert.isUndefined(result.statusText, 'has no statusText property')
+    assert.isUndefined(result.headers, 'has no headers property')
+    assert.isUndefined(result.payload, 'has no payload property')
+  })
+})
+
+test.group('Models > ErrorResponse > Initialization > From schema initialization', (group) => {
+  let base: IErrorResponse
+  group.each.setup(() => {
+    base = {
+      kind: HttpResponseKind,
+      status: 0,
+      error: 'test',
+    }
+  })
+
+  test('sets the kind', ({ assert }) => {
+    const init: IErrorResponse = { ...base }
+    const response = new ErrorResponse(init)
+    assert.equal(response.kind, HttpResponseKind)
+  })
+
+  test('sets the status', ({ assert }) => {
+    const init: IErrorResponse = { ...base, ...{ status: 200 } }
+    const response = new ErrorResponse(init)
+    assert.equal(response.status, 200)
+  })
+
+  test('sets the error', ({ assert }) => {
+    const init: IErrorResponse = { ...base }
+    const response = new ErrorResponse(init)
+    assert.equal(response.error.message, 'test')
+  })
+
+  test('sets the parent properties', ({ assert }) => {
+    const init: IErrorResponse = {
+      ...base,
+      ...{
+        status: 200,
+        statusText: 'hello',
+        headers: 'content-type: test',
+        payload: 'test',
+      },
+    }
+    const response = new ErrorResponse(JSON.stringify(init))
+    assert.equal(response.status, 200, 'has the status')
+    assert.equal(response.statusText, 'hello', 'has the statusText')
+    assert.equal(response.headers, 'content-type: test', 'has the headers')
+    assert.equal(response.payload, 'test', 'has the payload')
+  })
+})
+
+test.group('toJSON()', () => {
+  test('serializes the kind', ({ assert }) => {
+    const response = new ErrorResponse()
+    const result = response.toJSON()
+    assert.equal(result.kind, HttpResponseKind)
+  })
+
+  test('serializes the error', ({ assert }) => {
+    const response = ErrorResponse.fromError('test')
+    const result = response.toJSON()
+    assert.equal((result.error as ISerializedError).message, 'test')
+  })
+
+  test('serializes the parent values', ({ assert }) => {
+    const init: IErrorResponse = {
+      status: 200,
+      statusText: 'hello',
+      headers: 'content-type: test',
+      payload: 'test',
+      error: 'test',
+    }
+    const response = new ErrorResponse(init)
+    const result = response.toJSON()
+    assert.equal(result.status, 200)
+    assert.equal(result.statusText, 'hello')
+  })
+})
+
+test.group('ErrorResponse.isErrorResponse()', () => {
+  test('returns true when is an error response', ({ assert }) => {
+    const response = ErrorResponse.fromError('test')
+    assert.isTrue(ErrorResponse.isErrorResponse(response.toJSON()))
+  })
+
+  test('returns false otherwise', ({ assert }) => {
+    const response = HttpResponse.fromValues(200)
+    assert.isFalse(ErrorResponse.isErrorResponse(response.toJSON()))
+  })
+})
+
+test.group('ErrorResponse.fromLegacy()', () => {
+  test('sets the kind', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.kind, HttpResponseKind)
+  })
+
+  test('sets the status', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.status, 200)
+  })
+
+  test('sets the default status', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      // @ts-expect-error Used in testing
+      status: undefined,
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.status, 0)
+  })
+
+  test('sets the error', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.error.message, 'test')
+  })
+
+  test('sets the default error', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      // @ts-expect-error Used in testing
+      error: undefined,
+      status: 100,
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.error.message, 'Unknown error')
+  })
+
+  test('sets the headers', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+      headers: 'x-test: true',
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.headers, 'x-test: true')
+  })
+
+  test('sets the statusText', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+      statusText: 'Super OK',
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.statusText, 'Super OK')
+  })
+
+  test('sets the payload from a string', async ({ assert }) => {
+    const init: LegacyErrorResponse = {
+      error: new Error('test'),
+      status: 200,
+      payload: 'I am an error',
+    }
+    const response = await ErrorResponse.fromLegacy(init)
+    assert.equal(response.payload, 'I am an error')
+  })
+})

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

@@ -0,0 +1,86 @@
+import { test } from '@japa/runner'
+import { assert } from '@esm-bundle/chai'
+import { Property } from '../../../src/models/Property.js'
+import { HeadersArray } from '../../../src/models/HeadersArray.js'
+import { Headers } from '../../../src/lib/headers/Headers.js'
+
+test('HeadersArray.from() | initializes the array with the properties', () => {
+  const p1 = Property.String('a', 'b', true).toJSON()
+  const p2 = Property.String('c', 'd', false).toJSON()
+  const arr = HeadersArray.from([p1, p2])
+  assert.lengthOf(arr, 2, 'has 2 elements')
+  assert.equal(arr[0].name, 'a', 'has item #1 name')
+  assert.equal(arr[0].value, 'b', 'has item #1 value')
+  assert.equal(arr[0].enabled, true, 'has item #1 enabled')
+  assert.equal(arr[1].name, 'c', 'has item #2 name')
+  assert.equal(arr[1].value, 'd', 'has item #2 value')
+  assert.equal(arr[1].enabled, false, 'has item #2 enabled')
+  assert.instanceOf(arr[0], Property, 'items are instances of Property')
+})
+
+test('HeadersArray.from() | initializes the array from a set', () => {
+  const p1 = Property.String('a', 'b', true).toJSON()
+  const p2 = Property.String('c', 'd', false).toJSON()
+  const arr = HeadersArray.from([...new Set([p1, p2])])
+  assert.lengthOf(arr, 2, 'has 2 elements')
+  assert.instanceOf(arr[0], Property, 'items are instances of Property')
+})
+
+test('HeadersArray.fromHeaders() | initializes all items', () => {
+  const input = 'My_Test: header\n# disabled: value\nAbCd: Test'
+  const arr = HeadersArray.fromHeaders(input)
+  assert.lengthOf(arr, 3, 'has 3 elements')
+  assert.equal(arr[0].enabled, true, 'has item #1 enabled')
+  assert.equal(arr[1].enabled, false, 'has item #2 enabled')
+  assert.equal(arr[2].enabled, true, 'has item #3 enabled')
+
+  assert.equal(arr[0].type, 'string', 'has item #1 type')
+  assert.equal(arr[1].type, 'string', 'has item #2 type')
+  assert.equal(arr[2].type, 'string', 'has item #3 type')
+
+  assert.instanceOf(arr[0], Property, 'items are instances of Property')
+})
+
+test('HeadersArray#toString() | returns an HTTP string', () => {
+  const input = 'My_Test: header\nAbCd: Test'
+  const instance = HeadersArray.fromHeaders(input)
+  const result = instance.toString()
+  assert.equal(result, input)
+})
+
+test('HeadersArray#toString() | does not include disabled items', () => {
+  const input = 'My_Test: header\nAbCd: Test'
+  const str = 'My_Test: header\nAbCd: Test\n#disabled: value'
+  const instance = HeadersArray.fromHeaders(str)
+  const result = instance.toString()
+  assert.equal(result, input)
+})
+
+test('HeadersArray#toRawString() | returns an HTTP string', () => {
+  const input = 'My_Test: header\n# disabled: value\nAbCd: Test'
+  const instance = HeadersArray.fromHeaders(input)
+  const result = instance.toRawString()
+  assert.equal(result, input)
+})
+
+test('HeadersArray#toHeaders() | returns an instance of headers', () => {
+  const input = 'My_Test: header\n# disabled: value\nAbCd: Test'
+  const instance = HeadersArray.fromHeaders(input)
+  const result = instance.toHeaders()
+  assert.instanceOf(result, Headers, 'is the instance of headers')
+})
+
+test('HeadersArray#toHeaders() | has enabled properties', () => {
+  const input = 'My_Test: header\n# disabled: value\nAbCd: Test'
+  const instance = HeadersArray.fromHeaders(input)
+  const result = instance.toHeaders()
+  assert.equal(result.get('My_Test'), 'header')
+  assert.equal(result.get('AbCd'), 'Test')
+})
+
+test('HeadersArray#toHeaders() | has disabled properties', () => {
+  const input = 'My_Test: header\n# disabled: value\nAbCd: Test'
+  const instance = HeadersArray.fromHeaders(input)
+  const result = instance.toHeaders()
+  assert.equal(result._map['disabled'].value, 'value')
+})

package/tests/unit/models/http-actions/assertion/equal_assertion.spec.ts

@@ -0,0 +1,103 @@
+import { test } from '@japa/runner'
+import { assert } from '@esm-bundle/chai'
+import {
+  EqualAssertion,
+  EqualAssertionKind,
+} from '../../../../../src/models/http-flows/steps/assertion/EqualAssertion.js'
+
+test.group('EqualAssertion constructor()', () => {
+  test('initializes from values', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.equal(instance.value, 'a')
+    assert.equal(instance.dataType, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.isTrue(instance.strict)
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores not set values', () => {
+    const instance = new EqualAssertion('a')
+    assert.equal(instance.value, 'a')
+    assert.isUndefined(instance.dataType)
+    assert.isUndefined(instance.strict)
+  })
+
+  test('initializes from the schema', () => {
+    const instance = new EqualAssertion({
+      kind: EqualAssertionKind,
+      value: 'a',
+      strict: false,
+      dataType: 'http://www.w3.org/2001/XMLSchema#boolean',
+      enabled: false,
+    })
+    assert.equal(instance.value, 'a')
+    assert.equal(instance.dataType, 'http://www.w3.org/2001/XMLSchema#boolean')
+    assert.isFalse(instance.strict)
+    assert.isFalse(instance.enabled)
+  })
+
+  test('initializes empty class', () => {
+    const instance = new EqualAssertion()
+    assert.equal(instance.kind, EqualAssertionKind)
+    assert.isUndefined(instance.enabled)
+  })
+})
+
+test.group('EqualAssertion checkValidity()', () => {
+  test('returns true when has the value', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.isTrue(instance.checkValidity())
+  })
+
+  test('returns false when has no value', () => {
+    const instance = new EqualAssertion()
+    assert.isFalse(instance.checkValidity())
+  })
+})
+
+test.group('EqualAssertion toJSON()', () => {
+  test('serializes the kind', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.equal(instance.kind, EqualAssertionKind)
+  })
+
+  test('serializes the value when set', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.equal(instance.value, 'a')
+  })
+
+  test('ignores the value when not set', () => {
+    const instance = new EqualAssertion()
+    assert.isUndefined(instance.value)
+  })
+
+  test('serializes the dataType when set', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.equal(instance.dataType, 'http://www.w3.org/2001/XMLSchema#string')
+  })
+
+  test('ignores the dataType when not set', () => {
+    const instance = new EqualAssertion()
+    assert.isUndefined(instance.dataType)
+  })
+
+  test('serializes the strict when set', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    assert.isTrue(instance.strict)
+  })
+
+  test('ignores the strict when not set', () => {
+    const instance = new EqualAssertion()
+    assert.isUndefined(instance.strict)
+  })
+
+  test('serializes the enabled when set', () => {
+    const instance = new EqualAssertion('a', true, 'http://www.w3.org/2001/XMLSchema#string')
+    instance.enabled = true
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores the enabled when not set', () => {
+    const instance = new EqualAssertion()
+    assert.isUndefined(instance.enabled)
+  })
+})

package/tests/unit/models/http-actions/assertion/greater_than_assertion.spec.ts

@@ -0,0 +1,91 @@
+import { test } from '@japa/runner'
+import { assert } from '@esm-bundle/chai'
+import {
+  GreaterThanAssertion,
+  GreaterThanAssertionKind,
+} from '../../../../../src/models/http-flows/steps/assertion/GreaterThanAssertion.js'
+
+test.group('GreaterThanAssertion constructor()', () => {
+  test('initializes from values', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    assert.equal(instance.value, 10)
+    assert.isTrue(instance.equal)
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores not set values', () => {
+    const instance = new GreaterThanAssertion(5)
+    assert.equal(instance.value, 5)
+    assert.isUndefined(instance.equal)
+  })
+
+  test('initializes from the schema', () => {
+    const instance = new GreaterThanAssertion({
+      kind: GreaterThanAssertionKind,
+      value: 5,
+      equal: false,
+      enabled: false,
+    })
+    assert.equal(instance.value, 5)
+    assert.isFalse(instance.equal)
+    assert.isFalse(instance.enabled)
+  })
+
+  test('initializes empty class', () => {
+    const instance = new GreaterThanAssertion()
+    assert.equal(instance.kind, GreaterThanAssertionKind)
+    assert.isUndefined(instance.enabled)
+    assert.isUndefined(instance.value)
+    assert.isUndefined(instance.equal)
+  })
+})
+
+test.group('GreaterThanAssertion checkValidity()', () => {
+  test('returns true when has the value', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    assert.isTrue(instance.checkValidity())
+  })
+
+  test('returns false when has no value', () => {
+    const instance = new GreaterThanAssertion()
+    assert.isFalse(instance.checkValidity())
+  })
+})
+
+test.group('GreaterThanAssertion toJSON()', () => {
+  test('serializes the kind', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    assert.equal(instance.kind, GreaterThanAssertionKind)
+  })
+
+  test('serializes the value when set', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    assert.equal(instance.value, 10)
+  })
+
+  test('ignores the value when not set', () => {
+    const instance = new GreaterThanAssertion()
+    assert.isUndefined(instance.value)
+  })
+
+  test('serializes the equal when set', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    assert.isTrue(instance.equal)
+  })
+
+  test('ignores the strict when not set', () => {
+    const instance = new GreaterThanAssertion()
+    assert.isUndefined(instance.equal)
+  })
+
+  test('serializes the enabled when set', () => {
+    const instance = new GreaterThanAssertion(10, true)
+    instance.enabled = true
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores the enabled when not set', () => {
+    const instance = new GreaterThanAssertion()
+    assert.isUndefined(instance.enabled)
+  })
+})

package/tests/unit/models/http-actions/assertion/includes_assertion.spec.ts

@@ -0,0 +1,71 @@
+import { test } from '@japa/runner'
+import { assert } from '@esm-bundle/chai'
+import {
+  IncludesAssertion,
+  IncludesAssertionKind,
+} from '../../../../../src/models/http-flows/steps/assertion/IncludesAssertion.js'
+
+test.group('IncludesAssertion constructor()', () => {
+  test('initializes from values', () => {
+    const instance = new IncludesAssertion('test-value')
+    assert.equal(instance.value, 'test-value')
+    assert.isTrue(instance.enabled)
+  })
+
+  test('initializes from the schema', () => {
+    const instance = new IncludesAssertion({
+      kind: IncludesAssertionKind,
+      value: 'test-value',
+      enabled: false,
+    })
+    assert.equal(instance.value, 'test-value')
+    assert.isFalse(instance.enabled)
+  })
+
+  test('initializes empty class', () => {
+    const instance = new IncludesAssertion()
+    assert.equal(instance.kind, IncludesAssertionKind)
+    assert.isUndefined(instance.enabled)
+    assert.isUndefined(instance.value)
+  })
+})
+
+test.group('IncludesAssertion checkValidity()', () => {
+  test('returns true when has the value', () => {
+    const instance = new IncludesAssertion('test-value')
+    assert.isTrue(instance.checkValidity())
+  })
+
+  test('returns false when has no value', () => {
+    const instance = new IncludesAssertion()
+    assert.isFalse(instance.checkValidity())
+  })
+})
+
+test.group('IncludesAssertion toJSON()', () => {
+  test('serializes the kind', () => {
+    const instance = new IncludesAssertion('test-value')
+    assert.equal(instance.kind, IncludesAssertionKind)
+  })
+
+  test('serializes the value when set', () => {
+    const instance = new IncludesAssertion('test-value')
+    assert.equal(instance.value, 'test-value')
+  })
+
+  test('ignores the value when not set', () => {
+    const instance = new IncludesAssertion()
+    assert.isUndefined(instance.value)
+  })
+
+  test('serializes the enabled when set', () => {
+    const instance = new IncludesAssertion('test-value')
+    instance.enabled = true
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores the enabled when not set', () => {
+    const instance = new IncludesAssertion()
+    assert.isUndefined(instance.enabled)
+  })
+})

package/tests/unit/models/http-actions/assertion/less_than_assertion.spec.ts

@@ -0,0 +1,91 @@
+import { test } from '@japa/runner'
+import { assert } from '@esm-bundle/chai'
+import {
+  LessThanAssertion,
+  LessThanAssertionKind,
+} from '../../../../../src/models/http-flows/steps/assertion/LessThanAssertion.js'
+
+test.group('LessThanAssertion constructor()', () => {
+  test('initializes from values', () => {
+    const instance = new LessThanAssertion(10, true)
+    assert.equal(instance.value, 10)
+    assert.isTrue(instance.equal)
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores not set values', () => {
+    const instance = new LessThanAssertion(5)
+    assert.equal(instance.value, 5)
+    assert.isUndefined(instance.equal)
+  })
+
+  test('initializes from the schema', () => {
+    const instance = new LessThanAssertion({
+      kind: LessThanAssertionKind,
+      value: 5,
+      equal: false,
+      enabled: false,
+    })
+    assert.equal(instance.value, 5)
+    assert.isFalse(instance.equal)
+    assert.isFalse(instance.enabled)
+  })
+
+  test('initializes empty class', () => {
+    const instance = new LessThanAssertion()
+    assert.equal(instance.kind, LessThanAssertionKind)
+    assert.isUndefined(instance.enabled)
+    assert.isUndefined(instance.value)
+    assert.isUndefined(instance.equal)
+  })
+})
+
+test.group('LessThanAssertion checkValidity()', () => {
+  test('returns true when has the value', () => {
+    const instance = new LessThanAssertion(10, true)
+    assert.isTrue(instance.checkValidity())
+  })
+
+  test('returns false when has no value', () => {
+    const instance = new LessThanAssertion()
+    assert.isFalse(instance.checkValidity())
+  })
+})
+
+test.group('LessThanAssertion toJSON()', () => {
+  test('serializes the kind', () => {
+    const instance = new LessThanAssertion(10, true)
+    assert.equal(instance.kind, LessThanAssertionKind)
+  })
+
+  test('serializes the value when set', () => {
+    const instance = new LessThanAssertion(10, true)
+    assert.equal(instance.value, 10)
+  })
+
+  test('ignores the value when not set', () => {
+    const instance = new LessThanAssertion()
+    assert.isUndefined(instance.value)
+  })
+
+  test('serializes the equal when set', () => {
+    const instance = new LessThanAssertion(10, true)
+    assert.isTrue(instance.equal)
+  })
+
+  test('ignores the strict when not set', () => {
+    const instance = new LessThanAssertion()
+    assert.isUndefined(instance.equal)
+  })
+
+  test('serializes the enabled when set', () => {
+    const instance = new LessThanAssertion(10, true)
+    instance.enabled = true
+    assert.isTrue(instance.enabled)
+  })
+
+  test('ignores the enabled when not set', () => {
+    const instance = new LessThanAssertion()
+    assert.isUndefined(instance.enabled)
+  })
+})