@api-client/core 0.17.0 → 0.17.2

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

@@ -10,7 +10,7 @@ test.group('DataDomain.addProperty()', () => {
     const property = dataDomain.addProperty(entity.key, { key: 'test-property' })
     assert.instanceOf(property, DomainProperty)
     assert.isTrue(dataDomain.graph.hasNode(property.key))
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty adds a property with default values', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -21,14 +21,14 @@ test.group('DataDomain.addProperty()', () => {
     assert.isTrue(dataDomain.graph.hasNode(property.key))
     assert.equal(property.info.name, 'new_property')
     assert.equal(property.type, 'string')
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty throws an error if parent entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.addProperty('non-existent-entity', { key: 'test-property' })
     }, 'Parent entity non-existent-entity does not exist')
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty throws an error if parent is not an entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -36,7 +36,7 @@ test.group('DataDomain.addProperty()', () => {
     assert.throws(() => {
       dataDomain.addProperty(model.key)
     }, `Parent entity ${model.key} not found`)
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -44,7 +44,7 @@ test.group('DataDomain.addProperty()', () => {
     const entity = dataDomain.addEntity(model.key)
     dataDomain.addProperty(entity.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty adds a property to a parent entity - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -52,7 +52,7 @@ test.group('DataDomain.addProperty()', () => {
     const entity = dataDomain.addEntity(model.key)
     const property = dataDomain.addProperty(entity.key)
     assert.isTrue(dataDomain.graph.hasEdge(entity.key, property.key))
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty adds a property to a parent entity - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -60,7 +60,7 @@ test.group('DataDomain.addProperty()', () => {
     const entity = dataDomain.addEntity(model.key)
     const property = dataDomain.addProperty(entity.key)
     assert.deepInclude([...entity.listProperties()], property)
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty throws an error if no parent is provided', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -68,7 +68,7 @@ test.group('DataDomain.addProperty()', () => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addProperty(undefined)
     }, 'A property expects a DomainEntity parent')
-  })
+  }).tags(['@modeling', '@property', '@add'])
 
   test('addProperty throws when adding property to a foreign entity', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -85,7 +85,7 @@ test.group('DataDomain.addProperty()', () => {
     assert.throws(() => {
       domain1.addProperty(`${domain2.key}:${e2.key}`)
     }, 'Cannot add a property to a foreign domain')
-  })
+  }).tags(['@modeling', '@property', '@add'])
 })
 
 test.group('DataDomain.removeProperty()', () => {
@@ -96,14 +96,14 @@ test.group('DataDomain.removeProperty()', () => {
     const property = dataDomain.addProperty(entity.key)
     dataDomain.removeProperty(property.key)
     assert.isFalse(dataDomain.graph.hasNode(property.key))
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('throws an error if the property does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeProperty('non-existent-property')
     }, 'Property non-existent-property does not exist')
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('removes the property from the parent entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -112,7 +112,7 @@ test.group('DataDomain.removeProperty()', () => {
     const property = dataDomain.addProperty(entity.key)
     dataDomain.removeProperty(property.key)
     assert.isUndefined(entity.listProperties().next().value)
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('throws an error when the parent entity is not found', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -121,7 +121,7 @@ test.group('DataDomain.removeProperty()', () => {
     assert.throws(() => {
       dataDomain.removeProperty(property.key)
     }, `Parent entity not found for property ${property.key}`)
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -130,7 +130,7 @@ test.group('DataDomain.removeProperty()', () => {
     const property = dataDomain.addProperty(entity.key)
     dataDomain.removeProperty(property.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('throws an error if the property is not of type DomainProperty', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -139,7 +139,7 @@ test.group('DataDomain.removeProperty()', () => {
     assert.throws(() => {
       dataDomain.removeProperty(model.key)
     }, `Property ${model.key} not found`)
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('throws an error if trying to remove a property from a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -156,7 +156,7 @@ test.group('DataDomain.removeProperty()', () => {
     assert.throws(() => {
       domain1.removeProperty(`${domain2.key}:${property.key}`)
     }, 'Cannot remove a property from a foreign domain')
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 
   test('removes the property from the fields list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -165,7 +165,7 @@ test.group('DataDomain.removeProperty()', () => {
     const property = dataDomain.addProperty(entity.key)
     dataDomain.removeProperty(property.key)
     assert.deepEqual([...entity.listFields()], [])
-  })
+  }).tags(['@modeling', '@property', '@remove'])
 })
 
 test.group('DataDomain.findProperty()', () => {
@@ -176,75 +176,75 @@ test.group('DataDomain.findProperty()', () => {
     const property = dataDomain.addProperty(entity.key)
     const foundProperty = dataDomain.findProperty(property.key)
     assert.deepEqual(foundProperty, property)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if property does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundProperty = dataDomain.findProperty('non-existent-property')
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is not a property', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel()
     const foundProperty = dataDomain.findProperty(model.key)
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty(undefined)
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty(null)
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundProperty = dataDomain.findProperty('')
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty(123)
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty(true)
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty({})
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty([])
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundProperty = dataDomain.findProperty(() => {})
     assert.isUndefined(foundProperty)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 
   test('finds a property in a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -260,5 +260,5 @@ test.group('DataDomain.findProperty()', () => {
 
     const foundProperty = domain1.findProperty(`${domain2.key}:${property.key}`)
     assert.deepEqual(foundProperty, property)
-  })
+  }).tags(['@modeling', '@property', '@find'])
 })

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

@@ -19,7 +19,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
     assert.equal([...restored.graph.nodes()].length, 0)
     assert.equal([...restored.graph.edges()].length, 0)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with namespaces', ({ assert }) => {
     const domain = new DataDomain()
@@ -45,7 +45,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal(rn2!.key, ns2.key)
     assert.equal(rn2!.kind, DomainNamespaceKind)
     assert.equal(restored.graph.parent(ns2.key), ns1.key)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with models', ({ assert }) => {
     const domain = new DataDomain()
@@ -70,7 +70,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.isDefined(rm2)
     assert.equal(rm2!.key, m2.key)
     assert.equal(rm2!.kind, DomainModelKind)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with entities', ({ assert }) => {
     const domain = new DataDomain()
@@ -98,7 +98,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal(re2!.key, e2.key)
     assert.equal(re2!.kind, DomainEntityKind)
     assert.equal([...re2!.listParents()][0].key, e1.key)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with properties', ({ assert }) => {
     const domain = new DataDomain()
@@ -132,7 +132,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal(props.length, 2)
     assert.equal(props[0].key, p1.key)
     assert.equal(props[1].key, p2.key)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with associations', ({ assert }) => {
     const domain = new DataDomain()
@@ -155,7 +155,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal(ra1!.key, a1.key)
     assert.equal(ra1!.kind, DomainAssociationKind)
     assert.equal([...ra1!.listTargets()][0].key, e2.key)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a complex DataDomain', ({ assert }) => {
     const domain = new DataDomain()
@@ -236,7 +236,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal(ra1!.key, a1.key)
     assert.equal(ra1!.kind, DomainAssociationKind)
     assert.equal([...ra1!.listTargets()][0].key, e2.key)
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with foreign dependencies', ({ assert }) => {
     const fd = new DataDomain()
@@ -265,7 +265,7 @@ test.group('DataDomain Serialization and Deserialization', () => {
     // Associations look like: Entity -> (edge) -> Association -> (edge) -> ForeignEntity
     assert.isTrue(restored.graph.hasEdge(e1.key, a1.key), 'has edge from e1 to a1')
     assert.isTrue(restored.graph.hasEdge(a1.key, `${fd.key}:${fe1.key}`), 'has edge from a1 to fe1')
-  })
+  }).tags(['@modeling', '@serialization'])
 
   test('should serialize and deserialize a DataDomain with missing foreign dependencies', ({ assert }) => {
     const fd = new DataDomain()
@@ -290,5 +290,5 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.equal([...restored.graph.edges()].length, 1)
     assert.isTrue(restored.graph.hasEdge(e1.key, a1.key), 'has edge from e1 to a1')
     assert.isFalse(restored.graph.hasEdge(a1.key, `${fd.key}:${fe1.key}`), 'has no edge from a1 to fe1')
-  })
+  }).tags(['@modeling', '@serialization'])
 })

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

@@ -11,7 +11,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2)
     assert.deepEqual(association.targets, [{ key: entity2.key }])
     assert.isTrue(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('adds a target entity by key to the association', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -22,7 +22,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2.key)
     assert.deepEqual(association.targets, [{ key: entity2.key }])
     assert.isTrue(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('adds a target entity with a foreign namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -37,7 +37,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2.key, foreignDomain.key)
     assert.deepEqual(association.targets, [{ key: entity2.key, domain: foreignDomain.key }])
     assert.isTrue(dataDomain.graph.hasEdge(association.key, `${foreignDomain.key}:${entity2.key}`))
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('throws an error if the target entity already exists', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -49,7 +49,7 @@ test.group('DomainAssociation.addTarget()', () => {
     assert.throws(() => {
       association.addTarget(entity2)
     }, `Target ${entity2.key} already exists.`)
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('throws an error if the foreign namespace does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -60,7 +60,7 @@ test.group('DomainAssociation.addTarget()', () => {
     assert.throws(() => {
       association.addTarget(entity2.key, 'non-existent-namespace')
     }, 'Foreign namespace "non-existent-namespace" does not exist.')
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -70,7 +70,7 @@ test.group('DomainAssociation.addTarget()', () => {
     const association = new DomainAssociation(dataDomain, entity1.key)
     association.addTarget(entity2)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('creates a graph edge', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -81,7 +81,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2)
     assert.isTrue(dataDomain.graph.hasEdge(association.key, entity2.key))
     assert.deepEqual(dataDomain.graph.edge(association.key, entity2.key), { type: 'association' })
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('adds a target entity to the association with a foreign domain', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -96,7 +96,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2)
     assert.deepEqual(association.targets, [{ key: entity2.key, domain: foreignDomain.key }])
     assert.isTrue(dataDomain.graph.hasEdge(association.key, `${foreignDomain.key}:${entity2.key}`))
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('adds a target entity to the association with a foreign domain - entity instance', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -111,7 +111,7 @@ test.group('DomainAssociation.addTarget()', () => {
     association.addTarget(entity2)
     assert.deepEqual(association.targets, [{ key: entity2.key, domain: foreignDomain.key }])
     assert.isTrue(dataDomain.graph.hasEdge(association.key, `${foreignDomain.key}:${entity2.key}`))
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('throws an error if the foreign namespace does not exist when adding a target entity with a foreign domain', ({
     assert,
@@ -123,7 +123,7 @@ test.group('DomainAssociation.addTarget()', () => {
     assert.throws(() => {
       association.addTarget('test-entity', 'non-existent-domain')
     }, 'Foreign namespace "non-existent-domain" does not exist.')
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 
   test('throws an error if the target entity already exists with the same foreign namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -139,7 +139,7 @@ test.group('DomainAssociation.addTarget()', () => {
     assert.throws(() => {
       association.addTarget(entity2)
     }, `Target ${entity2.key} already exists.`)
-  })
+  }).tags(['@modeling', '@association', '@target', '@add'])
 })
 
 test.group('DomainAssociation.removeTarget()', () => {
@@ -153,7 +153,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.removeTarget(entity2)
     assert.deepEqual(association.targets, [])
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('removes a target entity by key from the targets list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -165,7 +165,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.removeTarget(entity2.key)
     assert.deepEqual(association.targets, [])
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('does not throw an error if the target entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -174,7 +174,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     const association = new DomainAssociation(dataDomain, entity1.key)
     association.removeTarget('non-existent-entity')
     assert.deepEqual(association.targets, [])
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -185,7 +185,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.addTarget(entity2)
     association.removeTarget(entity2)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('removes the graph edge', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -196,7 +196,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.addTarget(entity2)
     association.removeTarget(entity2)
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('removes a target entity with a foreign namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -212,7 +212,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.removeTarget(entity2.key)
     assert.deepEqual(association.targets, [])
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('removes a target entity with a foreign namespace - entity instance', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -228,7 +228,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     association.removeTarget(entity2)
     assert.deepEqual(association.targets, [])
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 
   test('removes only the specified target entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -243,7 +243,7 @@ test.group('DomainAssociation.removeTarget()', () => {
     assert.deepEqual(association.targets, [{ key: entity3.key }])
     assert.isFalse(dataDomain.graph.hasEdge(association.key, entity2.key))
     assert.isTrue(dataDomain.graph.hasEdge(association.key, entity3.key))
-  })
+  }).tags(['@modeling', '@association', '@target', '@remove'])
 })
 
 test.group('DomainAssociation.listTargets()', () => {
@@ -260,7 +260,7 @@ test.group('DomainAssociation.listTargets()', () => {
     assert.lengthOf(targets, 2)
     assert.deepInclude(targets, entity2)
     assert.deepInclude(targets, entity3)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('returns an empty array if there are no target entities', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -269,7 +269,7 @@ test.group('DomainAssociation.listTargets()', () => {
     const association = new DomainAssociation(dataDomain, entity1.key)
     const targets = [...association.listTargets()]
     assert.lengthOf(targets, 0)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('returns only entities that exist in the graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -282,7 +282,7 @@ test.group('DomainAssociation.listTargets()', () => {
     const targets = [...association.listTargets()]
     assert.lengthOf(targets, 1)
     assert.deepInclude(targets, entity2)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('lists target entities with foreign namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -299,7 +299,7 @@ test.group('DomainAssociation.listTargets()', () => {
     const targets = [...association.listTargets()]
     assert.lengthOf(targets, 1)
     assert.deepInclude(targets, dataDomain.findForeignEntity(entity2.key, foreignDomain.key)!)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('lists target entities when some targets are from foreign namespaces and some are local', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -318,7 +318,7 @@ test.group('DomainAssociation.listTargets()', () => {
     assert.lengthOf(targets, 2)
     assert.deepInclude(targets, entity2)
     assert.deepInclude(targets, dataDomain.findForeignEntity(entity3.key, foreignDomain.key)!)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('lists target entities when the target entity is added as an instance', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -330,7 +330,7 @@ test.group('DomainAssociation.listTargets()', () => {
     const targets = [...association.listTargets()]
     assert.lengthOf(targets, 1)
     assert.deepInclude(targets, entity2)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 
   test('lists target entities when the target entity is added as an instance from a foreign domain', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -346,5 +346,5 @@ test.group('DomainAssociation.listTargets()', () => {
     const targets = [...association.listTargets()]
     assert.lengthOf(targets, 1)
     assert.deepInclude(targets, dataDomain.findForeignEntity(entity2.key, foreignDomain.key)!)
-  })
+  }).tags(['@modeling', '@association', '@target', '@list'])
 })

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

@@ -247,6 +247,83 @@ test.group('Semantics', () => {
     assert.equal(totalSemantics, allSemantics, 'All semantics should be categorized')
   })
 
+  test('getSemanticsByCategory should filter by Entity scope', ({ assert }) => {
+    const semanticsByCategory = getSemanticsByCategory(SemanticScope.Entity)
+    const allEntitySemantics = Object.values(DataSemantics).filter((s) => s.scope === SemanticScope.Entity)
+
+    // Ensure only Entity scope semantics are present
+    Object.values(semanticsByCategory).forEach((categorySemantics) => {
+      categorySemantics.forEach((semantic) => {
+        assert.equal(semantic.scope, SemanticScope.Entity, 'Only Entity semantics should be returned')
+      })
+    })
+
+    // Ensure all Entity scope semantics are returned
+    const returnedEntitySemantics = Object.values(semanticsByCategory).flat()
+    assert.equal(returnedEntitySemantics.length, allEntitySemantics.length, 'All Entity semantics should be returned')
+    allEntitySemantics.forEach((expectedSemantic) => {
+      assert.include(
+        returnedEntitySemantics,
+        expectedSemantic,
+        `Expected Entity semantic ${expectedSemantic.id} not found`
+      )
+    })
+  })
+
+  test('getSemanticsByCategory should filter by Property scope', ({ assert }) => {
+    const semanticsByCategory = getSemanticsByCategory(SemanticScope.Property)
+    const allPropertySemantics = Object.values(DataSemantics).filter((s) => s.scope === SemanticScope.Property)
+
+    // Ensure only Property scope semantics are present
+    Object.values(semanticsByCategory).forEach((categorySemantics) => {
+      categorySemantics.forEach((semantic) => {
+        assert.equal(semantic.scope, SemanticScope.Property, 'Only Property semantics should be returned')
+      })
+    })
+
+    // Ensure all Property scope semantics are returned
+    const returnedPropertySemantics = Object.values(semanticsByCategory).flat()
+    assert.equal(
+      returnedPropertySemantics.length,
+      allPropertySemantics.length,
+      'All Property semantics should be returned'
+    )
+    allPropertySemantics.forEach((expectedSemantic) => {
+      assert.include(
+        returnedPropertySemantics,
+        expectedSemantic,
+        `Expected Property semantic ${expectedSemantic.id} not found`
+      )
+    })
+  })
+
+  test('getSemanticsByCategory should filter by Association scope', ({ assert }) => {
+    const semanticsByCategory = getSemanticsByCategory(SemanticScope.Association)
+    const allAssociationSemantics = Object.values(DataSemantics).filter((s) => s.scope === SemanticScope.Association)
+
+    // Ensure only Association scope semantics are present
+    Object.values(semanticsByCategory).forEach((categorySemantics) => {
+      categorySemantics.forEach((semantic) => {
+        assert.equal(semantic.scope, SemanticScope.Association, 'Only Association semantics should be returned')
+      })
+    })
+
+    // Ensure all Association scope semantics are returned
+    const returnedAssociationSemantics = Object.values(semanticsByCategory).flat()
+    assert.equal(
+      returnedAssociationSemantics.length,
+      allAssociationSemantics.length,
+      'All Association semantics should be returned'
+    )
+    allAssociationSemantics.forEach((expectedSemantic) => {
+      assert.include(
+        returnedAssociationSemantics,
+        expectedSemantic,
+        `Expected Association semantic ${expectedSemantic.id} not found`
+      )
+    })
+  })
+
   test('getSemanticsByCategoryType should filter semantics by category', ({ assert }) => {
     const identitySemantics = getSemanticsByCategoryType(SemanticCategory.Identity)