@api-client/core 0.14.2 → 0.14.4

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

@@ -17,7 +17,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isUndefined(schema.tags)
     assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.fields)
@@ -59,7 +59,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
   })
 
   test('creates a schema with tags', ({ assert }) => {
@@ -69,7 +69,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.tags, ['tag1', 'tag2'])
   })
 
@@ -80,7 +80,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.semantics, [{ id: SemanticType.User }])
   })
 
@@ -91,7 +91,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.fields, [{ key: 'test-property', type: 'property' }])
   })
 
@@ -102,7 +102,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isTrue(schema.deprecated)
   })
 
@@ -113,7 +113,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isFalse(schema.deprecated)
   })
 
@@ -164,7 +164,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.tags, [])
     assert.deepEqual(entity.semantics, [])
     assert.deepEqual(entity.fields, [])
@@ -213,7 +213,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
   })
 
   test('creates a new DomainEntity with tags', ({ assert }) => {
@@ -225,7 +225,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.tags, ['tag1', 'tag2'])
   })
 
@@ -238,7 +238,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.semantics, [{ id: SemanticType.User }])
   })
 
@@ -251,7 +251,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.fields, [{ key: 'test-property', type: 'property' }])
   })
 
@@ -264,7 +264,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.isTrue(entity.deprecated)
   })
 
@@ -277,7 +277,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.isFalse(entity.deprecated)
   })
 
@@ -350,7 +350,7 @@ test.group('DomainEntity.toJSON()', () => {
     const json = entity.toJSON()
     assert.equal(json.kind, DomainEntityKind)
     assert.equal(json.key, entity.key)
-    assert.deepInclude(json.info, { name: 'New entity' })
+    assert.deepInclude(json.info, { name: 'new_entity' })
     assert.isUndefined(json.tags)
     assert.isUndefined(json.semantics)
     assert.isUndefined(json.fields)

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

@@ -99,22 +99,12 @@ test.group('constructor()', () => {
       ],
       lastModified: { byMe: false, time: 0, user: 'id', name: 'test' },
     }
-    const result = new DomainFile(JSON.stringify(schema))
+    const result = new DomainFile(schema)
     assert.equal(result.kind, DomainFileKind)
     assert.equal(result.info.name, 'hello')
     assert.equal(result.key, '123')
     assert.deepEqual(result.lastModified, schema.lastModified)
   })
-
-  test('throws when invalid schema', ({ assert }) => {
-    assert.throws(() => {
-      new DomainFile(
-        JSON.stringify({
-          name: 'a name',
-        })
-      )
-    })
-  })
 })
 
 test.group('toJSON()', () => {

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

@@ -9,7 +9,7 @@ test.group('DomainModel.addEntity()', () => {
     assert.instanceOf(entity, DomainEntity)
     assert.equal(entity.kind, DomainEntityKind)
     assert.equal(entity.key, 'test-entity')
-    assert.deepInclude(entity.info, { name: 'New entity' })
+    assert.deepInclude(entity.info, { name: 'new_entity' })
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
   })
@@ -22,7 +22,7 @@ test.group('DomainModel.addEntity()', () => {
     assert.equal(entity.kind, DomainEntityKind)
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
-    assert.deepInclude(entity.info, { name: 'New entity' })
+    assert.deepInclude(entity.info, { name: 'new_entity' })
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
   })

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

@@ -14,17 +14,14 @@ import {
 
 test.group('Semantics', () => {
   test('SemanticType enum should have correct values', ({ assert }) => {
-    assert.equal(SemanticType.User, 'https://apinow.app/semantics/entities/#User')
-    assert.equal(SemanticType.CreatedTimestamp, 'https://apinow.app/semantics/properties/#CreatedTimestamp')
-    assert.equal(SemanticType.UpdatedTimestamp, 'https://apinow.app/semantics/properties/#UpdatedTimestamp')
-    assert.equal(SemanticType.DeletedTimestamp, 'https://apinow.app/semantics/properties/#DeletedTimestamp')
-    assert.equal(SemanticType.DeletedFlag, 'https://apinow.app/semantics/properties/#DeletedFlag')
-    assert.equal(SemanticType.PublicUniqueName, 'https://apinow.app/semantics/properties/#PublicUniqueName')
-    assert.equal(SemanticType.UserRole, 'https://apinow.app/semantics/entities/#UserRole')
-    assert.equal(
-      SemanticType.ResourceOwnerIdentifier,
-      'https://apinow.app/semantics/associations/#ResourceOwnerIdentifier'
-    )
+    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 }) => {

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)