| import { describe, expect, it } from 'vitest'; |
|
|
| import { OrderedHookSlot, createHooks } from '#/hooks'; |
|
|
| describe('OrderedHookSlot', () => { |
| it('runs the terminal when no handlers are registered', async () => { |
| const slot = new OrderedHookSlot<{ value: number }>(); |
| let terminalRan = false; |
| await slot.run({ value: 0 }, async () => { |
| terminalRan = true; |
| }); |
| expect(terminalRan).toBe(true); |
| }); |
|
|
| it('runs handlers in registration order and threads context', async () => { |
| const slot = new OrderedHookSlot<{ value: number }>(); |
| const order: string[] = []; |
| slot.register('a', async (ctx, next) => { |
| order.push('a'); |
| ctx.value += 1; |
| await next(); |
| }); |
| slot.register('b', async (ctx, next) => { |
| order.push('b'); |
| ctx.value += 10; |
| await next(); |
| }); |
| const ctx = { value: 0 }; |
| await slot.run(ctx); |
| expect(order).toEqual(['a', 'b']); |
| expect(ctx.value).toBe(11); |
| }); |
|
|
| it('removes a handler with delete()', async () => { |
| const slot = new OrderedHookSlot<Record<string, never>>(); |
| const order: string[] = []; |
| slot.register('a', async (_ctx, next) => { |
| order.push('a'); |
| await next(); |
| }); |
| slot.register('b', async (_ctx, next) => { |
| order.push('b'); |
| await next(); |
| }); |
| expect(slot.delete('a')).toBe(true); |
| await slot.run({}); |
| expect(order).toEqual(['b']); |
| }); |
|
|
| it('honors before / after ordering', async () => { |
| const slot = new OrderedHookSlot<Record<string, never>>(); |
| const order: string[] = []; |
| const mk = |
| (id: string) => |
| async (_ctx: Record<string, never>, next: () => Promise<void>) => { |
| order.push(id); |
| await next(); |
| }; |
| slot.register('a', mk('a')); |
| slot.register('c', mk('c')); |
| slot.register('b', mk('b'), { before: 'c' }); |
| await slot.run({}); |
| expect(order).toEqual(['a', 'b', 'c']); |
| }); |
|
|
| it('re-runs the remaining chain when next() is called more than once', async () => { |
| const slot = new OrderedHookSlot<Record<string, never>>(); |
| let terminalRuns = 0; |
| slot.register('a', async (_ctx, next) => { |
| await next(); |
| await next(); |
| }); |
| await slot.run({}, async () => { |
| terminalRuns += 1; |
| }); |
| expect(terminalRuns).toBe(2); |
| }); |
|
|
| it('skips downstream handlers and the terminal when next() is not called', async () => { |
| const slot = new OrderedHookSlot<{ value: number }>(); |
| const order: string[] = []; |
| slot.register('veto', () => { |
| order.push('veto'); |
| }); |
| slot.register('downstream', async (_ctx, next) => { |
| order.push('downstream'); |
| await next(); |
| }); |
| let terminalRan = false; |
| await slot.run({ value: 0 }, async () => { |
| terminalRan = true; |
| }); |
| expect(order).toEqual(['veto']); |
| expect(terminalRan).toBe(false); |
| }); |
|
|
| it('re-runs the remaining chain and terminal on each next() call', async () => { |
| const slot = new OrderedHookSlot<{ attempt: number; result?: string }>(); |
| const attempts: number[] = []; |
| slot.register('retry', async (ctx, next) => { |
| ctx.attempt = 1; |
| await next(); |
| if (ctx.result === 'fail') { |
| ctx.attempt = 2; |
| await next(); |
| } |
| }); |
| slot.register('downstream', async (ctx, next) => { |
| attempts.push(ctx.attempt); |
| await next(); |
| }); |
| const ctx: { attempt: number; result?: string } = { attempt: 0 }; |
| await slot.run(ctx, async (current) => { |
| current.result = current.attempt === 1 ? 'fail' : 'ok'; |
| }); |
| expect(attempts).toEqual([1, 2]); |
| expect(ctx.result).toBe('ok'); |
| }); |
|
|
| it('resumes the remaining chain and terminal with a forked context', async () => { |
| interface Ctx { |
| readonly id: number; |
| value: number; |
| result?: number; |
| } |
| const slot = new OrderedHookSlot<Ctx>(); |
| const seen: number[] = []; |
| slot.register('fork', async (ctx, next) => { |
| const fork: Ctx = { ...ctx, value: 100 }; |
| await next(fork); |
| ctx.result = fork.result; |
| }); |
| slot.register('downstream', async (ctx, next) => { |
| seen.push(ctx.value); |
| await next(); |
| }); |
| const original: Ctx = { id: 1, value: 0 }; |
| await slot.run(original, async (current) => { |
| current.result = current.value + 1; |
| }); |
| expect(seen).toEqual([100]); |
| expect(original.value).toBe(0); |
| expect(original.result).toBe(101); |
| }); |
|
|
| it('propagates a fork through nested next() calls without arguments', async () => { |
| interface Ctx { |
| value: number; |
| } |
| const slot = new OrderedHookSlot<Ctx>(); |
| slot.register('fork', async (ctx, next) => { |
| await next({ ...ctx, value: 42 }); |
| }); |
| slot.register('middle', async (_ctx, next) => { |
| await next(); |
| }); |
| let terminalValue: number | undefined; |
| await slot.run({ value: 0 }, async (current) => { |
| terminalValue = current.value; |
| }); |
| expect(terminalValue).toBe(42); |
| }); |
|
|
| it('runs forked branches concurrently', async () => { |
| interface Ctx { |
| input: number; |
| output?: number; |
| } |
| const slot = new OrderedHookSlot<Ctx>(); |
| slot.register('race', async (ctx, next) => { |
| const forks: Ctx[] = [ |
| { ...ctx, input: 1 }, |
| { ...ctx, input: 2 }, |
| ]; |
| await Promise.all(forks.map((fork) => next(fork))); |
| ctx.output = Math.max(...forks.map((fork) => fork.output ?? 0)); |
| }); |
| const ctx: Ctx = { input: 0 }; |
| await slot.run(ctx, async (current) => { |
| current.output = current.input * 10; |
| }); |
| expect(ctx.output).toBe(20); |
| }); |
| }); |
|
|
| describe('createHooks', () => { |
| it('creates one slot per event key', () => { |
| type HookEvents = { start: { x: number }; stop: { y: number } }; |
| const hooks = createHooks<HookEvents, keyof HookEvents>(['start', 'stop']); |
| expect(hooks.start).toBeInstanceOf(OrderedHookSlot); |
| expect(hooks.stop).toBeInstanceOf(OrderedHookSlot); |
| }); |
| }); |
|
|
