@api-client/core 0.14.9 → 0.15.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/tests/unit/models/http-actions/transformation/as_lower_case_step.spec.ts

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

package/tests/unit/models/http-actions/transformation/as_number_step.spec.ts

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