@api-client/core 0.18.7 → 0.18.8

package/tests/unit/modeling/importers/json_schema_importer.spec.ts

@@ -7,6 +7,11 @@ import { DataDomain } from '../../../../src/modeling/DataDomain.js'
 import type { JSONSchema7 } from 'json-schema'
 import type { DomainEntity } from '../../../../src/modeling/DomainEntity.js'
 import { DomainAssociation, DomainProperty } from '../../../../src/browser.js'
+import Person from '../../../fixtures/schemas/person.json' with { type: 'json' }
+import Arrays from '../../../fixtures/schemas/arrays.json' with { type: 'json' }
+import EnumValues from '../../../fixtures/schemas/enumerated_values.json' with { type: 'json' }
+import RegexpSchema from '../../../fixtures/schemas/regexp.json' with { type: 'json' }
+import ComplexSchema from '../../../fixtures/schemas/complex.json' with { type: 'json' }
 
 const input: InMemorySchema[] = []
 for (const [key, value] of Object.entries(schemas)) {
@@ -43,6 +48,13 @@ function findAssociationByName(entity: DomainEntity, name: string): DomainAssoci
   throw new Error(`Association with name "${name}" not found`)
 }
 
+async function importSchemas(input: InMemorySchema[]): Promise<DataDomain> {
+  const domain = new DataDomain({ info: { name: 'Test Domain' } })
+  const importer = new JsonSchemaImporter(domain)
+  await importer.import(input, 'imported_model')
+  return domain
+}
+
 test.group('JsonSchemaImporter', (g) => {
   let domain: DataDomain
 
@@ -449,3 +461,128 @@ test.group('JsonSchemaImporter', (g) => {
     )
   })
 })
+
+test.group('small batch of schemas', () => {
+  test('imports a single schema', async ({ assert }) => {
+    const domain = await importSchemas(input.slice(0, 1))
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    assert.equal(entities[0].info.name, '3_d_model', 'Entity should be 3_d_model')
+  })
+
+  test('imports two schemas only', async ({ assert }) => {
+    const domain = await importSchemas(input.slice(0, 2))
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    assert.equal(entities[0].info.name, '3_d_model', 'Entity should be 3_d_model')
+    assert.equal(entities[1].info.name, 'am_radio_channel', 'Entity should be am_radio_channel')
+  })
+})
+
+//
+// From the JSON Schema website.
+//
+test.group('JSON Schema Examples', () => {
+  test('imports Person schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'person.json', contents: Person as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const [person] = entities
+    const properties = [...person.listProperties()]
+    assert.lengthOf(properties, 3, 'Person should have three properties')
+    assert.equal(properties[0].info.name, 'first_name', 'First property should be first_name')
+    assert.equal(properties[1].info.name, 'last_name', 'Second property should be last_name')
+    assert.equal(properties[2].info.name, 'age', 'Third property should be age')
+    assert.equal(properties[0].type, 'string', 'First property should be string')
+    assert.equal(properties[1].type, 'string', 'Second property should be string')
+    assert.equal(properties[2].type, 'number', 'Third property should be number')
+    assert.strictEqual(properties[2].schema?.minimum, 0, 'Third property should have minimum 0')
+  })
+
+  test('imports Arrays schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'arrays.json', contents: Arrays as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    const arraysEntity = findEntityByName(domain, 'arrays')
+    const veggieEntity = findEntityByName(domain, 'veggie')
+    assert.exists(arraysEntity, 'arrays entity should exist')
+    assert.exists(veggieEntity, 'veggie entity should exist')
+    const arraysProperties = [...arraysEntity.listProperties()]
+    const arraysAssociations = [...arraysEntity.listAssociations()]
+    assert.lengthOf(arraysProperties, 1, 'Arrays entity should have one property')
+    assert.lengthOf(arraysAssociations, 1, 'Arrays entity should have one association')
+    const veggieProperties = [...veggieEntity.listProperties()]
+    const veggieAssociations = [...veggieEntity.listAssociations()]
+    assert.lengthOf(veggieProperties, 2, 'Veggie entity should have two properties')
+    assert.lengthOf(veggieAssociations, 0, 'Veggie entity should have no associations')
+    const [vp1, vp2] = veggieProperties
+    assert.equal(vp1.info.name, 'veggie_name', 'First veggie property should be veggie_name')
+    assert.equal(vp2.info.name, 'veggie_like', 'Second veggie property should be veggie_like')
+    assert.isTrue(vp1.required, 'veggie_name should be required')
+    assert.isTrue(vp2.required, 'veggie_like should not be required')
+  })
+
+  test('imports EnumValues schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'enumerated_values.json', contents: EnumValues as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const enumEntity = findEntityByName(domain, 'enumerated_values')
+    assert.exists(enumEntity, 'EnumeratedValues entity should exist')
+    const properties = [...enumEntity.listProperties()]
+    assert.lengthOf(properties, 1, 'EnumeratedValues entity should have one property')
+    const [p1] = properties
+    assert.equal(p1.info.name, 'data', 'Property should be data')
+    assert.deepEqual(
+      p1.schema?.enum,
+      ['42', 'true', 'hello', 'null', '1,2,3'],
+      'Property should have correct enum values'
+    )
+  })
+
+  test('imports RegexpSchema schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'regexp.json', contents: RegexpSchema as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 1, 'Should import one entity')
+    const entity = findEntityByName(domain, 'regular_expression_pattern')
+    assert.exists(entity, 'RegularExpressionPattern entity should exist')
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 1, 'RegularExpressionPattern entity should have one property')
+    const [p1] = properties
+    assert.equal(p1.info.name, 'code', 'Property should be code')
+    assert.equal(p1.schema?.pattern, '^[A-Z]{3}-\\d{3}$', 'Property should have correct pattern')
+  })
+
+  test('imports ComplexSchema schema correctly', async ({ assert }) => {
+    const domain = await importSchemas([{ path: 'complex.json', contents: ComplexSchema as JSONSchema7 }])
+    const models = [...domain.listModels()]
+    assert.lengthOf(models, 1, 'Should import one model')
+    const entities = [...domain.listEntities()]
+    assert.lengthOf(entities, 2, 'Should import two entities')
+    const entity = findEntityByName(domain, 'complex_object')
+    assert.exists(entity, 'ComplexObject entity should exist')
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 3, 'ComplexObject entity should have three properties')
+    const [p1, p2, p3] = properties
+    assert.equal(p1.info.name, 'name', 'First property should be name')
+    assert.equal(p2.info.name, 'age', 'Second property should be age')
+    assert.equal(p3.info.name, 'hobbies', 'Third property should be hobbies')
+    const associations = [...entity.listAssociations()]
+    assert.lengthOf(associations, 1, 'ComplexObject entity should have one association')
+    const inlineEntity = findEntityByName(domain, 'complex_object_address')
+    assert.exists(inlineEntity, 'ComplexObjectAddress entity should exist')
+    const [a1] = associations
+    assert.deepEqual(a1.targets, [{ key: inlineEntity.key }], 'Association should target ComplexObjectAddress')
+  })
+})