@api-client/core 0.19.10 → 0.19.12

package/tests/unit/amf/schema_gen_array.spec.ts

@@ -1,199 +0,0 @@
-import { test } from '@japa/runner'
-import { DOMParser } from '@xmldom/xmldom'
-import { AmfNamespace as ns } from '../../../src/amf/definitions/Namespace.js'
-import { ApiSchemaGenerator, ISchemaExample } from '../../../src/amf/ApiSchemaGenerator.js'
-import { AmfLoader } from './AmfLoader.js'
-import { IAmfDocument } from '../../../src/amf/definitions/Amf.js'
-
-const loader = new AmfLoader()
-const jsonMime = 'application/json'
-const xmlMime = 'application/xml'
-
-test.group(`array values / ${jsonMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-  })
-
-  test('generates a valid schema', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed, 'object', 'result is an object')
-  })
-
-  test('has only required fields', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed.tags, 'array', 'tags is set')
-    assert.typeOf(parsed.exampleValue, 'array', 'exampleValue is set')
-    assert.typeOf(parsed.examplesValue, 'array', 'examplesValue is set')
-    assert.typeOf(parsed.defaultValue, 'array', 'defaultValue is set')
-  })
-
-  test('has only default values', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed.tags, 'array', 'tags is set')
-    assert.typeOf(parsed.tags[0], 'string', 'tags have correct type')
-    assert.typeOf(parsed.exampleValue, 'array', 'exampleValue is set')
-    assert.typeOf(parsed.exampleValue[0], 'number', 'exampleValue is set')
-    assert.deepEqual(parsed.defaultValue, ['A tag'], 'defaultValue is set')
-  })
-
-  test('has default values and examples', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderExamples: true,
-    })
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed.tags, 'array', 'tags is set')
-    assert.typeOf(parsed.tags[0], 'string', 'tags have correct type')
-    assert.deepEqual(parsed.exampleValue, [123], 'exampleValue is set')
-    assert.deepEqual(parsed.examplesValue, ['value 1'], 'examplesValue is set')
-    assert.deepEqual(parsed.defaultValue, ['A tag'], 'defaultValue is set')
-  })
-
-  test('processes object items', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArrayObject')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderExamples: true,
-      renderMocked: true,
-    })
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed, 'array', 'result is an array')
-    const [schema] = parsed
-    assert.isNotEmpty(schema.id, 'sets a string type (id)')
-    assert.typeOf(schema.id, 'string', 'sets a string type (id)')
-    assert.strictEqual(schema.name, 'Pawel Uchida-Psztyc', 'sets a string type (name)')
-    assert.strictEqual(schema.sex, 'male', 'sets a string type (sex)')
-    assert.strictEqual(schema.tosAccepted, false, 'sets a boolean type from examples')
-  })
-
-  test('generates the example', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asExample(shape, jsonMime) as ISchemaExample
-    assert.typeOf(result, 'object', 'returns an object')
-    assert.isTrue(result.strict, 'has the strict property')
-    assert.deepEqual(result.types, [ns.aml.vocabularies.apiContract.Example], 'has the types property')
-    assert.equal(result.mediaType, jsonMime, 'has the mediaType property')
-    assert.typeOf(result.renderValue, 'string', 'has the renderValue')
-    const parsed = JSON.parse(result.renderValue as string)
-    assert.typeOf(parsed, 'object', 'result is an object')
-  })
-})
-
-test.group(`array values / ${xmlMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-  })
-  test('has only required fields', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderMocked: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    const tags = schema.getElementsByTagName('tags')[0]
-    assert.ok(tags, 'has array element')
-    assert.isNotEmpty(tags.textContent!.trim(), 'has auto-generated array item (tags)')
-
-    const exampleValue = schema.getElementsByTagName('exampleValue')[0]
-    assert.ok(exampleValue, 'has exampleValue array')
-    // this is a required field with integer value. This automatically adds number value to the schema.
-    assert.match(exampleValue.textContent!.trim(), /^\d+$/, 'has default generated value (exampleValue)')
-
-    const examplesValue = schema.getElementsByTagName('examplesValue')[0]
-    assert.ok(examplesValue, 'has examplesValue array')
-    assert.isNotEmpty(examplesValue.textContent!.trim(), 'has generated array item (examplesValue)')
-
-    const defaultValue = schema.getElementsByTagName('defaultValue')[0]
-    assert.ok(defaultValue, 'has defaultValue array')
-    assert.strictEqual(defaultValue.textContent!.trim(), 'A tag', 'has a default value (defaultValue)')
-  })
-
-  test('has default values, mocked values, and examples', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-      renderMocked: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    const tags = schema.getElementsByTagName('tags')[0]
-    assert.ok(tags, 'has tags array')
-    assert.isNotEmpty(tags.textContent!.trim(), 'has auto-generated array item (tags)')
-
-    const exampleValue = schema.getElementsByTagName('exampleValue')[0]
-    assert.ok(exampleValue, 'has exampleValue array')
-    assert.strictEqual(exampleValue.textContent!.trim(), '123', 'has example value (exampleValue)')
-
-    const examplesValue = schema.getElementsByTagName('examplesValue')
-    assert.lengthOf(examplesValue, 1, 'has the examplesValue array')
-    assert.strictEqual(examplesValue[0].textContent!.trim(), 'value 1', 'has example value (examplesValue[0])')
-    // assert.strictEqual(examplesValue[1].textContent!.trim(), 'value 2', 'has example value (examplesValue[1])');
-
-    const defaultValue = schema.getElementsByTagName('defaultValue')[0]
-    assert.ok(defaultValue, 'has defaultValue array')
-    assert.strictEqual(defaultValue.textContent!.trim(), 'A tag', 'has a default value (defaultValue)')
-  })
-
-  test('processes object items without wrapping', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArrayObject')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-    })
-    const parser = new DOMParser()
-    // array items not wrapped comes without parent.
-    const wrapped = `<parent-wrapper>${result}</parent-wrapper>`
-    const schema = parser.parseFromString(wrapped, xmlMime)
-
-    const parent = schema.getElementsByTagName('ObjectWithArrayObject')[0]
-    assert.ok(parent, 'has ObjectWithArrayObject object')
-
-    assert.strictEqual(
-      schema.getElementsByTagName('name')[0].textContent!.trim(),
-      'Pawel Uchida-Psztyc',
-      'sets a string type (name)'
-    )
-    assert.strictEqual(schema.getElementsByTagName('sex')[0].textContent!.trim(), 'male', 'sets a string type (sex)')
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-    assert.isUndefined(schema.getElementsByTagName('newsletter')[0], 'has no optional value (newsletter)')
-    assert.isUndefined(schema.getElementsByTagName('age')[0], 'has no optional value (age)')
-  })
-
-  test('generates the example', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = ApiSchemaGenerator.asExample(shape, xmlMime, {
-      renderMocked: true,
-    }) as ISchemaExample
-    assert.typeOf(result, 'object', 'returns an object')
-    assert.isTrue(result.strict, 'has the strict property')
-    assert.deepEqual(result.types, [ns.aml.vocabularies.apiContract.Example], 'has the types property')
-    assert.equal(result.mediaType, xmlMime, 'has the mediaType property')
-    assert.typeOf(result.renderValue, 'string', 'has the renderValue')
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result.renderValue as string, xmlMime)
-
-    const tags = schema.getElementsByTagName('tags')
-    assert.lengthOf(tags, 1, 'has only one <tags> element')
-    assert.isNotEmpty(tags[0].textContent!.trim(), 'has generated array item (tags)')
-  })
-})

