@api-client/core 0.11.1 → 0.11.2

package/tests/unit/modeling/data_entity.spec.ts

@@ -11,6 +11,8 @@ import {
   ValidationError,
   RemovePropertyException,
   RemoveAssociationException,
+  RemoveEntityException,
+  ForeignAssociationException,
 } from '../../../src/index.js'
 
 test.group('constructor() with defaults', (group) => {
@@ -265,6 +267,47 @@ test.group('new()', (group) => {
       assoc.new({})
     }, 'Invalid data entity definition.')
   })
+
+  test('sets the fields as a copy', ({ assert }) => {
+    const src = new DataEntity(root)
+    const p1 = src.addNamedProperty('p1')
+    const a1 = src.addNamedAssociation('a1')
+    const assoc = new DataEntity(root)
+    const init = src.toJSON()
+    assoc.new(init)
+    assert.deepEqual(assoc.fields, [
+      { type: 'property', key: p1.key },
+      { type: 'association', key: a1.key },
+    ])
+    const p2 = src.addNamedProperty('p2')
+    init.fields!.push({ type: 'property', key: p2.key })
+    assert.deepEqual(assoc.fields, [
+      { type: 'property', key: p1.key },
+      { type: 'association', key: a1.key },
+    ])
+  })
+
+  test('resets fields when not in the input', ({ assert }) => {
+    const assoc = new DataEntity(root)
+    assoc.addNamedProperty('p1')
+    assoc.addNamedAssociation('a1')
+    assoc.new(base)
+    assert.deepEqual(assoc.fields, [])
+  })
+
+  test('creates fields when missing', ({ assert }) => {
+    const assoc = new DataEntity(root)
+    const p1 = assoc.addNamedProperty('p1')
+    const a1 = assoc.addNamedAssociation('a1')
+    const init = assoc.toJSON()
+    delete init.fields
+    const instance = new DataEntity(root)
+    instance.new(init)
+    assert.deepEqual(instance.fields, [
+      { type: 'property', key: p1.key },
+      { type: 'association', key: a1.key },
+    ])
+  })
 })
 
 test.group('toJSON()', (group) => {
@@ -358,6 +401,37 @@ test.group('toJSON()', (group) => {
     base.addNamedAssociation('a2')
     assert.deepEqual(result.associations, [a1.key])
   })
+
+  test('serializes fields as a copy', ({ assert }) => {
+    const p1 = base.addNamedProperty('p1')
+    const a1 = base.addNamedAssociation('a1')
+    const result = base.toJSON()
+    assert.deepEqual(result.fields, [
+      { type: 'property', key: p1.key },
+      { type: 'association', key: a1.key },
+    ])
+    base.addNamedProperty('p2')
+    assert.deepEqual(result.fields, [
+      { type: 'property', key: p1.key },
+      { type: 'association', key: a1.key },
+    ])
+  })
+
+  test('does not serialize fields when empty', ({ assert }) => {
+    const result = base.toJSON()
+    assert.isUndefined(result.fields)
+  })
+
+  test('does not serialize deprecated by default', ({ assert }) => {
+    const result = base.toJSON()
+    assert.isUndefined(result.deprecated)
+  })
+
+  test('serialize the set deprecated', ({ assert }) => {
+    base.deprecated = false
+    const result = base.toJSON()
+    assert.isFalse(result.deprecated)
+  })
 })
 
 test.group('remove()', (group) => {
@@ -399,6 +473,16 @@ test.group('remove()', (group) => {
     assert.deepEqual(e2.associations, [a2])
     assert.deepEqual(root.definitions.associations, [a2])
   })
+
+  test('throws when removing an entity that is a target', ({ assert }) => {
+    // const e3 = m1.addEntity('e3')
+    e2.addTargetAssociation(e1.key)
+    assert.throws(
+      () => e1.remove(),
+      RemoveEntityException as unknown as ErrorConstructor,
+      `Cannot remove entity ${e1.info.name} because it is used as a target in associations in entities: e2.`
+    )
+  })
 })
 
 test.group('addTypedProperty()', (group) => {
@@ -639,6 +723,22 @@ test.group('addForeignAssociation()', (group) => {
     const a1 = e1.addForeignAssociation(e2.key, n2.key, 'my name')
     assert.equal(a1.info.name, 'my name')
   })
+
+  test('throws when the foreign namespace is not defined', ({ assert }) => {
+    assert.throws(
+      () => e1.addForeignAssociation(e2.key, 'unknown'),
+      ForeignAssociationException as unknown as ErrorConstructor,
+      'Trying to add a foreign association but the foreign namespace is not defined.'
+    )
+  })
+
+  test('throws when adding a foreign association that targets the same entity', ({ assert }) => {
+    assert.throws(
+      () => e1.addForeignAssociation(e1.key, n1.key),
+      ForeignAssociationException as unknown as ErrorConstructor,
+      'Trying to add a foreign association but the foreign namespace is not defined.'
+    )
+  })
 })
 
 test.group('removeAssociation()', (group) => {
@@ -777,6 +877,23 @@ test.group('getComputedChildren()', (group) => {
     const result = e1.getComputedChildren()
     assert.deepEqual(result, [e2])
   })
+
+  test('returns grandchildren', ({ assert }) => {
+    const e2 = m1.addEntity('e2')
+    const e3 = m1.addEntity('e3')
+    e2.addParent(e1.key)
+    e3.addParent(e2.key)
+    const result = e1.getComputedChildren()
+    assert.deepEqual(result, [e2])
+  })
+
+  test('returns empty array when no direct children', ({ assert }) => {
+    const e2 = m1.addEntity('e2')
+    const e3 = m1.addEntity('e3')
+    e3.addParent(e2.key)
+    const result = e1.getComputedChildren()
+    assert.deepEqual(result, [])
+  })
 })
 
 test.group('getComputedAssociations()', (group) => {
@@ -842,6 +959,37 @@ test.group('getComputedAssociations()', (group) => {
     const result = e1.getComputedAssociations()
     assert.deepEqual(result, [])
   })
+
+  test('returns multiple associations', ({ assert }) => {
+    const e2 = m1.addEntity('e2')
+    const e3 = m1.addEntity('e3')
+    e1.addTargetAssociation(e2.key)
+    e1.addTargetAssociation(e3.key)
+
+    const result = e1.getComputedAssociations()
+    assert.deepEqual(result.sort(), [e2, e3].sort())
+  })
+
+  test('returns indirect associations', ({ assert }) => {
+    const e2 = m1.addEntity('e2')
+    const e3 = m1.addEntity('e3')
+    e1.addTargetAssociation(e2.key)
+    e2.addTargetAssociation(e3.key)
+
+    const result = e1.getComputedAssociations()
+    assert.deepEqual(result, [e2])
+  })
+
+  test('returns multiple targets', ({ assert }) => {
+    const e2 = m1.addEntity('e2')
+    const e3 = m1.addEntity('e3')
+    const a1 = e1.addNamedAssociation('a1')
+    a1.addTarget(e2)
+    a1.addTarget(e3)
+
+    const result = e1.getComputedAssociations()
+    assert.deepEqual(result.sort(), [e2, e3].sort())
+  })
 })
 
 test.group('associationPath()', (group) => {
@@ -924,12 +1072,71 @@ test.group('associationPath()', (group) => {
   })
 })
 
