@api-client/core 0.11.11 → 0.12.0

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

@@ -0,0 +1,449 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../src/modeling/DataDomain.js'
+import { DomainEntity } from '../../../src/modeling/DomainEntity.js'
+
+test.group('DataDomain.addEntity()', () => {
+  test('addEntity adds an entity to the graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    assert.instanceOf(entity, DomainEntity)
+    assert.isTrue(dataDomain.graph.hasNode(entity.key))
+  })
+
+  test('addEntity adds an entity to the graph with a parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    assert.instanceOf(entity, DomainEntity)
+    assert.isTrue(dataDomain.graph.hasNode(entity.key))
+    assert.equal(dataDomain.graph.parent(entity.key), model.key)
+  })
+
+  test('addEntity throws an error if parent model does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      dataDomain.addEntity('non-existent-parent', { key: 'test-entity' })
+    }, 'The parent non-existent-parent does not exist')
+  })
+
+  test('addEntity throws an error if parent is not a model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace({ key: 'test-ns' })
+    assert.throws(() => {
+      dataDomain.addEntity(namespace.key, { key: 'test-entity' })
+    }, `Parent model ${namespace.key} is not a valid model`)
+  })
+
+  test('addEntity adds an entity with default values', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, {})
+    assert.instanceOf(entity, DomainEntity)
+    assert.isTrue(dataDomain.graph.hasNode(entity.key))
+    assert.equal(dataDomain.graph.parent(entity.key), model.key)
+  })
+
+  test('addEntity notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    dataDomain.addEntity(model.key, { key: 'test-entity' })
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('addEntity adds an entity to a parent model - checks parent-child relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentModel = dataDomain.addModel({ key: 'parent-model' })
+    const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
+    assert.isTrue(dataDomain.graph.hasParent(entity.key, parentModel.key))
+  })
+
+  test('addEntity adds an entity to a parent model - checks items list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentModel = dataDomain.addModel({ key: 'parent-model' })
+    const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
+    assert.deepInclude([...parentModel!.listEntities()], entity)
+  })
+
+  test('addEntity throws an error if no parent is provided', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      // @ts-expect-error For testing purposes, we are passing undefined
+      dataDomain.addEntity(undefined, { key: 'test-entity' })
+    }, `An entity expects a DataModel parent`)
+  })
+
+  test('addEntity throws when adding the same entity twice', ({ assert }) => {
+    const root = new DataDomain()
+    const m1 = root.addModel({ key: 'parent-model' })
+    root.addEntity(m1.key, { key: 'test-entity' })
+    assert.throws(() => {
+      root.addEntity(m1.key, { key: 'test-entity' })
+    }, `Entity with key test-entity already exists`)
+  })
+})
+
+test.group('DataDomain.removeEntity()', () => {
+  test('removeEntity removes an entity from the graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const entity = dataDomain.addModel({ key: 'test-model' }).addEntity({ key: 'test-entity' })
+    dataDomain.removeEntity(entity.key)
+    assert.isFalse(dataDomain.graph.hasNode(entity.key))
+  })
+
+  test('removeEntity throws an error if entity does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      dataDomain.removeEntity('non-existent-entity')
+    }, 'Entity non-existent-entity does not exist')
+  })
+
+  test('removeEntity notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    dataDomain.removeEntity(entity.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('removeEntity removes an entity from a parent model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentModel = dataDomain.addModel({ key: 'parent-model' })
+    const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
+    dataDomain.removeEntity(entity.key)
+    assert.isFalse(dataDomain.graph.hasNode(entity.key))
+    assert.equal(dataDomain.graph.parent(entity.key), undefined)
+  })
+
+  test('removeEntity removes an entity with properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const property = dataDomain.addProperty(entity.key, { key: 'test-property' })
+    dataDomain.removeEntity(entity.key)
+    assert.isFalse(dataDomain.graph.hasNode(entity.key))
+    assert.isFalse(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('removeEntity removes an entity from a parent model - checks parent-child relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentModel = dataDomain.addModel({ key: 'parent-model' })
+    const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
+    dataDomain.removeEntity(entity.key)
+    assert.isFalse(dataDomain.graph.hasParent(entity.key, parentModel.key))
+  })
+
+  test('removeEntity removes an entity from a parent model - checks items list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentModel = dataDomain.addModel({ key: 'parent-model' })
+    const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
+    dataDomain.removeEntity(entity.key)
+    assert.notDeepInclude([...parentModel!.listEntities()], entity)
+  })
+
+  test('removeEntity throws an error if key is not an entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    assert.throws(() => {
+      dataDomain.removeEntity(model.key)
+    }, `Parent model not found for entity ${model.key}`)
+  })
+})
+
+test.group('DataDomain.listEntities()', () => {
+  test('lists all entities in the graph for a given parent model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
+    const entity2 = dataDomain.addEntity(model.key, { key: 'entity2' })
+    const entities = [...dataDomain.listEntities(model.key)]
+    assert.lengthOf(entities, 2)
+    assert.deepInclude(entities, entity1)
+    assert.deepInclude(entities, entity2)
+  })
+
+  test('returns an empty array if there are no entities for a given parent model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entities = [...dataDomain.listEntities(model.key)]
+    assert.lengthOf(entities, 0)
+  })
+
+  test('returns only entities for a given parent model', ({ assert }) => {
+    const root = new DataDomain()
+    const m1 = root.addModel({ key: 'm1' })
+    const m2 = root.addModel({ key: 'm2' })
+    const e1 = root.addEntity(m1.key, { key: 'entity1' })
+    root.addEntity(m2.key, { key: 'entity2' })
+    root.addNamespace({ key: 'ns1' })
+    const entities = [...root.listEntities(m1.key)]
+    assert.lengthOf(entities, 1)
+    assert.deepInclude(entities, e1)
+  })
+
+  test('entities in the list are of type DomainEntity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    dataDomain.addEntity(model.key, { key: 'entity1' })
+    const entities = [...dataDomain.listEntities(model.key)]
+    assert.instanceOf(entities[0], DomainEntity)
+  })
+
+  test('lists entities when there are no entities', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entities = [...dataDomain.listEntities(model.key)]
+    assert.deepEqual(entities, [])
+  })
+
+  test('lists entities when there are other domain elements', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
+    dataDomain.addNamespace({ key: 'ns1' })
+    const entities = [...dataDomain.listEntities(model.key)]
+    assert.deepEqual(entities, [entity1])
+  })
+
+  test('returns an empty array if the parent model does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const entities = [...dataDomain.listEntities('non-existent-model')]
+    assert.deepEqual(entities, [])
+  })
+
+  test('returns an empty array if the parent is not a model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const namespace = dataDomain.addNamespace({ key: 'test-ns' })
+    const entities = [...dataDomain.listEntities(namespace.key)]
+    assert.deepEqual(entities, [])
+  })
+
+  test('lists entities from a foreign domain', ({ assert }) => {
+    const domain1 = new DataDomain()
+    const m1 = domain1.addModel({ key: 'model1' })
+    const e1 = domain1.addEntity(m1.key, { key: 'entity1' })
+
+    const domain2 = new DataDomain()
+    domain2.info.version = '1.0.0'
+    const m2 = domain2.addModel({ key: 'model2' })
+    domain2.addEntity(m2.key, { key: 'entity2' })
+    domain1.registerForeignDomain(domain2)
+
+    const children = [...domain1.listEntities(m1.key)]
+    assert.lengthOf(children, 1)
+    assert.deepInclude(children, e1)
+  })
+})
+
+test.group('DataDomain.findEntity()', () => {
+  test('finds an entity by its key', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const foundEntity = dataDomain.findEntity('test-entity')
+    assert.deepEqual(foundEntity, entity)
+  })
+
+  test('returns undefined if entity does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foundEntity = dataDomain.findEntity('non-existent-entity')
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is not an entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const foundEntity = dataDomain.findEntity(model.key)
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is undefined', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity(undefined)
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is null', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity(null)
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is an empty string', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foundEntity = dataDomain.findEntity('')
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is a number', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity(123)
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is a boolean', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity(true)
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is an object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity({})
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is an array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity([])
+    assert.isUndefined(foundEntity)
+  })
+
+  test('returns undefined if key is a function', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundEntity = dataDomain.findEntity(() => {})
+    assert.isUndefined(foundEntity)
+  })
+
+  test('finds an entity in a foreign domain', ({ assert }) => {
+    const domain1 = new DataDomain()
+    const m1 = domain1.addModel({ key: 'model1' })
+    const e1 = domain1.addEntity(m1.key, { key: 'entity1' })
+
+    const domain2 = new DataDomain()
+    const m2 = domain2.addModel({ key: 'model2' })
+    domain2.addEntity(m2.key, { key: 'entity2' })
+    domain2.info.version = '1.0.0'
+    domain1.registerForeignDomain(domain2)
+
+    const foundEntity = domain1.findEntity('entity1')
+    assert.deepEqual(foundEntity, e1)
+  })
+})
+
+test.group('DataDomain.moveEntity()', () => {
+  test('moves an entity from one model to another', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    dataDomain.moveEntity(entity.key, model1.key, model2.key)
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key)
+    assert.deepEqual(model1.fields, [])
+    assert.deepEqual(model2.fields, [{ key: entity.key, type: 'entity' }])
+  })
+
+  test('throws an error if the entity does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    assert.throws(() => {
+      dataDomain.moveEntity('non-existent-entity', model1.key, model2.key)
+    }, 'Entity non-existent-entity does not exist')
+  })
+
+  test('throws an error if the source model does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const entity = dataDomain.addEntity('model2', { key: 'entity1' })
+    assert.throws(() => {
+      dataDomain.moveEntity(entity.key, 'non-existent-model', model2.key)
+    }, 'Source model non-existent-model does not exist')
+  })
+
+  test('throws an error if the target model does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    assert.throws(() => {
+      dataDomain.moveEntity(entity.key, model1.key, 'non-existent-model')
+    }, 'Target model non-existent-model does not exist')
+  })
+
+  test('throws an error if the entity is not in the same domain', ({ assert }) => {
+    const dataDomain1 = new DataDomain()
+    const model1 = dataDomain1.addModel({ key: 'model1' })
+    const entity = model1.addEntity({ key: 'entity1' })
+
+    const dataDomain2 = new DataDomain()
+    const model2 = dataDomain2.addModel({ key: 'model2' })
+    dataDomain1.info.version = '1.0.0'
+    dataDomain2.registerForeignDomain(dataDomain1)
+
+    assert.throws(() => {
+      dataDomain2.moveEntity(`${dataDomain1.key}:${entity.key}`, `${dataDomain1.key}:${model1.key}`, model2.key)
+    }, 'Cannot move an entity from a foreign domain')
+  })
+
+  test('throws an error if the target model is not in the same domain', ({ assert }) => {
+    const dataDomain1 = new DataDomain()
+    const model1 = dataDomain1.addModel({ key: 'model1' })
+    const entity = model1.addEntity({ key: 'entity1' })
+
+    const dataDomain2 = new DataDomain()
+    const model2 = dataDomain2.addModel({ key: 'model2' })
+    dataDomain2.info.version = '1.0.0'
+    dataDomain1.registerForeignDomain(dataDomain2)
+
+    assert.throws(() => {
+      dataDomain1.moveEntity(entity.key, model1.key, `${dataDomain2.key}:${model2.key}`)
+    }, 'Cannot move an entity to a foreign domain')
+  })
+
+  test('throws an error if the source and target models are the same', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    assert.throws(() => {
+      dataDomain.moveEntity(entity.key, model1.key, model1.key)
+    }, 'Cannot move an entity to the same model')
+  })
+
+  test('throws an error if the target is not a model', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const namespace = dataDomain.addNamespace({ key: 'namespace1' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    assert.throws(() => {
+      dataDomain.moveEntity(entity.key, model1.key, namespace.key)
+    }, 'Entity or models not found in the graph')
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    dataDomain.moveEntity(entity.key, model1.key, model2.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('moves an entity with properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    entity.addProperty({ key: 'test-property', type: 'string' })
+    dataDomain.moveEntity(entity.key, model1.key, model2.key)
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key)
+    assert.isTrue(dataDomain.graph.hasNode('test-property'))
+  })
+
+  test('moves an entity with associations', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const entity = model1.addEntity({ key: 'entity1' })
+    const assoc = entity.addAssociation()
+    dataDomain.moveEntity(entity.key, model1.key, model2.key)
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key)
+    assert.isTrue(dataDomain.graph.hasNode(assoc.key))
+  })
+})