@api-client/core 0.17.0 → 0.17.1

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

@@ -12,7 +12,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
     assert.equal(dataDomain.dependencies.get(foreignDomain.key), foreignDomain)
     assert.equal(dataDomain.dependencyList.length, 1)
     assert.deepEqual(dataDomain.dependencyList[0], { key: foreignDomain.key, version: '1.0.0' })
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('throws an error when registering a domain with the same key', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -23,7 +23,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
       () => dataDomain.registerForeignDomain(foreignDomain1),
       `Foreign domain with key ${foreignDomain1.key} already registered`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('throws an error when registering a domain without a version', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -32,7 +32,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
       () => dataDomain.registerForeignDomain(foreignDomain),
       `Foreign domain ${foreignDomain.key} does not have a version set`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies nodes from the foreign domain to the local graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -49,7 +49,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
     assert.deepEqual(dataDomain.graph.node(`${foreignDomain.key}:${model.key}`), model)
     assert.deepEqual(dataDomain.graph.node(`${foreignDomain.key}:${entity.key}`), entity)
     assert.deepEqual(dataDomain.graph.node(`${foreignDomain.key}:${property.key}`), property)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies edges from the foreign domain to the local graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -67,7 +67,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
       dataDomain.graph.edge(`${foreignDomain.key}:${entity.key}`, `${foreignDomain.key}:${property.key}`),
       { type: 'property', domain: foreignDomain.key, foreign: true }
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies parent-child relationships from the foreign domain to the local graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -83,7 +83,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
       dataDomain.graph.hasEdge(`${foreignDomain.key}:${childEntity.key}`, `${foreignDomain.key}:${entity.key}`)
     )
     assert.isTrue(dataDomain.graph.hasParent(`${foreignDomain.key}:${entity.key}`, `${foreignDomain.key}:${model.key}`))
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies multiple parent-child relationships from the foreign domain to the local graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -110,7 +110,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
       dataDomain.graph.hasParent(`${foreignDomain.key}:${entity2.key}`, `${foreignDomain.key}:${model.key}`)
     )
     // assert.isTrue(dataDomain.graph.hasParent(`${foreignDomain.key}:${model.key}`))
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies association edges from the foreign domain to the local graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -128,7 +128,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
     assert.isTrue(
       dataDomain.graph.hasEdge(`${foreignDomain.key}:${association.key}`, `${foreignDomain.key}:${entity2.key}`)
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 
   test('copies foreign domain entities to the root of the graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -140,7 +140,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
 
     assert.isTrue(dataDomain.graph.hasNode(`${foreignDomain.key}:${entity.key}`))
     assert.isTrue(dataDomain.graph.hasParent(`${foreignDomain.key}:${entity.key}`, `${foreignDomain.key}:${model.key}`))
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@register'])
 })
 
 test.group('DataDomain.findNamespace()', () => {
@@ -152,7 +152,7 @@ test.group('DataDomain.findNamespace()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findNamespace('test-namespace', fd.key)
     assert.deepEqual(result, ns)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@namespace'])
 
   test('returns undefined when namespace not found', ({ assert }) => {
     const domain = new DataDomain()
@@ -161,7 +161,7 @@ test.group('DataDomain.findNamespace()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findNamespace('other-namespace', fd.key)
     assert.isUndefined(result)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@namespace'])
 
   test("throws when namespace's namespace not found", ({ assert }) => {
     const domain = new DataDomain()
@@ -169,7 +169,7 @@ test.group('DataDomain.findNamespace()', () => {
     assert.throws(() => {
       domain.findNamespace('test-namespace', 'non-existent-domain')
     }, `Foreign domain non-existent-domain not found`)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@namespace'])
 })
 
 test.group('DataDomain.findModel()', () => {
@@ -182,7 +182,7 @@ test.group('DataDomain.findModel()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findModel('test-model', fd.key)
     assert.deepEqual(result, model)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@model'])
 
   test('returns undefined when model not found', ({ assert }) => {
     const domain = new DataDomain()
@@ -191,7 +191,7 @@ test.group('DataDomain.findModel()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findModel('other-model', fd.key)
     assert.isUndefined(result)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@model'])
 
   test("throws when model's namespace not found", ({ assert }) => {
     const domain = new DataDomain()
@@ -199,7 +199,7 @@ test.group('DataDomain.findModel()', () => {
     assert.throws(() => {
       domain.findModel('test-model', 'non-existent-domain')
     }, `Foreign domain non-existent-domain not found`)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@model'])
 })
 
 test.group('DataDomain.findEntity()', () => {
@@ -212,7 +212,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity('test-entity', foreignDomain.key)
     assert.deepEqual(foundEntity, entity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when the foreign domain does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -220,7 +220,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity('test-entity', 'non-existent-domain'),
       `Foreign domain non-existent-domain not found`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if the entity does not exist in the foreign domain', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -229,7 +229,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity('non-existent-entity', foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if the key is not an entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -239,7 +239,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity(model.key, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -249,7 +249,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(undefined, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -259,7 +259,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(null, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -268,7 +268,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity('', foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -278,7 +278,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(123, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -288,7 +288,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(true, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -298,7 +298,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity({}, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -308,7 +308,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity([], foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -318,7 +318,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(() => {}, foreignDomain.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if domainKey is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -329,7 +329,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity(entity.key, undefined)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if domainKey is null', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -341,7 +341,7 @@ test.group('DataDomain.findEntity()', () => {
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(entity.key, null)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('returns undefined if domainKey is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -352,7 +352,7 @@ test.group('DataDomain.findEntity()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     const foundEntity = dataDomain.findEntity(entity.key, '')
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when domainKey is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -366,7 +366,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity(entity.key, 123),
       `Invalid namespace key. Expected a string, got number`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when domainKey is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -380,7 +380,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity(entity.key, true),
       `Invalid namespace key. Expected a string, got boolean`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when domainKey is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -394,7 +394,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity(entity.key, {}),
       `Invalid namespace key. Expected a string, got object`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when domainKey is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -408,7 +408,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity(entity.key, []),
       `Invalid namespace key. Expected a string, got object`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 
   test('throws when domainKey is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -422,7 +422,7 @@ test.group('DataDomain.findEntity()', () => {
       () => dataDomain.findEntity(entity.key, () => {}),
       `Invalid namespace key. Expected a string, got function`
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@entity'])
 })
 
 test.group('DataDomain.listForeignNamespaces()', () => {
@@ -440,7 +440,7 @@ test.group('DataDomain.listForeignNamespaces()', () => {
     assert.lengthOf(namespaces, 2)
     assert.deepInclude(namespaces, ns1Foreign)
     assert.deepInclude(namespaces, ns2Foreign)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@namespace'])
 
   test('returns an empty generator if the foreign domain has no namespaces', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -450,7 +450,7 @@ test.group('DataDomain.listForeignNamespaces()', () => {
 
     const namespaces = [...localDomain.listForeignNamespaces(foreignDomain.key)]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@namespace'])
 
   test('returns an empty generator if foreign namespaces are not in the local graph', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -464,7 +464,7 @@ test.group('DataDomain.listForeignNamespaces()', () => {
 
     const namespacesAfterRemoval = [...localDomain.listForeignNamespaces(foreignDomain.key)]
     assert.lengthOf(namespacesAfterRemoval, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@namespace'])
 
   test('throws an error if the foreign domain key is not registered', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -472,7 +472,7 @@ test.group('DataDomain.listForeignNamespaces()', () => {
       () => [...localDomain.listForeignNamespaces('nonExistentKey')],
       'Foreign domain nonExistentKey not found'
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@namespace'])
 })
 
 test.group('DataDomain.listForeignModels()', () => {
@@ -494,7 +494,7 @@ test.group('DataDomain.listForeignModels()', () => {
     assert.lengthOf(models, 2)
     assert.deepInclude(models, model1Foreign)
     assert.deepInclude(models, model2Foreign)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@model'])
 
   test('returns an empty generator if the foreign domain has no models', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -504,7 +504,7 @@ test.group('DataDomain.listForeignModels()', () => {
 
     const models = [...localDomain.listForeignModels(foreignDomain.key)]
     assert.lengthOf(models, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@model'])
 
   test('returns an empty generator if foreign models are not in the local graph', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -518,12 +518,12 @@ test.group('DataDomain.listForeignModels()', () => {
 
     const modelsAfterRemoval = [...localDomain.listForeignModels(foreignDomain.key)]
     assert.lengthOf(modelsAfterRemoval, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@model'])
 
   test('throws an error if the foreign domain key is not registered', ({ assert }) => {
     const localDomain = new DataDomain()
     assert.throws(() => [...localDomain.listForeignModels('nonExistentKey')], 'Foreign domain nonExistentKey not found')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@model'])
 })
 
 test.group('DataDomain.listForeignEntities()', () => {
@@ -546,7 +546,7 @@ test.group('DataDomain.listForeignEntities()', () => {
     assert.lengthOf(entities, 2)
     assert.deepInclude(entities, entity1Foreign)
     assert.deepInclude(entities, entity2Foreign)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@entity'])
 
   test('returns an empty generator if the foreign domain has no entities', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -556,7 +556,7 @@ test.group('DataDomain.listForeignEntities()', () => {
 
     const entities = [...localDomain.listForeignEntities(foreignDomain.key)]
     assert.lengthOf(entities, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@entity'])
 
   test('returns an empty generator if foreign entities are not in the local graph', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -571,7 +571,7 @@ test.group('DataDomain.listForeignEntities()', () => {
 
     const entitiesAfterRemoval = [...localDomain.listForeignEntities(foreignDomain.key)]
     assert.lengthOf(entitiesAfterRemoval, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@entity'])
 
   test('throws an error if the foreign domain key is not registered', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -579,7 +579,7 @@ test.group('DataDomain.listForeignEntities()', () => {
       () => [...localDomain.listForeignEntities('nonExistentKey')],
       'Foreign domain nonExistentKey not found'
     )
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@entity'])
 
   test('lists entities from a foreign domain even if local domain has entities', ({ assert }) => {
     const localDomain = new DataDomain()
@@ -596,7 +596,7 @@ test.group('DataDomain.listForeignEntities()', () => {
     assert.lengthOf(entities, 1)
     assert.deepInclude(entities, entityForeign)
     assert.notDeepInclude(entities, localDomain.findEntity('entityL') as DomainEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@list', '@entity'])
 })
 
 test.group('DataDomain.findAssociation()', () => {
@@ -611,7 +611,7 @@ test.group('DataDomain.findAssociation()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findAssociation(a1.key, fd.key)
     assert.deepEqual(result, a1)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@association'])
 
   test('returns undefined when association not found', ({ assert }) => {
     const domain = new DataDomain()
@@ -620,7 +620,7 @@ test.group('DataDomain.findAssociation()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findAssociation('other-association', fd.key)
     assert.isUndefined(result)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@association'])
 
   test("throws when association's namespace not found", ({ assert }) => {
     const domain = new DataDomain()
@@ -628,7 +628,7 @@ test.group('DataDomain.findAssociation()', () => {
     assert.throws(() => {
       domain.findAssociation('test-association', 'non-existent-domain')
     }, `Foreign domain non-existent-domain not found`)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@association'])
 })
 
 test.group('DataDomain.findProperty()', () => {
@@ -642,7 +642,7 @@ test.group('DataDomain.findProperty()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findProperty(p1.key, fd.key)
     assert.deepEqual(result, p1)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@property'])
 
   test('returns undefined when property not found', ({ assert }) => {
     const domain = new DataDomain()
@@ -651,7 +651,7 @@ test.group('DataDomain.findProperty()', () => {
     domain.registerForeignDomain(fd)
     const result = domain.findProperty('other-property', fd.key)
     assert.isUndefined(result)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@property'])
 
   test("throws when property's namespace not found", ({ assert }) => {
     const domain = new DataDomain()
@@ -659,7 +659,7 @@ test.group('DataDomain.findProperty()', () => {
     assert.throws(() => {
       domain.findProperty('test-property', 'non-existent-domain')
     }, `Foreign domain non-existent-domain not found`)
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@find', '@property'])
 })
 
 test.group('DataDomain foreign elements namespace property', () => {
@@ -674,7 +674,7 @@ test.group('DataDomain foreign elements namespace property', () => {
     assert.ok(retrievedNs, 'Foreign namespace should be found in local domain')
     assert.equal(retrievedNs!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
     assert.equal(retrievedNs!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@namespace_property', '@check'])
 
   test('DomainModel retains its original namespace key after foreign registration', ({ assert }) => {
     const localDomain = new DataDomain({ key: 'localKey' })
@@ -688,7 +688,7 @@ test.group('DataDomain foreign elements namespace property', () => {
     assert.ok(retrievedModel, 'Foreign model should be found in local domain')
     assert.equal(retrievedModel!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
     assert.equal(retrievedModel!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@namespace_property', '@check'])
 
   test('DomainEntity retains its original namespace key after foreign registration', ({ assert }) => {
     const localDomain = new DataDomain({ key: 'localKey' })
@@ -703,7 +703,7 @@ test.group('DataDomain foreign elements namespace property', () => {
     assert.ok(retrievedEntity, 'Foreign entity should be found in local domain')
     assert.equal(retrievedEntity!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
     assert.equal(retrievedEntity!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@namespace_property', '@check'])
 
   test('DomainProperty retains its original namespace key after foreign registration', ({ assert }) => {
     const localDomain = new DataDomain({ key: 'localKey' })
@@ -719,7 +719,7 @@ test.group('DataDomain foreign elements namespace property', () => {
     assert.ok(retrievedProperty, 'Foreign property should be found in local domain')
     assert.equal(retrievedProperty!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
     assert.equal(retrievedProperty!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@namespace_property', '@check'])
 
   test('DomainElement.namespace is the key of the domain it was created in', ({ assert }) => {
     const domain = new DataDomain({ key: 'originalDomainKey' })
@@ -728,5 +728,5 @@ test.group('DataDomain foreign elements namespace property', () => {
 
     assert.equal(model.namespace, 'originalDomainKey')
     assert.equal(entity.namespace, 'originalDomainKey')
-  })
+  }).tags(['@modeling', '@datadomain', '@foreign', '@namespace_property', '@check'])
 })