package/tests/unit/amf/schema_gen_oas.spec.ts

@@ -1,140 +0,0 @@
-import { test } from '@japa/runner'
-import { DOMParser } from '@xmldom/xmldom'
-import { ApiSchemaGenerator } from '../../../src/amf/ApiSchemaGenerator.js'
-import { AmfLoader } from './AmfLoader.js'
-import { IAmfDocument } from '../../../src/amf/definitions/Amf.js'
-
-const loader = new AmfLoader()
-const jsonMime = 'application/json'
-const xmlMime = 'application/xml'
-
-test.group(`OAS union types / ${jsonMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('oas-unions')
-  })
-  test('generates schema for a oneOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'OneOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: true,
-      renderExamples: true,
-      renderMocked: true,
-    }) as string
-    assert.typeOf(result, 'string', 'is a string')
-    const value = JSON.parse(result)
-    assert.typeOf(value.hunts, 'boolean')
-    assert.typeOf(value.age, 'number')
-  })
-
-  test('generates schema for a allOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'AllOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: true,
-      renderExamples: true,
-      renderMocked: true,
-    }) as string
-
-    assert.typeOf(result, 'string', 'is a string')
-    const value = JSON.parse(result)
-    assert.typeOf(value.hunts, 'boolean')
-    assert.typeOf(value.bark, 'boolean')
-    assert.typeOf(value.age, 'number')
-    assert.equal(value.breed, 'Dingo', 'has the example value')
-  })
-
-  test('generates schema for a anyOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'AnyOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: true,
-      renderExamples: true,
-      renderMocked: true,
-    }) as string
-    assert.typeOf(result, 'string', 'is a string')
-    const value = JSON.parse(result)
-    assert.typeOf(value.hunts, 'boolean')
-    assert.typeOf(value.age, 'number')
-  })
-})
-
-test.group(`OAS union types / ${xmlMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('oas-unions')
-  })
-  test('generates schema for a oneOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'OneOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-      renderMocked: true,
-      renderOptional: true,
-    }) as string
-    assert.typeOf(result, 'string', 'generates a string')
-    assert.isNotEmpty(result, 'generates a value')
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result, xmlMime)
-
-    const root = schema.getElementsByTagName('Cat')[0]
-    assert.ok(root, 'has the Cat parent')
-    const hunts = root.getElementsByTagName('hunts')[0]
-    assert.ok(hunts, 'has the hunts node')
-    assert.match(hunts.textContent!.trim(), /true|false/, 'hunts node has a generated value')
-    const age = root.getElementsByTagName('age')[0]
-    assert.ok(age, 'has the age node')
-    assert.match(age.textContent!.trim(), /\d+/, 'age node has a generated value')
-  })
-
-  test('generates schema for a allOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'AllOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-      renderMocked: true,
-      renderOptional: true,
-    }) as string
-    assert.typeOf(result, 'string', 'generates a string')
-    assert.isNotEmpty(result, 'generates a value')
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result, xmlMime)
-
-    const root = schema.getElementsByTagName('AllOfSchema')[0]
-    assert.ok(root, 'has the AllOfSchema parent')
-    const hunts = root.getElementsByTagName('hunts')[0]
-    assert.ok(hunts, 'has the hunts node')
-    assert.match(hunts.textContent!.trim(), /true|false/, 'hunts node has a generated value')
-    const age = root.getElementsByTagName('age')[0]
-    assert.ok(age, 'has the age node')
-    assert.match(age.textContent!.trim(), /\d+/, 'age node has a generated value')
-    const bark = root.getElementsByTagName('bark')[0]
-    assert.ok(bark, 'has the bark node')
-    assert.match(bark.textContent!.trim(), /true|false/, 'bark node has a generated value')
-    const breed = root.getElementsByTagName('breed')[0]
-    assert.ok(breed, 'has the breed node')
-    assert.equal(breed.textContent!.trim(), 'Dingo', 'breed node has the example value')
-  })
-
-  test('generates schema for a anyOf union', async ({ assert }) => {
-    const shape = loader.getShape(model, 'AnyOfSchema')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-      renderMocked: true,
-      renderOptional: true,
-    }) as string
-    assert.typeOf(result, 'string', 'generates a string')
-    assert.isNotEmpty(result, 'generates a value')
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result, xmlMime)
-
-    const root = schema.getElementsByTagName('Cat')[0]
-    assert.ok(root, 'has the Cat parent')
-    const hunts = root.getElementsByTagName('hunts')[0]
-    assert.ok(hunts, 'has the hunts node')
-    assert.match(hunts.textContent!.trim(), /true|false/, 'hunts node has a generated value')
-    const age = root.getElementsByTagName('age')[0]
-    assert.ok(age, 'has the age node')
-    assert.match(age.textContent!.trim(), /\d+/, 'age node has a generated value')
-  })
-})

