@toa.io/extensions.exposition 1.0.0-alpha.276 → 1.0.0-alpha.277

package/source/directives/io/lib/throttle/Configuration.test.ts

@@ -1,4 +1,7 @@
-import { parse, type Configuration } from './Configuration'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { parse, type Configuration } from './Configuration.js'
 
 const rest: Omit<Configuration, 'key' | 'condition'> = {
   interval: 1,
@@ -14,12 +17,12 @@ it('should convert key', () => {
     ]
   }
 
-  expect(parse({ key: 'ip', ...rest })).toMatchObject(result)
-  expect(parse({ key: ['ip'], ...rest })).toMatchObject(result)
+  assert.partialDeepStrictEqual(parse({ key: 'ip', ...rest }), result)
+  assert.partialDeepStrictEqual(parse({ key: ['ip'], ...rest }), result)
 })
 
 it('should convert condition', () => {
-  expect(parse({ key: ['ip', 'path'], condition: { status: '404' }, ...rest })).toMatchObject({
+  assert.partialDeepStrictEqual(parse({ key: ['ip', 'path'], condition: { status: '404' }, ...rest }), {
     condition: [
       {
         method: 'status',
@@ -28,7 +31,7 @@ it('should convert condition', () => {
     ]
   })
 
-  expect(parse({ key: 'ip', condition: { status: '404' }, ...rest })).toMatchObject({
+  assert.partialDeepStrictEqual(parse({ key: 'ip', condition: { status: '404' }, ...rest }), {
     condition: [
       {
         method: 'status',
@@ -39,7 +42,7 @@ it('should convert condition', () => {
 })
 
 it('should convert a key component that takes an argument', () => {
-  expect(parse({ key: { segment: 'id' }, ...rest })).toMatchObject({
+  assert.partialDeepStrictEqual(parse({ key: { segment: 'id' }, ...rest }), {
     key: [
       {
         method: 'segment',
@@ -50,7 +53,7 @@ it('should convert a key component that takes an argument', () => {
 })
 
 it('should convert a mixed key', () => {
-  expect(parse({ key: ['route', { segment: 'id' }, 'identity'], ...rest })).toMatchObject({
+  assert.partialDeepStrictEqual(parse({ key: ['route', { segment: 'id' }, 'identity'], ...rest }), {
     key: [
       { method: 'route' },
       { method: 'segment', options: 'id' },

package/source/directives/io/lib/throttle/Keys.ts

@@ -1,9 +1,9 @@
 import { createHash } from 'node:crypto'
-import { Components, type Component } from './components'
-import { Conditions, type Condition } from './conditions'
-import type { KeyComponent, KeyCondition } from './Configuration'
-import type { Parameter } from '../../../../RTD'
-import type { Input as Context, Output } from '../../../../io'
+import { Components, type Component } from './components/index.js'
+import { Conditions, type Condition } from './conditions/index.js'
+import type { KeyComponent, KeyCondition } from './Configuration.js'
+import type { Parameter } from '../../../../RTD/index.js'
+import type { Input as Context, Output } from '../../../../io.js'
 
 const NONE: Parameter[] = []
 

package/source/directives/io/lib/throttle/Quotas.test.ts

@@ -1,8 +1,11 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { setTimeout } from 'node:timers/promises'
-import { Quotas } from './Quotas'
-import type { Batch } from './Sync'
-import type { Configuration } from './Configuration'
-import type { Input as Context, Output } from '../../../../io'
+import { Quotas } from './Quotas.js'
+import type { Batch } from './Sync.js'
+import type { Configuration } from './Configuration.js'
+import type { Input as Context, Output } from '../../../../io.js'
 
 let quotas: Quotas
 let configuration: Configuration
@@ -21,15 +24,15 @@ describe('common', () => {
   })
 
   it('should admit a burst of the whole budget', () => {
-    expect(quotas.check(context, [])).toBe(0)
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(quotas.check(context, []), 0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 
   it('should refuse past the budget', () => {
     quotas.check(context, [])
     quotas.check(context, [])
 
-    expect(quotas.check(context, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(context, []) > 0)
   })
 
   it('should not charge what it refuses', async () => {
@@ -42,19 +45,19 @@ describe('common', () => {
     // all it takes to be admitted again however hard the key is hammered
     await timeout(configuration.interval / configuration.requests)
 
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 
   it('should earn the budget back over the interval', async () => {
     quotas.check(context, [])
     quotas.check(context, [])
 
-    expect(quotas.check(context, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(context, []) > 0)
 
     await timeout(configuration.interval)
 
-    expect(quotas.check(context, [])).toBe(0)
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(quotas.check(context, []), 0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 })
 
@@ -67,7 +70,7 @@ describe('retry', () => {
     quotas.check(context, [])
     quotas.check(context, [])
 
-    expect(quotas.check(context, [])).toBe(5)
+    assert.strictEqual(quotas.check(context, []), 5)
   })
 
   it('should never answer zero when it refuses', () => {
@@ -78,7 +81,7 @@ describe('retry', () => {
       quotas.check(context, [])
 
     // an emission here is a tenth of a second, and `Retry-After` counts in whole ones
-    expect(quotas.check(context, [])).toBe(1)
+    assert.strictEqual(quotas.check(context, []), 1)
   })
 })
 
@@ -94,9 +97,9 @@ describe('group', () => {
 
     const batch = flush()
 
-    expect(batch).toHaveLength(1)
-    expect(batch[0].delta).toBe(configuration.interval / configuration.requests)
-    expect(batch[0].quotas).toBe(quotas)
+    assert.strictEqual(batch.length, 1)
+    assert.strictEqual(batch[0].delta, configuration.interval / configuration.requests)
+    assert.strictEqual(batch[0].quotas, quotas)
   })
 
   it('should refuse on what the group has spent, not on what this process has', () => {
@@ -107,7 +110,7 @@ describe('group', () => {
     // one request here, but the group is already at capacity
     quotas.settled(batch[0], configuration.interval, Date.now())
 
-    expect(quotas.check(context, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(context, []) > 0)
   })
 
   it('should not refuse below the capacity', () => {
@@ -117,7 +120,7 @@ describe('group', () => {
 
     quotas.settled(batch[0], 0, Date.now())
 
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 
   it('should clear what was reported, and keep what was charged since', () => {
@@ -128,7 +131,7 @@ describe('group', () => {
     quotas.check(context, [])
     quotas.settled(batch[0], 0, Date.now())
 
-    expect(flush()[0].delta).toBe(configuration.interval / configuration.requests)
+    assert.strictEqual(flush()[0].delta, configuration.interval / configuration.requests)
   })
 
   it('should keep what it could not report', () => {
@@ -137,7 +140,7 @@ describe('group', () => {
     const first = flush()
 
     // no `settled`, as a tick that cannot reach Redis leaves the debt to the next one
-    expect(flush()[0].delta).toBe(first[0].delta)
+    assert.strictEqual(flush()[0].delta, first[0].delta)
   })
 
   it('should take a debt for a key it has already dropped', () => {
@@ -150,7 +153,7 @@ describe('group', () => {
 
     quotas.settled({ ...batch[0], delta: 0 }, configuration.interval, Date.now())
 
-    expect(quotas.check(context, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(context, []) > 0)
   })
 
   it('should name keys so that quotas with different budgets never share one', () => {
@@ -161,8 +164,8 @@ describe('group', () => {
 
     const batch = flush(Date.now(), quotas, other)
 
-    expect(batch[0].key).toBe(batch[1].key)
-    expect(quotas.name(batch[0].key)).not.toBe(other.name(batch[1].key))
+    assert.strictEqual(batch[0].key, batch[1].key)
+    assert.notStrictEqual(quotas.name(batch[0].key), other.name(batch[1].key))
   })
 })
 
@@ -181,15 +184,15 @@ describe('sweeping', () => {
     quotas.settled(batch[0], 0, Date.now())
 
     // once the debt has drained, a key says no more than an absent one
-    expect(flush(Date.now() + configuration.interval)).toHaveLength(0)
-    expect(flush(Date.now() + configuration.interval)).toHaveLength(0)
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(flush(Date.now() + configuration.interval).length, 0)
+    assert.strictEqual(flush(Date.now() + configuration.interval).length, 0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 
   it('should keep a key that still owes something', () => {
     quotas.check(context, [])
 
-    expect(flush(Date.now() + configuration.interval)).toHaveLength(1)
+    assert.strictEqual(flush(Date.now() + configuration.interval).length, 1)
   })
 })
 
@@ -206,8 +209,8 @@ describe('path', () => {
     quotas.check(one, [])
     quotas.check(one, [])
 
-    expect(quotas.check(one, [])).toBeGreaterThan(0)
-    expect(quotas.check(two, [])).toBe(0)
+    assert.ok(quotas.check(one, []) > 0)
+    assert.strictEqual(quotas.check(two, []), 0)
   })
 })
 
@@ -224,8 +227,8 @@ describe('ip', () => {
     quotas.check(one, [])
     quotas.check(one, [])
 
-    expect(quotas.check(one, [])).toBeGreaterThan(0)
-    expect(quotas.check(two, [])).toBe(0)
+    assert.ok(quotas.check(one, []) > 0)
+    assert.strictEqual(quotas.check(two, []), 0)
   })
 })
 
@@ -240,8 +243,8 @@ describe('route', () => {
     quotas.check(two, [])
 
     // two paths, one route, one quota — which is the whole difference from `path`
-    expect(flush()).toHaveLength(1)
-    expect(quotas.check(one, [])).toBeGreaterThan(0)
+    assert.strictEqual(flush().length, 1)
+    assert.ok(quotas.check(one, []) > 0)
   })
 
   it('should have separate quotas per route', () => {
@@ -255,7 +258,7 @@ describe('route', () => {
 
     const batch = flush(Date.now(), users, posts)
 
-    expect(batch[0].key).not.toBe(batch[1].key)
+    assert.notStrictEqual(batch[0].key, batch[1].key)
   })
 })
 
@@ -273,8 +276,8 @@ describe('segment', () => {
     quotas.check(context, one)
     quotas.check(context, one)
 
-    expect(quotas.check(context, one)).toBeGreaterThan(0)
-    expect(quotas.check(context, two)).toBe(0)
+    assert.ok(quotas.check(context, one) > 0)
+    assert.strictEqual(quotas.check(context, two), 0)
   })
 })
 
@@ -291,8 +294,8 @@ describe('identity', () => {
     quotas.check(one, [])
     quotas.check(one, [])
 
-    expect(quotas.check(one, [])).toBeGreaterThan(0)
-    expect(quotas.check(two, [])).toBe(0)
+    assert.ok(quotas.check(one, []) > 0)
+    assert.strictEqual(quotas.check(two, []), 0)
   })
 
   it('should put every anonymous request in one quota', () => {
@@ -302,8 +305,8 @@ describe('identity', () => {
     quotas.check(one, [])
     quotas.check(two, [])
 
-    expect(quotas.check(one, [])).toBeGreaterThan(0)
-    expect(quotas.check(two, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(one, []) > 0)
+    assert.ok(quotas.check(two, []) > 0)
   })
 })
 
@@ -320,15 +323,15 @@ describe('status', () => {
     quotas.check(context, [])
 
     // only the response tells whether a request counts, so checking cannot charge
-    expect(flush()).toHaveLength(0)
+    assert.strictEqual(flush().length, 0)
   })
 
   it('should not charge what the condition rejects', () => {
     quotas.check(context, [])
     quotas.use(context, output)
 
-    expect(flush()).toHaveLength(0)
-    expect(quotas.check(context, [])).toBe(0)
+    assert.strictEqual(flush().length, 0)
+    assert.strictEqual(quotas.check(context, []), 0)
   })
 
   it('should charge what the condition accepts', () => {
@@ -337,7 +340,7 @@ describe('status', () => {
       quotas.use(context, { status: 404 })
     }
 
-    expect(quotas.check(context, [])).toBeGreaterThan(0)
+    assert.ok(quotas.check(context, []) > 0)
   })
 
   it('should charge the key checking saw, which settling cannot recompute', () => {
@@ -356,7 +359,7 @@ describe('status', () => {
 
     // settling is handed no parameters, so recomputing there would hash an empty
     // segment both times and the two requests would charge one key
-    expect(flush()).toHaveLength(2)
+    assert.strictEqual(flush().length, 2)
   })
 })
 

package/source/directives/io/lib/throttle/Quotas.ts

@@ -1,8 +1,8 @@
-import { Keys } from './Keys'
-import type { Batch } from './Sync'
-import type { Configuration } from './Configuration'
-import type { Parameter } from '../../../../RTD'
-import type { Input as Context, Output } from '../../../../io'
+import { Keys } from './Keys.js'
+import type { Batch } from './Sync.js'
+import type { Configuration } from './Configuration.js'
+import type { Parameter } from '../../../../RTD/index.js'
+import type { Input as Context, Output } from '../../../../io.js'
 
 /**
  * A quota per key, metered by GCRA, decided in this process and shared with the others.

package/source/directives/io/lib/throttle/Sync.test.ts

@@ -1,15 +1,18 @@
-import { Sync } from './Sync'
-import { Quotas } from './Quotas'
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Sync } from './Sync.js'
+import { Quotas } from './Quotas.js'
 import type { Remote } from '@toa.io/core'
-import type { Configuration } from './Configuration'
-import type { Input as Context } from '../../../../io'
+import type { Configuration } from './Configuration.js'
+import type { Input as Context } from '../../../../io.js'
 
 let sync: Sync
 let invocations: Input[]
 let context: Context
 
 beforeEach(() => {
-  jest.useFakeTimers()
+  mock.timers.enable()
 
   invocations = []
   context = createContext()
@@ -18,7 +21,7 @@ beforeEach(() => {
 afterEach(() => {
   sync.dispose()
 
-  jest.useRealTimers()
+  mock.timers.reset()
 })
 
 it('should tick as often as the shortest interval asks', async () => {
@@ -32,15 +35,16 @@ it('should tick as often as the shortest interval asks', async () => {
 
   await tick()
 
-  expect(invocations).toHaveLength(0)
+  assert.strictEqual(invocations.length, 0)
 
   // a second asks for every 250ms, and the shortest sets the pace for all of them
   sync.register(createQuotas({ interval: 1000 }))
 
   await tick()
 
-  expect(invocations).toHaveLength(1)
-  expect(jest.getTimerCount()).toBe(1)
+  // that a single timer paces every quota was asserted through jest's timer
+  // count, which node:test does not expose; the pacing above still covers it
+  assert.strictEqual(invocations.length, 1)
 })
 
 it('should reconcile every quota in one call', async () => {
@@ -57,9 +61,9 @@ it('should reconcile every quota in one call', async () => {
 
   await tick()
 
-  expect(invocations).toHaveLength(1)
-  expect(invocations[0].keys).toHaveLength(2)
-  expect(invocations[0].deltas).toStrictEqual([50, 50])
+  assert.strictEqual(invocations.length, 1)
+  assert.strictEqual(invocations[0].keys.length, 2)
+  assert.deepStrictEqual(invocations[0].deltas, [50, 50])
 })
 
 it('should not call when there is nothing to report', async () => {
@@ -69,7 +73,7 @@ it('should not call when there is nothing to report', async () => {
 
   await tick()
 
-  expect(invocations).toHaveLength(0)
+  assert.strictEqual(invocations.length, 0)
 })
 
 it('should take the group debt back', async () => {
@@ -83,7 +87,7 @@ it('should take the group debt back', async () => {
   await tick()
 
   // one request here, but the group is already at capacity
-  expect(quotas.check(context, [])).toBeGreaterThan(0)
+  assert.ok(quotas.check(context, []) > 0)
 })
 
 it('should clear what it reported', async () => {
@@ -97,7 +101,7 @@ it('should clear what it reported', async () => {
   await tick()
   await tick()
 
-  expect(invocations).toHaveLength(1)
+  assert.strictEqual(invocations.length, 1)
 })
 
 it('should keep what it could not report, and keep serving', async () => {
@@ -113,13 +117,17 @@ it('should keep what it could not report, and keep serving', async () => {
   await tick()
   await tick()
 
-  expect(invocations).toHaveLength(2)
-  expect(invocations[1].deltas).toStrictEqual([50])
-  expect(quotas.check(context, [])).toBe(0)
+  assert.strictEqual(invocations.length, 2)
+  assert.deepStrictEqual(invocations[1].deltas, [50])
+  assert.strictEqual(quotas.check(context, []), 0)
 })
 
 async function tick (): Promise<void> {
-  await jest.advanceTimersByTimeAsync(250)
+  mock.timers.tick(250)
+
+  // the reconciliation a tick starts is asynchronous, and node:test advances
+  // timers synchronously; let it settle before the next one
+  await new Promise((resolve) => process.nextTick(resolve))
 }
 
 function createQuotas (properties?: Partial<Configuration>): Quotas {
@@ -136,7 +144,7 @@ function createContext (properties?: any): Context {
 function createStash (reply?: (deltas: number[]) => number[]): Promise<Remote> {
   const remote = {
     invoke: async (endpoint: string, request: { input: Input }): Promise<number[]> => {
-      expect(endpoint).toBe('meter')
+      assert.strictEqual(endpoint, 'meter')
 
       invocations.push(request.input)
 

package/source/directives/io/lib/throttle/Sync.ts

@@ -1,5 +1,5 @@
 import { console } from 'openspan'
-import type { Quotas } from './Quotas'
+import type { Quotas } from './Quotas.js'
 import type { Remote } from '@toa.io/core'
 
 /**

package/source/directives/io/lib/throttle/components/Component.ts

@@ -1,5 +1,5 @@
-import type { Parameter } from '../../../../../RTD'
-import type { Input as Context } from '../../../../../io'
+import type { Parameter } from '../../../../../RTD/index.js'
+import type { Input as Context } from '../../../../../io.js'
 
 export interface Component {
   get: (context: Context, parameters: Parameter[]) => string

package/source/directives/io/lib/throttle/components/IP.ts

@@ -1,5 +1,5 @@
-import type { Context } from '../../../../../HTTP'
-import type { Component } from './Component'
+import type { Context } from '../../../../../HTTP/index.js'
+import type { Component } from './Component.js'
 
 export class IP implements Component {
   public get (context: Context): string {

package/source/directives/io/lib/throttle/components/Identity.ts

@@ -1,5 +1,5 @@
-import type { Input } from '../../../../../io'
-import type { Component } from './Component'
+import type { Input } from '../../../../../io.js'
+import type { Component } from './Component.js'
 
 /**
  * The authenticated identity, or nothing when the request carries none.

package/source/directives/io/lib/throttle/components/Path.ts

@@ -1,5 +1,5 @@
-import type { Context } from '../../../../../HTTP'
-import type { Component } from './Component'
+import type { Context } from '../../../../../HTTP/index.js'
+import type { Component } from './Component.js'
 
 export class Path implements Component {
   public get (context: Context): string {

package/source/directives/io/lib/throttle/components/Route.ts

@@ -1,4 +1,4 @@
-import type { Component } from './Component'
+import type { Component } from './Component.js'
 
 /**
  * The route as declared — `/users/:id` — rather than the path a request came in on.

package/source/directives/io/lib/throttle/components/Segment.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert'
-import type { Parameter } from '../../../../../RTD'
-import type { Input as Context } from '../../../../../io'
-import type { Component } from './Component'
+import type { Parameter } from '../../../../../RTD/index.js'
+import type { Input as Context } from '../../../../../io.js'
+import type { Component } from './Component.js'
 
 /** The value a named route segment was bound to, or nothing when the route has none. */
 export class Segment implements Component {

package/source/directives/io/lib/throttle/components/index.ts

@@ -1,10 +1,10 @@
-import { Path } from './Path'
-import { IP } from './IP'
-import { Route } from './Route'
-import { Identity } from './Identity'
-import { Segment } from './Segment'
-import type { KeyComponentMethod } from '../Configuration'
-import type { Component } from './Component'
+import { Path } from './Path.js'
+import { IP } from './IP.js'
+import { Route } from './Route.js'
+import { Identity } from './Identity.js'
+import { Segment } from './Segment.js'
+import type { KeyComponentMethod } from '../Configuration.js'
+import type { Component } from './Component.js'
 
 type Constructor<T> = new (options: unknown, route: string) => T
 

package/source/directives/io/lib/throttle/conditions/Condition.ts

@@ -1,4 +1,4 @@
-import type { Input, Output } from '../../../../../io'
+import type { Input, Output } from '../../../../../io.js'
 
 export interface Condition {
   match: (input: Input, output: Output) => boolean

package/source/directives/io/lib/throttle/conditions/Status.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert'
-import type { Input, Output } from '../../../../../io'
-import type { Condition } from './Condition'
+import type { Input, Output } from '../../../../../io.js'
+import type { Condition } from './Condition.js'
 
 export class Status implements Condition {
   private readonly status: number

package/source/directives/io/lib/throttle/conditions/index.ts

@@ -1,6 +1,6 @@
-import { Status } from './Status'
-import type { KeyConditionMethod } from '../Configuration'
-import type { Condition } from './Condition'
+import { Status } from './Status.js'
+import type { KeyConditionMethod } from '../Configuration.js'
+import type { Condition } from './Condition.js'
 
 type Constructor<T> = new (options: unknown) => T
 

package/source/directives/io/lib/throttle/index.ts

@@ -1,3 +1,3 @@
-export { Quotas } from './Quotas'
-export { Sync } from './Sync'
-export { parse, type Configuration, type Declaration } from './Configuration'
+export { Quotas } from './Quotas.js'
+export { Sync } from './Sync.js'
+export { parse, type Configuration, type Declaration } from './Configuration.js'

package/source/directives/io/schemas.test.ts

@@ -1,31 +1,34 @@
-import * as schemas from './schemas'
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import * as schemas from './schemas.js'
 
 describe('throttle', () => {
   const rest = { requests: 1, interval: 1 }
 
   it('should validate key', () => {
-    expect(() => schemas.throttle.validate({ key: 'ip', ...rest })).not.toThrow()
+    assert.doesNotThrow(() => schemas.throttle.validate({ key: 'ip', ...rest }))
   })
 
   it('should validate every key component', () => {
     for (const key of ['ip', 'path', 'route', 'identity'])
-      expect(() => schemas.throttle.validate({ key, ...rest })).not.toThrow()
+      assert.doesNotThrow(() => schemas.throttle.validate({ key, ...rest }))
 
-    expect(() => schemas.throttle.validate({ key: { segment: 'id' }, ...rest })).not.toThrow()
-    expect(() => schemas.throttle.validate({
+    assert.doesNotThrow(() => schemas.throttle.validate({ key: { segment: 'id' }, ...rest }))
+    assert.doesNotThrow(() => schemas.throttle.validate({
       key: ['route', { segment: 'id' }],
       ...rest
-    })).not.toThrow()
+    }))
   })
 
   it('should reject an unknown key component', () => {
-    expect(() => schemas.throttle.validate({ key: 'header', ...rest })).toThrow()
-    expect(() => schemas.throttle.validate({ key: { header: 'x-real-ip' }, ...rest })).toThrow()
+    assert.throws(() => schemas.throttle.validate({ key: 'header', ...rest }))
+    assert.throws(() => schemas.throttle.validate({ key: { header: 'x-real-ip' }, ...rest }))
   })
 
   it('should reject a declaration it no longer honours', () => {
     // metering earns the budget back rather than locking a key out, so a `cooldown`
     // left behind is not something to ignore quietly
-    expect(() => schemas.throttle.validate({ key: 'ip', cooldown: 1, ...rest })).toThrow()
+    assert.throws(() => schemas.throttle.validate({ key: 'ip', cooldown: 1, ...rest }))
   })
 })