@api-client/core 0.19.9 → 0.19.11

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

@@ -1,250 +0,0 @@
-import { test } from '@japa/runner'
-import { DOMParser } from '@xmldom/xmldom'
-import { AmfNamespace as ns } from '../../../src/amf/definitions/Namespace.js'
-import { ApiExampleGenerator } from '../../../src/amf/ApiExampleGenerator.js'
-import { AmfLoader } from './AmfLoader.js'
-import { IAmfDocument } from '../../../src/amf/definitions/Amf.js'
-import { IApiAnyShape, IApiDataExample } from '../../../src/amf/definitions/Shapes.js'
-
-const loader = new AmfLoader()
-const jsonMime = 'application/json'
-const xmlMime = 'application/xml'
-const urlEncodedMime = 'application/x-www-form-urlencoded'
-
-test.group(jsonMime, (group) => {
-  let reader: ApiExampleGenerator
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-    reader = new ApiExampleGenerator()
-  })
-
-  test('returns null when no value and no structured value', ({ assert }) => {
-    const example: IApiDataExample = {
-      id: '',
-      strict: true,
-      types: [ns.aml.vocabularies.document.NamedExamples],
-      customDomainProperties: [],
-    }
-    const result = reader.read(example, jsonMime)
-    assert.isUndefined(result)
-  })
-
-  test('returns the value when no mime type', ({ assert }) => {
-    const example: IApiDataExample = {
-      id: '',
-      strict: true,
-      types: [ns.aml.vocabularies.document.NamedExamples],
-      value: 'test',
-      customDomainProperties: [],
-    }
-    const result = reader.read(example)
-    assert.strictEqual(result, 'test')
-  })
-
-  test('returns the value when corresponds to the mime type', ({ assert }) => {
-    const example: IApiDataExample = {
-      id: '',
-      strict: true,
-      types: [ns.aml.vocabularies.document.NamedExamples],
-      value: '[]',
-      customDomainProperties: [],
-    }
-    const result = reader.read(example, jsonMime)
-    assert.strictEqual(result, '[]')
-  })
-
-  test('reads a number scalar value', ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarNumberWithExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], jsonMime)
-    assert.strictEqual(result, '24')
-  })
-
-  test('reads a string array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'StringArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], jsonMime) as string
-    const parsed = JSON.parse(result)
-    assert.deepEqual(parsed, ['test', 'other'])
-  })
-
-  test('reads a number array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'NumberArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], jsonMime) as string
-    const parsed = JSON.parse(result)
-    assert.deepEqual(parsed, [1, 2])
-  })
-
-  test('reads a complex value value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarObjectUnionExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], jsonMime) as string
-    const parsed = JSON.parse(result)
-    assert.strictEqual(parsed.name, 'Pawel Uchida-Psztyc', 'has example.name')
-    assert.strictEqual(parsed.id, '128a654bc54d898e43f', 'has example.id')
-    assert.strictEqual(parsed.age, 30, 'has example.age')
-    assert.strictEqual(parsed.sex, 'male', 'has example.sex')
-    assert.strictEqual(parsed.newsletter, false, 'has example.newsletter')
-    assert.strictEqual(parsed.tosAccepted, true, 'has example.tosAccepted')
-  })
-})
-
-test.group(xmlMime, (group) => {
-  let reader: ApiExampleGenerator
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-    reader = new ApiExampleGenerator()
-  })
-
-  test('returns the value when corresponds to the mime type', ({ assert }) => {
-    const example: IApiDataExample = {
-      id: '',
-      strict: true,
-      types: [ns.aml.vocabularies.document.NamedExamples],
-      value: '<feed></feed>',
-      customDomainProperties: [],
-    }
-    const result = reader.read(example, xmlMime)
-    assert.strictEqual(result, '<feed></feed>')
-  })
-
-  test('reads a number scalar value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarNumberWithExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], xmlMime, shape)
-    assert.strictEqual(result, '<ScalarNumberWithExample>24</ScalarNumberWithExample>\n')
-  })
-
-  test('reads a string array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'StringArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], xmlMime, shape)
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(`<root>${result}</root>`, xmlMime)
-
-    const nodes = schema.getElementsByTagName('StringArrayExample')
-    assert.lengthOf(nodes, 2, 'has both example values')
-    assert.equal((nodes[0].textContent as string).trim(), 'test', 'has first example value')
-    assert.equal((nodes[1].textContent as string).trim(), 'other', 'has second example value')
-  })
-
-  test('reads an object array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'XmlArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], xmlMime, shape) as string
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result, xmlMime)
-
-    const root = schema.getElementsByTagName('XmlArrayExample')[0]
-    assert.ok(root, 'has the root node')
-    const street = root.getElementsByTagName('street')[0]
-    const city = root.getElementsByTagName('city')[0]
-    assert.ok(street, 'has the street node')
-    assert.ok(city, 'has the city node')
-    assert.equal((street.textContent as string).trim(), '1234 Market street')
-    assert.equal((city.textContent as string).trim(), 'San Francisco')
-  })
-
-  test('reads a number array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'NumberArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], xmlMime, shape)
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(`<root>${result}</root>`, xmlMime)
-
-    const nodes = schema.getElementsByTagName('NumberArrayExample')
-    assert.lengthOf(nodes, 2, 'has both example values')
-    assert.equal((nodes[0].textContent as string).trim(), '1', 'has first example value')
-    assert.equal((nodes[1].textContent as string).trim(), '2', 'has second example value')
-  })
-
-  test('reads a complex value value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarObjectUnionExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], xmlMime, shape) as string
-
-    const parser = new DOMParser()
-    const schema = parser.parseFromString(result, xmlMime)
-
-    const root = schema.getElementsByTagName('ScalarObjectUnionExample')[0]
-    assert.ok(root, 'has the root node')
-    const name = root.getElementsByTagName('name')[0]
-    const id = root.getElementsByTagName('id')[0]
-    const age = root.getElementsByTagName('age')[0]
-    const sex = root.getElementsByTagName('sex')[0]
-    const newsletter = root.getElementsByTagName('newsletter')[0]
-    const tosAccepted = root.getElementsByTagName('tosAccepted')[0]
-    assert.ok(name, 'has the name node')
-    assert.ok(id, 'has the id node')
-    assert.ok(age, 'has the age node')
-    assert.ok(sex, 'has the sex node')
-    assert.ok(newsletter, 'has the newsletter node')
-    assert.ok(tosAccepted, 'has the tosAccepted node')
-    assert.equal((name.textContent as string).trim(), 'Pawel Uchida-Psztyc')
-    assert.equal((id.textContent as string).trim(), '128a654bc54d898e43f')
-    assert.equal((age.textContent as string).trim(), '30')
-    assert.equal((sex.textContent as string).trim(), 'male')
-    assert.equal((newsletter.textContent as string).trim(), 'false')
-    assert.equal((tosAccepted.textContent as string).trim(), 'true')
-  })
-})
-
-test.group(urlEncodedMime, (group) => {
-  let reader: ApiExampleGenerator
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-    reader = new ApiExampleGenerator()
-  })
-
-  test('returns the value when corresponds to the mime type', ({ assert }) => {
-    const example: IApiDataExample = {
-      id: '',
-      strict: true,
-      types: [ns.aml.vocabularies.document.NamedExamples],
-      value: 'a=b&c=d',
-      customDomainProperties: [],
-    }
-    const result = reader.read(example, urlEncodedMime)
-    assert.strictEqual(result, 'a=b&c=d')
-  })
-
-  test('reads a number scalar value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarNumberWithExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], urlEncodedMime, shape)
-    assert.strictEqual(result, 'ScalarNumberWithExample=24')
-  })
-
-  test('reads a string array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'StringArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], urlEncodedMime, shape)
-
-    assert.strictEqual(result, 'StringArrayExample[]=test&StringArrayExample[]=other')
-  })
-
-  test('reads an object array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'XmlArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], urlEncodedMime, shape)
-
-    assert.strictEqual(result, 'street=1234+Market+street&city=San+Francisco')
-  })
-
-  test('reads a number array value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'NumberArrayExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], urlEncodedMime, shape)
-
-    assert.strictEqual(result, 'NumberArrayExample[]=1&NumberArrayExample[]=2')
-  })
-
-  test('reads a complex value value', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ScalarObjectUnionExample') as IApiAnyShape
-    const result = reader.read(shape.examples[0], urlEncodedMime, shape) as string
-    const parsed = new URLSearchParams(result)
-    assert.equal(parsed.get('name'), 'Pawel Uchida-Psztyc')
-    assert.equal(parsed.get('id'), '128a654bc54d898e43f')
-    assert.equal(parsed.get('age'), '30')
-    assert.equal(parsed.get('sex'), 'male')
-    assert.equal(parsed.get('newsletter'), 'false')
-    assert.equal(parsed.get('tosAccepted'), 'true')
-  })
-})

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

