@owlmeans/queue 0.1.18-rc.2 → 0.1.18-rc.20

package/tests/config.spec.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect } from 'bun:test'
+import { declareQueue, isListening, listenQueues, queueOf, queueOfJob } from '../src/config.js'
+import { UnknownQueue } from '../src/errors.js'
+import type { Config } from '../src/types.js'
+
+const cfg = (): Config => ({ ready: false, service: 'test', type: 'backend' } as unknown as Config)
+
+describe('declaring queues', () => {
+  test('a declaration records the queue and the jobs it accepts', () => {
+    const config = declareQueue(cfg(), 'work', ['story:code', 'story:gate'])
+
+    expect(queueOf(config, 'work').jobs).toEqual(['story:code', 'story:gate'])
+  })
+
+  /**
+   * Declaring runs from a helper that an application may call once per app it composes, so the
+   * second call must not leave two entries under one name — a duplicate would make `queueOf`
+   * answer with whichever happened to be first.
+   */
+  test('re-declaring the same name replaces rather than appends', () => {
+    let config = declareQueue(cfg(), 'work', ['story:code'])
+    config = declareQueue(config, 'work', ['story:code', 'story:gate'])
+
+    expect(config.queue?.queues).toHaveLength(1)
+    expect(queueOf(config, 'work').jobs).toHaveLength(2)
+  })
+
+  test('asking for a queue nobody declared is an error, not undefined', () => {
+    expect(() => queueOf(cfg(), 'missing')).toThrow(UnknownQueue)
+  })
+
+  test('a job name resolves back to the queue that accepts it', () => {
+    const config = declareQueue(declareQueue(cfg(), 'work', ['story:code']), 'ops', ['files:get'])
+
+    expect(queueOfJob(config, 'files:get')?.name).toBe('ops')
+    expect(queueOfJob(config, 'nothing:declared')).toBeUndefined()
+  })
+})
+
+describe('listening', () => {
+  /**
+   * Declaring a queue must NOT make this process consume it — that separation is what lets one
+   * binary deploy as a producer in one place and a worker in another.
+   */
+  test('declaring a queue does not make the process listen to it', () => {
+    const config = declareQueue(cfg(), 'work', ['story:code'])
+
+    expect(isListening(config, 'work')).toBe(false)
+    expect(config.queue?.listen ?? []).toHaveLength(0)
+  })
+
+  test('listening is additive and free of duplicates', () => {
+    let config = listenQueues(cfg(), 'work')
+    config = listenQueues(config, 'work', 'ops')
+
+    expect(config.queue?.listen).toEqual(['work', 'ops'])
+    expect(isListening(config, 'ops')).toBe(true)
+  })
+
+  test('listening and declaring do not overwrite each other', () => {
+    const config = declareQueue(listenQueues(cfg(), 'work'), 'work', ['story:code'])
+
+    expect(isListening(config, 'work')).toBe(true)
+    expect(queueOf(config, 'work').jobs).toEqual(['story:code'])
+  })
+})

package/tests/protocol.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+import { contract, protocol, schema } from '@owlmeans/entrypoint'
+import { job, route } from '@owlmeans/route'
+import type { JSONSchemaType } from 'ajv'
+import { enqueueProtocol, waitForProtocol, 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 enqueueProtocol(ctx as never, 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 waitForProtocol(ctx as never, declaration, queued as never)).toEqual({ doubled: 6 })
+  })
+
+  test('rejects raw aliases and non-queue declarations at runtime', async () => {
+    await expect(enqueueProtocol(context() as never, declaration.alias as never, {} as never)).rejects.toThrow()
+    const http = protocol(route('test:http', '/http'), contract())
+    await expect(enqueueProtocol(context() as never, http, {})).rejects.toThrow()
+  })
+
+  test('rejects a job from another queue or protocol', async () => {
+    await expect(waitForProtocol(context() as never, declaration, {
+      id: 'x', queue: 'other', name: declaration.alias, data: {},
+    } as never)).rejects.toThrow()
+  })
+})

package/tsconfig.json

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