@api-client/core 0.16.1 → 0.17.1

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

@@ -8,7 +8,7 @@ test.group('DataDomain.addNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' })
     assert.instanceOf(namespace, DomainNamespace)
     assert.isTrue(dataDomain.graph.hasNode(namespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace adds a namespace to the graph with a parent', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -17,20 +17,20 @@ test.group('DataDomain.addNamespace()', () => {
     assert.instanceOf(cNs, DomainNamespace)
     assert.isTrue(dataDomain.graph.hasNode(cNs.key))
     assert.equal(dataDomain.graph.parent(cNs.key), pNs.key)
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace throws an error if parent namespace does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.addNamespace({ key: 'child-ns' }, 'non-existent-parent')
     }, 'Parent namespace non-existent-parent does not exist')
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace({ key: 'test-ns' })
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace adds a namespace to the root of the graph', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -38,7 +38,7 @@ test.group('DataDomain.addNamespace()', () => {
     assert.instanceOf(namespace, DomainNamespace)
     assert.isTrue(dataDomain.graph.hasNode(namespace.key))
     assert.isUndefined(dataDomain.graph.parent(namespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace adds a namespace to a parent namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -47,7 +47,7 @@ test.group('DataDomain.addNamespace()', () => {
     assert.instanceOf(childNamespace, DomainNamespace)
     assert.isTrue(dataDomain.graph.hasNode(childNamespace.key))
     assert.equal(dataDomain.graph.parent(childNamespace.key), parentNamespace.key)
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace adds a namespace with default values', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -55,7 +55,7 @@ test.group('DataDomain.addNamespace()', () => {
     assert.instanceOf(namespace, DomainNamespace)
     assert.isTrue(dataDomain.graph.hasNode(namespace.key))
     assert.isUndefined(dataDomain.graph.parent(namespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 
   test('addNamespace adds to the fields list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -64,7 +64,7 @@ test.group('DataDomain.addNamespace()', () => {
     const [field] = dataDomain.fields
     assert.equal(field.key, namespace.key)
     assert.equal(field.type, 'namespace')
-  })
+  }).tags(['@modeling', '@namespace', '@add'])
 })
 
 test.group('DataDomain.removeNamespace()', () => {
@@ -73,7 +73,7 @@ test.group('DataDomain.removeNamespace()', () => {
     const namespace = root.addNamespace({ key: 'test-ns' })
     root.removeNamespace(namespace.key)
     assert.isFalse(root.graph.hasNode(namespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removes a nested namespace from the graph', ({ assert }) => {
     const root = new DataDomain()
@@ -82,21 +82,21 @@ test.group('DataDomain.removeNamespace()', () => {
     root.removeNamespace(n2.key)
     assert.isFalse(root.graph.hasNode(n2.key))
     assert.isTrue(root.graph.hasNode(n1.key))
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace throws an error if namespace does not exist', ({ assert }) => {
     const root = new DataDomain()
     assert.throws(() => {
       root.removeNamespace('non-existent-ns')
     }, 'Namespace non-existent-ns does not exist')
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace notifies change', async ({ assert }) => {
     const root = new DataDomain()
     const n1 = root.addNamespace({ key: 'test-ns' })
     root.removeNamespace(n1.key)
     await assert.dispatches(root, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes a namespace from the root of the graph', ({ assert }) => {
     const root = new DataDomain()
@@ -104,7 +104,7 @@ test.group('DataDomain.removeNamespace()', () => {
     root.removeNamespace(n1.key)
     assert.isFalse(root.graph.hasNode(n1.key))
     assert.isUndefined(root.listGraphNamespaces().next().value)
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes a namespace from a parent namespace', ({ assert }) => {
     const root = new DataDomain()
@@ -113,7 +113,7 @@ test.group('DataDomain.removeNamespace()', () => {
     root.removeNamespace(n2.key)
     assert.isFalse(root.graph.hasNode(n2.key))
     assert.equal(root.graph.parent(n2.key), undefined)
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes a namespace with children', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -124,7 +124,7 @@ test.group('DataDomain.removeNamespace()', () => {
     assert.isFalse(dataDomain.graph.hasNode(parentNamespace.key))
     assert.isFalse(dataDomain.graph.hasNode(childNamespace.key))
     assert.isFalse(dataDomain.graph.hasNode(grandChildNamespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes a namespace with models', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -133,7 +133,7 @@ test.group('DataDomain.removeNamespace()', () => {
     dataDomain.removeNamespace(parentNamespace.key)
     assert.isFalse(dataDomain.graph.hasNode(parentNamespace.key))
     assert.isFalse(dataDomain.graph.hasNode(model.key))
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes the whole domain structure', ({ assert }) => {
     const d1 = new DataDomain()
@@ -154,7 +154,7 @@ test.group('DataDomain.removeNamespace()', () => {
     assert.isFalse(d1.graph.hasNode(a1.key))
     assert.deepEqual([...d1.graph.edges()], [])
     assert.deepEqual([...d1.graph.nodes()], [])
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace throws an error if key is not a namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -162,14 +162,14 @@ test.group('DataDomain.removeNamespace()', () => {
     assert.throws(() => {
       dataDomain.removeNamespace(model.key)
     }, `Namespace ${model.key} not found`)
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 
   test('removeNamespace removes from fields', ({ assert }) => {
     const root = new DataDomain()
     const n1 = root.addNamespace()
     root.removeNamespace(n1.key)
     assert.deepEqual(root.fields, [])
-  })
+  }).tags(['@modeling', '@namespace', '@remove'])
 })
 
 test.group('DataDomain.listNamespaces()', () => {
@@ -181,13 +181,13 @@ test.group('DataDomain.listNamespaces()', () => {
     assert.lengthOf(namespaces, 2)
     assert.deepInclude(namespaces, namespace1)
     assert.deepInclude(namespaces, namespace2)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns an empty array if there are no namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
     const namespaces = [...dataDomain.listNamespaces()]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns only namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -196,14 +196,14 @@ test.group('DataDomain.listNamespaces()', () => {
     const namespaces = [...dataDomain.listNamespaces()]
     assert.lengthOf(namespaces, 1)
     assert.deepInclude(namespaces, namespace1)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('namespaces in the list are of type DomainNamespace', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace()
     const namespaces = [...dataDomain.listNamespaces()]
     assert.instanceOf(namespaces[0], DomainNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces in the order they were added', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -211,13 +211,13 @@ test.group('DataDomain.listNamespaces()', () => {
     const namespace2 = dataDomain.addNamespace()
     const namespaces = [...dataDomain.listNamespaces()]
     assert.deepEqual(namespaces, [namespace1, namespace2])
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces when there are no namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
     const namespaces = [...dataDomain.listNamespaces()]
     assert.deepEqual(namespaces, [])
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces when there are other domain elements', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -225,7 +225,7 @@ test.group('DataDomain.listNamespaces()', () => {
     dataDomain.addModel()
     const namespaces = [...dataDomain.listNamespaces()]
     assert.deepEqual(namespaces, [namespace1])
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 })
 
 test.group('DataDomain.hasNamespaces()', () => {
@@ -233,31 +233,31 @@ test.group('DataDomain.hasNamespaces()', () => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace()
     assert.isTrue(dataDomain.hasNamespaces())
-  })
+  }).tags(['@modeling', '@namespace', '@has'])
 
   test('returns false if there are no child namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.isFalse(dataDomain.hasNamespaces())
-  })
+  }).tags(['@modeling', '@namespace', '@has'])
 
   test('returns false if there are only models', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addModel()
     assert.isFalse(dataDomain.hasNamespaces())
-  })
+  }).tags(['@modeling', '@namespace', '@has'])
 
   test('returns true if there are both models and namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace()
     dataDomain.addModel()
     assert.isTrue(dataDomain.hasNamespaces())
-  })
+  }).tags(['@modeling', '@namespace', '@has'])
 
   test('returns false if the data domain has no fields', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.fields = []
     assert.isFalse(dataDomain.hasNamespaces())
-  })
+  }).tags(['@modeling', '@namespace', '@has'])
 })
 
 test.group('DataDomain.listGraphNamespaces()', () => {
@@ -269,7 +269,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     assert.lengthOf(namespaces, 2)
     assert.deepInclude(namespaces, n1)
     assert.deepInclude(namespaces, n2)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists all namespaces in the graph with a parent', ({ assert }) => {
     const root = new DataDomain()
@@ -279,19 +279,19 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const namespaces = [...root.listGraphNamespaces(n1.key)]
     assert.lengthOf(namespaces, 1)
     assert.deepInclude(namespaces, n2)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns an empty array if there are no namespaces', ({ assert }) => {
     const root = new DataDomain()
     const namespaces = [...root.listGraphNamespaces()]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns an empty array if the parent does not exist', ({ assert }) => {
     const root = new DataDomain()
     const namespaces = [...root.listGraphNamespaces('non-existent-parent')]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns only namespaces', ({ assert }) => {
     const root = new DataDomain()
@@ -300,7 +300,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const namespaces = [...root.listGraphNamespaces()]
     assert.lengthOf(namespaces, 1)
     assert.deepInclude(namespaces, n1)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('returns only namespaces for the given parent', ({ assert }) => {
     const root = new DataDomain()
@@ -312,14 +312,14 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const namespaces = [...root.listGraphNamespaces(n1.key)]
     assert.lengthOf(namespaces, 1)
     assert.deepInclude(namespaces, n2)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('namespaces in the list are of type DomainNamespace', ({ assert }) => {
     const dataDomain = new DataDomain()
     dataDomain.addNamespace({ key: 'ns1' })
     const namespaces = [...dataDomain.listGraphNamespaces()]
     assert.instanceOf(namespaces[0], DomainNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces from the root when no parent is provided', ({ assert }) => {
     const root = new DataDomain()
@@ -332,7 +332,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     assert.deepInclude(namespaces, n1)
     assert.deepInclude(namespaces, n2)
     assert.deepInclude(namespaces, n3)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces from a parent namespace when provided', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -343,7 +343,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const namespaces = [...dataDomain.listGraphNamespaces(parentNamespace.key)]
     assert.lengthOf(namespaces, 1)
     assert.deepInclude(namespaces, namespace1)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces from a parent namespace when provided and the parent has no namespaces', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -351,7 +351,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
 
     const namespaces = [...dataDomain.listGraphNamespaces(parentNamespace.key)]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces from a parent namespace when provided and the parent is not a namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -359,14 +359,14 @@ test.group('DataDomain.listGraphNamespaces()', () => {
 
     const namespaces = [...dataDomain.listGraphNamespaces(model.key)]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists namespaces from a parent namespace when provided and the parent is not in the graph', ({ assert }) => {
     const dataDomain = new DataDomain()
 
     const namespaces = [...dataDomain.listGraphNamespaces('non-existent-parent')]
     assert.lengthOf(namespaces, 0)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists all children for the root, excluding foreign namespaces', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -380,7 +380,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const children = [...domain1.listGraphNamespaces()]
     assert.lengthOf(children, 1)
     assert.deepInclude(children, ns1)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 
   test('lists all children for a namespace, excluding foreign namespaces', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -395,7 +395,7 @@ test.group('DataDomain.listGraphNamespaces()', () => {
     const children = [...domain1.listGraphNamespaces(ns1.key)]
     assert.lengthOf(children, 1)
     assert.deepInclude(children, ns2)
-  })
+  }).tags(['@modeling', '@namespace', '@list'])
 })
 
 test.group('DataDomain.findNamespace()', () => {
@@ -404,75 +404,75 @@ test.group('DataDomain.findNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' })
     const foundNamespace = dataDomain.findNamespace('test-ns')
     assert.deepEqual(foundNamespace, namespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if namespace does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundNamespace = dataDomain.findNamespace('non-existent-ns')
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is not a namespace', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const foundNamespace = dataDomain.findNamespace(model.key)
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace(undefined)
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace(null)
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundNamespace = dataDomain.findNamespace('')
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace(123)
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace(true)
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace({})
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace([])
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundNamespace = dataDomain.findNamespace(() => {})
     assert.isUndefined(foundNamespace)
-  })
+  }).tags(['@modeling', '@namespace', '@find'])
 })
 
 test.group('DataDomain.moveNamespace()', () => {
@@ -484,7 +484,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.equal(dataDomain.graph.parent(namespace.key), parentNamespace.key)
     const children = [...parentNamespace.listNamespaces()]
     assert.deepEqual(children, [namespace])
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from a parent namespace to the root', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -493,7 +493,7 @@ test.group('DataDomain.moveNamespace()', () => {
     dataDomain.moveNamespace(namespace.key)
     assert.equal(dataDomain.graph.parent(namespace.key), undefined)
     assert.deepEqual([...parentNamespace.listNamespaces()], [])
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from one parent namespace to another', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -504,14 +504,14 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.equal(dataDomain.graph.parent(namespace.key), parentNamespace2.key)
     assert.deepEqual([...parentNamespace1.listNamespaces()], [])
     assert.deepEqual([...parentNamespace2.listNamespaces()], [namespace])
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if namespace does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.moveNamespace('non-existent-ns', 'parent-ns')
     }, 'Namespace non-existent-ns does not exist')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if parent namespace does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -519,7 +519,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.throws(() => {
       dataDomain.moveNamespace(namespace.key, 'non-existent-parent')
     }, 'Parent namespace non-existent-parent does not exist')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if namespace is moved to itself', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -527,7 +527,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.throws(() => {
       dataDomain.moveNamespace(namespace.key, namespace.key)
     }, 'Cannot move a namespace to itself')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if namespace is moved to its own child', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -536,7 +536,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.throws(() => {
       dataDomain.moveNamespace(parentNamespace.key, namespace.key)
     }, 'Cannot move a namespace to its own child')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if namespace is moved to a foreign domain', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -551,7 +551,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.throws(() => {
       dataDomain1.moveNamespace(namespace.key, `${dataDomain2.key}:${foreignNamespace.key}`)
     }, 'Cannot move a namespace to a foreign domain')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('throws an error if namespace is moved from a foreign domain', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -566,7 +566,7 @@ test.group('DataDomain.moveNamespace()', () => {
     assert.throws(() => {
       dataDomain1.moveNamespace(`${dataDomain2.key}:${foreignNamespace.key}`, namespace.key)
     }, 'Cannot move a namespace from a foreign domain')
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moveNamespace notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -574,7 +574,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const parentNamespace = dataDomain.addNamespace({ key: 'parent-ns' })
     dataDomain.moveNamespace(namespace.key, parentNamespace.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from the root to a parent namespace - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -582,7 +582,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const parentNamespace = dataDomain.addNamespace({ key: 'parent-ns' })
     dataDomain.moveNamespace(namespace.key, parentNamespace.key)
     assert.isTrue(dataDomain.graph.hasParent(namespace.key, parentNamespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from a parent namespace to the root - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -590,7 +590,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' }, parentNamespace.key)
     dataDomain.moveNamespace(namespace.key)
     assert.isFalse(dataDomain.graph.hasParent(namespace.key, parentNamespace.key))
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from one parent namespace to another - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -600,7 +600,7 @@ test.group('DataDomain.moveNamespace()', () => {
     dataDomain.moveNamespace(namespace.key, parentNamespace2.key)
     assert.isFalse(dataDomain.graph.hasParent(namespace.key, parentNamespace1.key))
     assert.isTrue(dataDomain.graph.hasParent(namespace.key, parentNamespace2.key))
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from the root to a parent namespace - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -609,7 +609,7 @@ test.group('DataDomain.moveNamespace()', () => {
     dataDomain.moveNamespace(namespace.key, parentNamespace.key)
     const parentNs = dataDomain.findNamespace(parentNamespace.key)
     assert.deepInclude([...parentNs!.listNamespaces()], namespace)
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from a parent namespace to the root - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -617,7 +617,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' }, parentNamespace.key)
     dataDomain.moveNamespace(namespace.key)
     assert.deepInclude([...dataDomain.listGraphNamespaces()], namespace)
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from one parent namespace to another - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -629,7 +629,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const parentNs2 = dataDomain.findNamespace(parentNamespace2.key)
     assert.notDeepInclude([...parentNs1!.listNamespaces()], namespace)
     assert.deepInclude([...parentNs2!.listNamespaces()], namespace)
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from the root to a parent namespace - updates fields array', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -637,7 +637,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const parentNamespace = dataDomain.addNamespace({ key: 'parent-ns' })
     dataDomain.moveNamespace(namespace.key, parentNamespace.key)
     assert.notDeepInclude(dataDomain.fields, { key: namespace.key, type: 'namespace' })
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from a parent namespace to the root - updates fields array', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -645,7 +645,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' }, parentNamespace.key)
     dataDomain.moveNamespace(namespace.key)
     assert.deepInclude(dataDomain.fields, { key: namespace.key, type: 'namespace' })
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from one parent namespace to another - updates fields array', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -654,7 +654,7 @@ test.group('DataDomain.moveNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' }, parentNamespace1.key)
     dataDomain.moveNamespace(namespace.key, parentNamespace2.key)
     assert.notDeepInclude(dataDomain.fields, { key: namespace.key, type: 'namespace' })
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 
   test('moves a namespace from one parent namespace to another - updates fields array when moving to root', ({
     assert,
@@ -664,5 +664,5 @@ test.group('DataDomain.moveNamespace()', () => {
     const namespace = dataDomain.addNamespace({ key: 'test-ns' }, parentNamespace1.key)
     dataDomain.moveNamespace(namespace.key)
     assert.deepInclude(dataDomain.fields, { key: namespace.key, type: 'namespace' })
-  })
+  }).tags(['@modeling', '@namespace', '@move'])
 })