package/tests/unit/amf/schema_gen_object.spec.ts

@@ -1,279 +0,0 @@
-import { test } from '@japa/runner'
-import { DOMParser } from '@xmldom/xmldom'
-import { AmfNamespace as ns } from '../../../src/amf/definitions/Namespace.js'
-import { ApiSchemaGenerator, ISchemaExample } from '../../../src/amf/ApiSchemaGenerator.js'
-import { AmfLoader } from './AmfLoader.js'
-import { IAmfDocument } from '../../../src/amf/definitions/Amf.js'
-
-const loader = new AmfLoader()
-const jsonMime = 'application/json'
-const xmlMime = 'application/xml'
-
-test.group(`object values / ${jsonMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-  })
-
-  test('generates a schema for a simple object', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    assert.typeOf(result, 'string', 'is a string')
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed, 'object', 'represents an object')
-    ;['id', 'name', 'sex', 'tosAccepted'].forEach((key) => assert.isDefined(parsed[key], `${key} property is set`))
-  })
-
-  test('has only required fields with default values or enums', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    assert.typeOf(result, 'string', 'is a string')
-    const schema = JSON.parse(String(result))
-
-    assert.typeOf(schema.id, 'string', 'sets a string type (id)')
-    assert.typeOf(schema.name, 'string', 'sets a string type (name)')
-    assert.strictEqual(schema.sex, 'male', 'sets a string type (sex)')
-    assert.strictEqual(schema.tosAccepted, false, 'sets a boolean type from examples')
-    assert.isUndefined(schema.newsletter, 'sets a boolean type from examples')
-    assert.isUndefined(schema.age, 'sets a boolean type from examples')
-  })
-
-  test('has default values and examples', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderExamples: true,
-    })
-    const schema = JSON.parse(String(result))
-    assert.strictEqual(schema.name, 'Pawel Uchida-Psztyc', 'sets a string type (name)')
-    assert.strictEqual(schema.sex, 'male', 'sets a string type (sex)')
-    assert.strictEqual(schema.tosAccepted, false, 'sets a boolean type from examples')
-  })
-
-  test('has default values and examples with optional', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: true,
-      renderExamples: true,
-    })
-    const schema = JSON.parse(String(result))
-
-    assert.strictEqual(schema.name, 'Pawel Uchida-Psztyc', 'sets a string type (name)')
-    assert.strictEqual(schema.sex, 'male', 'sets a string type (sex)')
-    assert.typeOf(schema.tosAccepted, 'boolean', 'sets a boolean type from examples')
-    assert.strictEqual(schema.age, 21, 'has the age property')
-    assert.typeOf(schema.newsletter, 'boolean', 'has the newsletter property')
-  })
-
-  test('gets the parent properties', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithParent')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: true,
-      renderExamples: true,
-      renderMocked: true,
-    })
-    const parsed = JSON.parse(String(result))
-    assert.strictEqual(parsed.name, 'Pawel Uchida-Psztyc', 'has parent name')
-    assert.strictEqual(parsed.age, 25, 'has child age')
-    assert.typeOf(parsed.newsletter, 'boolean', 'has parent newsletter')
-    assert.typeOf(parsed.tosAccepted, 'boolean', 'has parent tosAccepted')
-    assert.match(parsed.addedProperty, /^[0-9]{2}:[0-9]{2}:[0-9]{2}$/, 'has child addedProperty')
-  })
-
-  test('renders object example value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithExample')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime, {
-      renderOptional: false,
-      renderExamples: true,
-    })
-    const parsed = JSON.parse(String(result))
-    assert.strictEqual(parsed.error, true, 'has schema.error')
-    assert.strictEqual(parsed.message, 'Error message', 'has schema.message')
-    assert.isUndefined(parsed.optional, 'has no optional property')
-  })
-
-  test('renders object with multiple level parents', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ChildLvl2')
-    const result = ApiSchemaGenerator.asSchema(shape, jsonMime)
-    const parsed = JSON.parse(String(result))
-    assert.typeOf(parsed.id, 'string', 'has top most property')
-    assert.typeOf(parsed.ch1, 'boolean', 'has parent property')
-    assert.typeOf(parsed.ch2, 'string', 'has own property')
-  })
-
-  test('generates the example', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asExample(shape, jsonMime) as ISchemaExample
-    assert.typeOf(result, 'object', 'returns an object')
-    assert.isTrue(result.strict, 'has the strict property')
-    assert.deepEqual(result.types, [ns.aml.vocabularies.apiContract.Example], 'has the types property')
-    assert.equal(result.mediaType, jsonMime, 'has the mediaType property')
-    assert.typeOf(result.renderValue, 'string', 'has the renderValue')
-    const parsed = JSON.parse(result.renderValue as string)
-    assert.typeOf(parsed, 'object', 'represents an object')
-  })
-})
-
-test.group(`object values / ${xmlMime}`, (group) => {
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-  })
-
-  test('has only required fields with default values or enums', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderMocked: true,
-    })
-    assert.typeOf(result, 'string', 'is a string')
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    assert.ok(schema.getElementsByTagName('id')[0], 'sets a string type (id)')
-    assert.ok(schema.getElementsByTagName('name')[0], 'has the name')
-    assert.isNotEmpty(schema.getElementsByTagName('name')[0].textContent!.trim(), 'sets a string type (name)')
-    assert.strictEqual(schema.getElementsByTagName('sex')[0].textContent!.trim(), 'male', 'sets a string type (sex)')
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-    assert.isUndefined(schema.getElementsByTagName('newsletter')[0], 'has no optional value (newsletter)')
-    assert.isUndefined(schema.getElementsByTagName('age')[0], 'has no optional value (age)')
-  })
-
-  test('has default values and examples', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderExamples: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    assert.strictEqual(
-      schema.getElementsByTagName('name')[0].textContent!.trim(),
-      'Pawel Uchida-Psztyc',
-      'sets a string type (name)'
-    )
-    assert.strictEqual(schema.getElementsByTagName('sex')[0].textContent!.trim(), 'male', 'sets a string type (sex)')
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-    assert.isUndefined(schema.getElementsByTagName('newsletter')[0], 'has no optional value (newsletter)')
-    assert.isUndefined(schema.getElementsByTagName('age')[0], 'has no optional value (age)')
-  })
-
-  test('has default values and examples with optional', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderOptional: true,
-      renderExamples: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    assert.strictEqual(
-      schema.getElementsByTagName('name')[0].textContent!.trim(),
-      'Pawel Uchida-Psztyc',
-      'sets a string type (name)'
-    )
-    assert.strictEqual(schema.getElementsByTagName('sex')[0].textContent!.trim(), 'male', 'sets a string type (sex)')
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-    assert.strictEqual(schema.getElementsByTagName('age')[0].textContent!.trim(), '21', 'has the age property')
-    assert.match(
-      schema.getElementsByTagName('newsletter')[0].textContent!.trim(),
-      /false|true/,
-      'has the newsletter property'
-    )
-  })
-
-  test('gets the parent properties', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithParent')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderOptional: true,
-      renderExamples: true,
-      renderMocked: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    assert.strictEqual(
-      schema.getElementsByTagName('name')[0].textContent!.trim(),
-      'Pawel Uchida-Psztyc',
-      'sets a string type (name)'
-    )
-    assert.strictEqual(schema.getElementsByTagName('sex')[0].textContent!.trim(), 'male', 'sets a string type (sex)')
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-    assert.strictEqual(schema.getElementsByTagName('age')[0].textContent!.trim(), '25', 'has the age property')
-    assert.match(
-      schema.getElementsByTagName('newsletter')[0].textContent!.trim(),
-      /false|true/,
-      'has the newsletter property'
-    )
-    const addedProperty = schema.getElementsByTagName('addedProperty')[0].textContent!.trim()
-    assert.match(addedProperty, /^[0-9]{2}:[0-9]{2}:[0-9]{2}$/, 'has child addedProperty')
-  })
-
-  test('renders object example value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithExample')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderOptional: false,
-      renderExamples: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    const root = schema.getElementsByTagName('ObjectWithExample')[0]
-    assert.ok(root, 'has the root node')
-    assert.strictEqual(root.getElementsByTagName('error')[0].textContent!.trim(), 'true', 'has schema.error')
-    assert.strictEqual(
-      root.getElementsByTagName('message')[0].textContent!.trim(),
-      'Error message',
-      'has schema.message'
-    )
-    assert.notOk(root.getElementsByTagName('optional')[0], 'has no optional property')
-  })
-
-  test('renders object with multiple level parents', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ChildLvl2')
-    const result = ApiSchemaGenerator.asSchema(shape, xmlMime, {
-      renderMocked: true,
-    })
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(String(result), xmlMime)
-
-    const root = schema.getElementsByTagName('ChildLvl2')[0]
-    assert.ok(root, 'has the root node')
-    assert.isNotEmpty(root.getElementsByTagName('ch2')[0].textContent!.trim(), 'has own property')
-    assert.match(root.getElementsByTagName('ch1')[0].textContent!.trim(), /false|true/, 'has parent property')
-    assert.isNotEmpty(root.getElementsByTagName('id')[0].textContent!.trim(), 'has top most property')
-  })
-
-  test('generates the example', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = ApiSchemaGenerator.asExample(shape, xmlMime) as ISchemaExample
-    assert.typeOf(result, 'object', 'returns an object')
-    assert.isTrue(result.strict, 'has the strict property')
-    assert.deepEqual(result.types, [ns.aml.vocabularies.apiContract.Example], 'has the types property')
-    assert.equal(result.mediaType, xmlMime, 'has the mediaType property')
-    assert.typeOf(result.renderValue, 'string', 'has the renderValue')
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result.renderValue as string, xmlMime)
-    assert.strictEqual(
-      schema.getElementsByTagName('tosAccepted')[0].textContent!.trim(),
-      'false',
-      'sets a boolean type from examples'
-    )
-  })
-})