@api-client/core 0.19.9 → 0.19.11

package/tests/unit/amf/serializer/APIC-483.spec.ts

@@ -1,36 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfLoader } from '../AmfLoader.js'
-import { AmfSerializer } from '../../../../src/amf/AmfSerializer.js'
-import type { IAmfDocument } from '../../../../src/amf/definitions/Amf.js'
-import type { IApiNodeShape, IApiTupleShape } from '../../../../src/amf/definitions/Shapes.js'
-import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
-
-test.group('APIC-483', (group) => {
-  const fileName = 'APIC-483'
-  const loader = new AmfLoader()
-
-  let api: IAmfDocument
-  let serializer: AmfSerializer
-  group.setup(async () => {
-    api = await loader.getGraph(fileName)
-    serializer = new AmfSerializer()
-    serializer.amf = api
-  })
-
-  test('serializes a TupleShape', ({ assert }) => {
-    const expects = loader.lookupExpects(api, '/banks', 'post')
-    // @ts-expect-error Used in testing
-    const payload = expects[loader._getAmfKey(AmfNamespace.aml.vocabularies.apiContract.payload)][0]
-    const shape = payload[serializer._getAmfKey(AmfNamespace.aml.vocabularies.shapes.schema)][0]
-    const result = serializer.unknownShape(shape) as IApiNodeShape
-    const { examples, properties } = result
-
-    // serializer recognizes that the this example is referenced to a payload and not to a type.
-    assert.lengthOf(examples, 0, 'has the examples')
-    assert.lengthOf(properties, 1, 'has the properties')
-    const array = properties[0].range as IApiTupleShape
-    const { types, items } = array
-    assert.include(types, AmfNamespace.aml.vocabularies.shapes.TupleShape, 'range has the TupleShape')
-    assert.lengthOf(items, 1, 'range has the items')
-  })
-})

package/tests/unit/amf/serializer/Anotations.spec.ts

@@ -1,50 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfSerializer } from '../../../../src/amf/AmfSerializer.js'
-import type { IAmfDocument } from '../../../../src/amf/definitions/Amf.js'
-import type { IApiObjectNode, IApiScalarNode } from '../../../../src/amf/definitions/Shapes.js'
-import { AmfLoader } from '../AmfLoader.js'
-
-const loader = new AmfLoader()
-
-test.group('Annotations', (group) => {
-  let api: IAmfDocument
-  let serializer: AmfSerializer
-  group.setup(async () => {
-    api = await loader.getGraph('amf-helper-api')
-    serializer = new AmfSerializer()
-    serializer.amf = api
-  })
-
-  test('ObjectNode annotations', ({ assert }) => {
-    const shape = loader.lookupOperation(api, '/about', 'get')
-    const result = serializer.operation(shape)
-    assert.typeOf(result, 'object', 'returns an object')
-    const { customDomainProperties } = result
-    assert.typeOf(customDomainProperties, 'array', 'has the customDomainProperties')
-    assert.lengthOf(customDomainProperties, 1, 'has a single annotation')
-    const [annotation] = customDomainProperties
-    assert.equal(annotation.name, 'clearanceLevel', 'has the extensionName')
-    assert.typeOf(annotation.extension, 'object', 'has the extension')
-    const { properties } = annotation.extension as IApiObjectNode
-    assert.typeOf(properties, 'object', 'has properties')
-    const { level, signature } = properties
-    assert.typeOf(level, 'object', 'has the level property')
-    assert.typeOf(signature, 'object', 'has the level property')
-  })
-
-  test('ScalarShape annotations', ({ assert }) => {
-    const shape = loader.lookupOperation(api, '/files', 'post')
-    const result = serializer.operation(shape)
-    assert.typeOf(result, 'object', 'returns an object')
-    const { customDomainProperties } = result
-    assert.typeOf(customDomainProperties, 'array', 'has the customDomainProperties')
-    assert.lengthOf(customDomainProperties, 1, 'has a single annotation')
-    const [annotation] = customDomainProperties
-    assert.equal(annotation.name, 'deprecated', 'has the extensionName')
-    assert.typeOf(annotation.extension, 'object', 'has the extension')
-
-    const { value, dataType } = annotation.extension as IApiScalarNode
-    assert.equal(dataType, 'http://www.w3.org/2001/XMLSchema#string', 'has the dataType')
-    assert.equal(value, 'This operation is deprecated and will be removed.', 'has the value')
-  })
-})

