@api-client/core 0.18.56 → 0.18.58

package/tests/unit/modeling/actions/ReadAction.spec.ts

@@ -0,0 +1,77 @@
+import { test } from '@japa/runner'
+import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
+import { AccessRule } from '../../../../src/modeling/rules/index.js'
+
+test.group('ReadAction', () => {
+  test('initializes with default values', ({ assert }) => {
+    const action = new ReadAction()
+    assert.equal(action.kind, 'read')
+    assert.isEmpty(action.accessRule) // Inherited from Action
+  }).tags(['@modeling', '@action', '@read-action'])
+
+  test('initializes with inherited values', ({ assert }) => {
+    const action = new ReadAction({
+      accessRule: [{ type: 'public' }],
+    })
+
+    assert.equal(action.kind, 'read')
+    assert.lengthOf(action.accessRule, 1)
+    assert.equal(action.accessRule[0].type, 'public')
+  }).tags(['@modeling', '@action', '@read-action'])
+
+  test('constructor copies arrays (immutability)', ({ assert }) => {
+    const rules = [{ type: 'public' }]
+
+    const action = new ReadAction({
+      accessRule: rules,
+    })
+
+    // Modify original source
+    rules.push({ type: 'admin' })
+    rules[0].type = 'changed'
+
+    assert.lengthOf(action.accessRule, 1)
+    assert.equal(action.accessRule[0].type, 'public')
+  }).tags(['@modeling', '@action', '@read-action', '@immutability'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const action = new ReadAction({
+      accessRule: [{ type: 'public' }],
+    })
+
+    const json = action.toJSON()
+
+    assert.equal(json.kind, 'read')
+    if (json.accessRule) {
+      assert.lengthOf(json.accessRule, 1)
+      assert.equal(json.accessRule[0].type, 'public')
+    } else {
+      assert.fail('accessRule should be present in JSON')
+    }
+  }).tags(['@modeling', '@action', '@read-action', '@serialization'])
+
+  test('notifies change when inherited property changes', async ({ assert }) => {
+    const action = new ReadAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    // Modify inherited property
+    action.accessRule = [new AccessRule({ type: 'admin' })]
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@read-action', '@observed'])
+
+  test('notifies change when accessRule value change', async ({ assert }) => {
+    const action = new ReadAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    action.accessRule.push(new AccessRule({ type: 'admin' }))
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@read-action', '@observed'])
+})

package/tests/unit/modeling/actions/SearchAction.spec.ts

@@ -0,0 +1,73 @@
+import { test } from '@japa/runner'
+import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+
+test.group('SearchAction', () => {
+  test('initializes with default values', ({ assert }) => {
+    const action = new SearchAction()
+    assert.equal(action.kind, 'search')
+    assert.deepEqual(action.fields, [])
+    assert.isEmpty(action.accessRule)
+  }).tags(['@modeling', '@action', '@search-action'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const fields = ['name', 'description']
+    const action = new SearchAction({
+      fields,
+    })
+
+    assert.equal(action.kind, 'search')
+    assert.deepEqual(action.fields, fields)
+  }).tags(['@modeling', '@action', '@search-action'])
+
+  test('constructor copies arrays (immutability)', ({ assert }) => {
+    const fields = ['name']
+
+    const action = new SearchAction({
+      fields,
+    })
+
+    // Modify original source
+    fields.push('age')
+
+    assert.deepEqual(action.fields, ['name'])
+  }).tags(['@modeling', '@action', '@search-action', '@immutability'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const action = new SearchAction({
+      fields: ['name'],
+    })
+
+    const json = action.toJSON()
+
+    // Modify JSON
+    json.fields.push('new')
+
+    assert.equal(json.kind, 'search')
+    assert.lengthOf(action.fields, 1) // Ensure immutability
+    assert.equal(action.fields[0], 'name')
+  }).tags(['@modeling', '@action', '@search-action', '@serialization', '@immutability'])
+
+  test('notifies change when fields changes', async ({ assert }) => {
+    const action = new SearchAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    action.fields = ['name']
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@search-action', '@observed'])
+
+  test('notifies change when fields value change', async ({ assert }) => {
+    const action = new SearchAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    action.fields.push('name')
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@search-action', '@observed'])
+})

package/tests/unit/modeling/actions/UpdateAction.spec.ts

@@ -0,0 +1,73 @@
+import { test } from '@japa/runner'
+import { UpdateAction } from '../../../../src/modeling/actions/UpdateAction.js'
+
+test.group('UpdateAction', () => {
+  test('initializes with default values', ({ assert }) => {
+    const action = new UpdateAction()
+    assert.equal(action.kind, 'update')
+    assert.deepEqual(action.allowedMethods, ['PATCH'])
+    assert.isEmpty(action.accessRule)
+  }).tags(['@modeling', '@action', '@update-action'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const methods: ('PUT' | 'PATCH')[] = ['PUT', 'PATCH']
+    const action = new UpdateAction({
+      allowedMethods: methods,
+    })
+
+    assert.equal(action.kind, 'update')
+    assert.deepEqual(action.allowedMethods, methods)
+  }).tags(['@modeling', '@action', '@update-action'])
+
+  test('constructor copies arrays (immutability)', ({ assert }) => {
+    const methods: ('PUT' | 'PATCH')[] = ['PUT']
+
+    const action = new UpdateAction({
+      allowedMethods: methods,
+    })
+
+    // Modify original source
+    methods.push('PATCH')
+
+    assert.deepEqual(action.allowedMethods, ['PUT'])
+  }).tags(['@modeling', '@action', '@update-action', '@immutability'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const action = new UpdateAction({
+      allowedMethods: ['PUT'],
+    })
+
+    const json = action.toJSON()
+
+    // Modify JSON
+    json.allowedMethods.push('PATCH')
+
+    assert.equal(json.kind, 'update')
+    assert.lengthOf(action.allowedMethods, 1) // Ensure immutability
+    assert.equal(action.allowedMethods[0], 'PUT')
+  }).tags(['@modeling', '@action', '@update-action', '@serialization', '@immutability'])
+
+  test('notifies change when allowedMethods changes', async ({ assert }) => {
+    const action = new UpdateAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    action.allowedMethods = ['PUT', 'PATCH']
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@update-action', '@observed'])
+
+  test('notifies change when allowedMethods value change', async ({ assert }) => {
+    const action = new UpdateAction()
+    let notified = false
+    action.addEventListener('change', () => {
+      notified = true
+    })
+
+    action.allowedMethods.push('PUT')
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@action', '@update-action', '@observed'])
+})

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

@@ -11,6 +11,9 @@ import {
   ExposedEntityKind,
   ExposedEntity,
 } from '../../../src/index.js'
+import { AllowPublicAccessRule } from '../../../src/modeling/rules/AllowPublic.js'
+import { RateLimitingConfiguration } from '../../../src/modeling/rules/RateLimitingConfiguration.js'
+import { Action } from '../../../src/modeling/index.js'
 
 test.group('ApiModel.createSchema()', () => {
   test('creates a schema with default values', ({ assert }) => {
@@ -99,7 +102,7 @@ test.group('ApiModel.constructor()', () => {
     assert.isUndefined(model.authentication)
     assert.isUndefined(model.authorization)
     assert.isUndefined(model.session)
-    assert.isUndefined(model.accessRule)
+    assert.isEmpty(model.accessRule)
     assert.isUndefined(model.rateLimiting)
     assert.isUndefined(model.termsOfService)
     assert.isUndefined(model.contact)
@@ -144,8 +147,8 @@ test.group('ApiModel.constructor()', () => {
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(model.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(model.session, { secret: 'secret', properties: ['email'] })
-    assert.deepEqual(model.accessRule, [{ type: 'public' }])
-    assert.deepEqual(model.rateLimiting, { rules: [] })
+    assert.deepEqual(model.accessRule, [new AllowPublicAccessRule()])
+    assert.deepEqual(model.rateLimiting, new RateLimitingConfiguration())
     assert.equal(model.termsOfService, 'https://example.com/terms')
     assert.deepEqual(model.contact, { name: 'John Doe', email: 'john.doe@example.com' })
     assert.deepEqual(model.license, { name: 'MIT', url: 'https://opensource.org/licenses/MIT' })
@@ -193,6 +196,30 @@ test.group('ApiModel.constructor()', () => {
     await Promise.resolve() // Allow microtask to run
     assert.isTrue(notified)
   }).tags(['@modeling', '@api', '@creation'])
+
+  test('notifies change when nested action changes', async ({ assert }) => {
+    const model = new ApiModel({
+      exposes: [
+        {
+          kind: ExposedEntityKind,
+          key: 'e1',
+          entity: { key: 'e1' },
+          resourcePath: '/e1',
+          hasCollection: false,
+          actions: [{ kind: 'read' }],
+        },
+      ],
+    })
+
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+
+    model.exposes[0].actions[0].kind = 'write'
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@api', '@observed'])
 })
 
 test.group('ApiModel.toJSON()', () => {
@@ -260,6 +287,24 @@ test.group('ApiModel.toJSON()', () => {
     assert.deepEqual(json.contact, { name: 'John Doe', email: 'john.doe@example.com' })
     assert.deepEqual(json.license, { name: 'MIT', url: 'https://opensource.org/licenses/MIT' })
   }).tags(['@modeling', '@api', '@serialization'])
+
+  test('actions are immutable', ({ assert }) => {
+    const model = new ApiModel()
+    const action = new Action({ kind: 'read' })
+    const entityKey = 'get-entity'
+    const exposed: ExposedEntitySchema = {
+      key: entityKey,
+      actions: [action.toJSON()],
+      hasCollection: true,
+      kind: ExposedEntityKind,
+      resourcePath: '/',
+      entity: { key: entityKey },
+    }
+    model.exposes.push(new ExposedEntity(model, exposed))
+    const json = model.toJSON()
+    json.exposes[0].actions[0].kind = 'write'
+    assert.equal(model.exposes[0].actions[0].kind, 'read')
+  }).tags(['@modeling', '@api', '@serialization'])
 })
 
 test.group('ApiModel.getExposedEntity()', () => {

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

@@ -152,4 +152,77 @@ test.group('ExposedEntity', () => {
     await Promise.resolve()
     assert.isAtLeast(notified, 1)
   }).tags(['@modeling', '@exposed-entity', '@observed'])
+
+  test('restores actions and rules from schema', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      actions: [{ kind: 'read', accessRule: [{ type: 'public' }] }],
+      accessRule: [{ type: 'admin' }],
+    })
+
+    assert.lengthOf(ex.actions, 1)
+    assert.equal(ex.actions[0].kind, 'read')
+    assert.lengthOf(ex.actions[0].accessRule, 1)
+    assert.equal(ex.actions[0].accessRule[0].type, 'public')
+
+    assert.lengthOf(ex.accessRule!, 1)
+    assert.equal(ex.accessRule![0].type, 'admin')
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('serializes actions and rules', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      actions: [{ kind: 'read' }],
+      accessRule: [{ type: 'admin' }],
+    })
+
+    const json = ex.toJSON()
+    assert.deepInclude(json.actions[0], { kind: 'read' })
+    assert.deepInclude(json.accessRule![0], { type: 'admin' })
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('notifies change when action property changes', async ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      actions: [{ kind: 'read' }],
+    })
+
+    let notified = false
+    ex.addEventListener('change', () => {
+      notified = true
+    })
+
+    ex.actions[0].kind = 'write'
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@exposed-entity', '@observed'])
+
+  test('constructor copies actions array (immutability)', ({ assert }) => {
+    const model = new ApiModel()
+    const actions = [{ kind: 'read' }]
+    const ex = new ExposedEntity(model, { actions })
+
+    // Modify original array
+    actions.push({ kind: 'write' })
+    actions[0].kind = 'changed'
+
+    assert.lengthOf(ex.actions, 1)
+    assert.equal(ex.actions[0].kind, 'read')
+  }).tags(['@modeling', '@exposed-entity', '@immutability'])
+
+  test('constructor copies accessRule array (immutability)', ({ assert }) => {
+    const model = new ApiModel()
+    const rules = [{ type: 'public' }]
+    const ex = new ExposedEntity(model, {
+      actions: [],
+      accessRule: rules,
+    })
+
+    // Modify original array
+    rules.push({ type: 'admin' })
+    rules[0].type = 'changed'
+
+    assert.lengthOf(ex.accessRule!, 1)
+    assert.equal(ex.accessRule![0].type, 'public')
+  }).tags(['@modeling', '@exposed-entity', '@immutability'])
 })

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

@@ -39,6 +39,7 @@ import {
   addStreetAddressField,
   addCityField,
   addRegionField,
+  addStreetAddressSupplementalField,
 } from '../../../../src/modeling/helpers/Intelisense.js'
 import { SemanticType } from '../../../../src/modeling/Semantics.js'
 import { createCountrySemantic } from '../../../../src/modeling/definitions/Country.js'
@@ -1237,3 +1238,48 @@ test.group('addRegionField()', () => {
     assert.equal(field.info.description, 'Region XXX')
   })
 })
+
+test.group('addStreetAddressSupplementalField()', () => {
+  test('creates first supplemental field when none exists', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressSupplementalField(entity)
+    assert.instanceOf(field, DomainProperty)
+    assert.equal(field.info.name, 'street_address_1')
+    assert.equal(field.info.displayName, 'Street Address 1')
+    assert.equal(field.type, 'string')
+    assert.isFalse(field.required)
+    assert.isTrue(field.hasSemantic(SemanticType.StreetAddressSupplemental))
+  })
+
+  test('increments supplemental field index', ({ assert }) => {
+    const entity = createTestEntity()
+    const field1 = addStreetAddressSupplementalField(entity)
+    const field2 = addStreetAddressSupplementalField(entity)
+
+    assert.equal(field1.info.name, 'street_address_1')
+    assert.equal(field2.info.name, 'street_address_2')
+    assert.equal(field2.info.displayName, 'Street Address 2')
+  })
+
+  test('handles gaps in numbering', ({ assert }) => {
+    const entity = createTestEntity()
+    // Manually add a field mimicking a higher number
+    const manualField = entity.addProperty({
+      info: { name: 'street_address_5', displayName: 'Street Address 5' },
+      type: 'string',
+      required: false,
+    })
+    manualField.addSemantic({ id: SemanticType.StreetAddressSupplemental })
+
+    const field = addStreetAddressSupplementalField(entity)
+    assert.equal(field.info.name, 'street_address_6')
+    assert.equal(field.info.displayName, 'Street Address 6')
+  })
+
+  test('merges custom info', ({ assert }) => {
+    const entity = createTestEntity()
+    const field = addStreetAddressSupplementalField(entity, { description: 'Extra line' })
+    assert.equal(field.info.name, 'street_address_1')
+    assert.equal(field.info.description, 'Extra line')
+  })
+})

package/tests/unit/modeling/rules/AccessRule.spec.ts

@@ -0,0 +1,42 @@
+import { test } from '@japa/runner'
+import { AccessRule, type AccessRuleSchema } from '../../../../src/modeling/index.js'
+
+test.group('AccessRule', () => {
+  test('initializes with default values', ({ assert }) => {
+    const rule = new AccessRule()
+    assert.equal(rule.type, '')
+  }).tags(['@modeling', '@access-rule'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const schema: AccessRuleSchema = { type: 'public' }
+    const rule = new AccessRule(schema)
+    assert.equal(rule.type, 'public')
+  }).tags(['@modeling', '@access-rule'])
+
+  test('serializes to JSON', ({ assert }) => {
+    const rule = new AccessRule({ type: 'authenticated' })
+    const json = rule.toJSON()
+    assert.deepEqual(json, { type: 'authenticated' })
+  }).tags(['@modeling', '@access-rule'])
+
+  test('notifies change', async ({ assert }) => {
+    const rule = new AccessRule({ type: 'public' })
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.notifyChange()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@access-rule'])
+
+  test('toJSON returns safe copy (immutability)', ({ assert }) => {
+    const rule = new AccessRule({ type: 'public' })
+    const json = rule.toJSON()
+
+    // Modify JSON (simulate runtime mutation)
+    json.type = 'changed'
+
+    assert.equal(rule.type, 'public')
+  }).tags(['@modeling', '@access-rule', '@immutability'])
+})

package/tests/unit/modeling/rules/AllowAuthenticated.spec.ts

@@ -0,0 +1,28 @@
+import { test } from '@japa/runner'
+import { AllowAuthenticatedAccessRule } from '../../../../src/modeling/rules/AllowAuthenticated.js'
+
+test.group('AllowAuthenticatedAccessRule', () => {
+  test('initializes with correct type', ({ assert }) => {
+    const rule = new AllowAuthenticatedAccessRule()
+    assert.equal(rule.type, 'authenticated')
+  }).tags(['@modeling', '@rule', '@allow-authenticated'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new AllowAuthenticatedAccessRule()
+    const json = rule.toJSON()
+
+    assert.equal(json.type, 'authenticated')
+  }).tags(['@modeling', '@rule', '@allow-authenticated', '@serialization'])
+
+  test('notifies change', async ({ assert }) => {
+    const rule = new AllowAuthenticatedAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.notifyChange()
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@allow-authenticated', '@observed'])
+})

package/tests/unit/modeling/rules/AllowPublic.spec.ts

@@ -0,0 +1,28 @@
+import { test } from '@japa/runner'
+import { AllowPublicAccessRule } from '../../../../src/modeling/rules/AllowPublic.js'
+
+test.group('AllowPublicAccessRule', () => {
+  test('initializes with correct type', ({ assert }) => {
+    const rule = new AllowPublicAccessRule()
+    assert.equal(rule.type, 'public')
+  }).tags(['@modeling', '@rule', '@allow-public'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new AllowPublicAccessRule()
+    const json = rule.toJSON()
+
+    assert.equal(json.type, 'public')
+  }).tags(['@modeling', '@rule', '@allow-public', '@serialization'])
+
+  test('notifies change', async ({ assert }) => {
+    const rule = new AllowPublicAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.notifyChange()
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@allow-public', '@observed'])
+})

package/tests/unit/modeling/rules/MatchEmailDomain.spec.ts

@@ -0,0 +1,52 @@
+import { test } from '@japa/runner'
+import { MatchEmailDomainAccessRule } from '../../../../src/modeling/rules/MatchEmailDomain.js'
+
+test.group('MatchEmailDomainAccessRule', () => {
+  test('initializes with default values', ({ assert }) => {
+    const rule = new MatchEmailDomainAccessRule()
+    assert.equal(rule.type, 'matchEmailDomain')
+    assert.deepEqual(rule.domains, [])
+  }).tags(['@modeling', '@rule', '@match-email-domain'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const domains = ['example.com', 'test.org']
+    const rule = new MatchEmailDomainAccessRule({ domains })
+
+    assert.equal(rule.type, 'matchEmailDomain')
+    assert.deepEqual(rule.domains, domains)
+  }).tags(['@modeling', '@rule', '@match-email-domain'])
+
+  test('constructor copies arrays (immutability)', ({ assert }) => {
+    const domains = ['example.com']
+    const rule = new MatchEmailDomainAccessRule({ domains })
+
+    // Modify original source
+    domains.push('hacker.com')
+
+    assert.deepEqual(rule.domains, ['example.com'])
+  }).tags(['@modeling', '@rule', '@match-email-domain', '@immutability'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new MatchEmailDomainAccessRule({ domains: ['example.com'] })
+    const json = rule.toJSON()
+
+    // Modify JSON
+    json.domains.push('hacker.com')
+
+    assert.equal(json.type, 'matchEmailDomain')
+    assert.lengthOf(rule.domains, 1) // Ensure immutability
+    assert.equal(rule.domains[0], 'example.com')
+  }).tags(['@modeling', '@rule', '@match-email-domain', '@serialization', '@immutability'])
+
+  test('notifies change when domains changes', async ({ assert }) => {
+    const rule = new MatchEmailDomainAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.domains = ['example.com']
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@match-email-domain', '@observed'])
+})

package/tests/unit/modeling/rules/MatchResourceOwner.spec.ts

@@ -0,0 +1,37 @@
+import { test } from '@japa/runner'
+import { MatchResourceOwnerAccessRule } from '../../../../src/modeling/rules/MatchResourceOwner.js'
+
+test.group('MatchResourceOwnerAccessRule', () => {
+  test('initializes with default values', ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule()
+    assert.equal(rule.type, 'resourceOwner')
+    assert.equal(rule.property, '')
+  }).tags(['@modeling', '@rule', '@match-resource-owner'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
+
+    assert.equal(rule.type, 'resourceOwner')
+    assert.equal(rule.property, 'creatorId')
+  }).tags(['@modeling', '@rule', '@match-resource-owner'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule({ property: 'creatorId' })
+    const json = rule.toJSON()
+
+    assert.equal(json.type, 'resourceOwner')
+    assert.equal(json.property, 'creatorId')
+  }).tags(['@modeling', '@rule', '@match-resource-owner', '@serialization'])
+
+  test('notifies change when property changes', async ({ assert }) => {
+    const rule = new MatchResourceOwnerAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.property = 'ownerId'
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@match-resource-owner', '@observed'])
+})