@camstack/server 0.2.2 → 1.0.1

package/src/__tests__/live-events-subscription.spec.ts

@@ -1,149 +0,0 @@
-/**
- * Live events subscription — unit + in-process e2e test.
- *
- * Proves that an event emitted on `EventBusService` is delivered to a
- * consumer that went through `live.onEvent` → `iterableSubscription`.
- * This is the same path UI components use via the WS client (AlertBell,
- * EngineTab). If this test passes but the UI still doesn't receive
- * events, the bug is downstream in the WS adapter, not in the routing.
- */
-import { describe, it, expect, vi } from 'vitest'
-import { SystemEventBus } from '@camstack/core'
-import { createLiveEventsRouter } from '../api/core/live-events.router.js'
-import { makeCtx } from './cap-routers/harness.js'
-import type { EventBusService } from '../core/events/event-bus.service.js'
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function makeEvent(category: string, data: Record<string, unknown> = {}) {
-  return {
-    id: `evt-${Math.random().toString(36).slice(2, 8)}`,
-    timestamp: new Date(),
-    source: { type: 'pipeline' as const, id: 'benchmark' },
-    category,
-    data: { type: `pipeline.${category}`, ...data },
-  }
-}
-
-describe('live events subscription', () => {
-  it('delivers events emitted AFTER subscription', async () => {
-    const bus = new SystemEventBus() as unknown as EventBusService
-    const router = createLiveEventsRouter(bus, {
-      getDeviceRegistry: () => ({ getAll: () => [], getAllForAddon: () => [] }),
-    } as never)
-    const caller = router.createCaller(makeCtx('admin'))
-
-    const iter = await caller.onEvent({ category: 'benchmark.progress' })
-
-    // Collect received events concurrently while emitting.
-    const received: Array<{ category: string; data: Record<string, unknown> }> = []
-    const collector = (async () => {
-      for await (const ev of iter) {
-        received.push({ category: ev.category, data: ev.data })
-        if (received.length >= 3) return
-      }
-    })()
-
-    // Give the async generator a tick to wire up its internal promise.
-    await sleep(10)
-
-    bus.emit(makeEvent('benchmark.progress', { iteration: 1, totalMs: 50 }))
-    bus.emit(makeEvent('benchmark.progress', { iteration: 2, totalMs: 48 }))
-    bus.emit(makeEvent('other.category', { ignored: true }))
-    bus.emit(makeEvent('benchmark.progress', { iteration: 3, totalMs: 52 }))
-
-    await collector
-
-    expect(received).toHaveLength(3)
-    expect(received.map((r) => r.data.iteration)).toEqual([1, 2, 3])
-  })
-
-  it('filters events that do not match the requested category', async () => {
-    const bus = new SystemEventBus() as unknown as EventBusService
-    const router = createLiveEventsRouter(bus, {
-      getDeviceRegistry: () => ({ getAll: () => [], getAllForAddon: () => [] }),
-    } as never)
-    const caller = router.createCaller(makeCtx('admin'))
-
-    const iter = await caller.onEvent({ category: 'benchmark.progress' })
-
-    const received: string[] = []
-    const stop = vi.fn()
-    const collector = (async () => {
-      for await (const ev of iter) {
-        received.push(ev.category)
-        if (received.length >= 2) {
-          stop()
-          return
-        }
-      }
-    })()
-
-    await sleep(10)
-
-    // Emit a mix — only 'benchmark.progress' should pass.
-    bus.emit(makeEvent('alert.created', {}))
-    bus.emit(makeEvent('benchmark.progress', { iteration: 1 }))
-    bus.emit(makeEvent('benchmark.heartbeat', {}))
-    bus.emit(makeEvent('alert.updated', {}))
-    bus.emit(makeEvent('benchmark.progress', { iteration: 2 }))
-
-    await collector
-
-    expect(received).toEqual(['benchmark.progress', 'benchmark.progress'])
-    expect(stop).toHaveBeenCalledOnce()
-  })
-
-  it('receives recent events via recentSystemEvents query', async () => {
-    const bus = new SystemEventBus() as unknown as EventBusService
-    const router = createLiveEventsRouter(bus, {
-      getDeviceRegistry: () => ({ getAll: () => [], getAllForAddon: () => [] }),
-    } as never)
-    const caller = router.createCaller(makeCtx('admin'))
-
-    bus.emit(makeEvent('benchmark.progress', { iteration: 1 }))
-    bus.emit(makeEvent('alert.created', {}))
-    bus.emit(makeEvent('benchmark.progress', { iteration: 2 }))
-
-    const recent = await caller.recentSystemEvents({ category: 'benchmark.progress', limit: 10 })
-    expect(recent).toHaveLength(2)
-    // recentSystemEvents returns newest-first
-    const iterations = recent.map((e) => e.data.iteration as number).toSorted((a, b) => a - b)
-    expect(iterations).toEqual([1, 2])
-  })
-
-  it('delivers bursts — multiple events queued before the consumer drains', async () => {
-    // Reproduces the benchmark scenario where runBenchmark emits 3 events
-    // back-to-back; the subscription should buffer them and deliver all 3.
-    const bus = new SystemEventBus() as unknown as EventBusService
-    const router = createLiveEventsRouter(bus, {
-      getDeviceRegistry: () => ({ getAll: () => [], getAllForAddon: () => [] }),
-    } as never)
-    const caller = router.createCaller(makeCtx('admin'))
-
-    const iter = await caller.onEvent({ category: 'benchmark.progress' })
-
-    const received: number[] = []
-    const collector = (async () => {
-      for await (const ev of iter) {
-        received.push(ev.data.iteration as number)
-        if (received.length >= 5) return
-      }
-    })()
-
-    // Let the generator body run through its first `await`, registering the
-    // bus subscription. Without this tick subscribe() hasn't attached yet.
-    await sleep(20)
-
-    // Emit 5 events synchronously — no awaits between.
-    for (let i = 1; i <= 5; i++) {
-      bus.emit(makeEvent('benchmark.progress', { iteration: i }))
-    }
-
-    await collector
-
-    expect(received).toEqual([1, 2, 3, 4, 5])
-  })
-})

