@api-client/core 0.11.11 → 0.12.0

package/tests/unit/modeling/domain.property.spec.ts

@@ -0,0 +1,822 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainPropertyKind, DomainProperty, Thing, DataFormat } from '../../../src/index.js'
+
+test.group('DomainProperty.createSchema()', () => {
+  test('creates a schema with default values', ({ assert }) => {
+    const schema = DomainProperty.createSchema()
+    assert.equal(schema.kind, DomainPropertyKind)
+    assert.typeOf(schema.key, 'string')
+    assert.isNotEmpty(schema.key)
+    assert.deepInclude(schema.info, { name: 'New property' })
+    assert.equal(schema.type, 'string')
+    assert.isUndefined(schema.multiple)
+    assert.isUndefined(schema.required)
+    assert.isUndefined(schema.index)
+    assert.isUndefined(schema.primary)
+    assert.isUndefined(schema.readOnly)
+    assert.isUndefined(schema.writeOnly)
+    assert.isUndefined(schema.deprecated)
+    assert.isUndefined(schema.tags)
+    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.schema)
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with provided values', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      key: 'test-property',
+      info: { name: 'Test Property', description: 'A test property' },
+      required: true,
+      multiple: true,
+      primary: true,
+      index: true,
+      readOnly: true,
+      writeOnly: true,
+      deprecated: true,
+      tags: ['tag1', 'tag2'],
+      taxonomy: ['tax1', 'tax2'],
+      type: 'number',
+      schema: { minimum: 0 },
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    assert.equal(schema.kind, DomainPropertyKind)
+    assert.equal(schema.key, 'test-property')
+    assert.deepInclude(schema.info, { name: 'Test Property', description: 'A test property' })
+    assert.equal(schema.type, 'number')
+    assert.isTrue(schema.required)
+    assert.isTrue(schema.multiple)
+    assert.isTrue(schema.primary)
+    assert.isTrue(schema.index)
+    assert.isTrue(schema.readOnly)
+    assert.isTrue(schema.writeOnly)
+    assert.isTrue(schema.deprecated)
+    assert.deepEqual(schema.tags, ['tag1', 'tag2'])
+    assert.deepEqual(schema.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(schema.schema, { minimum: 0 })
+    assert.deepEqual(schema.bindings, [{ type: 'web', schema: { format: 'float' } }])
+  })
+
+  test('creates a schema with partial info', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      info: { name: 'Test Property' },
+    })
+    assert.deepInclude(schema.info, { name: 'Test Property' })
+  })
+
+  test('creates a schema with a specific type', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      type: 'boolean',
+    })
+    assert.equal(schema.type, 'boolean')
+  })
+
+  test('throws an error with an invalid type', ({ assert }) => {
+    assert.throws(() => {
+      // @ts-expect-error Testing invalid type
+      DomainProperty.createSchema({ type: 'invalid-type' })
+    }, 'Invalid data property type invalid-type')
+  })
+
+  test('creates a schema with all properties undefined', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      multiple: undefined,
+      required: undefined,
+      index: undefined,
+      primary: undefined,
+      readOnly: undefined,
+      writeOnly: undefined,
+      deprecated: undefined,
+      tags: undefined,
+      taxonomy: undefined,
+      schema: undefined,
+      bindings: undefined,
+    })
+    assert.equal(schema.kind, DomainPropertyKind)
+    assert.typeOf(schema.key, 'string')
+    assert.isNotEmpty(schema.key)
+    assert.deepInclude(schema.info, { name: 'New property' })
+    assert.equal(schema.type, 'string')
+    assert.isUndefined(schema.multiple)
+    assert.isUndefined(schema.required)
+    assert.isUndefined(schema.index)
+    assert.isUndefined(schema.primary)
+    assert.isUndefined(schema.readOnly)
+    assert.isUndefined(schema.writeOnly)
+    assert.isUndefined(schema.deprecated)
+    assert.isUndefined(schema.tags)
+    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.schema)
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with all properties null', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      // @ts-expect-error Testing null values
+      multiple: null,
+      // @ts-expect-error Testing null values
+      required: null,
+      // @ts-expect-error Testing null values
+      index: null,
+      // @ts-expect-error Testing null values
+      primary: null,
+      // @ts-expect-error Testing null values
+      readOnly: null,
+      // @ts-expect-error Testing null values
+      writeOnly: null,
+      // @ts-expect-error Testing null values
+      deprecated: null,
+      // @ts-expect-error Testing null values
+      tags: null,
+      // @ts-expect-error Testing null values
+      taxonomy: null,
+      // @ts-expect-error Testing null values
+      schema: null,
+      // @ts-expect-error Testing null values
+      bindings: null,
+    })
+    assert.isUndefined(schema.multiple)
+    assert.isUndefined(schema.required)
+    assert.isUndefined(schema.index)
+    assert.isUndefined(schema.primary)
+    assert.isUndefined(schema.readOnly)
+    assert.isUndefined(schema.writeOnly)
+    assert.isUndefined(schema.deprecated)
+    assert.isUndefined(schema.tags)
+    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.schema)
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with all properties empty array', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      tags: [],
+      taxonomy: [],
+      bindings: [],
+    })
+    assert.deepEqual(schema.tags, [])
+    assert.deepEqual(schema.taxonomy, [])
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with all boolean properties set to false', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      required: false,
+      multiple: false,
+      primary: false,
+      index: false,
+      readOnly: false,
+      writeOnly: false,
+      deprecated: false,
+    })
+    assert.isFalse(schema.required)
+    assert.isFalse(schema.multiple)
+    assert.isFalse(schema.primary)
+    assert.isFalse(schema.index)
+    assert.isFalse(schema.readOnly)
+    assert.isFalse(schema.writeOnly)
+    assert.isFalse(schema.deprecated)
+  })
+
+  test('creates a schema with all array properties set to empty arrays', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      tags: [],
+      taxonomy: [],
+      bindings: [],
+    })
+    assert.deepEqual(schema.tags, [])
+    assert.deepEqual(schema.taxonomy, [])
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with all object properties set to empty objects', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      info: {},
+      schema: {},
+    })
+    assert.deepInclude(schema.info, { name: 'New property' })
+    assert.deepEqual(schema.schema, {})
+  })
+
+  test('creates a schema with all array properties set to null', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      // @ts-expect-error Testing null values
+      tags: null,
+      // @ts-expect-error Testing null values
+      taxonomy: null,
+      // @ts-expect-error Testing null values
+      bindings: null,
+    })
+    assert.isUndefined(schema.tags)
+    assert.isUndefined(schema.taxonomy)
+    assert.deepEqual(schema.bindings, [])
+  })
+
+  test('creates a schema with all object properties set to null', ({ assert }) => {
+    const schema = DomainProperty.createSchema({
+      // @ts-expect-error Testing null values
+      info: null,
+      // @ts-expect-error Testing null values
+      schema: null,
+    })
+    assert.deepInclude(schema.info, { name: 'New property' })
+    assert.isUndefined(schema.schema)
+  })
+})
+
+test.group('DomainProperty.constructor()', () => {
+  test('creates a DomainProperty with default values', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent)
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.typeOf(property.key, 'string')
+    assert.isNotEmpty(property.key)
+    assert.instanceOf(property.info, Thing)
+    assert.deepInclude(property.info.toJSON(), { name: 'New property' })
+    assert.equal(property.type, 'string')
+    assert.isUndefined(property.multiple)
+    assert.isUndefined(property.required)
+    assert.isUndefined(property.index)
+    assert.isUndefined(property.primary)
+    assert.isUndefined(property.readOnly)
+    assert.isUndefined(property.writeOnly)
+    assert.isUndefined(property.deprecated)
+    assert.deepEqual(property.tags, [])
+    assert.deepEqual(property.taxonomy, [])
+    assert.isUndefined(property.schema)
+    assert.deepEqual(property.bindings, [])
+    assert.equal(property['parent'], parent)
+    assert.equal(property.domain, root)
+  })
+
+  test('creates a DomainProperty with provided values', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      key: 'test-property',
+      info: { name: 'Test Property', description: 'A test property' },
+      required: true,
+      multiple: true,
+      primary: true,
+      index: true,
+      readOnly: true,
+      writeOnly: true,
+      deprecated: true,
+      tags: ['tag1', 'tag2'],
+      taxonomy: ['tax1', 'tax2'],
+      type: 'number',
+      schema: { minimum: 0 },
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.equal(property.key, 'test-property')
+    assert.instanceOf(property.info, Thing)
+    assert.deepInclude(property.info.toJSON(), { name: 'Test Property', description: 'A test property' })
+    assert.equal(property.type, 'number')
+    assert.isTrue(property.required)
+    assert.isTrue(property.multiple)
+    assert.isTrue(property.primary)
+    assert.isTrue(property.index)
+    assert.isTrue(property.readOnly)
+    assert.isTrue(property.writeOnly)
+    assert.isTrue(property.deprecated)
+    assert.deepEqual(property.tags, ['tag1', 'tag2'])
+    assert.deepEqual(property.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(property.schema, { minimum: 0 })
+    assert.deepEqual(property.bindings, [{ type: 'web', schema: { format: 'float' } }])
+    assert.equal(property['parent'], parent)
+    assert.equal(property.domain, root)
+  })
+
+  test('creates a DomainProperty with partial info', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      info: { name: 'Test Property' },
+    })
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.typeOf(property.key, 'string')
+    assert.isNotEmpty(property.key)
+    assert.instanceOf(property.info, Thing)
+    assert.deepInclude(property.info.toJSON(), { name: 'Test Property' })
+  })
+
+  test('creates a DomainProperty with a specific type', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      type: 'boolean',
+    })
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.typeOf(property.key, 'string')
+    assert.isNotEmpty(property.key)
+    assert.instanceOf(property.info, Thing)
+    assert.deepInclude(property.info.toJSON(), { name: 'New property' })
+    assert.equal(property.type, 'boolean')
+  })
+
+  test('throws an error with an invalid type', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    assert.throws(() => {
+      // @ts-expect-error Testing invalid type
+      new DomainProperty(root, parent, { type: 'invalid-type' })
+    }, 'Invalid data property type invalid-type')
+  })
+})
+
+test.group('DomainProperty.validate()', () => {
+  test('returns false for null input', ({ assert }) => {
+    const result = DomainProperty.validate(null)
+    assert.isFalse(result)
+  })
+
+  test('returns false for undefined input', ({ assert }) => {
+    const result = DomainProperty.validate(undefined)
+    assert.isFalse(result)
+  })
+
+  test('returns false for non-object input', ({ assert }) => {
+    const result = DomainProperty.validate('string')
+    assert.isFalse(result)
+  })
+
+  test('returns true for valid input', ({ assert }) => {
+    const validInput = {
+      kind: DomainPropertyKind,
+      key: 'test-key',
+      info: { name: 'Test Property' },
+      type: 'string',
+    }
+    const result = DomainProperty.validate(validInput)
+    assert.isTrue(result)
+  })
+
+  test('returns false for mismatched kind in strict mode', ({ assert }) => {
+    const invalidInput = {
+      kind: 'InvalidKind',
+      key: 'test-key',
+      info: { name: 'Test Property' },
+      type: 'string',
+    }
+    const result = DomainProperty.validate(invalidInput, { strict: true })
+    assert.isFalse(result)
+  })
+
+  test('returns false for missing kind in strict mode', ({ assert }) => {
+    const invalidInput = {
+      key: 'test-key',
+      info: { name: 'Test Property' },
+      type: 'string',
+    }
+    const result = DomainProperty.validate(invalidInput, { strict: true })
+    assert.isFalse(result)
+  })
+
+  test('returns true for missing kind in non-strict mode', ({ assert }) => {
+    const validInput = {
+      key: 'test-key',
+      info: { name: 'Test Property' },
+      type: 'string',
+    }
+    const result = DomainProperty.validate(validInput)
+    assert.isTrue(result)
+  })
+})
+
+test.group('DomainProperty.toJSON()', () => {
+  test('serializes with default values', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent)
+    const json = property.toJSON()
+
+    assert.equal(json.kind, DomainPropertyKind)
+    assert.typeOf(json.key, 'string')
+    assert.isNotEmpty(json.key)
+    assert.deepInclude(json.info, { name: 'New property' })
+    assert.equal(json.type, 'string')
+    assert.isUndefined(json.multiple)
+    assert.isUndefined(json.required)
+    assert.isUndefined(json.index)
+    assert.isUndefined(json.primary)
+    assert.isUndefined(json.readOnly)
+    assert.isUndefined(json.writeOnly)
+    assert.isUndefined(json.deprecated)
+    assert.isUndefined(json.tags)
+    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.schema)
+    assert.isUndefined(json.bindings)
+  })
+
+  test('serializes with custom values', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      key: 'test-property',
+      info: { name: 'Test Property', description: 'A test property' },
+      required: true,
+      multiple: true,
+      primary: true,
+      index: true,
+      readOnly: true,
+      writeOnly: true,
+      deprecated: true,
+      tags: ['tag1', 'tag2'],
+      taxonomy: ['tax1', 'tax2'],
+      type: 'number',
+      schema: { minimum: 0 },
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    const json = property.toJSON()
+
+    assert.equal(json.kind, DomainPropertyKind)
+    assert.equal(json.key, 'test-property')
+    assert.deepInclude(json.info, { name: 'Test Property', description: 'A test property' })
+    assert.equal(json.type, 'number')
+    assert.isTrue(json.required)
+    assert.isTrue(json.multiple)
+    assert.isTrue(json.primary)
+    assert.isTrue(json.index)
+    assert.isTrue(json.readOnly)
+    assert.isTrue(json.writeOnly)
+    assert.isTrue(json.deprecated)
+    assert.deepEqual(json.tags, ['tag1', 'tag2'])
+    assert.deepEqual(json.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(json.schema, { minimum: 0 })
+    assert.deepEqual(json.bindings, [{ type: 'web', schema: { format: 'float' } }])
+  })
+
+  test('serializes with empty arrays', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      tags: [],
+      taxonomy: [],
+      bindings: [],
+    })
+    const json = property.toJSON()
+
+    assert.isUndefined(json.tags)
+    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.bindings)
+  })
+
+  test('excludes undefined properties', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      required: undefined,
+      multiple: undefined,
+      index: undefined,
+      primary: undefined,
+      readOnly: undefined,
+      writeOnly: undefined,
+      deprecated: undefined,
+      tags: undefined,
+      taxonomy: undefined,
+      schema: undefined,
+      bindings: undefined,
+    })
+    const json = property.toJSON()
+
+    assert.isUndefined(json.required)
+    assert.isUndefined(json.multiple)
+    assert.isUndefined(json.index)
+    assert.isUndefined(json.primary)
+    assert.isUndefined(json.readOnly)
+    assert.isUndefined(json.writeOnly)
+    assert.isUndefined(json.deprecated)
+    assert.isUndefined(json.tags)
+    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.schema)
+    assert.isUndefined(json.bindings)
+  })
+
+  test('serializes nested objects', ({ assert }) => {
+    const root = new DataDomain()
+    const parent = 'test-parent'
+    const property = new DomainProperty(root, parent, {
+      info: { name: 'Nested Info', description: 'Nested description' },
+      schema: { minimum: 10, maximum: 100 },
+    })
+    const json = property.toJSON()
+
+    assert.deepInclude(json.info, { name: 'Nested Info', description: 'Nested description' })
+    assert.deepEqual(json.schema, { minimum: 10, maximum: 100 })
+  })
+})
+
+test.group('DomainProperty.remove()', () => {
+  test('removes the property from the parent entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    property.remove()
+    assert.isFalse(dataDomain.graph.hasNode(property.key))
+    assert.deepEqual(entity.fields, [])
+  })
+})
+
+test.group('DomainProperty.getParentInstance()', () => {
+  test('returns the parent entity when the property is a child', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty()
+    const parent = property.getParentInstance()
+    assert.deepEqual(parent, entity)
+  })
+
+  test('returns undefined when the property has no parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'non-existent-entity')
+    dataDomain.graph.setNode(property.key, property)
+    const parent = property.getParentInstance()
+    assert.isUndefined(parent)
+  })
+
+  test('returns the correct parent when there are multiple levels of nesting', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty()
+    const parent = property.getParentInstance()
+    assert.deepEqual(parent, entity)
+  })
+
+  test('returns undefined when the parent entity is removed from the graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty()
+    dataDomain.graph.removeNode(entity.key)
+    const parent = property.getParentInstance()
+    assert.isUndefined(parent)
+  })
+})
+
+test.group('DomainProperty.isValidType()', () => {
+  test('returns true for valid data types', ({ assert }) => {
+    DataFormat.DomainPropertyTypes.forEach((type) => {
+      assert.isTrue(DomainProperty.isValidType(type), `Type "${type}" should be valid`)
+    })
+  })
+
+  test('returns false for invalid data types', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidType('invalid-type'))
+    assert.isFalse(DomainProperty.isValidType(123))
+    assert.isFalse(DomainProperty.isValidType(true))
+    assert.isFalse(DomainProperty.isValidType({}))
+    assert.isFalse(DomainProperty.isValidType([]))
+    assert.isFalse(DomainProperty.isValidType(null))
+    assert.isFalse(DomainProperty.isValidType(undefined))
+  })
+
+  test('returns false for non-string values', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidType(123))
+    assert.isFalse(DomainProperty.isValidType(true))
+    assert.isFalse(DomainProperty.isValidType({}))
+    assert.isFalse(DomainProperty.isValidType([]))
+    assert.isFalse(DomainProperty.isValidType(null))
+    assert.isFalse(DomainProperty.isValidType(undefined))
+  })
+
+  test('returns false for empty string', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidType(''))
+  })
+})
+
+test.group('DomainProperty.isValidAttribute()', () => {
+  test('returns true for valid data property attributes', ({ assert }) => {
+    const validAttributes: DataFormat.DomainAttributeAttribute[] = ['required', 'multiple']
+    validAttributes.forEach((attribute) => {
+      assert.isTrue(DomainProperty.isValidAttribute(attribute), `Attribute "${attribute}" should be valid`)
+    })
+  })
+
+  test('returns false for invalid data property attributes', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidAttribute('invalid-attribute'))
+    assert.isFalse(DomainProperty.isValidAttribute(123))
+    assert.isFalse(DomainProperty.isValidAttribute(true))
+    assert.isFalse(DomainProperty.isValidAttribute({}))
+    assert.isFalse(DomainProperty.isValidAttribute([]))
+    assert.isFalse(DomainProperty.isValidAttribute(null))
+    assert.isFalse(DomainProperty.isValidAttribute(undefined))
+  })
+
+  test('returns false for non-string values', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidAttribute(123))
+    assert.isFalse(DomainProperty.isValidAttribute(true))
+    assert.isFalse(DomainProperty.isValidAttribute({}))
+    assert.isFalse(DomainProperty.isValidAttribute([]))
+    assert.isFalse(DomainProperty.isValidAttribute(null))
+    assert.isFalse(DomainProperty.isValidAttribute(undefined))
+  })
+
+  test('returns false for empty string', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidAttribute(''))
+  })
+})
+
+test.group('DomainProperty.isValidFormat()', () => {
+  test('returns true for valid data property formats', ({ assert }) => {
+    const validFormats: DataFormat.DomainPropertyFormat[] = [...DataFormat.NumberFormats, ...DataFormat.BinaryFormats]
+    validFormats.forEach((format) => {
+      assert.isTrue(DomainProperty.isValidFormat(format), `Format "${format}" should be valid`)
+    })
+  })
+
+  test('returns true for undefined format', ({ assert }) => {
+    assert.isTrue(DomainProperty.isValidFormat(undefined), 'Undefined format should be valid')
+  })
+
+  test('returns false for invalid data property formats', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidFormat('invalid-format'))
+    assert.isFalse(DomainProperty.isValidFormat(123))
+    assert.isFalse(DomainProperty.isValidFormat(true))
+    assert.isFalse(DomainProperty.isValidFormat({}))
+    assert.isFalse(DomainProperty.isValidFormat([]))
+    assert.isFalse(DomainProperty.isValidFormat(null))
+  })
+
+  test('returns false for non-string values', ({ assert }) => {
+    assert.isFalse(DomainProperty.isValidFormat(123))
+    assert.isFalse(DomainProperty.isValidFormat(true))
+    assert.isFalse(DomainProperty.isValidFormat({}))
+    assert.isFalse(DomainProperty.isValidFormat([]))
+    assert.isFalse(DomainProperty.isValidFormat(null))
+  })
+})
+
+test.group('DomainProperty.ensureSchema()', () => {
+  test('creates the schema object if it does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    assert.isUndefined(property.schema)
+    const schema = property.ensureSchema()
+    assert.isDefined(property.schema)
+    assert.deepEqual(schema, {})
+    assert.deepEqual(schema, schema)
+  })
+
+  test('returns the existing schema object if it exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { schema: { minimum: 0 } })
+    const originalSchema = property.schema
+    const schema = property.ensureSchema()
+    assert.deepEqual(schema, { minimum: 0 })
+    assert.strictEqual(schema, originalSchema)
+  })
+
+  test('does not modify the existing schema object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { schema: { minimum: 0 } })
+    const originalSchema = property.schema
+    property.ensureSchema()
+    assert.deepEqual(property.schema, { minimum: 0 })
+    assert.strictEqual(property.schema, originalSchema)
+  })
+})
+
+test.group('DomainProperty.getWebBinding()', () => {
+  test('creates web bindings if they do not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    const webBindings = property.getWebBinding()
+    assert.isDefined(webBindings)
+    assert.deepEqual(webBindings, {})
+    assert.lengthOf(property.bindings, 1)
+    assert.equal(property.bindings[0].type, 'web')
+  })
+
+  test('returns existing web bindings if they exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    const webBindings = property.getWebBinding()
+    assert.isDefined(webBindings)
+    assert.deepEqual(webBindings, { format: 'float' })
+    assert.lengthOf(property.bindings, 1)
+    assert.equal(property.bindings[0].type, 'web')
+  })
+
+  test('does not modify existing web bindings object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    const originalBindings = property.bindings[0].schema
+    property.getWebBinding()
+    assert.deepEqual(property.bindings[0].schema, { format: 'float' })
+    assert.deepEqual(property.bindings[0].schema, originalBindings)
+  })
+
+  test('notifies change when creating new bindings', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    const webBindings = property.getWebBinding()
+    assert.isDefined(webBindings)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainProperty.readBinding()', () => {
+  test('returns undefined if no binding exists for the given type', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    const binding = property.readBinding('web')
+    assert.isUndefined(binding)
+  })
+
+  test('returns the web binding schema if it exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      bindings: [{ type: 'web', schema: { format: 'float' } }],
+    })
+    const webBindings = property.readBinding('web')
+    assert.deepEqual(webBindings, { format: 'float' })
+  })
+
+  test('returns the protobuf binding schema if it exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      bindings: [{ type: 'protobuf', schema: { field: 1 } }],
+    })
+    const protobufBindings = property.readBinding('protobuf')
+    assert.deepEqual(protobufBindings, { field: 1 })
+  })
+
+  test('returns undefined if the binding exists but has no schema', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      // @ts-expect-error Testing undefined value
+      bindings: [{ type: 'web', schema: undefined }],
+    })
+    const webBindings = property.readBinding('web')
+    assert.isUndefined(webBindings)
+  })
+
+  test('returns undefined if the binding exists but the schema is null', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', {
+      // @ts-expect-error Testing null value
+      bindings: [{ type: 'web', schema: null }],
+    })
+    const webBindings = property.readBinding('web')
+    assert.isUndefined(webBindings)
+  })
+})
+
+test.group('DomainProperty.toApiShape()', () => {
+  test('returns an object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty()
+    const result = property.toApiShape()
+    assert.typeOf(result, 'object')
+  })
+
+  test('returns a shape with the correct kind', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty()
+    const result = property.toApiShape()
+    // While we can't directly test the kind (as it's an AMF object),
+    // we can check for the presence of the @type property
+    // which is a good indicator that it's a valid AMF shape.
+    assert.isDefined(result)
+  })
+
+  test('returns a shape with the correct id', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property' })
+    const result = property.toApiShape()
+    assert.isDefined(result)
+  })
+
+  test('returns a shape with the correct data type', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ type: 'number' })
+    const result = property.toApiShape()
+    assert.isDefined(result)
+  })
+
+  test('returns a shape with the correct data type and format', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ type: 'number' })
+    property.getWebBinding().format = 'float'
+    const result = property.toApiShape()
+    assert.isDefined(result)
+  })
+})