package/tests/unit/amf/serializer/Api.spec.ts

@@ -1,210 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfLoader } from '../AmfLoader.js'
-import { AmfSerializer } from '../../../../src/amf/AmfSerializer.js'
-import type { IAmfDomainElement } from '../../../../src/amf/definitions/Amf.js'
-
-const loader = new AmfLoader()
-
-test.group('apiSummary()', (group) => {
-  let petstore: IAmfDomainElement
-  let demoApi: IAmfDomainElement
-  let petstoreSerializer: AmfSerializer
-  let demoSerializer: AmfSerializer
-
-  group.setup(async () => {
-    const a1 = await loader.getGraph('petstore')
-    const a2 = await loader.getGraph('arc-demo-api')
-    petstoreSerializer = new AmfSerializer(a1)
-    demoSerializer = new AmfSerializer(a2)
-    petstore = petstoreSerializer._computeEncodes(a1) as IAmfDomainElement
-    demoApi = demoSerializer._computeEncodes(a2) as IAmfDomainElement
-  })
-
-  test('serializes the id', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.typeOf(result.id, 'string', 'has the id')
-    assert.equal(result.id, demoApi['@id'], 'has the web api id')
-  })
-
-  test('serializes the types', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.typeOf(result.types, 'array', 'has the id')
-    assert.equal(result.types.length, demoApi['@type'].length, 'has all types')
-  })
-
-  test('serializes empty customDomainProperties', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.typeOf(result.customDomainProperties, 'array', 'has the customDomainProperties')
-    assert.lengthOf(result.customDomainProperties, 0, 'has no values')
-  })
-
-  test('serializes the sourceMaps', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.typeOf(result.sourceMaps, 'object', 'has the sourceMaps')
-  })
-
-  test('serializes the schemes', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.deepEqual(result.schemes, ['HTTP', 'HTTPS'])
-  })
-
-  test('has default schemes', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    assert.deepEqual(result.schemes, [])
-  })
-
-  test('serializes the accepts', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.deepEqual(result.accepts, ['application/json', 'application/xml'])
-  })
-
-  test('has default accepts', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    assert.deepEqual(result.accepts, [])
-  })
-
-  test('serializes the contentType', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.deepEqual(result.contentType, ['application/json', 'application/xml'])
-  })
-
-  test('has default contentType', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    assert.deepEqual(result.contentType, [])
-  })
-
-  test('serializes the documentations', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    assert.typeOf(result.documentations, 'array', 'has the array')
-    assert.lengthOf(result.documentations, 1, 'has a single documentation')
-  })
-
-  test('serializes the tags', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    assert.typeOf(result.tags, 'array', 'has the tags')
-    assert.lengthOf(result.tags, 3, 'has all tags')
-    const [tag] = result.tags
-    assert.equal(tag.name, 'pet', 'has the tags definition')
-  })
-
-  test('has default tags', ({ assert }) => {
-    const result = demoSerializer.apiSummary(demoApi)
-    assert.deepEqual(result.tags, [])
-  })
-
-  test('serializes the license', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    const { name, url } = result.license!
-    assert.equal(name, 'Apache 2.0', 'has the license.name')
-    assert.equal(url, 'http://www.apache.org/licenses/LICENSE-2.0.html', 'has the license.url')
-  })
-
-  test('serializes the provider', ({ assert }) => {
-    const result = petstoreSerializer.apiSummary(petstore)
-    const { name, url, email } = result.provider!
-    assert.equal(name, 'Swagger IO', 'has the provider.name')
-    assert.equal(url, 'swagger.io', 'has the provider.url')
-    assert.equal(email, 'apiteam@swagger.io', 'has the provider.email')
-  })
-})
-
-test.group('api()', (group) => {
-  let demoApi: IAmfDomainElement
-  let demoSerializer: AmfSerializer
-
-  group.setup(async () => {
-    const a2 = await loader.getGraph('arc-demo-api')
-    demoSerializer = new AmfSerializer(a2)
-    demoApi = demoSerializer._computeEncodes(a2) as IAmfDomainElement
-  })
-
-  test('has the ApiSummary properties', ({ assert }) => {
-    const result = demoSerializer.api(demoApi)
-    assert.typeOf(result.id, 'string', 'has the id')
-    assert.equal(result.id, demoApi['@id'], 'has the web api id')
-    assert.deepEqual(result.schemes, ['HTTP', 'HTTPS'])
-    assert.deepEqual(result.accepts, ['application/json', 'application/xml'])
-  })
-
-  test('has the end points', ({ assert }) => {
-    const result = demoSerializer.api(demoApi)
-    assert.typeOf(result.endPoints, 'array', 'has the endpoints')
-    const [endPoint] = result.endPoints
-    assert.equal(endPoint.path, '/test-parameters/{feature}', 'has the end point definition')
-  })
-
-  test('has the servers', ({ assert }) => {
-    const result = demoSerializer.api(demoApi)
-    assert.typeOf(result.servers, 'array', 'has the servers')
-    const [server] = result.servers
-    assert.equal(server.url, 'http://{instance}.domain.com/', 'has the server definition')
-  })
-})
-
-test.group('webApi()', (group) => {
-  let demoApi: IAmfDomainElement
-  let demoSerializer: AmfSerializer
-
-  group.setup(async () => {
-    const a2 = await loader.getGraph('arc-demo-api')
-    demoSerializer = new AmfSerializer(a2)
-    demoApi = demoSerializer._computeEncodes(a2) as IAmfDomainElement
-  })
-
-  test('has the ApiSummary properties', ({ assert }) => {
-    const result = demoSerializer.webApi(demoApi)
-    assert.typeOf(result.id, 'string', 'has the id')
-    assert.equal(result.id, demoApi['@id'], 'has the web api id')
-    assert.deepEqual(result.schemes, ['HTTP', 'HTTPS'])
-    assert.deepEqual(result.accepts, ['application/json', 'application/xml'])
-  })
-
-  test('has the end points', ({ assert }) => {
-    const result = demoSerializer.webApi(demoApi)
-    assert.typeOf(result.endPoints, 'array', 'has the endpoints')
-    const [endPoint] = result.endPoints
-    assert.equal(endPoint.path, '/test-parameters/{feature}', 'has the end point definition')
-  })
-
-  test('has the servers', ({ assert }) => {
-    const result = demoSerializer.webApi(demoApi)
-    assert.typeOf(result.servers, 'array', 'has the servers')
-    const [server] = result.servers
-    assert.equal(server.url, 'http://{instance}.domain.com/', 'has the server definition')
-  })
-})
-
-test.group('asyncApi()', (group) => {
-  let asyncApi: IAmfDomainElement
-  let demoSerializer: AmfSerializer
-  let asyncSerializer: AmfSerializer
-
-  group.setup(async () => {
-    const a2 = await loader.getGraph('arc-demo-api')
-    const a3 = await loader.getGraph('async-api')
-    demoSerializer = new AmfSerializer(a2)
-    asyncSerializer = new AmfSerializer(a3)
-    asyncApi = asyncSerializer._computeEncodes(a3) as IAmfDomainElement
-  })
-
-  test('has the ApiSummary properties', ({ assert }) => {
-    const result = demoSerializer.asyncApi(asyncApi)
-    assert.typeOf(result.id, 'string', 'has the id')
-    assert.equal(result.id, asyncApi['@id'], 'has the web api id')
-    assert.equal(result.name, 'Hello world application')
-  })
-
-  test('has the end points', ({ assert }) => {
-    const result = demoSerializer.asyncApi(asyncApi)
-    assert.typeOf(result.endPoints, 'array', 'has the endpoints')
-    const [endPoint] = result.endPoints
-    assert.equal(endPoint.path, 'hello', 'has the end point definition')
-  })
-
-  test('has the servers', ({ assert }) => {
-    const result = demoSerializer.asyncApi(asyncApi)
-    assert.typeOf(result.servers, 'array', 'has the servers')
-    const [server] = result.servers
-    assert.equal(server.url, 'broker.mycompany.com', 'has the server definition')
-  })
-})

