@api-client/core 0.18.54 → 0.18.55

package/tests/unit/modeling/helpers/intellisense.spec.ts

@@ -34,8 +34,15 @@ import {
   addRecommendedFields,
   addDisplayNameField,
   addRoleField,
+  addCountryField,
+  addPostalCodeField,
+  addStreetAddressField,
+  addCityField,
+  addRegionField,
 } from '../../../../src/modeling/helpers/Intelisense.js'
 import { SemanticType } from '../../../../src/modeling/Semantics.js'
+import { createCountrySemantic } from '../../../../src/modeling/definitions/Country.js'
+import { createPostalCodeSemantic } from '../../../../src/modeling/definitions/PostalCode.js'
 
 function createTestEntity(): DomainEntity {
   const domain = new DataDomain({ key: 'test-domain', info: { name: 'Test Domain' } })
@@ -261,6 +268,46 @@ test.group('addAutoField()', () => {
     assert.equal(field.type, 'number')
     assert.isTrue(field.required)
   })
+
+  test('adds street address field when autoField is "street-address"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'street-address') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'street_address')
+    assert.isTrue(field.hasSemantic(SemanticType.StreetAddress))
+  })
+
+  test('adds city field when autoField is "city"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'city') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'city')
+    assert.isTrue(field.hasSemantic(SemanticType.City))
+  })
+
+  test('adds postal code field when autoField is "postal-code"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'postal-code') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'postal_code')
+    assert.isTrue(field.hasSemantic(SemanticType.PostalCode))
+  })
+
+  test('adds country field when autoField is "country"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'country') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'country')
+    assert.isTrue(field.hasSemantic(SemanticType.Country))
+  })
+
+  test('adds region field when autoField is "region"', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addAutoField(entity, 'region') as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'region')
+    assert.isTrue(field.hasSemantic(SemanticType.Region))
+  })
 })
 
 test.group('addIdField()', () => {
@@ -1028,3 +1075,165 @@ test.group('addRecommendedFields()', () => {
     assert.isAtLeast([...entity.properties].length, initialFieldCount + 1)
   })
 })
+
+test.group('addCountryField()', () => {
+  test('creates new country field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCountryField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'country')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing country field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'country', displayName: 'Country' },
+      type: 'string',
+      semantics: [createCountrySemantic()],
+    })
+    const field = addCountryField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCountryField(entity, { description: 'Country code' }) as DomainProperty
+    assert.equal(field.info.name, 'country')
+    assert.equal(field.info.displayName, 'Country')
+    assert.equal(field.info.description, 'Country code')
+  })
+})
+
+test.group('addPostalCodeField()', () => {
+  test('creates new postal code field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addPostalCodeField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'postal_code')
+    assert.equal(field.info.displayName, 'Postal Code')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing postal code field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'postal_code', displayName: 'Postal Code' },
+      type: 'string',
+      semantics: [createPostalCodeSemantic()],
+    })
+    const field = addPostalCodeField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addPostalCodeField(entity, { description: 'ZIP code' }) as DomainProperty
+    assert.equal(field.info.name, 'postal_code')
+    assert.equal(field.info.displayName, 'Postal Code')
+    assert.equal(field.info.description, 'ZIP code')
+  })
+})
+
+test.group('addStreetAddressField()', () => {
+  test('creates new street address field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'street_address')
+    assert.equal(field.info.displayName, 'Street Address')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing street address field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'street_address', displayName: 'Street Address' },
+      type: 'string',
+      semantics: [{ id: SemanticType.StreetAddress }],
+    })
+    const field = addStreetAddressField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressField(entity, { description: 'Street address XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'street_address')
+    assert.equal(field.info.displayName, 'Street Address')
+    assert.equal(field.info.description, 'Street address XXX')
+  })
+})
+
+test.group('addCityField()', () => {
+  test('creates new city field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCityField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'city')
+    assert.equal(field.info.displayName, 'City')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.required)
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing city field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'city', displayName: 'City' },
+      type: 'string',
+      semantics: [{ id: SemanticType.City }],
+    })
+    const field = addCityField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addCityField(entity, { description: 'City XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'city')
+    assert.equal(field.info.displayName, 'City')
+    assert.equal(field.info.description, 'City XXX')
+  })
+})
+
+test.group('addRegionField()', () => {
+  test('creates new region field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRegionField(entity) as DomainProperty
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'region')
+    assert.equal(field.info.displayName, 'Region')
+    assert.equal(field.type, 'string')
+    assert.isTrue(field.index)
+    assert.isTrue(field.semantics.length > 0)
+  })
+
+  test('returns existing region field when one exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const existingField = entity.addProperty({
+      info: { name: 'region', displayName: 'Region' },
+      type: 'string',
+      semantics: [{ id: SemanticType.Region }],
+    })
+    const field = addRegionField(entity)
+    assert.equal(field, existingField)
+  })
+
+  test('merges custom info with defaults', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addRegionField(entity, { description: 'Region XXX' }) as DomainProperty
+    assert.equal(field.info.name, 'region')
+    assert.equal(field.info.displayName, 'Region')
+    assert.equal(field.info.description, 'Region XXX')
+  })
+})