@owlmeans/queue 0.1.18-rc.4 → 0.1.18-rc.41

package/tests/protocol.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+import { contract, protocol, schema } from '@owlmeans/entrypoint'
+import { route } from '@owlmeans/route'
+import type { JSONSchemaType } from 'ajv'
+import { job, queueProtocolOf, type JobRecord } from '../src/index.js'
+
+interface Input { value: number }
+interface Output { doubled: number }
+const InputSchema = schema<Input>({
+  type: 'object', properties: { value: { type: 'number' } }, required: ['value'], additionalProperties: false,
+} as JSONSchemaType<Input>)
+const OutputSchema = schema<Output>({
+  type: 'object', properties: { doubled: { type: 'number' } }, required: ['doubled'], additionalProperties: false,
+} as JSONSchemaType<Output>)
+const declaration = protocol(
+  route('test:double', '/double', job({ queue: 'test' })),
+  contract(InputSchema, OutputSchema),
+)
+
+const context = (reply: unknown = { value: { doubled: 6 } }) => {
+  const created: Partial<JobRecord>[] = []
+  return {
+    cfg: { queue: { queues: [{ name: 'test', jobs: [declaration.alias] }] } },
+    jobs: () => ({
+      create: async (record: Partial<JobRecord>) => {
+        created.push(record)
+        return { ...record, id: 'job-1' } as JobRecord
+      },
+      wait: async () => reply,
+    }),
+    created,
+  }
+}
+
+describe('protocol-aware queue calls', () => {
+  test('derives the broker address and keeps per-call options', async () => {
+    const ctx = context()
+    const queued = await queueProtocolOf(ctx as never).enqueue(declaration, { body: { value: 3 } }, {
+      delay: 250, attempts: 3, id: 'projection-1',
+    })
+    expect(queued.queue).toBe('test')
+    expect(ctx.created[0]?.name).toBe(declaration.alias)
+    expect(ctx.created[0]?.opts).toEqual({ delay: 250, attempts: 3, id: 'projection-1' })
+    expect(await queueProtocolOf(ctx as never).waitFor(declaration, queued as never)).toEqual({ doubled: 6 })
+  })
+
+  test('rejects raw aliases and non-queue declarations at runtime', async () => {
+    await expect(queueProtocolOf(context() as never).enqueue(declaration.alias as never, {} as never)).rejects.toThrow()
+    const http = protocol(route('test:http', '/http'), contract())
+    await expect(queueProtocolOf(context() as never).enqueue(http, {})).rejects.toThrow()
+  })
+
+  test('rejects a job from another queue or protocol', async () => {
+    await expect(queueProtocolOf(context() as never).waitFor(declaration, {
+      id: 'x', queue: 'other', name: declaration.alias, data: {},
+    } as never)).rejects.toThrow()
+  })
+})

package/tests/schedule.spec.ts