package/tests/unit/amf/serializer/Documentation.spec.ts

@@ -1,52 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfLoader } from '../AmfLoader.js'
-import { AmfSerializer } from '../../../../src/amf/AmfSerializer.js'
-import type { IAmfDocument } from '../../../../src/amf/definitions/Amf.js'
-import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
-
-const loader = new AmfLoader()
-
-test.group('OAS documentation', (group) => {
-  let api: IAmfDocument
-  let serializer: AmfSerializer
-  group.setup(async () => {
-    api = await loader.getGraph('petstore')
-    serializer = new AmfSerializer()
-    serializer.amf = api
-  })
-
-  test('has the documentation properties', ({ assert }) => {
-    const enc = serializer._computeEncodes(api)!
-    // @ts-expect-error Used in testing
-    const docs = enc[serializer._getAmfKey(AmfNamespace.aml.vocabularies.core.documentation)][0]
-    const result = serializer.documentation(docs)
-    assert.typeOf(result, 'object', 'has the result')
-    assert.equal(result.url, 'http://swagger.io', 'has the url')
-    assert.equal(result.description, 'Find out more about Swagger', 'has the description')
-    assert.deepEqual(result.customDomainProperties, [], 'has no customDomainProperties')
-    assert.typeOf(result.sourceMaps, 'object', 'has source maps')
-  })
-})
-
-test.group('RAML documentation', (group) => {
-  let api: IAmfDocument
-  let serializer: AmfSerializer
-  group.setup(async () => {
-    api = await loader.getGraph('amf-helper-api')
-    serializer = new AmfSerializer()
-    serializer.amf = api
-  })
-
-  test('has the documentation properties', ({ assert }) => {
-    const enc = serializer._computeEncodes(api)!
-    // @ts-expect-error Used in testing
-    const docs = enc[serializer._getAmfKey(AmfNamespace.aml.vocabularies.core.documentation)][0]
-    const result = serializer.documentation(docs)
-    assert.typeOf(result, 'object', 'has the result')
-    assert.isUndefined(result.url, 'has no url')
-    assert.equal(result.title, 'How to begin', 'has the title')
-    assert.equal(result.description, 'Example content\n', 'has the description')
-    assert.deepEqual(result.customDomainProperties, [], 'has no customDomainProperties')
-    assert.typeOf(result.sourceMaps, 'object', 'has source maps')
-  })
-})

