@api-client/core 0.12.1 → 0.12.3

package/tests/unit/modeling/validation/entity_validation.spec.ts

@@ -0,0 +1,192 @@
+import { test } from '@japa/runner'
+import { DataDomain, EntityValidation } from '../../../../src/index.js'
+
+test.group('EntityValidation', (group) => {
+  let domain: DataDomain
+  let validation: EntityValidation
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    validation = new EntityValidation(domain)
+  })
+
+  test('validate() should return an error when the entity does not exist', ({ assert }) => {
+    const results = validation.validate('nonExistentEntity')
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'exists')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validate() should call other validation methods', ({ assert, sinon }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const primaryKeySpy = sinon.spy(validation, 'validatePrimaryKey')
+    const minimumRequiredPropertiesSpy = sinon.spy(validation, 'minimumRequiredProperties')
+    const validateNameSpy = sinon.spy(validation, 'validateName')
+    const uniqueNameSpy = sinon.spy(validation, 'uniqueName')
+
+    validation.validate(entity)
+
+    assert.calledWith(primaryKeySpy, entity)
+    assert.calledWith(minimumRequiredPropertiesSpy, entity)
+    assert.calledWith(validateNameSpy, entity)
+    assert.calledWith(uniqueNameSpy, entity)
+    sinon.restore()
+  })
+
+  test('validatePrimaryKey() should return an error when the entity has no primary key', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const results = validation.validatePrimaryKey(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'primary_key')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validatePrimaryKey() should return no errors when the entity has a primary key', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    entity.addProperty({ key: 'id', type: 'string', primary: true })
+    const results = validation.validatePrimaryKey(entity)
+    assert.lengthOf(results, 0)
+  })
+
+  test('validatePrimaryKey() should return no errors when the entity inherits a primary key', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const parent = model.addEntity({ key: 'parent', info: { name: 'Parent' } })
+    parent.addProperty({ key: 'id', type: 'string', primary: true })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    entity.addParent(parent.key)
+    const results = validation.validatePrimaryKey(entity)
+    assert.lengthOf(results, 0)
+  })
+
+  test('minimumRequiredProperties() should return a warning when the entity has no properties', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const results = validation.minimumRequiredProperties(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'required')
+    assert.equal(results[0].severity, 'warning')
+  })
+
+  test('minimumRequiredProperties() should return no errors when the entity has properties', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    entity.addProperty({ key: 'name', type: 'string' })
+    const results = validation.minimumRequiredProperties(entity)
+    assert.lengthOf(results, 0)
+  })
+
+  test('validateName() should return an error when the entity has no name', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: {} })
+    entity.info.name = undefined
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'required')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the entity name is too short', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'a' } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the entity name is too long', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'a'.repeat(32) } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the entity name has invalid characters', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'invalid-name' } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an info when the entity name is not in snake case', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'EntityName' } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'snake_case')
+    assert.equal(results[0].severity, 'info')
+  })
+
+  test('validateName() should return an error when the entity name is a reserved keyword', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'select' } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'reserved')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return no errors when the entity name is valid', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'valid_name' } })
+    const results = validation.validateName(entity)
+    assert.lengthOf(results, 0)
+  })
+
+  test('uniqueName() should return an error when the entity name is not unique', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity1', info: { name: 'entity_name' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity_name' } })
+    const results = validation.uniqueName(entity2)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'unique')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('uniqueName() should return no errors when the entity name is unique', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity1', info: { name: 'entity_name_1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity_name_2' } })
+    const results = validation.uniqueName(entity2)
+    assert.lengthOf(results, 0)
+  })
+
+  test('uniqueName() should return an error when the entity name is not unique (case insensitive)', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity1', info: { name: 'Entity_Name1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity_name1' } })
+    const results = validation.uniqueName(entity2)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'unique')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('uniqueName() should return no errors when the entity name is not set', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    model.addEntity({ key: 'entity1', info: { name: 'EntityName1' } })
+    const entity2 = model.addEntity({ key: 'entity2', info: {} })
+    const results = validation.uniqueName(entity2)
+    assert.lengthOf(results, 0)
+  })
+
+  test('uniqueName() should return an error when the entity name is not unique in a foreign domain', ({ assert }) => {
+    const foreignDomain = new DataDomain()
+    const foreignModel = foreignDomain.addModel({ key: 'foreignModel' })
+    foreignModel.addEntity({ key: 'foreignEntity', info: { name: 'entity_name' } })
+    foreignDomain.info.version = '1.0.0'
+    domain.registerForeignDomain(foreignDomain)
+    const model = domain.addModel({ key: 'model' })
+    const entity2 = model.addEntity({ key: 'entity2', info: { name: 'entity_name' } })
+    const results = validation.uniqueName(entity2)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'unique')
+    assert.equal(results[0].severity, 'error')
+  })
+})