package/src/__tests__/moleculer/uds-readiness.spec.ts

@@ -1,150 +0,0 @@
-/**
- * UDS readiness snapshot wiring — unit test for Task D1.
- *
- * Verifies that:
- *  1. The hub's `LocalChildRegistry.onReadinessSnapshotRequest` is wired to
- *     return `readinessRegistry.getSnapshotForTransport()` — the same records
- *     `$readiness.getSnapshot` returns, now also reachable over UDS.
- *  2. The agent's `agentUdsRegistry.onReadinessSnapshotRequest` is wired to
- *     return its own registry's snapshot.
- *
- * We do NOT spin up a full broker — instead we test the wiring function
- * `wireReadinessSnapshotHandler` which is extracted from the hub/agent setup
- * so the glue code is unit-testable.
- */
-import { describe, it, expect, vi } from 'vitest'
-import type { IReadinessRegistryRecord } from '@camstack/types'
-
-// --------------------------------------------------------------------------
-// Helpers
-// --------------------------------------------------------------------------
-
-interface FakeReadinessRegistry {
-  getSnapshotForTransport(): readonly IReadinessRegistryRecord[]
-}
-
-interface FakeLocalChildRegistry {
-  onReadinessSnapshotRequest(handler: () => readonly IReadinessRegistryRecord[]): void
-}
-
-/**
- * Minimal wiring function — production code calls exactly this at the same
- * site in moleculer.service.ts and agent-bootstrap.ts.
- */
-function wireReadinessSnapshotHandler(
-  childRegistry: FakeLocalChildRegistry,
-  readinessRegistry: FakeReadinessRegistry,
-): void {
-  childRegistry.onReadinessSnapshotRequest(() => readinessRegistry.getSnapshotForTransport())
-}
-
-// --------------------------------------------------------------------------
-// Tests
-// --------------------------------------------------------------------------
-
-describe('D1 — wireReadinessSnapshotHandler', () => {
-  it('registers a handler on the child registry', () => {
-    const childReg: FakeLocalChildRegistry = {
-      onReadinessSnapshotRequest: vi.fn(),
-    }
-    const readinessReg: FakeReadinessRegistry = {
-      getSnapshotForTransport: () => [],
-    }
-
-    wireReadinessSnapshotHandler(childReg, readinessReg)
-
-    expect(childReg.onReadinessSnapshotRequest).toHaveBeenCalledOnce()
-  })
-
-  it('the registered handler returns getSnapshotForTransport() records', () => {
-    const records: IReadinessRegistryRecord[] = [
-      {
-        capName: 'pipeline-executor',
-        scope: { type: 'global' },
-        state: 'ready',
-        generation: 'gen-abc',
-        epoch: 1,
-        lastChange: 1_000_000,
-        sourceNodeId: 'hub/pipeline-executor',
-      },
-    ]
-
-    let capturedHandler: (() => readonly IReadinessRegistryRecord[]) | null = null
-    const childReg: FakeLocalChildRegistry = {
-      onReadinessSnapshotRequest: (h) => {
-        capturedHandler = h
-      },
-    }
-    const readinessReg: FakeReadinessRegistry = {
-      getSnapshotForTransport: () => records,
-    }
-
-    wireReadinessSnapshotHandler(childReg, readinessReg)
-
-    expect(capturedHandler).not.toBeNull()
-    const result = capturedHandler!()
-    expect(result).toBe(records)
-  })
-
-  it('handler calls getSnapshotForTransport on every invocation (live snapshot)', () => {
-    const getSnapshot = vi
-      .fn<[], readonly IReadinessRegistryRecord[]>()
-      .mockReturnValueOnce([])
-      .mockReturnValueOnce([
-        {
-          capName: 'stream-broker',
-          scope: { type: 'node', nodeId: 'hub' },
-          state: 'ready',
-          generation: 'gen-1',
-          epoch: 1,
-          lastChange: 1_000,
-          sourceNodeId: 'hub',
-        },
-      ])
-
-    let capturedHandler: (() => readonly IReadinessRegistryRecord[]) | null = null
-    const childReg: FakeLocalChildRegistry = {
-      onReadinessSnapshotRequest: (h) => {
-        capturedHandler = h
-      },
-    }
-    const readinessReg: FakeReadinessRegistry = { getSnapshotForTransport: getSnapshot }
-
-    wireReadinessSnapshotHandler(childReg, readinessReg)
-
-    expect(capturedHandler!()).toHaveLength(0)
-    expect(capturedHandler!()).toHaveLength(1)
-    expect(getSnapshot).toHaveBeenCalledTimes(2)
-  })
-
-  it('handler snapshot reflects current registry state (not a frozen copy)', () => {
-    const mutableRecords: IReadinessRegistryRecord[] = []
-    const readinessReg: FakeReadinessRegistry = {
-      getSnapshotForTransport: () => [...mutableRecords],
-    }
-
-    let capturedHandler: (() => readonly IReadinessRegistryRecord[]) | null = null
-    const childReg: FakeLocalChildRegistry = {
-      onReadinessSnapshotRequest: (h) => {
-        capturedHandler = h
-      },
-    }
-
-    wireReadinessSnapshotHandler(childReg, readinessReg)
-
-    expect(capturedHandler!()).toHaveLength(0)
-
-    mutableRecords.push({
-      capName: 'motion-detector',
-      scope: { type: 'device', deviceId: 7 },
-      state: 'starting',
-      generation: 'gen-2',
-      epoch: 0,
-      lastChange: 2_000,
-      sourceNodeId: 'hub/provider-reolink',
-    })
-
-    expect(capturedHandler!()).toHaveLength(1)
-    expect(capturedHandler!()[0]!.capName).toBe('motion-detector')
-  })
-})