package/tests/unit/amf/serializer/Endpoints.spec.ts

@@ -1,172 +0,0 @@
-import { test } from '@japa/runner'
-import { AmfLoader } from '../AmfLoader.js'
-import { AmfSerializer } from '../../../../src/amf/AmfSerializer.js'
-import type { IAmfDocument } from '../../../../src/amf/definitions/Amf.js'
-import type { IApiObjectNode, IApiScalarShape } from '../../../../src/amf/definitions/Shapes.js'
-import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
-
-const loader = new AmfLoader()
-
-test.group('OAS endpoints', (group) => {
-  let api: IAmfDocument
-  let serializer: AmfSerializer
-  group.setup(async () => {
-    api = await loader.getGraph('petstore')
-    serializer = new AmfSerializer()
-    serializer.amf = api
-  })
-
-  test('translates an endpoint', ({ assert }) => {
-    const shape = loader.lookupEndpoint(api, '/pet')
-    const result = serializer.endPoint(shape)
-    assert.typeOf(result, 'object', 'returns an object')
-    assert.include(result.types, AmfNamespace.aml.vocabularies.apiContract.EndPoint, 'has the EndPoint type')
-    assert.equal(result.path, '/pet', 'has the path')
-    assert.typeOf(result.operations, 'array', 'has the operations')
-    assert.lengthOf(result.operations, 2, 'has all operations')
-    assert.typeOf(result.sourceMaps, 'object', 'has source maps')
-  })
-
-  test('adds the servers property', ({ assert }) => {
-    const shape = loader.lookupEndpoint(api, '/pet')
-    const result = serializer.endPoint(shape)
-    assert.typeOf(result.servers, 'array', 'has the servers')
-    assert.lengthOf(result.servers, 1, 'has a single server')
-    assert.include(result.servers[0].types, AmfNamespace.aml.vocabularies.apiContract.Server, 'has the Server type')
-  })
-
-  test('adds the summary & description property', ({ assert }) => {
-    const shape = loader.lookupEndpoint(api, '/user/{username}')
-    const result = serializer.endPoint(shape)
-    assert.equal(result.summary, 'Represents a user', 'has the summary')
-    assert.typeOf(result.description, 'string', 'has description property')
-  })
-})
-
-test.group('RAML endpoints', (group) => {
-  let demoApi: IAmfDocument
-  let arcDemoApi: IAmfDocument
-  let demoSerializer: AmfSerializer
-  let arcDemoSerializer: AmfSerializer
-  group.setup(async () => {
-    demoApi = await loader.getGraph('amf-helper-api')
-    arcDemoApi = await loader.getGraph('arc-demo-api')
-    demoSerializer = new AmfSerializer(demoApi)
-    arcDemoSerializer = new AmfSerializer(arcDemoApi)
-  })
-
-  test('has annotations', ({ assert }) => {
-    const shape = loader.lookupEndpoint(demoApi, '/annotations')
-    const result = demoSerializer.endPoint(shape)
-    assert.typeOf(result.customDomainProperties, 'array', 'has the array')
-    assert.lengthOf(result.customDomainProperties, 1, 'has the annotation')
-    const [item] = result.customDomainProperties
-    assert.equal(item.name, 'clearanceLevel', 'has the name')
-    const typed = item.extension as IApiObjectNode
-    assert.typeOf(typed.properties, 'object', 'has the properties')
-    assert.lengthOf(Object.keys(typed.properties), 2, 'has all properties')
-  })
-
-  test('has parameters', ({ assert }) => {
-    const shape = loader.lookupEndpoint(demoApi, '/{groupId}/{assetId}/{version}')
-    const result = demoSerializer.endPoint(shape)
-    const { parameters } = result
-    assert.typeOf(parameters, 'array', 'has the array')
-    assert.lengthOf(parameters, 3, 'has the parameters')
-    const [p1, p2, p3] = parameters
-    assert.include(p1.types, AmfNamespace.aml.vocabularies.apiContract.Parameter, 'p1 has the type')
-    assert.include(p2.types, AmfNamespace.aml.vocabularies.apiContract.Parameter, 'p2 has the type')
-    assert.include(p3.types, AmfNamespace.aml.vocabularies.apiContract.Parameter, 'p3 has the type')
-    assert.equal(p1.name, 'assetId', 'p1 has the name')
-    assert.equal(p2.name, 'groupId', 'p2 has the name')
-    assert.equal(p3.name, 'version', 'p3 has the name')
-    assert.equal(p1.paramName, 'assetId', 'p1 has the paramName')
-    assert.equal(p2.paramName, 'groupId', 'p2 has the paramName')
-    assert.equal(p3.paramName, 'version', 'p3 has the paramName')
-    assert.isTrue(p1.required, 'p1 has the required')
-    assert.isTrue(p2.required, 'p2 has the required')
-    assert.isTrue(p3.required, 'p3 has the required')
-    assert.equal(p1.binding, 'path', 'p1 has the binding')
-    assert.equal(p2.binding, 'path', 'p2 has the binding')
-    assert.equal(p3.binding, 'path', 'p3 has the binding')
-    assert.typeOf(p1.schema, 'object', 'p1 has the schema')
-    assert.typeOf(p2.schema, 'object', 'p2 has the schema')
-    assert.typeOf(p3.schema, 'object', 'p3 has the schema')
-    assert.equal(
-      (p1.schema as IApiScalarShape).dataType,
-      AmfNamespace.w3.xmlSchema.string,
-      'p1.schema has the dataType'
-    )
-    assert.equal(
-      (p2.schema as IApiScalarShape).dataType,
-      AmfNamespace.w3.xmlSchema.string,
-      'p2.schema has the dataType'
-    )
-    assert.equal(
-      (p3.schema as IApiScalarShape).dataType,
-      AmfNamespace.aml.vocabularies.shapes.number,
-      'p3.schema has the dataType'
-    )
-  })
-
-  test('adds resource type definition', ({ assert }) => {
-    const shape = loader.lookupEndpoint(demoApi, '/files/{fileId}')
-    const result = demoSerializer.endPoint(shape)
-    const { operations } = result
-    const get = operations.find((o) => o.method === 'get')!
-    const param = get.request!.queryParameters.find((p) => p.paramName === 'access_token')
-    assert.ok(param)
-  })
-
-  test('adds a resource type extension', ({ assert }) => {
-    const shape = loader.lookupEndpoint(arcDemoApi, '/products')
-    const result = arcDemoSerializer.endPoint(shape)
-    const { extends: extensions } = result
-    assert.typeOf(extensions, 'array', 'has the extensions array')
-    assert.lengthOf(extensions, 1, 'has a single extension')
-
-    const [type] = extensions
-
-    assert.typeOf(type.id, 'string', 'has the id')
-    assert.typeOf(type.types, 'array', 'has the types')
-    assert.include(
-      type.types,
-      AmfNamespace.aml.vocabularies.apiContract.ParametrizedResourceType,
-      'has the type in the types'
-    )
-    assert.equal(type.name, 'RequestErrorResponse', 'has the name')
-    assert.typeOf(type.target, 'object', 'has the target definition')
-  })
-
-  test('adds a trait extension', ({ assert }) => {
-    const shape = loader.lookupEndpoint(arcDemoApi, '/orgs/{orgId}')
-    const result = arcDemoSerializer.endPoint(shape)
-    const { extends: extensions } = result
-    assert.typeOf(extensions, 'array', 'has the extensions array')
-    assert.lengthOf(extensions, 1, 'has a single extension')
-
-    const [type] = extensions
-
-    assert.typeOf(type.id, 'string', 'has the id')
-    assert.typeOf(type.types, 'array', 'has the types')
-    assert.include(type.types, AmfNamespace.aml.vocabularies.apiContract.ParametrizedTrait, 'has the type in the types')
-    assert.equal(type.name, 'RateLimited', 'has the name')
-    assert.typeOf(type.target, 'object', 'has the target definition')
-  })
-
-  test('adds both a trait and a resource type extensions', ({ assert }) => {
-    const shape = loader.lookupEndpoint(arcDemoApi, '/people')
-    const result = arcDemoSerializer.endPoint(shape)
-    const { extends: extensions } = result
-    assert.typeOf(extensions, 'array', 'has the extensions array')
-    assert.lengthOf(extensions, 2, 'has both extensions')
-
-    const type = extensions.find((e) =>
-      e.types.includes(AmfNamespace.aml.vocabularies.apiContract.ParametrizedResourceType)
-    )
-    const trait = extensions.find((e) => e.types.includes(AmfNamespace.aml.vocabularies.apiContract.ParametrizedTrait))
-
-    assert.ok(type, 'has the resource type')
-    assert.ok(trait, 'has the trait')
-  })
-})