@api-client/core 0.14.0 → 0.14.1

package/tests/unit/modeling/legacy/amf_shape_generator.spec.ts

@@ -1,1041 +0,0 @@
-import { test } from '@japa/runner'
-import { DataProperty } from '../../../../src/modeling/legacy/DataProperty.js'
-import { DataEntity } from '../../../../src/modeling/legacy/DataEntity.js'
-import { DataNamespace } from '../../../../src/modeling/legacy/DataNamespace.js'
-import { DataModel } from '../../../../src/modeling/legacy/DataModel.js'
-import {
-  IApiArrayShape,
-  IApiDataExample,
-  IApiFileShape,
-  IApiNodeShape,
-  IApiScalarNode,
-  IApiScalarShape,
-  IApiUnionShape,
-  IApiXmlSerializer,
-  IShapeUnion,
-} from '../../../../src/amf/definitions/Shapes.js'
-import {
-  IAmfAnyTypes,
-  IAmfArrayTypes,
-  IAmfExampleTypes,
-  IAmfFileTypes,
-  IAmfNodeTypes,
-  IAmfPropertyTypes,
-  IAmfScalarTypes,
-  IAmfUnionTypes,
-} from '../../../../src/amf/AmfTypes.js'
-import { AmfNamespace } from '../../../../src/amf/definitions/Namespace.js'
-import { AmfShapeGenerator } from '../../../../src/amf/AmfShapeGenerator.js'
-import { DataAssociation } from '../../../../src/modeling/legacy/DataAssociation.js'
-import type { PropertyWebBindings } from '../../../../src/index.js'
-
-test.group('entity()', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-  })
-
-  test('returns the basic shape', ({ assert }) => {
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.equal(result.id, e1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfNodeTypes, 'has the types')
-    assert.deepEqual(result.values, [], 'has the values')
-    assert.deepEqual(result.inherits, [], 'has the inherits')
-    assert.deepEqual(result.or, [], 'has the or')
-    assert.deepEqual(result.and, [], 'has the and')
-    assert.deepEqual(result.xone, [], 'has the xone')
-    assert.deepEqual(result.examples, [], 'has the examples')
-    assert.deepEqual(result.properties, [], 'has the properties')
-    assert.typeOf(result.xmlSerialization, 'object', 'has the xmlSerialization')
-    assert.equal(result.name, 'e1', 'has the name')
-  })
-
-  test('returns the display name', ({ assert }) => {
-    e1.info.displayName = 'e 1 name'
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.equal(result.displayName, 'e 1 name')
-  })
-
-  test('returns the description', ({ assert }) => {
-    e1.info.description = 'e 1 description'
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.equal(result.description, 'e 1 description')
-  })
-
-  test('returns the deprecated', ({ assert }) => {
-    e1.deprecated = true
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.isTrue(result.deprecated)
-  })
-
-  test('returns empty properties', ({ assert }) => {
-    e1.info.description = 'e 1 description'
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.deepEqual(result.properties, [])
-  })
-
-  test('returns defined properties', ({ assert }) => {
-    e1.addNamedProperty('test')
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.lengthOf(result.properties, 1)
-  })
-
-  test('adds associations to the properties', ({ assert }) => {
-    e1.addNamedProperty('test')
-    e1.addNamedAssociation('test association')
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.lengthOf(result.properties, 2)
-    assert.equal(result.properties[1].name, 'test association')
-  })
-
-  test('adds parents to the inherits', ({ assert }) => {
-    const e2 = m1.addEntity('e2')
-    e1.parents = [e2.key]
-    const result = e1.toApiShape() as IApiNodeShape
-
-    assert.lengthOf(result.inherits, 1)
-    assert.equal(result.inherits[0].name, 'e2')
-  })
-})
-
-test.group('property() / just data model', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-  let p1: DataProperty
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-    p1 = e1.addNamedProperty('p1')
-  })
-
-  test('returns the basic shape', ({ assert }) => {
-    const result = p1.toApiShape()
-    assert.equal(result.id, p1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfPropertyTypes, 'has the types')
-    assert.deepEqual(result.values, [], 'has the values')
-    assert.deepEqual(result.inherits, [], 'has the inherits')
-    assert.deepEqual(result.or, [], 'has the or')
-    assert.deepEqual(result.and, [], 'has the and')
-    assert.deepEqual(result.xone, [], 'has the xone')
-    assert.equal(result.path, AmfNamespace.aml.vocabularies.data.key + 'p1', 'has the path')
-    assert.equal(result.name, 'p1', 'has the name')
-  })
-
-  test('sets the minCount', ({ assert }) => {
-    p1.required = true
-    const result = p1.toApiShape()
-
-    assert.equal(result.minCount, 1)
-  })
-
-  test('has the default range for a string', ({ assert }) => {
-    p1.info.displayName = 'string dn'
-    p1.info.description = 'string desc'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `scalar-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfScalarTypes, 'has the types')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string, 'has the dataType')
-    assert.equal(range.name, 'p1', 'has the name')
-    assert.equal(range.displayName, 'string dn', 'has the displayName')
-    assert.equal(range.description, 'string desc', 'has the description')
-  })
-
-  test('handles examples', ({ assert }) => {
-    p1.schema = { examples: ['example1', 'example2'] }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.lengthOf(range.examples, 2)
-    assert.property(range.examples[0], 'structuredValue')
-    assert.property(range.examples[1], 'structuredValue')
-  })
-
-  test('handles defaultValue', ({ assert }) => {
-    p1.schema = { defaultValue: { value: 'defaultValue', type: 'literal' } }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.property(range, 'defaultValue')
-    assert.containsSubset(range.defaultValue, {
-      value: 'defaultValue',
-    })
-  })
-
-  test('handles enum', ({ assert }) => {
-    p1.schema = { enum: ['enum1', 'enum2'] }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.lengthOf(range.values, 2)
-    assert.containsSubset(range.values[0], {
-      dataType: AmfNamespace.w3.xmlSchema.string,
-      value: `enum1`,
-    })
-    assert.containsSubset(range.values[1], {
-      dataType: AmfNamespace.w3.xmlSchema.string,
-      value: `enum2`,
-    })
-  })
-
-  test('has the default range for a number', ({ assert }) => {
-    p1.type = 'number'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.number, 'has the dataType')
-  })
-
-  test('handles readOnly and writeOnly', ({ assert }) => {
-    p1.readOnly = true
-    p1.writeOnly = true
-    const result = p1.toApiShape()
-    assert.isTrue(result.range?.readOnly)
-    assert.isTrue(result.range?.writeOnly)
-  })
-
-  test('handles deprecated', ({ assert }) => {
-    p1.deprecated = true
-    const result = p1.toApiShape()
-    assert.isTrue(result.deprecated)
-  })
-
-  test('handles multiple properties', ({ assert }) => {
-    p1.multiple = true
-    const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
-    assert.property(range, 'items')
-  })
-
-  test('handles binary base64 format', ({ assert }) => {
-    p1.type = 'binary'
-    const bindings = p1.getWebBinding() as PropertyWebBindings
-    bindings.format = 'base64'
-    const result = p1.toApiShape()
-    const range = result.range as IApiFileShape
-    assert.equal(range.format, AmfNamespace.w3.xmlSchema.base64Binary)
-  })
-
-  test('has the default range for an int32 format', ({ assert }) => {
-    p1.type = 'number'
-    const bindings = p1.getWebBinding()
-    bindings.format = 'int32'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.integer, 'has the dataType')
-  })
-
-  test('has the default range for an int64 format', ({ assert }) => {
-    p1.type = 'number'
-    const bindings = p1.getWebBinding()
-    bindings.format = 'int64'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.integer, 'has the dataType')
-  })
-
-  test('has the default range for a date', ({ assert }) => {
-    p1.type = 'date'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.date, 'has the dataType')
-  })
-
-  test('has the default range for a datetime', ({ assert }) => {
-    p1.type = 'datetime'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.dateTime, 'has the dataType')
-  })
-
-  test('has the default range for a time', ({ assert }) => {
-    p1.type = 'time'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.dateTimeOnly, 'has the dataType')
-  })
-
-  // test('has the default range for a nil', ({ assert }) => {
-  //   p1.type = 'nil'
-  //   const result = p1.toApiShape()
-  //   const range = result.range as IApiScalarShape
-
-  //   assert.typeOf(range, 'object', 'has the range')
-  //   assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.nil, 'has the dataType')
-  // })
-
-  test('has the default range for a boolean', ({ assert }) => {
-    p1.type = 'boolean'
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.boolean, 'has the dataType')
-  })
-
-  // test('has the default range for an any', ({ assert }) => {
-  //   p1.type = 'any'
-  //   const result = p1.toApiShape()
-  //   const range = result.range as IApiScalarShape
-
-  //   assert.typeOf(range, 'object', 'has the range')
-  //   assert.equal(range.dataType, AmfNamespace.aml.vocabularies.shapes.AnyShape, 'has the dataType')
-  // })
-
-  test('has the default range for a file', ({ assert }) => {
-    p1.type = 'binary'
-    p1.info.displayName = 'string dn'
-    p1.info.description = 'string desc'
-    const result = p1.toApiShape()
-    const range = result.range as IApiFileShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `file-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfFileTypes, 'has the types')
-    assert.equal(range.name, 'p1', 'has the name')
-    assert.equal(range.displayName, 'string dn', 'has the displayName')
-    assert.equal(range.description, 'string desc', 'has the description')
-  })
-
-  test('has the default range for a string when a multiple', ({ assert }) => {
-    p1.multiple = true
-    p1.info.displayName = 'string dn'
-    p1.info.description = 'string desc'
-    const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'has the types')
-
-    const items = range.items as IApiScalarShape
-
-    assert.typeOf(items, 'object', 'has the items')
-    assert.equal(items.id, `scalar-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(items.types, IAmfScalarTypes, 'has the types')
-
-    assert.equal(items.name, 'p1', 'has the name')
-    assert.equal(items.displayName, 'string dn', 'has the displayName')
-    assert.equal(items.description, 'string desc', 'has the description')
-  })
-
-  test('has the default range for a file when a multiple', ({ assert }) => {
-    p1.multiple = true
-    p1.type = 'binary'
-    p1.info.displayName = 'string dn'
-    p1.info.description = 'string desc'
-    const result = p1.toApiShape()
-    const range = result.range as IApiArrayShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'has the types')
-
-    const items = range.items as IApiFileShape
-
-    assert.typeOf(items, 'object', 'has the items')
-    assert.equal(items.id, `file-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(items.types, IAmfFileTypes, 'has the types')
-
-    assert.equal(items.name, 'p1', 'has the name')
-    assert.equal(items.displayName, 'string dn', 'has the displayName')
-    assert.equal(items.description, 'string desc', 'has the description')
-  })
-})
-
-test.group('property() / with web bindings', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-  })
-
-  test('updates the name when changed', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    p1.bindings = [
-      {
-        type: 'web',
-        schema: {
-          name: 'other',
-        },
-      },
-    ]
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-
-    assert.equal(string.name, 'other', 'the range has the changed name')
-    assert.equal(result.name, 'other', 'the property has the changed name')
-  })
-
-  // test('sets the dataType', ({ assert }) => {
-  //   const p1 = e1.addTypedProperty('string', 'p1')
-  //   p1.bindings = [
-  //     {
-  //       type: 'web',
-  //       schema: {
-  //         // dataType: AmfNamespace.w3.xmlSchema.date,
-  //       },
-  //     },
-  //   ]
-  //   const result = p1.toApiShape()
-  //   const string = result.range as IApiScalarShape
-  //   assert.equal(string.dataType, AmfNamespace.w3.xmlSchema.date)
-  // })
-
-  test('sets the xml serialization', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    const value: IApiXmlSerializer = {
-      id: '',
-      types: [],
-      customDomainProperties: [],
-      name: 'test',
-    }
-    p1.bindings = [
-      {
-        type: 'web',
-        schema: {
-          xml: value,
-        },
-      },
-    ]
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.deepEqual(string.xmlSerialization, value)
-  })
-
-  test('sets the file types', ({ assert }) => {
-    const p1 = e1.addTypedProperty('binary', 'p1')
-    const value: string[] = ['a']
-    p1.bindings = [
-      {
-        type: 'web',
-        schema: {
-          fileTypes: value,
-        },
-      },
-    ]
-    const result = p1.toApiShape()
-    const file = result.range as IApiFileShape
-    assert.deepEqual(file.fileTypes, value)
-  })
-
-  test('sets the pattern', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    p1.bindings = [
-      {
-        type: 'web',
-        schema: {
-          pattern: 'a-z',
-        },
-      },
-    ]
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.pattern, 'a-z')
-  })
-
-  test('sets the minLength', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    p1.schema = {
-      minimum: 1,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.minLength, 1)
-  })
-
-  test('sets the maxLength', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    p1.schema = {
-      maximum: 1,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.maxLength, 1)
-  })
-
-  test('sets the minimum', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      minimum: 1,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.minimum, 1)
-  })
-
-  test('sets the maximum', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      maximum: 1,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.maximum, 1)
-  })
-
-  test('sets the multipleOf', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      multipleOf: 1,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.multipleOf, 1)
-  })
-
-  test('sets the exclusiveMinimum', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      exclusiveMinimum: true,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.isTrue(string.exclusiveMinimum)
-  })
-
-  test('sets the exclusiveMaximum to false', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      exclusiveMaximum: false,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.isFalse(string.exclusiveMaximum)
-  })
-
-  test('sets the exclusiveMaximum to true', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      exclusiveMaximum: true,
-    }
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.isTrue(string.exclusiveMaximum)
-  })
-
-  test('sets the format', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.bindings = [
-      {
-        type: 'web',
-        schema: {
-          format: 'float',
-        },
-      },
-    ]
-    const result = p1.toApiShape()
-    const string = result.range as IApiScalarShape
-    assert.equal(string.format, AmfNamespace.w3.xmlSchema.float)
-  })
-})
-
-test.group('property() / with schema', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-  })
-
-  test('sets the default value', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      defaultValue: { value: '123', type: 'literal' },
-    }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object', 'has the defaultValue')
-    const value = range.defaultValue as IApiScalarNode
-    assert.strictEqual(value.value, '123', 'has the value')
-    assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.number, 'has the range data type')
-  })
-
-  test('sets the enum value', ({ assert }) => {
-    const p1 = e1.addTypedProperty('number', 'p1')
-    p1.schema = {
-      enum: ['123'],
-    }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.values, 'array', 'has the values')
-    const value = range.values[0] as IApiScalarNode
-    assert.strictEqual(value.value, '123', 'has the value')
-    assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.number, 'has the range data type')
-  })
-
-  test('sets the examples value', ({ assert }) => {
-    const p1 = e1.addTypedProperty('string', 'p1')
-    p1.schema = {
-      examples: ['123'],
-    }
-    const result = p1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.examples, 'array', 'has the examples')
-    const example = range.examples[0] as IApiDataExample
-
-    assert.typeOf(example.id, 'string', 'has the example.id')
-    assert.isNotEmpty(example.id, 'the example.id is not empty')
-    assert.deepEqual(example.types, IAmfExampleTypes, 'the example.types')
-    assert.typeOf(example.structuredValue, 'object', 'has the example.structuredValue')
-
-    const value = example.structuredValue as IApiScalarNode
-    assert.strictEqual(value.value, '123', 'has the value')
-    assert.equal(value.dataType, AmfNamespace.w3.xmlSchema.string, 'has the range data type')
-  })
-})
-
-test.group('property() / default value functions', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-  let p1: DataProperty
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-    p1 = e1.addNamedProperty('p1')
-  })
-
-  test('generates random string for "random" function', ({ assert }) => {
-    p1.schema = { defaultValue: { value: 'random', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
-    assert.typeOf(value.value, 'string')
-    assert.lengthOf(value.value as string, 8)
-  })
-
-  test('generates uuid for "uuid-v4" function', ({ assert }) => {
-    p1.schema = { defaultValue: { value: 'uuid-v4', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
-    assert.typeOf(value.value, 'string')
-    assert.lengthOf(value.value as string, 36)
-    assert.match(value.value as string, /^[0-9a-f-]+$/)
-  })
-
-  test('generates incremental number for "incremental" function', ({ assert }) => {
-    p1.type = 'number'
-    p1.schema = { defaultValue: { value: 'incremental', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result1 = generator.property(p1)
-    const range1 = result1.range as IApiScalarShape
-    assert.typeOf(range1.defaultValue, 'object')
-    const value1 = range1.defaultValue as IApiScalarNode
-    assert.typeOf(value1.value, 'string')
-    assert.equal(parseInt(value1.value as string), 0)
-
-    const result2 = generator.property(p1)
-    const range2 = result2.range as IApiScalarShape
-    assert.typeOf(range2.defaultValue, 'object')
-    const value2 = range2.defaultValue as IApiScalarNode
-    assert.typeOf(value2.value, 'string')
-    assert.equal(parseInt(value2.value as string), 1)
-  })
-
-  test('generates current date for "now" function (date type)', ({ assert }) => {
-    p1.type = 'date'
-    p1.schema = { defaultValue: { value: 'now', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
-    assert.typeOf(value.value, 'string')
-    assert.match(value.value as string, /^\d{4}-\d{2}-\d{2}$/)
-  })
-
-  test('generates current time for "now" function (time type)', ({ assert }) => {
-    p1.type = 'time'
-    p1.schema = { defaultValue: { value: 'now', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
-    assert.typeOf(value.value, 'string')
-    assert.match(value.value as string, /^\d{2}:\d{2}:\d{2}$/)
-  })
-
-  test('generates current datetime for "now" function (datetime type)', ({ assert }) => {
-    p1.type = 'datetime'
-    p1.schema = { defaultValue: { value: 'now', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.typeOf(range.defaultValue, 'object')
-    const value = range.defaultValue as IApiScalarNode
-    assert.typeOf(value.value, 'string')
-    assert.match(value.value as string, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/)
-  })
-
-  test('returns noValue for unsupported function', ({ assert }) => {
-    p1.schema = { defaultValue: { value: 'unsupported', type: 'function' } }
-    const generator = new AmfShapeGenerator()
-    const result = generator.property(p1)
-    const range = result.range as IApiScalarShape
-    assert.isUndefined(range.defaultValue)
-  })
-})
-
-test.group('refactorArrayToShape()', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-  let p1: DataProperty
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-    p1 = e1.addNamedProperty('p1')
-  })
-
-  test('returns the array items', ({ assert }) => {
-    p1.multiple = true
-    const parameter = p1.toApiShape()
-    const range = parameter.range as IApiArrayShape
-    const shape = range.items as IApiScalarShape
-    const generator = new AmfShapeGenerator()
-    const result = generator.refactorArrayToShape(range)
-    assert.deepEqual(result, shape)
-  })
-})
-
-test.group('refactorShapeToArray()', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-  let p1: DataProperty
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-    p1 = e1.addNamedProperty('p1')
-  })
-
-  test('returns the array items', ({ assert }) => {
-    const parameter = p1.toApiShape()
-    const range = parameter.range as IApiScalarShape
-    const generator = new AmfShapeGenerator()
-    const result = generator.refactorShapeToArray(p1.key, range)
-
-    assert.typeOf(result, 'object', 'has the range')
-    assert.equal(result.id, `array-shape-${p1.key}`, 'has the id')
-    assert.deepEqual(result.types, IAmfArrayTypes, 'has the types')
-
-    const items = result.items as IApiScalarShape
-    assert.deepEqual(items, range)
-  })
-})
-
-test.group('associationProperty()', (group) => {
-  let root: DataNamespace
-  let m1: DataModel
-  let e1: DataEntity
-  let e2: DataEntity
-  let a1: DataAssociation
-  let p2: DataProperty
-
-  group.each.setup(() => {
-    root = new DataNamespace()
-    m1 = root.addDataModel('m1')
-    e1 = m1.addEntity('e1')
-    e2 = m1.addEntity('e2')
-    a1 = e1.addTargetAssociation(e2.key, 'a1')
-    e1.addTypedProperty('boolean', 'p1')
-    p2 = e2.addTypedProperty('number', 'p2')
-  })
-
-  test('returns basic shape definition', ({ assert }) => {
-    const result = a1.toApiShape()
-    assert.typeOf(result, 'object')
-
-    assert.equal(result.id, a1.key, 'has the id')
-    assert.deepEqual(result.types, IAmfPropertyTypes, 'has the types')
-    assert.deepEqual(result.values, [], 'has the values')
-    assert.deepEqual(result.inherits, [], 'has the inherits')
-    assert.deepEqual(result.or, [], 'has the or')
-    assert.deepEqual(result.and, [], 'has the and')
-    assert.deepEqual(result.xone, [], 'has the xone')
-    assert.equal(result.path, AmfNamespace.aml.vocabularies.data.key + 'a1', 'has the path')
-
-    const range = result.range as IApiNodeShape
-    assert.typeOf(range, 'object', 'has the range')
-    assert.deepEqual(range.types, IAmfNodeTypes, 'range has the types')
-    assert.equal(range.name, 'e2', 'range has the name')
-    assert.lengthOf(range.properties, 1, 'range has the properties')
-
-    const [prop] = range.properties
-    assert.equal(prop.id, p2.key, 'property has the id')
-    assert.deepEqual(prop.types, IAmfPropertyTypes, 'property has the types')
-
-    const pRange = prop.range as IApiScalarShape
-    assert.typeOf(pRange, 'object', 'property range is an object')
-    assert.deepEqual(pRange.types, IAmfScalarTypes, 'property range has the types')
-    assert.equal(pRange.name, 'p2', 'property range has the name')
-    assert.equal(pRange.dataType, AmfNamespace.w3.xmlSchema.number, 'property range has the dataType')
-  })
-
-  test('sets property description', ({ assert }) => {
-    a1.info.displayName = 'dn a1'
-    a1.info.description = 'desc a1'
-    const result = a1.toApiShape()
-    assert.equal(result.name, 'a1')
-    assert.equal(result.displayName, 'dn a1')
-    assert.equal(result.description, 'desc a1')
-  })
-
-  test('sets the minCount', ({ assert }) => {
-    a1.required = true
-    const result = a1.toApiShape()
-    assert.equal(result.minCount, 1)
-  })
-
-  test('sets the path', ({ assert }) => {
-    a1.required = true
-    const result = a1.toApiShape()
-    assert.equal(result.path, AmfNamespace.aml.vocabularies.data.key + 'a1', 'has the path')
-  })
-
-  test('returns a link definition when created on the schema', ({ assert }) => {
-    a1.schema = { linked: true }
-    const result = a1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.equal(range.id, `link-${a1.key}`)
-    assert.deepEqual(range.types, IAmfScalarTypes)
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string)
-  })
-
-  test('returns a default union type', ({ assert }) => {
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
-    assert.lengthOf(range.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = range.anyOf as IApiNodeShape[]
-
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(p1.properties, 1, 'p1 has the properties')
-    assert.lengthOf(p2.properties, 0, 'p2 has the properties')
-  })
-
-  test('has no range when no associations', ({ assert }) => {
-    a1.removeTarget(e2)
-    const result = a1.toApiShape()
-    assert.isUndefined(result.range)
-  })
-
-  test('returns an array shape when multiple', ({ assert }) => {
-    a1.multiple = true
-    const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
-    assert.deepEqual(range.types, IAmfArrayTypes)
-
-    const arrayRange = range.items as IApiNodeShape
-    assert.typeOf(arrayRange, 'object', 'has the range')
-    assert.deepEqual(arrayRange.types, IAmfNodeTypes, 'range has the types')
-    assert.equal(arrayRange.name, 'e2', 'range has the name')
-    assert.lengthOf(arrayRange.properties, 1, 'range has the properties')
-  })
-
-  test('creates the "anyOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'anyOf' }
-
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
-    assert.lengthOf(range.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = range.anyOf as IApiNodeShape[]
-
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(p1.properties, 1, 'p1 has the properties')
-    assert.lengthOf(p2.properties, 0, 'p2 has the properties')
-  })
-
-  test('creates the "allOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'allOf' }
-
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
-    assert.lengthOf(range.and, 2, 'has the anyOf array')
-    const [p1, p2] = range.and as IApiNodeShape[]
-
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(p1.properties, 1, 'p1 has the properties')
-    assert.lengthOf(p2.properties, 0, 'p2 has the properties')
-  })
-
-  test('creates the "oneOf" union', ({ assert }) => {
-    a1.schema = { unionType: 'oneOf' }
-
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
-    assert.lengthOf(range.xone, 2, 'has the oneOf array')
-    const [p1, p2] = range.xone as IApiNodeShape[]
-
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(p1.properties, 1, 'p1 has the properties')
-    assert.lengthOf(p2.properties, 0, 'p2 has the properties')
-  })
-
-  test('creates the "not" union', ({ assert }) => {
-    a1.schema = { unionType: 'not' }
-
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `union-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfUnionTypes, 'the range has the types')
-    assert.typeOf(range.not, 'object', 'has the not object')
-
-    const not = range.not as IApiNodeShape
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(not.properties, 1, 'p1 has the properties')
-  })
-
-  test('creates the "not" shape', ({ assert }) => {
-    a1.schema = { unionType: 'not' }
-
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `not-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfAnyTypes, 'the range has the types')
-    assert.typeOf(range.not, 'object', 'has the not object')
-
-    const not = range.not as IApiNodeShape
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(not.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(not.properties, 1, 'p1 has the properties')
-  })
-
-  test('wraps the union in the array shape', ({ assert }) => {
-    a1.multiple = true
-    a1.schema = { unionType: 'anyOf' }
-
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
-
-    assert.typeOf(range, 'object', 'has the range')
-    assert.equal(range.id, `array-shape-${a1.key}`, 'the range has the id')
-    assert.deepEqual(range.types, IAmfArrayTypes, 'the range has the types')
-
-    const items = range.items as IApiUnionShape
-
-    assert.lengthOf(items.anyOf, 2, 'has the anyOf array')
-    const [p1, p2] = items.anyOf as IApiNodeShape[]
-
-    assert.deepEqual(p1.types, IAmfNodeTypes, 'p1 has the types')
-    assert.deepEqual(p2.types, IAmfNodeTypes, 'p2 has the types')
-    assert.lengthOf(p1.properties, 1, 'p1 has the properties')
-    assert.lengthOf(p2.properties, 0, 'p2 has the properties')
-  })
-
-  test('handles linked schema', ({ assert }) => {
-    a1.schema = { linked: true }
-    const result = a1.toApiShape()
-    const range = result.range as IApiScalarShape
-    assert.equal(range.dataType, AmfNamespace.w3.xmlSchema.string)
-  })
-
-  test('handles multiple associations', ({ assert }) => {
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-    assert.lengthOf(range.anyOf, 2)
-  })
-
-  test('handles unionType', ({ assert }) => {
-    a1.schema = { unionType: 'allOf' }
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiUnionShape
-    assert.lengthOf(range.and, 2)
-  })
-
-  test('handles multiple and unionType', ({ assert }) => {
-    a1.multiple = true
-    a1.schema = { unionType: 'allOf' }
-    const e3 = m1.addEntity('e3')
-    a1.addTarget(e3)
-    const result = a1.toApiShape()
-    const range = result.range as IApiArrayShape
-    const items = range.items as IShapeUnion
-    assert.lengthOf(items.and, 2)
-  })
-})