+test.group('associationPath() - More Complex Scenarios', (group) => {
+  let root: DataNamespace
+  let model: DataModel
+  let entityA: DataEntity
+  let entityB: DataEntity
+  let entityC: DataEntity
+  let entityD: DataEntity
+  let foreignRoot: DataNamespace
+  let foreignEntity: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    model = root.addDataModel('model')
+    entityA = model.addEntity('entityA')
+    entityB = model.addEntity('entityB')
+    entityC = model.addEntity('entityC')
+    entityD = model.addEntity('entityD')
+
+    foreignRoot = new DataNamespace()
+    root.addForeign(foreignRoot)
+    const foreignModel = foreignRoot.addDataModel('foreignModel')
+    foreignEntity = foreignModel.addEntity('foreignEntity')
+  })
+
+  test('returns multiple paths when multiple indirect associations', ({ assert }) => {
+    entityA.addTargetAssociation(entityB.key)
+    entityA.addTargetAssociation(entityC.key)
+    entityB.addTargetAssociation(entityD.key)
+    entityC.addTargetAssociation(entityD.key)
+    const result = [...entityA.associationPath(entityD.key)]
+    assert.deepEqual(result, [
+      [entityA.key, entityC.key, entityD.key],
+      [entityA.key, entityB.key, entityD.key],
+    ])
+  })
+
+  test('returns empty array when not associated', ({ assert }) => {
+    entityA.addTargetAssociation(entityB.key)
+    const result = [...entityA.associationPath(entityC.key)]
+    assert.deepEqual(result, [])
+  })
+
+  test('returns empty array when no associations in foreign namespaces', ({ assert }) => {
+    entityA.addForeignAssociation(foreignEntity.key, foreignRoot.key)
+    const result = [...entityA.associationPath(entityB.key)]
+    assert.deepEqual(result, [])
+  })
+
+  test('returns the path when foreign association', ({ assert }) => {
+    entityA.addForeignAssociation(foreignEntity.key, foreignRoot.key)
+    const result = [...entityA.associationPath(foreignEntity.key)]
+    assert.deepEqual(result, [[entityA.key, foreignEntity.key]])
+  })
+})
+
 test.group('isAssociated()', (group) => {
   let root: DataNamespace
   let m1: DataModel
   let e1: DataEntity
   let e2: DataEntity
   let e3: DataEntity
+  let e4: DataEntity
+
+  let foreignRoot: DataNamespace
+  let foreignEntity: DataEntity
 
   group.each.setup(() => {
     root = new DataNamespace()
@@ -937,6 +1144,12 @@ test.group('isAssociated()', (group) => {
     e1 = m1.addEntity('e1')
     e2 = m1.addEntity('e2')
     e3 = m1.addEntity('e3')
+    e4 = m1.addEntity('e4')
+
+    foreignRoot = new DataNamespace()
+    root.addForeign(foreignRoot)
+    const foreignModel = foreignRoot.addDataModel('foreignModel')
+    foreignEntity = foreignModel.addEntity('foreignEntity')
   })
 
   test('returns true when testing self', ({ assert }) => {
@@ -962,6 +1175,41 @@ test.group('isAssociated()', (group) => {
     const result = e1.isAssociated(e3.key)
     assert.isFalse(result)
   })
+
+  test('returns true when has multiple paths', ({ assert }) => {
+    e1.addTargetAssociation(e2.key)
+    e1.addTargetAssociation(e3.key)
+    e3.addTargetAssociation(e4.key)
+    e2.addTargetAssociation(e4.key)
+    const result = e1.isAssociated(e4.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when has no path', ({ assert }) => {
+    e1.addTargetAssociation(e2.key)
+    const result = e1.isAssociated(e3.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when no association', ({ assert }) => {
+    const result = DataEntity.isAssociated(e1, e2)
+    assert.isFalse(result)
+  })
+
+  test('returns true when foreign association', ({ assert }) => {
+    e1.addForeignAssociation(foreignEntity.key, foreignRoot.key)
+    const result = DataEntity.isAssociated(e1, foreignEntity)
+    assert.isTrue(result)
+  })
+
+  test('returns true when has multiple paths', ({ assert }) => {
+    e1.addTargetAssociation(e2.key)
+    e1.addTargetAssociation(e3.key)
+    e3.addTargetAssociation(e4.key)
+    e2.addTargetAssociation(e4.key)
+    const result = DataEntity.isAssociated(e1, e4)
+    assert.isTrue(result)
+  })
 })
 
 test.group('getRelatedEntities()', (group) => {
@@ -983,6 +1231,7 @@ test.group('getRelatedEntities()', (group) => {
     e1b = m1.addEntity('e1b')
     e2a = m2.addEntity('e2a')
     m2.addEntity('e2b')
+    m2.addEntity('e2b')
   })
 
   test('reads entities from the same namespace', ({ assert }) => {
@@ -1006,6 +1255,13 @@ test.group('getRelatedEntities()', (group) => {
     const result = e1a.getRelatedEntities()
     assert.deepEqual(result, [e1b, e2a])
   })
+
+  test('returns multiple related entities', ({ assert }) => {
+    e1b.addTargetAssociation(e1a)
+    e2a.addTargetAssociation(e1a)
+    const result = e1a.getRelatedEntities()
+    assert.deepEqual(result.sort(), [e1b, e2a].sort())
+  })
 })
 
 test.group('breadcrumbs()', (group) => {
@@ -1014,6 +1270,14 @@ test.group('breadcrumbs()', (group) => {
     root = new DataNamespace()
   })
 
+  test('adds root and self', ({ assert }) => {
+    const e1 = new DataEntity(root)
+    const result = e1.breadcrumbs()
+    assert.lengthOf(result, 2, 'has the entire path')
+    assert.equal(result[0].key, root.key, 'has the root as first')
+    assert.equal(result[1].key, e1.key, 'has the entity as last')
+  })
+
   test('adds root, data model, and self', ({ assert }) => {
     const m1 = root.addDataModel('m1')
     const e1 = m1.addEntity('e1')
@@ -1128,6 +1392,39 @@ test.group('removeTag()', (group) => {
   })
 })
 
+test.group('addTag() and removeTag() - More Scenarios', (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('adds multiple tags to the property', ({ assert }) => {
+    e1.addTag('Test1')
+    e1.addTag('Test2')
+    assert.deepEqual(e1.tags, ['Test1', 'Test2'])
+  })
+
+  test('removes multiple tags from the property', ({ assert }) => {
+    e1.addTag('t1')
+    e1.addTag('t2')
+    e1.addTag('t3')
+    e1.removeTag('t1')
+    e1.removeTag('t3')
+    assert.deepEqual(e1.tags, ['t2'])
+  })
+
+  test('removes a tag case insensitive', ({ assert }) => {
+    e1.addTag('Test')
+    e1.removeTag('teSt')
+    assert.deepEqual(e1.tags, [])
+  })
+})
+
 test.group('toApiShape()', (group) => {
   let root: DataNamespace
   let m1: DataModel
@@ -1302,6 +1599,43 @@ test.group('addParent()', (group) => {
     assert.doesNotThrow(() => entity2.addParent(entity3.key))
     assert.deepEqual(entity2.parents, [entity3.key])
   })
+
+  test('throws an error when adding the same parent twice', ({ assert }) => {
+    entity2.addParent(entity1.key)
+    assert.throws(
+      () => entity2.addParent(entity1.key),
+      ValidationError as unknown as ErrorConstructor,
+      `Parent ${entity1.key} already exists.`
+    )
+  })
+
+  test('adds multiple parents', ({ assert }) => {
+    entity3.addParent(entity1.key)
+    entity3.addParent(entity2.key)
+    assert.deepEqual(entity3.parents.sort(), [entity1.key, entity2.key].sort())
+  })
+})
+
+test.group('DataEntity - getParent()', (group) => {
+  let root: DataNamespace
+  let model: DataModel
+  let entity1: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    model = root.addDataModel('model')
+    entity1 = model.addEntity('entity1')
+  })
+
+  test('returns undefined when the entity is not in a model', ({ assert }) => {
+    const result = new DataEntity(root).getParent()
+    assert.isUndefined(result)
+  })
+
+  test('returns the parent data model', ({ assert }) => {
+    const result = entity1.getParent()
+    assert.instanceOf(result, DataModel)
+  })
 })
 
 test.group('hasCircularParent()', (group) => {
@@ -1354,6 +1688,13 @@ test.group('hasCircularParent()', (group) => {
     assert.isTrue(entity2.hasCircularParent(entity1.key))
     assert.isTrue(entity3.hasCircularParent(entity1.key))
   })
+
+  test('returns true when indirect circular dependency - multiple parents', ({ assert }) => {
+    entity1.addParent(entity2.key)
+    entity1.addParent(entity3.key)
+    entity2.addParent(entity4.key)
+    assert.isTrue(entity4.hasCircularParent(entity1.key))
+  })
 })
 
 test.group('associationPath()', (group) => {
@@ -1466,3 +1807,143 @@ test.group('getRelatedEntities()', (group) => {
     assert.deepEqual(result, [entityA, entityD])
   })
 })
+
+test.group('listProperties()', (group) => {
+  let root: DataNamespace
+  let m1: DataModel
+  let e1: DataEntity
+  let p1: DataProperty
+  let p2: DataProperty
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    m1 = root.addDataModel('m1')
+    e1 = m1.addEntity('e1')
+    p1 = e1.addNamedProperty('p1')
+    p2 = e1.addNamedProperty('p2')
+  })
+
+  test('lists all properties', ({ assert }) => {
+    const result = e1.listProperties()
+    assert.deepEqual(result, [p1, p2])
+  })
+
+  test('returns a copy of the array', ({ assert }) => {
+    const result = e1.listProperties()
+    result.pop()
+    assert.lengthOf(e1.properties, 2)
+  })
+})
+
+test.group('listAssociations()', (group) => {
+  let root: DataNamespace
+  let m1: DataModel
+  let e1: DataEntity
+  let a1: DataAssociation
+  let a2: DataAssociation
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    m1 = root.addDataModel('m1')
+    e1 = m1.addEntity('e1')
+    a1 = e1.addNamedAssociation('a1')
+    a2 = e1.addNamedAssociation('a2')
+  })
+
+  test('lists all associations', ({ assert }) => {
+    const result = e1.listAssociations()
+    assert.deepEqual(result, [a1, a2])
+  })
+
+  test('returns a copy of the array', ({ assert }) => {
+    const result = e1.listAssociations()
+    result.pop()
+    assert.lengthOf(e1.associations, 2)
+  })
+})
+
+test.group('listFields()', (group) => {
+  let root: DataNamespace
+  let m1: DataModel
+  let e1: DataEntity
+  let p1: DataProperty
+  let p2: DataProperty
+  let a1: DataAssociation
+  let a2: DataAssociation
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    m1 = root.addDataModel('m1')
+    e1 = m1.addEntity('e1')
+    p1 = e1.addNamedProperty('p1')
+    p2 = e1.addNamedProperty('p2')
+    a1 = e1.addNamedAssociation('a1')
+    a2 = e1.addNamedAssociation('a2')
+  })
+
+  test('lists all fields in order', ({ assert }) => {
+    const result = e1.listFields()
+    assert.deepEqual(result, [p1, p2, a1, a2])
+  })
+
+  test('returns a copy of the array', ({ assert }) => {
+    const result = e1.listFields()
+    result.pop()
+    assert.lengthOf(e1.fields, 4)
+  })
+
+  test('returns fields in the order of the fields array', ({ assert }) => {
+    e1.moveField(p1.key, 3)
+    const result = e1.listFields()
+    assert.deepEqual(result, [p2, a1, a2, p1])
+  })
+})
+
+test.group('moveField()', (group) => {
+  let root: DataNamespace
+  let m1: DataModel
+  let e1: DataEntity
+  let p1: DataProperty
+  let p2: DataProperty
+  let a1: DataAssociation
+  let a2: DataAssociation
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    m1 = root.addDataModel('m1')
+    e1 = m1.addEntity('e1')
+    p1 = e1.addNamedProperty('p1')
+    p2 = e1.addNamedProperty('p2')
+    a1 = e1.addNamedAssociation('a1')
+    a2 = e1.addNamedAssociation('a2')
+  })
+
+  test('moves the field to a new index', ({ assert }) => {
+    e1.moveField(p1.key, 3)
+    assert.deepEqual(
+      e1.fields.map((i) => i.key),
+      [p2.key, a1.key, a2.key, p1.key]
+    )
+  })
+
+  test('Moving a field to the same index', ({ assert }) => {
+    e1.moveField(p1.key, 0)
+    assert.deepEqual(
+      e1.fields.map((i) => i.key),
+      [p1.key, p2.key, a1.key, a2.key]
+    )
+  })
+
+  test('throws when the field does not exist', ({ assert }) => {
+    assert.throws(
+      () => e1.moveField('unknown', 0),
+      ValidationError as unknown as ErrorConstructor,
+      'Validation failure'
+    )
+  })
+
+  test('throws when the index is out of bounds', ({ assert }) => {
+    assert.throws(() => e1.moveField(p1.key, -1), ValidationError as unknown as ErrorConstructor, 'Validation failure')
+    assert.throws(() => e1.moveField(p1.key, 4), ValidationError as unknown as ErrorConstructor, 'Validation failure')
+  })
+})