@api-client/core 0.14.1 → 0.14.3

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

@@ -0,0 +1,146 @@
+import { test } from '@japa/runner'
+import {
+  SemanticType,
+  SemanticScope,
+  isEntitySemantic,
+  isPropertySemantic,
+  isAssociationSemantic,
+  DataSemantics,
+  type EntitySemantic,
+  type PropertySemantic,
+  type AssociationSemantic,
+  type DataSemantic,
+} from '../../../src/modeling/Semantics.js'
+
+test.group('Semantics', () => {
+  test('SemanticType enum should have correct values', ({ assert }) => {
+    assert.equal(SemanticType.User, 'Semantic#User')
+    assert.equal(SemanticType.CreatedTimestamp, 'Semantic#CreatedTimestamp')
+    assert.equal(SemanticType.UpdatedTimestamp, 'Semantic#UpdatedTimestamp')
+    assert.equal(SemanticType.DeletedTimestamp, 'Semantic#DeletedTimestamp')
+    assert.equal(SemanticType.DeletedFlag, 'Semantic#DeletedFlag')
+    assert.equal(SemanticType.PublicUniqueName, 'Semantic#PublicUniqueName')
+    assert.equal(SemanticType.UserRole, 'Semantic#UserRole')
+    assert.equal(SemanticType.ResourceOwnerIdentifier, 'Semantic#ResourceOwnerIdentifier')
+  })
+
+  test('SemanticScope enum should have correct values', ({ assert }) => {
+    assert.equal(SemanticScope.Entity, 'Entity')
+    assert.equal(SemanticScope.Property, 'Property')
+    assert.equal(SemanticScope.Association, 'Association')
+  })
+
+  test('isEntitySemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isTrue(isEntitySemantic(entitySemantic))
+    assert.isFalse(isEntitySemantic(propertySemantic))
+    assert.isFalse(isEntitySemantic(associationSemantic))
+  })
+
+  test('isPropertySemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isFalse(isPropertySemantic(entitySemantic))
+    assert.isTrue(isPropertySemantic(propertySemantic))
+    assert.isFalse(isPropertySemantic(associationSemantic))
+  })
+
+  test('isAssociationSemantic type guard', ({ assert }) => {
+    const entitySemantic: EntitySemantic = {
+      id: SemanticType.User,
+      displayName: 'User Entity',
+      description: 'Test',
+      scope: SemanticScope.Entity,
+    }
+    const propertySemantic: PropertySemantic = {
+      id: SemanticType.CreatedTimestamp,
+      displayName: 'Creation Timestamp',
+      description: 'Test',
+      scope: SemanticScope.Property,
+    }
+    const associationSemantic: AssociationSemantic = {
+      id: SemanticType.ResourceOwnerIdentifier,
+      displayName: 'Resource Owner Identifier',
+      description: 'Test',
+      scope: SemanticScope.Association,
+    }
+
+    assert.isFalse(isAssociationSemantic(entitySemantic))
+    assert.isFalse(isAssociationSemantic(propertySemantic))
+    assert.isTrue(isAssociationSemantic(associationSemantic))
+  })
+
+  test('DataSemantics should contain correct definitions', ({ assert }) => {
+    const semanticTypes = Object.values(SemanticType)
+    semanticTypes.forEach((type) => {
+      const semantic: DataSemantic | undefined = DataSemantics[type]
+      assert.isDefined(semantic, `Semantic definition for ${type} should exist`)
+      if (!semantic) return
+
+      assert.equal(semantic.id, type, `ID for ${type} should match`)
+      assert.isString(semantic.displayName, `displayName for ${type} should be a string`)
+      assert.isNotEmpty(semantic.displayName, `displayName for ${type} should not be empty`)
+      assert.isString(semantic.description, `description for ${type} should be a string`)
+      assert.isNotEmpty(semantic.description, `description for ${type} should not be empty`)
+
+      assert.oneOf(semantic.scope, Object.values(SemanticScope), `scope for ${type} should be a valid SemanticScope`)
+
+      if (isPropertySemantic(semantic)) {
+        if (semantic.applicableDataTypes) {
+          assert.isArray(semantic.applicableDataTypes, `applicableDataTypes for ${type} should be an array if present`)
+          semantic.applicableDataTypes.forEach((dt) => {
+            assert.isString(dt, `Each applicableDataType for ${type} should be a string`)
+          })
+        }
+      }
+    })
+
+    // Specific checks for some semantics
+    const userSemantic = DataSemantics[SemanticType.User]
+    assert.equal(userSemantic.scope, SemanticScope.Entity)
+
+    const createdTimestampSemantic = DataSemantics[SemanticType.CreatedTimestamp]
+    assert.equal(createdTimestampSemantic.scope, SemanticScope.Property)
+    if (isPropertySemantic(createdTimestampSemantic)) {
+      assert.deepEqual(createdTimestampSemantic.applicableDataTypes, ['datetime'])
+    }
+
+    const resourceOwnerSemantic = DataSemantics[SemanticType.ResourceOwnerIdentifier]
+    assert.equal(resourceOwnerSemantic.scope, SemanticScope.Association)
+  })
+})

package/tests/unit/models/File/constructor.spec.ts

@@ -5,8 +5,9 @@ test.group('File.constructor()', () => {
   test('creates a default File', ({ assert }) => {
     const result = new File()
     assert.equal(result.kind, '')
-    assert.equal(result.key, '')
-    assert.deepEqual(result.info.toJSON(), { kind: ThingKind, name: '' })
+    assert.isString(result.key, 'has the key')
+    assert.isNotEmpty(result.key, 'key is not empty')
+    assert.deepEqual(result.info.toJSON(), { kind: ThingKind, name: 'Unnamed file' })
     assert.deepEqual(result.parents, [])
     assert.deepEqual(result.permissionIds, [])
     assert.isFalse(result.deleted, 'deleted')

package/tests/unit/models/File/shortcutTo.spec.ts

@@ -46,7 +46,7 @@ test.group('File.shortcutTo()', () => {
   })
 
   test('creates a shortcut from a name with fromName()', ({ assert }) => {
-    const file = File.fromName('test-file')
+    const file = File.fromName('test-file', 'shortcut')
     const targetId = 'target-file-id'
     file.shortcutTo(targetId)
     assert.equal(file.shortcutTarget, targetId)