@@ -1,183 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfNamespace as ns } from '../../../src/amf/definitions/Namespace.js'
-import {
-  ApiMonacoSchemaGenerator,
-  IMonacoArrayProperty,
-  IMonacoObjectProperty,
-  IMonacoScalarProperty,
-} from '../../../src/amf/ApiMonacoSchemaGenerator.js'
-import { AmfLoader } from './AmfLoader.js'
-import { IAmfDocument } from '../../../src/amf/definitions/Amf.js'
-const loader = new AmfLoader()
-
-test.group('generate()', (group) => {
-  const parentUri = 'https://domain.com'
-
-  let reader: ApiMonacoSchemaGenerator
-  let model: IAmfDocument
-
-  group.setup(async () => {
-    model = await loader.getGraph('schema-api')
-    reader = new ApiMonacoSchemaGenerator()
-  })
-
-  test('creates a schema for an object', async ({ assert }) => {
-    const shape = loader.getShape(model, 'SimpleObject')
-    const result = reader.generate(shape, parentUri)
-
-    assert.typeOf(result, 'array', 'result is an array')
-    const [object] = result
-    assert.equal(object.uri, shape.id, 'has uri')
-    assert.deepEqual(object.fileMatch, [parentUri], 'has fileMatch')
-    const schema = object.schema as IMonacoObjectProperty
-    assert.typeOf(schema, 'object', 'has schema')
-
-    assert.equal(schema.title, 'SimpleObject', 'has schema.title')
-    assert.equal(schema.type, 'object', 'has schema.type')
-    assert.typeOf(schema.properties, 'object', 'has schema.properties')
-    assert.deepEqual(schema.required, ['id', 'name', 'sex', 'tosAccepted'], 'has schema.required')
-
-    const id = schema.properties.id as IMonacoScalarProperty
-    assert.typeOf(id.$id, 'string', 'id.$id is set')
-    assert.equal(id.type, 'string', 'id.type is set')
-    assert.equal(id.title, 'id', 'id.title is set')
-
-    const name = schema.properties.name as IMonacoScalarProperty
-    assert.typeOf(name.$id, 'string', 'name.$id is set')
-    assert.equal(name.type, 'string', 'name.type is set')
-    assert.equal(name.title, 'Name', 'name.title is set')
-
-    const age = schema.properties.age as IMonacoScalarProperty
-    assert.typeOf(age.$id, 'string', 'age.$id is set')
-    assert.equal(age.type, 'number', 'age.type is set')
-    assert.equal(age.title, 'age', 'age.title is set')
-    assert.equal(age.description, 'Optional person age.', 'age.description is set')
-    assert.equal(age.minimum, 18, 'age.minimum is set')
-
-    const sex = schema.properties.sex as IMonacoScalarProperty
-    assert.typeOf(sex.$id, 'string', 'sex.$id is set')
-    assert.equal(sex.type, 'string', 'sex.type is set')
-    assert.equal(sex.title, 'sex', 'sex.title is set')
-    assert.equal(sex.description, 'An example of an enum.', 'sex.description is set')
-    assert.deepEqual(sex.enum, ['male', 'female'], 'sex.enum is set')
-
-    const newsletter = schema.properties.newsletter as IMonacoScalarProperty
-    assert.typeOf(newsletter.$id, 'string', 'newsletter.$id is set')
-    assert.equal(newsletter.type, 'boolean', 'newsletter.type is set')
-    assert.equal(newsletter.title, 'newsletter', 'newsletter.title is set')
-    assert.equal(
-      newsletter.description,
-      'Whether the user wants to be added to the newsletter',
-      'newsletter.description is set'
-    )
-
-    const tosAccepted = schema.properties.tosAccepted as IMonacoScalarProperty
-    assert.typeOf(tosAccepted.$id, 'string', 'tosAccepted.$id is set')
-    assert.equal(tosAccepted.type, 'boolean', 'tosAccepted.type is set')
-    assert.equal(tosAccepted.title, 'tosAccepted', 'tosAccepted.title is set')
-    assert.equal(
-      tosAccepted.description,
-      'Whether terms of service is accepted by the user.',
-      'tosAccepted.description is set'
-    )
-    assert.equal(tosAccepted.default, 'false', 'tosAccepted.default is set')
-  })
-
-  test('creates a schema for an object with a parent', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithParent')
-    const result = reader.generate(shape, parentUri)
-
-    assert.typeOf(result, 'array', 'result is an array')
-    const [object] = result
-    assert.equal(object.uri, shape.id, 'has uri')
-    assert.deepEqual(object.fileMatch, [parentUri], 'has fileMatch')
-    const schema = object.schema as IMonacoObjectProperty
-    assert.typeOf(schema, 'object', 'has schema')
-
-    assert.equal(schema.title, 'ObjectWithParent', 'has schema.title')
-    assert.equal(schema.type, 'object', 'has schema.type')
-    assert.typeOf(schema.properties, 'object', 'has schema.properties')
-    const required = ['addedProperty', 'age', 'id', 'name', 'sex', 'tosAccepted']
-    schema.required.forEach((r) => assert.include(required, r, `required has ${r}`))
-
-    const id = schema.properties.id
-    const name = schema.properties.name
-    const sex = schema.properties.sex
-    const newsletter = schema.properties.newsletter
-    const tosAccepted = schema.properties.tosAccepted
-    assert.ok(id, 'has parent id property')
-    assert.ok(name, 'has parent name property')
-    assert.ok(sex, 'has parent sex property')
-    assert.ok(newsletter, 'has parent newsletter property')
-    assert.ok(tosAccepted, 'has parent tosAccepted property')
-
-    const addedProperty = schema.properties.addedProperty as IMonacoScalarProperty
-    assert.typeOf(addedProperty.$id, 'string', 'addedProperty.$id is set')
-    assert.equal(addedProperty.type, 'string', 'addedProperty.type is set')
-    assert.equal(addedProperty.title, 'addedProperty', 'addedProperty.title is set')
-    assert.equal(addedProperty.format, 'time', 'addedProperty.format is set')
-
-    const age = schema.properties.age as IMonacoScalarProperty
-    assert.typeOf(age.$id, 'string', 'age.$id is set')
-    assert.equal(age.type, 'number', 'age.type is set')
-    assert.equal(age.title, 'age', 'age.title is set')
-    assert.equal(age.description, 'Age is not optional anymore.', 'age.description is set')
-    assert.equal(age.minimum, 18, 'age.minimum is set')
-  })
-
-  test('creates a schema for an object with array values', async ({ assert }) => {
-    const shape = loader.getShape(model, 'ObjectWithArray')
-    const result = reader.generate(shape, parentUri)
-
-    assert.typeOf(result, 'array', 'result is an array')
-    const [object] = result
-    assert.equal(object.uri, shape.id, 'has uri')
-    assert.deepEqual(object.fileMatch, [parentUri], 'has fileMatch')
-    const schema = object.schema as IMonacoObjectProperty
-    assert.typeOf(schema, 'object', 'has schema')
-
-    const tags = schema.properties.tags as IMonacoArrayProperty
-    assert.typeOf(tags.$id, 'string', 'tags.$id is set')
-    assert.equal(tags.type, 'array', 'tags.type is set')
-    assert.equal(tags.title, 'tags', 'tags.title is set')
-    assert.equal(tags.description, 'These are tags', 'tags.description is set')
-    assert.deepEqual(tags.required, [], 'tags.required is set')
-    assert.isFalse(tags.additionalItems, 'tags.additionalItems is set')
-    const { items } = tags
-    assert.equal(items.anyOf[0].type, 'string')
-  })
-})
-
-test.group('schemaTypeToJsonDataType()', (group) => {
-  let reader: ApiMonacoSchemaGenerator
-
-  group.setup(async () => {
-    reader = new ApiMonacoSchemaGenerator()
-  })
-  ;[
-    [ns.w3.xmlSchema.number, 'number'],
-    [ns.aml.vocabularies.shapes.number, 'number'],
-    [ns.w3.xmlSchema.integer, 'number'],
-    [ns.aml.vocabularies.shapes.integer, 'number'],
-    [ns.w3.xmlSchema.float, 'number'],
-    [ns.aml.vocabularies.shapes.float, 'number'],
-    [ns.w3.xmlSchema.long, 'number'],
-    [ns.aml.vocabularies.shapes.long, 'number'],
-    [ns.w3.xmlSchema.double, 'number'],
-    [ns.aml.vocabularies.shapes.double, 'number'],
-    [ns.aml.vocabularies.shapes.boolean, 'boolean'],
-    [ns.w3.xmlSchema.boolean, 'boolean'],
-    [ns.w3.xmlSchema.date, 'string'],
-    [ns.w3.xmlSchema.time, 'string'],
-    [ns.w3.xmlSchema.dateTime, 'string'],
-    [ns.aml.vocabularies.shapes.dateTimeOnly, 'string'],
-    [ns.w3.xmlSchema.string, 'string'],
-    [ns.aml.vocabularies.shapes.nil, 'null'],
-    [ns.w3.xmlSchema.nil, 'null'],
-  ].forEach(([key, expected]) => {
-    test(`recognizes a type for ${key}`, ({ assert }) => {
-      const result = reader.schemaTypeToJsonDataType(key)
-      assert.strictEqual(result, expected)
-    })
-  })
-})