@@ -0,0 +1,99 @@
+import { describe, test, expect } from 'bun:test'
+import { declareQueue, declareSchedule } from '../src/config.js'
+import { queueConfigOf } from '../src/queue-config.js'
+import { ScheduleMisdeclared, UnknownJobName, UnknownQueue } from '../src/errors.js'
+import type { Config, ScheduleDeclaration } from '../src/types.js'
+
+const cfg = (): Config => declareQueue(
+  declareQueue({ ready: false, service: 'test', type: 'backend' } as unknown as Config,
+    'maintenance', ['reconcile', 'sweep']),
+  'work', ['story:code']
+)
+
+const nightly: ScheduleDeclaration = {
+  id: 'nightly-reconcile', queue: 'maintenance', name: 'reconcile', pattern: '17 3 * * *', tz: 'UTC',
+}
+
+const misdeclared = (schedule: Partial<ScheduleDeclaration>): () => void =>
+  () => queueConfigOf(cfg()).assertSchedule({ ...nightly, ...schedule } as ScheduleDeclaration)
+
+describe('declaring schedules', () => {
+  test('a declaration is recorded and read back by its queue', () => {
+    const config = declareSchedule(cfg(), nightly)
+
+    expect(queueConfigOf(config).schedulesOf('maintenance')).toEqual([nightly])
+    expect(queueConfigOf(config).schedulesOf('work')).toEqual([])
+    expect(queueConfigOf(config).schedulesOf()).toHaveLength(1)
+  })
+
+  test('re-declaring an id replaces rather than appends', () => {
+    let config = declareSchedule(cfg(), nightly)
+    config = declareSchedule(config, { ...nightly, pattern: '0 4 * * *' })
+
+    expect(queueConfigOf(config).schedulesOf()).toHaveLength(1)
+    expect(queueConfigOf(config).schedulesOf()[0].pattern).toBe('0 4 * * *')
+  })
+
+  /**
+   * A scheduled run of a name the queue does not accept would fail on every tick. Refusing at
+   * declaration turns that into one error at boot, and the refused schedule is not recorded.
+   */
+  test('a schedule for an undeclared queue or job name is refused and not recorded', () => {
+    const config = cfg()
+
+    expect(() => declareSchedule(config, { ...nightly, queue: 'missing' })).toThrow(UnknownQueue)
+    expect(() => declareSchedule(config, { ...nightly, name: 'story:code' })).toThrow(UnknownJobName)
+    expect(queueConfigOf(config).schedulesOf()).toHaveLength(0)
+  })
+
+  test('re-declaring the queue keeps its schedules', () => {
+    const config = declareQueue(declareSchedule(cfg(), nightly), 'maintenance', ['reconcile'])
+
+    expect(queueConfigOf(config).queueOf('maintenance').jobs).toEqual(['reconcile'])
+    expect(queueConfigOf(config).schedulesOf()).toEqual([nightly])
+  })
+})
+
+describe('asserting a schedule', () => {
+  test('exactly one of every and pattern', () => {
+    expect(misdeclared({ every: 1_000 })).toThrow(/every-or-pattern/)
+    expect(misdeclared({ pattern: undefined, tz: undefined })).toThrow(/every-or-pattern/)
+    expect(misdeclared({ pattern: undefined, tz: undefined, every: 0 })).toThrow(/:every$/)
+    expect(misdeclared({ pattern: undefined, tz: undefined, every: 1.5 })).toThrow(ScheduleMisdeclared)
+  })
+
+  test('tz and immediately belong to a pattern only', () => {
+    expect(misdeclared({ pattern: undefined, every: 1_000 })).toThrow(/:tz$/)
+    expect(misdeclared({ pattern: undefined, tz: undefined, every: 1_000, immediately: true }))
+      .toThrow(/:immediately$/)
+    expect(misdeclared({ immediately: true, startDate: new Date() })).toThrow(/immediately-start-date/)
+    expect(misdeclared({ immediately: true })).not.toThrow()
+  })
+
+  test('the broker owns a scheduled run\'s id and delay', () => {
+    expect(misdeclared({ opts: { id: 'fixed' } as ScheduleDeclaration['opts'] })).toThrow(/opts-id/)
+    expect(misdeclared({ opts: { delay: 10 } as ScheduleDeclaration['opts'] })).toThrow(/opts-delay/)
+    expect(misdeclared({ opts: { attempts: 3 } })).not.toThrow()
+  })
+
+  test('an empty id is refused', () => {
+    expect(misdeclared({ id: ' ' })).toThrow(ScheduleMisdeclared)
+  })
+})
+
+describe('asserting every schedule', () => {
+  test('two schedules under one id are refused', () => {
+    const config = declareSchedule(cfg(), nightly)
+    config.queue?.schedules?.push({ ...nightly, pattern: '0 5 * * *' })
+
+    expect(() => queueConfigOf(config).assertSchedules()).toThrow(/duplicate/)
+  })
+
+  /** The configuration is plain data; a schedule written into it directly is checked too. */
+  test('a schedule written past declareSchedule is still checked', () => {
+    const config = declareSchedule(cfg(), nightly)
+    config.queue?.schedules?.push({ id: 'orphan', queue: 'maintenance', name: 'gone', every: 1_000 })
+
+    expect(() => queueConfigOf(config).assertSchedules()).toThrow(UnknownJobName)
+  })
+})

package/tsconfig.json

@@ -10,6 +10,7 @@
   "exclude": [
     "./dist/**/*",
     "./build/**/*",
+    "./tests/**/*",
     "./*.ts"
   ]
 }