@api-client/core 0.16.1 → 0.17.1

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

@@ -17,13 +17,13 @@ test.group('DataDomain', () => {
     assert.isNotEmpty(dataDomain.key)
     assert.isDefined(dataDomain.graph)
     assert.deepEqual(dataDomain.fields, [])
-  })
+  }).tags(['@modeling', '@datadomain', '@core', '@unit', '@fast'])
 
   test('notifyChange dispatches a change event', async ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.notifyChange()
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@datadomain', '@core', '@unit', '@events', '@async'])
 })
 
 test.group('DataDomain.removeDomainElement()', () => {
@@ -33,7 +33,7 @@ test.group('DataDomain.removeDomainElement()', () => {
     dataDomain.removeDomainElement(namespace.key, DomainNamespaceKind)
     assert.isUndefined(dataDomain.findNamespace(namespace.key))
     assert.isFalse(dataDomain.graph.hasNode(namespace.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('removes a data model', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -41,7 +41,7 @@ test.group('DataDomain.removeDomainElement()', () => {
     dataDomain.removeDomainElement(model.key, DomainModelKind)
     assert.isUndefined(dataDomain.findModel(model.key))
     assert.isFalse(dataDomain.graph.hasNode(model.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('removes an entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -50,7 +50,7 @@ test.group('DataDomain.removeDomainElement()', () => {
     dataDomain.removeDomainElement(entity.key, DomainEntityKind)
     assert.isUndefined(dataDomain.findEntity(entity.key))
     assert.isFalse(dataDomain.graph.hasNode(entity.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('removes a property', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -60,7 +60,7 @@ test.group('DataDomain.removeDomainElement()', () => {
     dataDomain.removeDomainElement(property.key, DomainPropertyKind)
     assert.isUndefined(dataDomain.findProperty(property.key))
     assert.isFalse(dataDomain.graph.hasNode(property.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('removes an association', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -70,49 +70,49 @@ test.group('DataDomain.removeDomainElement()', () => {
     dataDomain.removeDomainElement(association.key, DomainAssociationKind)
     assert.isUndefined(dataDomain.findAssociation(association.key))
     assert.isFalse(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error for an unknown kind', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('test-unknown', 'unknown-kind')
     }, 'Unknown kind unknown-kind for the object test-unknown')
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error when removing a non-existing namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('non-existent-namespace', DomainNamespaceKind)
     }, `Namespace non-existent-namespace does not exist`)
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error when removing a non-existing model', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('non-existent-model', DomainModelKind)
     }, `Data model non-existent-model does not exist`)
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error when removing a non-existing entity', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('non-existent-entity', DomainEntityKind)
     }, `Entity non-existent-entity does not exist`)
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error when removing a non-existing property', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('non-existent-property', DomainPropertyKind)
     }, `Property non-existent-property does not exist`)
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('throws an error when removing a non-existing association', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeDomainElement('non-existent-association', DomainAssociationKind)
     }, `Association non-existent-association does not exist`)
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 
   test('removes a namespace with children', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -138,7 +138,7 @@ test.group('DataDomain.removeDomainElement()', () => {
     assert.isFalse(dataDomain.graph.hasNode(entity.key))
     assert.isFalse(dataDomain.graph.hasNode(property.key))
     assert.isFalse(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@datadomain', '@crud', '@removal'])
 })
 
 test.group('DataDomain.createSchema()', () => {
@@ -151,7 +151,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.isUndefined(schema.graph)
     assert.isUndefined(schema.dependencyList)
     assert.isUndefined(schema.fields)
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with provided values', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -167,7 +167,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.deepEqual(schema.graph, { nodes: [], edges: [], options: {} })
     assert.deepEqual(schema.dependencyList, [{ key: 'dep1', version: '1.0.0' }])
     assert.deepEqual(schema.fields, [{ key: 'field1', type: 'namespace' }])
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with partial info', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -177,7 +177,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Test Domain' })
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with empty info', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -187,7 +187,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Unnamed domain' })
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with dependencyList', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -198,7 +198,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Unnamed domain' })
     assert.deepEqual(schema.dependencyList, [{ key: 'dep1', version: '1.0.0' }])
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with graph', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -209,7 +209,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Unnamed domain' })
     assert.deepEqual(schema.graph, { nodes: [], edges: [], options: {} })
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 
   test('creates a schema with fields', ({ assert }) => {
     const schema = DataDomain.createSchema({
@@ -220,7 +220,7 @@ test.group('DataDomain.createSchema()', () => {
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'Unnamed domain' })
     assert.deepEqual(schema.fields, [{ key: 'field1', type: 'namespace' }])
-  })
+  }).tags(['@modeling', '@datadomain', '@schema', '@factory'])
 })
 
 test.group('DataDomain.constructor()', () => {
@@ -233,7 +233,7 @@ test.group('DataDomain.constructor()', () => {
     assert.deepInclude(dataDomain.info.toJSON(), { name: 'Unnamed domain' })
     assert.isDefined(dataDomain.graph)
     assert.deepEqual(dataDomain.dependencyList, [])
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with provided values', ({ assert }) => {
     const dataDomain = new DataDomain({
@@ -247,7 +247,7 @@ test.group('DataDomain.constructor()', () => {
     assert.deepInclude(dataDomain.info.toJSON(), { name: 'Test Domain', description: 'A test domain' })
     assert.isDefined(dataDomain.graph)
     assert.deepEqual(dataDomain.dependencyList, [{ key: 'dep1', version: '1.0.0' }])
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with partial info', ({ assert }) => {
     const dataDomain = new DataDomain({
@@ -258,7 +258,7 @@ test.group('DataDomain.constructor()', () => {
     assert.isNotEmpty(dataDomain.key)
     assert.instanceOf(dataDomain.info, Thing)
     assert.deepInclude(dataDomain.info.toJSON(), { name: 'Test Domain' })
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with empty info', ({ assert }) => {
     const dataDomain = new DataDomain({
@@ -269,7 +269,7 @@ test.group('DataDomain.constructor()', () => {
     assert.isNotEmpty(dataDomain.key)
     assert.instanceOf(dataDomain.info, Thing)
     assert.deepInclude(dataDomain.info.toJSON(), { name: 'Unnamed domain' })
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with dependencyList', ({ assert }) => {
     const dataDomain = new DataDomain({
@@ -281,40 +281,40 @@ test.group('DataDomain.constructor()', () => {
     assert.instanceOf(dataDomain.info, Thing)
     assert.deepInclude(dataDomain.info.toJSON(), { name: 'Unnamed domain' })
     assert.deepEqual(dataDomain.dependencyList, [{ key: 'dep1', version: '1.0.0' }])
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with a custom key', ({ assert }) => {
     const dataDomain = new DataDomain({ key: 'custom-key' })
     assert.equal(dataDomain.key, 'custom-key')
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('creates a new DataDomain with custom info', ({ assert }) => {
     const customInfo = { name: 'Custom Name', description: 'Custom Description' }
     const dataDomain = new DataDomain({ info: customInfo })
     assert.deepInclude(dataDomain.info.toJSON(), customInfo)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('initializes the graph', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.isDefined(dataDomain.graph)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('initializes the dependencies map', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.instanceOf(dataDomain.dependencies, Map)
     assert.equal(dataDomain.dependencies.size, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('initializes the dependencyList array', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.isArray(dataDomain.dependencyList)
     assert.equal(dataDomain.dependencyList.length, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('does not notify change during initialization', async ({ assert }) => {
     const dataDomain = new DataDomain()
     await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('restores the graph from a serialized state', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -326,7 +326,7 @@ test.group('DataDomain.constructor()', () => {
     const restoredEntity = dataDomain2.findEntity(entity.key)
     assert.isDefined(restoredEntity)
     assert.equal(restoredEntity!.key, entity.key)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 
   test('restores the graph with dependencies', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -338,7 +338,7 @@ test.group('DataDomain.constructor()', () => {
     const dataDomain2 = new DataDomain(serialized, [dataDomain1])
     const restoredEntity = dataDomain2.findForeignEntity(entity.key, dataDomain1.key)
     assert.ok(restoredEntity)
-  })
+  }).tags(['@modeling', '@datadomain', '@constructor', '@initialization'])
 })
 
 test.group('DataDomain.hasFields()', () => {
@@ -346,31 +346,31 @@ test.group('DataDomain.hasFields()', () => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace()
     assert.isTrue(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 
   test('returns true if there are child models', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addModel()
     assert.isTrue(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 
   test('returns true if there are both namespaces and models', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace()
     dataDomain.addModel()
     assert.isTrue(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 
   test('returns false if there are no child namespaces or models', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.isFalse(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 
   test('returns false if the data domain has no fields', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.fields = []
     assert.isFalse(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 
   test('returns true if there are only foreign namespaces or models', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -379,7 +379,7 @@ test.group('DataDomain.hasFields()', () => {
     dataDomain.registerForeignDomain(foreignDomain)
     foreignDomain.addNamespace()
     assert.isFalse(dataDomain.hasFields())
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@query'])
 })
 
 test.group('DataDomain.listFields()', () => {
@@ -391,13 +391,13 @@ test.group('DataDomain.listFields()', () => {
     assert.lengthOf(fields, 2)
     assert.deepInclude(fields, namespace)
     assert.deepInclude(fields, model)
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('returns an empty array if there are no child namespaces or models', ({ assert }) => {
     const dataDomain = new DataDomain()
     const fields = [...dataDomain.listFields()]
     assert.lengthOf(fields, 0)
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('returns only namespaces and models', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -408,7 +408,7 @@ test.group('DataDomain.listFields()', () => {
     assert.lengthOf(fields, 2)
     assert.deepInclude(fields, namespace)
     assert.deepInclude(fields, model)
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('namespaces and models in the list are of type DomainNamespace and DomainModel', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -417,7 +417,7 @@ test.group('DataDomain.listFields()', () => {
     const fields = [...dataDomain.listFields()]
     assert.instanceOf(fields[0], DomainNamespace)
     assert.instanceOf(fields[1], DomainModel)
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('lists namespaces and models in the order they were added', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -425,13 +425,13 @@ test.group('DataDomain.listFields()', () => {
     const model = dataDomain.addModel()
     const fields = [...dataDomain.listFields()]
     assert.deepEqual(fields, [namespace, model])
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('lists namespaces and models when there are no namespaces or models', ({ assert }) => {
     const dataDomain = new DataDomain()
     const fields = [...dataDomain.listFields()]
     assert.deepEqual(fields, [])
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 
   test('lists namespaces and models when there are other domain elements', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -440,5 +440,5 @@ test.group('DataDomain.listFields()', () => {
     dataDomain.addEntity(model.key) // Add an entity to make sure it's not included
     const fields = [...dataDomain.listFields()]
     assert.deepEqual(fields, [namespace, model])
-  })
+  }).tags(['@modeling', '@datadomain', '@fields', '@listing'])
 })

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

@@ -10,7 +10,7 @@ test.group('DataDomain.addAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity with a target', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -20,14 +20,14 @@ test.group('DataDomain.addAssociation()', () => {
     const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if source entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.addAssociation('non-existent-entity')
     }, 'Source entity non-existent-entity not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association with default values', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -38,7 +38,7 @@ test.group('DataDomain.addAssociation()', () => {
     assert.isTrue(dataDomain.graph.hasNode(association.key))
     assert.typeOf(association.key, 'string')
     assert.equal(association.info.name, 'new_association')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -46,7 +46,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.addAssociation(entity.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -54,7 +54,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     const association = dataDomain.addAssociation(entity.key)
     assert.isTrue(dataDomain.graph.hasEdge(entity.key, association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -62,7 +62,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     const association = dataDomain.addAssociation(entity.key)
     assert.deepInclude([...entity.listAssociations()], association)
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if no source is provided', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -70,7 +70,7 @@ test.group('DataDomain.addAssociation()', () => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addAssociation(undefined)
     }, 'Source entity undefined not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to a foreign entity', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -87,7 +87,7 @@ test.group('DataDomain.addAssociation()', () => {
     const association = domain1.addAssociation(e1.key, { key: 'entity2', domain: domain2.key })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(domain1.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if foreign entity does not exist', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -101,7 +101,7 @@ test.group('DataDomain.addAssociation()', () => {
     assert.throws(() => {
       domain1.addAssociation(e1.key, { key: 'non-existent-entity', domain: 'domain2' })
     }, 'Foreign entity domain2:non-existent-entity not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 })
 
 test.group('DataDomain.removeAssociation()', () => {
@@ -112,14 +112,14 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.isFalse(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error if the association does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeAssociation('non-existent-association')
     }, 'Association non-existent-association does not exist')
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes the association from the parent entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -128,7 +128,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.isFalse(entity.hasAssociations())
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error when the parent entity is not found', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -137,7 +137,7 @@ test.group('DataDomain.removeAssociation()', () => {
     assert.throws(() => {
       dataDomain.removeAssociation(association.key)
     }, `Parent entity not found for association ${association.key}`)
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -146,7 +146,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes an association to a foreign entity', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -162,7 +162,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = domain1.addAssociation(e1.key, { key: e2.key, domain: domain2.key })
     domain1.removeAssociation(association.key)
     assert.isFalse(domain1.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error if the association is not of type DomainAssociation', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -171,7 +171,7 @@ test.group('DataDomain.removeAssociation()', () => {
     assert.throws(() => {
       dataDomain.removeAssociation(model.key)
     }, 'Association test-model not found')
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes the association from the fields list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -180,7 +180,18 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.deepEqual([...entity.listFields()], [])
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
+
+  test('keeps both source and target entities in the graph after removing an association', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
+    const entity2 = dataDomain.addEntity(model.key, { key: 'entity2' })
+    const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
+    dataDomain.removeAssociation(association.key)
+    assert.isTrue(dataDomain.graph.hasNode(entity1.key))
+    assert.isTrue(dataDomain.graph.hasNode(entity2.key))
+  }).tags(['@modeling', '@associations', '@remove'])
 })
 
 test.group('DataDomain.findAssociation()', () => {
@@ -191,75 +202,75 @@ test.group('DataDomain.findAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     const foundAssociation = dataDomain.findAssociation(association.key)
     assert.deepEqual(foundAssociation, association)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if association does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundAssociation = dataDomain.findAssociation('non-existent-association')
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is not an association', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const foundAssociation = dataDomain.findAssociation(model.key)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(undefined)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(null)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundAssociation = dataDomain.findAssociation('')
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(123)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(true)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation({})
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation([])
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(() => {})
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('finds an association to a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -275,5 +286,5 @@ test.group('DataDomain.findAssociation()', () => {
 
     const foundAssociation = domain1.findAssociation(association.key)
     assert.deepEqual(foundAssociation, association)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 })