@api-client/core 0.18.57 → 0.18.59

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'])
+})

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

@@ -0,0 +1,58 @@
+import { test } from '@japa/runner'
+import { MatchUserPropertyAccessRule } from '../../../../src/modeling/rules/MatchUserProperty.js'
+
+test.group('MatchUserPropertyAccessRule', () => {
+  test('initializes with default values', ({ assert }) => {
+    const rule = new MatchUserPropertyAccessRule()
+    assert.equal(rule.type, 'matchUserProperty')
+    assert.equal(rule.property, '')
+    assert.equal(rule.value, '')
+  }).tags(['@modeling', '@rule', '@match-user-property'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const rule = new MatchUserPropertyAccessRule({
+      property: 'department',
+      value: 'engineering',
+    })
+
+    assert.equal(rule.type, 'matchUserProperty')
+    assert.equal(rule.property, 'department')
+    assert.equal(rule.value, 'engineering')
+  }).tags(['@modeling', '@rule', '@match-user-property'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new MatchUserPropertyAccessRule({
+      property: 'department',
+      value: 'engineering',
+    })
+    const json = rule.toJSON()
+
+    assert.equal(json.type, 'matchUserProperty')
+    assert.equal(json.property, 'department')
+    assert.equal(json.value, 'engineering')
+  }).tags(['@modeling', '@rule', '@match-user-property', '@serialization'])
+
+  test('notifies change when property changes', async ({ assert }) => {
+    const rule = new MatchUserPropertyAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.property = 'dept'
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@match-user-property', '@observed'])
+
+  test('notifies change when value changes', async ({ assert }) => {
+    const rule = new MatchUserPropertyAccessRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.value = 'sales'
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@match-user-property', '@observed'])
+})

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

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

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

@@ -0,0 +1,70 @@
+import { test } from '@japa/runner'
+import { RateLimitRule } from '../../../../src/modeling/rules/RateLimitRule.js'
+
+test.group('RateLimitRule', () => {
+  test('initializes with default values', ({ assert }) => {
+    const rule = new RateLimitRule()
+    assert.isUndefined(rule.description)
+    assert.isUndefined(rule.key)
+    assert.isUndefined(rule.rate)
+    assert.isUndefined(rule.interval)
+    assert.isUndefined(rule.burst)
+  }).tags(['@modeling', '@rule', '@rate-limit'])
+
+  test('initializes with provided values', ({ assert }) => {
+    const rule = new RateLimitRule({
+      description: 'Test Rule',
+      key: { type: 'ip' },
+      rate: 100,
+      interval: 'minute',
+      burst: 10,
+    })
+
+    assert.equal(rule.description, 'Test Rule')
+    assert.deepEqual(rule.key, { type: 'ip' })
+    assert.equal(rule.rate, 100)
+    assert.equal(rule.interval, 'minute')
+    assert.equal(rule.burst, 10)
+  }).tags(['@modeling', '@rule', '@rate-limit'])
+
+  test('constructor copies objects (immutability)', ({ assert }) => {
+    const key = { type: 'role', value: 'admin' } as const
+    const rule = new RateLimitRule({ key })
+
+    // Modify original source
+    // @ts-expect-error: modifying readonly property for test
+    key.value = 'guest'
+
+    assert.deepEqual(rule.key, { type: 'role', value: 'admin' })
+  }).tags(['@modeling', '@rule', '@rate-limit', '@immutability'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const rule = new RateLimitRule({
+      description: 'Test Rule',
+      key: { type: 'userId' },
+      rate: 60,
+      interval: 'hour',
+      burst: 5,
+    })
+
+    const json = rule.toJSON()
+
+    assert.equal(json.description, 'Test Rule')
+    assert.deepEqual(json.key, { type: 'userId' })
+    assert.equal(json.rate, 60)
+    assert.equal(json.interval, 'hour')
+    assert.equal(json.burst, 5)
+  }).tags(['@modeling', '@rule', '@rate-limit', '@serialization'])
+
+  test('notifies change when properties change', async ({ assert }) => {
+    const rule = new RateLimitRule()
+    let notified = false
+    rule.addEventListener('change', () => {
+      notified = true
+    })
+
+    rule.rate = 50
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@rate-limit', '@observed'])
+})

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

@@ -0,0 +1,61 @@
+import { test } from '@japa/runner'
+import { RateLimitingConfiguration } from '../../../../src/modeling/rules/RateLimitingConfiguration.js'
+import { RateLimitRule } from '../../../../src/modeling/rules/RateLimitRule.js'
+
+test.group('RateLimitingConfiguration', () => {
+  test('initializes with default values', ({ assert }) => {
+    const config = new RateLimitingConfiguration()
+    assert.deepEqual(config.rules, [])
+  }).tags(['@modeling', '@rule', '@rate-limiting-config'])
+
+  test('initializes with provided rules', ({ assert }) => {
+    const rule = { rate: 100, interval: 'minute' } as const
+    const config = new RateLimitingConfiguration({
+      rules: [rule],
+    })
+
+    assert.lengthOf(config.rules, 1)
+    assert.instanceOf(config.rules[0], RateLimitRule)
+    assert.equal(config.rules[0].rate, 100)
+  }).tags(['@modeling', '@rule', '@rate-limiting-config'])
+
+  test('toJSON returns valid schema', ({ assert }) => {
+    const config = new RateLimitingConfiguration({
+      rules: [{ rate: 100, interval: 'minute' }],
+    })
+
+    const json = config.toJSON()
+
+    assert.lengthOf(json.rules, 1)
+    assert.equal(json.rules[0].rate, 100)
+    assert.equal(json.rules[0].interval, 'minute')
+  }).tags(['@modeling', '@rule', '@rate-limiting-config', '@serialization'])
+
+  test('notifies change when rules are added', async ({ assert }) => {
+    const config = new RateLimitingConfiguration()
+    let notified = false
+    config.addEventListener('change', () => {
+      notified = true
+    })
+
+    config.rules.push(new RateLimitRule({ rate: 10 }))
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@rate-limiting-config', '@observed'])
+
+  test('notifies change when nested rule changes', async ({ assert }) => {
+    const rule = new RateLimitRule({ rate: 10 })
+    const config = new RateLimitingConfiguration()
+    config.rules.push(rule)
+    await Promise.resolve() // Wait for push notification to settle
+
+    let notified = false
+    config.addEventListener('change', () => {
+      notified = true
+    })
+
+    config.rules[0].rate = 20
+    await Promise.resolve()
+    assert.isTrue(notified)
+  }).tags(['@modeling', '@rule', '@rate-limiting-config', '@observed'])
+})