@api-client/core 0.11.1 → 0.11.3

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

@@ -821,3 +821,248 @@ test.group('computeForeignNamespaceKeys()', () => {
     assert.deepEqual(result, [n2.key])
   })
 })
+
+test.group('findAssociatedEntity()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+  let e1: DataEntity
+  let e2: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    root.addForeign(foreign)
+    const model1 = root.addDataModel('m1')
+    const model2 = foreign.addDataModel('m2')
+    e1 = model1.addEntity('e1')
+    e2 = model2.addEntity('e2')
+  })
+
+  test('finds an entity in the current namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e1.key)
+    assert.deepEqual(result, e1)
+  })
+
+  test('finds an entity in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key, foreign.key)
+    assert.deepEqual(result, e2)
+  })
+
+  test('returns undefined when the entity is not found in the current namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity('non-existent-key')
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when the entity is not found in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity('non-existent-key', foreign.key)
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when the foreign namespace does not exist', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key, 'non-existent-namespace')
+    assert.isUndefined(result)
+  })
+
+  test('returns undefined when no namespace is provided and the entity is in a foreign namespace', ({ assert }) => {
+    const result = root.findAssociatedEntity(e2.key)
+    assert.isUndefined(result)
+  })
+})
+
+test.group('addForeign()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+  })
+
+  test('adds a foreign namespace', ({ assert }) => {
+    root.addForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign])
+  })
+
+  test('does not add the same foreign namespace twice', ({ assert }) => {
+    root.addForeign(foreign)
+    root.addForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign])
+  })
+})
+
+test.group('removeForeign()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+  let foreign2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    foreign2 = new DataNamespace()
+    root.addForeign(foreign)
+    root.addForeign(foreign2)
+  })
+
+  test('removes a foreign namespace', ({ assert }) => {
+    root.removeForeign(foreign)
+    assert.deepEqual(root.foreign, [foreign2])
+  })
+
+  test('does nothing when the foreign namespace does not exist', ({ assert }) => {
+    const other = new DataNamespace()
+    root.removeForeign(other)
+    assert.deepEqual(root.foreign, [foreign, foreign2])
+  })
+})
+
+test.group('hasForeignNamespace()', (group) => {
+  let root: DataNamespace
+  let foreign: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    foreign = new DataNamespace()
+    root.addForeign(foreign)
+  })
+
+  test('returns true when the foreign namespace exists', ({ assert }) => {
+    const result = root.hasForeignNamespace(foreign.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when the foreign namespace does not exist', ({ assert }) => {
+    const result = root.hasForeignNamespace('non-existent-key')
+    assert.isFalse(result)
+  })
+})
+
+test.group('listNamespaces()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+    m1 = root.addDataModel('m1')
+  })
+
+  test('lists all namespaces', ({ assert }) => {
+    const result = root.listNamespaces()
+    assert.deepEqual(result, [n1, n2])
+  })
+
+  test('lists namespaces in a sub-namespace', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    const result = n1.listNamespaces()
+    assert.deepEqual(result, [n3])
+  })
+
+  test('does not list data models', ({ assert }) => {
+    const result = root.listNamespaces()
+    assert.notDeepInclude(result, m1)
+  })
+})
+
+test.group('listDataModels()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let e1: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    m1 = root.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    e1 = m2.addEntity('e1')
+  })
+
+  test('lists all data models', ({ assert }) => {
+    const result = root.listDataModels()
+    assert.deepEqual(result, [m1])
+  })
+
+  test('lists data models in a sub-namespace', ({ assert }) => {
+    const m3 = n1.addDataModel('m3')
+    const result = n1.listDataModels()
+    assert.deepEqual(result, [m2, m3])
+  })
+
+  test('does not list entities', ({ assert }) => {
+    const result = root.listDataModels()
+    assert.notDeepInclude(result, e1)
+  })
+})
+
+test.group('getRoot()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+  })
+
+  test('returns self when called on the root namespace', ({ assert }) => {
+    const result = root.getRoot()
+    assert.deepEqual(result, root)
+  })
+
+  test('returns the root namespace when called on a sub-namespace', ({ assert }) => {
+    const result = n1.getRoot()
+    assert.deepEqual(result, root)
+  })
+
+  test('returns the root namespace when called on a sub-sub-namespace', ({ assert }) => {
+    const result = n2.getRoot()
+    assert.deepEqual(result, root)
+  })
+})
+
+test.group('getParent()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+  })
+
+  test('returns undefined when called on the root namespace', ({ assert }) => {
+    const result = root.getParent()
+    assert.isUndefined(result)
+  })
+
+  test('returns the parent namespace when called on a sub-namespace', ({ assert }) => {
+    const result = n2.getParent()
+    assert.deepEqual(result, n1)
+  })
+})
+
+test.group('isRoot()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+  })
+
+  test('returns true when called on the root namespace', ({ assert }) => {
+    const result = root.isRoot()
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sub-namespace', ({ assert }) => {
+    const result = n1.isRoot()
+    assert.isFalse(result)
+  })
+})