package/tests/unit/modeling/validation/property_validation.spec.ts

@@ -0,0 +1,135 @@
+import { test } from '@japa/runner'
+import { DataDomain, PropertyValidation } from '../../../../src/index.js'
+
+test.group('PropertyValidation', (group) => {
+  let domain: DataDomain
+  let validation: PropertyValidation
+
+  group.each.setup(() => {
+    domain = new DataDomain()
+    validation = new PropertyValidation(domain)
+  })
+
+  test('validate() should return an error when the property does not exist', ({ assert }) => {
+    const results = validation.validate('nonExistentProperty')
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'exists')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validate() should call other validation methods', ({ assert, sinon }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'property', type: 'string', info: { name: 'property' } })
+    const validateNameSpy = sinon.spy(validation, 'validateName')
+
+    validation.validate(property)
+
+    assert.calledWith(validateNameSpy, property)
+    sinon.restore()
+  })
+
+  test('validateName() should return an error when the property has no name', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'property', type: 'string' })
+    property.info.name = undefined
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'required')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the property name starts with a number', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: '1property', type: 'string', info: { name: '1property' } })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the property name contains invalid characters', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({
+      key: 'invalid-property!',
+      type: 'string',
+      info: { name: 'invalid-property!' },
+    })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the property name is too short', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'a', type: 'string', info: { name: 'a' } })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return an error when the property name is too long', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'a'.repeat(60), type: 'string', info: { name: 'a'.repeat(60) } })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'length')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validateName() should return no errors when the property name is valid', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({
+      key: 'valid_property123',
+      type: 'string',
+      info: { name: 'valid_property123' },
+    })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 0)
+  })
+
+  test('validateName() should return no errors when the property name starts with underscore', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: '_property', type: 'string', info: { name: '_property' } })
+    const results = validation.validateName(property)
+    assert.lengthOf(results, 0)
+  })
+
+  test('validate() should return an error when the target property is not found (string)', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    entity.addProperty({ key: 'existingProperty', type: 'string', info: { name: 'existing_property' } })
+    const results = validation.validate('nonExistingProperty')
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'exists')
+    assert.equal(results[0].severity, 'error')
+    assert.equal(results[0].key, 'nonExistingProperty')
+  })
+
+  test('validate() should return validation errors for an invalid property name', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'invalid-name', type: 'string', info: { name: 'invalid-name' } })
+    const results = validation.validate(property)
+    assert.lengthOf(results, 1)
+    assert.equal(results[0].rule, 'format')
+    assert.equal(results[0].severity, 'error')
+  })
+
+  test('validate() should return no errors for a valid property name', ({ assert }) => {
+    const model = domain.addModel({ key: 'model' })
+    const entity = model.addEntity({ key: 'entity', info: { name: 'Entity' } })
+    const property = entity.addProperty({ key: 'valid_name', type: 'string', info: { name: 'valid_name' } })
+    const results = validation.validate(property)
+    assert.lengthOf(results, 0)
+  })
+})