@api-client/core 0.10.12 → 0.11.0

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

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

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