@camstack/server 0.2.2 → 1.0.1

package/src/__tests__/uds-log-ingest.spec.ts

@@ -1,183 +0,0 @@
-/**
- * UDS child log ingest — unit test for Task B2.
- *
- * Verifies that wiring `LocalChildRegistry.onChildLog` to
- * `LoggingService.writeFromWorker` correctly maps a `ChildLogMessage`
- * produced over a UDS channel to the `writeFromWorker` entry shape.
- *
- * We test the helper `udsChildLogToWorkerEntry` (extracted from the
- * hub/agent wiring) directly, plus the full registry+handler pairing so
- * the glue code exercises the real `onChildLog` callback path.
- */
-import { describe, it, expect, vi } from 'vitest'
-import type { ChildLogMessage } from '@camstack/kernel'
-import { udsChildLogToWorkerEntry } from '@camstack/kernel'
-
-// --------------------------------------------------------------------------
-// Minimal `WriteFromWorkerEntry` shape mirrored from LoggingService signature
-// --------------------------------------------------------------------------
-interface WriteFromWorkerEntry {
-  addonId: string
-  nodeId?: string
-  level: string
-  message: string
-  scope?: string
-  tags?: Record<string, string | number | undefined>
-  meta?: Record<string, unknown>
-}
-
-// --------------------------------------------------------------------------
-// Helper: build a minimal ChildLogMessage
-// --------------------------------------------------------------------------
-function makeLogMessage(overrides?: Partial<ChildLogMessage>): ChildLogMessage {
-  return {
-    kind: 'log',
-    level: 'info',
-    message: 'hello from child',
-    addonId: 'stream-broker',
-    ...overrides,
-  }
-}
-
-// --------------------------------------------------------------------------
-// Tests for udsChildLogToWorkerEntry
-// --------------------------------------------------------------------------
-
-describe('udsChildLogToWorkerEntry', () => {
-  it('maps the required fields — addonId, level, message', () => {
-    const entry = makeLogMessage()
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.addonId).toBe('stream-broker')
-    expect(result.level).toBe('info')
-    expect(result.message).toBe('hello from child')
-  })
-
-  it('uses entry.nodeId when present', () => {
-    const entry = makeLogMessage({ nodeId: 'hub/stream-broker' })
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.nodeId).toBe('hub/stream-broker')
-  })
-
-  it('falls back to childId when nodeId is absent', () => {
-    const entry = makeLogMessage()
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.nodeId).toBe('stream-broker')
-  })
-
-  it('omits scope when not present in entry', () => {
-    const entry = makeLogMessage()
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(Object.prototype.hasOwnProperty.call(result, 'scope')).toBe(false)
-  })
-
-  it('includes scope when present in entry', () => {
-    const entry = makeLogMessage({ scope: 'rtsp' })
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.scope).toBe('rtsp')
-  })
-
-  it('omits tags when not present in entry', () => {
-    const entry = makeLogMessage()
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(Object.prototype.hasOwnProperty.call(result, 'tags')).toBe(false)
-  })
-
-  it('includes tags when present in entry', () => {
-    const entry = makeLogMessage({ tags: { deviceId: 5, streamId: '5/main' } })
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.tags).toEqual({ deviceId: 5, streamId: '5/main' })
-  })
-
-  it('omits meta when not present in entry', () => {
-    const entry = makeLogMessage()
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(Object.prototype.hasOwnProperty.call(result, 'meta')).toBe(false)
-  })
-
-  it('includes meta when present in entry', () => {
-    const entry = makeLogMessage({ meta: { rtt: 42 } })
-    const result = udsChildLogToWorkerEntry('stream-broker', entry)
-
-    expect(result.meta).toEqual({ rtt: 42 })
-  })
-
-  it('produces the same shape that $hub.log onLog produces', () => {
-    // The existing onLog wiring in moleculer.service.ts maps:
-    //   { addonId, nodeId, level, message, scope?, tags?, meta? }
-    // Verify we produce an identical structure for a fully-populated entry.
-    const entry = makeLogMessage({
-      addonId: 'ptz-provider',
-      nodeId: 'hub/ptz-provider',
-      level: 'warn',
-      message: 'PTZ timeout',
-      scope: 'ptz',
-      tags: { deviceId: 3 },
-      meta: { timeout: 5000 },
-    })
-    const result = udsChildLogToWorkerEntry('hub/ptz-provider', entry)
-
-    const expected: WriteFromWorkerEntry = {
-      addonId: 'ptz-provider',
-      nodeId: 'hub/ptz-provider',
-      level: 'warn',
-      message: 'PTZ timeout',
-      scope: 'ptz',
-      tags: { deviceId: 3 },
-      meta: { timeout: 5000 },
-    }
-    expect(result).toEqual(expected)
-  })
-})
-
-// --------------------------------------------------------------------------
-// Tests for the registry+handler wiring (the onChildLog callback path)
-// --------------------------------------------------------------------------
-
-describe('onChildLog handler wiring', () => {
-  it('calls writeFromWorker when a ChildLogMessage arrives', () => {
-    // Fake logging service — typed minimal interface
-    const fakeLogging = {
-      writeFromWorker: vi.fn<[WriteFromWorkerEntry], void>(),
-    }
-
-    // The actual wiring closure (mirrors hub & agent wiring)
-    const handler = (childId: string, entry: ChildLogMessage): void => {
-      fakeLogging.writeFromWorker(udsChildLogToWorkerEntry(childId, entry))
-    }
-
-    const entry = makeLogMessage({ addonId: 'motion-detector', nodeId: 'hub/motion-detector' })
-    handler('hub/motion-detector', entry)
-
-    expect(fakeLogging.writeFromWorker).toHaveBeenCalledOnce()
-    const called = fakeLogging.writeFromWorker.mock.calls[0]![0]
-    expect(called.addonId).toBe('motion-detector')
-    expect(called.nodeId).toBe('hub/motion-detector')
-    expect(called.level).toBe('info')
-    expect(called.message).toBe('hello from child')
-  })
-
-  it('invokes writeFromWorker once per log entry', () => {
-    const fakeLogging = {
-      writeFromWorker: vi.fn<[WriteFromWorkerEntry], void>(),
-    }
-
-    const handler = (childId: string, entry: ChildLogMessage): void => {
-      fakeLogging.writeFromWorker(udsChildLogToWorkerEntry(childId, entry))
-    }
-
-    handler('child-a', makeLogMessage({ addonId: 'child-a', level: 'debug', message: 'first' }))
-    handler('child-b', makeLogMessage({ addonId: 'child-b', level: 'error', message: 'second' }))
-
-    expect(fakeLogging.writeFromWorker).toHaveBeenCalledTimes(2)
-    expect(fakeLogging.writeFromWorker.mock.calls[0]![0].addonId).toBe('child-a')
-    expect(fakeLogging.writeFromWorker.mock.calls[1]![0].addonId).toBe('child-b')
-  })
-})

package/src/api/__tests__/addons-custom.spec.ts

@@ -1,148 +0,0 @@
-/**
- * Tests for `api.addons.custom` — the generic addon custom-action dispatcher
- * built in Task 7.2 of the device-proxy redesign.
- *
- * Verifies:
- *   - dispatch to a registered action returns the addon's value
- *   - input is round-tripped through the action's Zod schema
- *   - unknown (addonId, action) → NOT_FOUND
- *   - unauthenticated caller → UNAUTHORIZED
- *   - per-action `auth: 'admin'` is enforced (viewer rejected, admin allowed)
- *   - per-action `auth: 'public'` allows anonymous callers
- *   - addon output that violates its own schema → BAD_REQUEST (Zod parse)
- */
-import { describe, it, expect, beforeEach } from 'vitest'
-import { z } from 'zod'
-import { TRPCError } from '@trpc/server'
-import { customAction, defineCustomActions } from '@camstack/types'
-import { CustomActionRegistry } from '@camstack/kernel'
-import { trpcRouter } from '../trpc/trpc.middleware.js'
-import { createAddonsCustomProcedures } from '../addons-custom.router.js'
-import { makeCtx } from '../../__tests__/cap-routers/harness.js'
-
-const catalog = defineCustomActions({
-  ping: customAction(z.void(), z.literal('pong')),
-  echo: customAction(z.object({ msg: z.string() }), z.object({ msg: z.string() })),
-  adminOnly: customAction(z.void(), z.literal('ok'), { kind: 'mutation', auth: 'admin' }),
-  open: customAction(z.void(), z.literal('open'), { auth: 'public' }),
-  badOutput: customAction(z.void(), z.literal('expected')),
-})
-
-function buildRouter(registry: CustomActionRegistry) {
-  return trpcRouter({
-    ...createAddonsCustomProcedures({ getCustomActionRegistry: () => registry }),
-  })
-}
-
-describe('api.addons.custom', () => {
-  let registry: CustomActionRegistry
-  let router: ReturnType<typeof buildRouter>
-
-  beforeEach(() => {
-    registry = new CustomActionRegistry()
-    registry.registerAddon('benchmark', catalog, async (action, input) => {
-      switch (action) {
-        case 'ping':
-          return 'pong'
-        case 'echo':
-          return { msg: (input as { msg: string }).msg }
-        case 'adminOnly':
-          return 'ok'
-        case 'open':
-          return 'open'
-        case 'badOutput':
-          return 'WRONG' // will fail output validation
-        default:
-          throw new Error(`unknown action ${action}`)
-      }
-    })
-    router = buildRouter(registry)
-  })
-
-  it('dispatches a void/literal action and returns the addon value', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    const result = await caller.custom({ addonId: 'benchmark', action: 'ping', input: undefined })
-    expect(result).toBe('pong')
-  })
-
-  it('round-trips structured input through the action schema', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    const result = await caller.custom({
-      addonId: 'benchmark',
-      action: 'echo',
-      input: { msg: 'hi' },
-    })
-    expect(result).toEqual({ msg: 'hi' })
-  })
-
-  it('rejects unknown (addonId, action) with NOT_FOUND', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'missing', input: {} }),
-    ).rejects.toMatchObject({ code: 'NOT_FOUND' })
-
-    await expect(
-      caller.custom({ addonId: 'unknown-addon', action: 'ping', input: undefined }),
-    ).rejects.toMatchObject({ code: 'NOT_FOUND' })
-  })
-
-  it('rejects unauthenticated callers with UNAUTHORIZED', async () => {
-    const caller = router.createCaller(makeCtx('anonymous'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'ping', input: undefined }),
-    ).rejects.toMatchObject({ code: 'UNAUTHORIZED' })
-  })
-
-  it('enforces per-action auth: admin-only action rejects viewer', async () => {
-    const caller = router.createCaller(makeCtx('viewer'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'adminOnly', input: undefined }),
-    ).rejects.toMatchObject({ code: 'FORBIDDEN' })
-  })
-
-  it('enforces per-action auth: admin-only action allows admin', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    const result = await caller.custom({
-      addonId: 'benchmark',
-      action: 'adminOnly',
-      input: undefined,
-    })
-    expect(result).toBe('ok')
-  })
-
-  it('rejects bad input against the action schema', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'echo', input: { msg: 123 } }),
-    ).rejects.toBeInstanceOf(Error)
-  })
-
-  it('rejects bad addon output against the action schema (crash-early)', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'badOutput', input: undefined }),
-    ).rejects.toBeInstanceOf(Error)
-  })
-
-  // The outer `protectedProcedure` runs before the per-action auth check, so
-  // even a `public` action requires authentication today. This documents the
-  // intentional behavior: addons cannot expose anonymous endpoints through
-  // the generic dispatcher.
-  it('the outer protectedProcedure short-circuits even for public-auth actions', async () => {
-    const caller = router.createCaller(makeCtx('anonymous'))
-    await expect(
-      caller.custom({ addonId: 'benchmark', action: 'open', input: undefined }),
-    ).rejects.toMatchObject({ code: 'UNAUTHORIZED' })
-  })
-
-  it('TRPCError carries a descriptive message for unknown actions', async () => {
-    const caller = router.createCaller(makeCtx('admin'))
-    try {
-      await caller.custom({ addonId: 'benchmark', action: 'missing', input: {} })
-      expect.fail('should have thrown')
-    } catch (err) {
-      expect(err).toBeInstanceOf(TRPCError)
-      expect((err as TRPCError).message).toMatch(/no custom action 'missing'/)
-    }
-  })
-})

package/src/api/__tests__/capabilities.router.test.ts

@@ -1,56 +0,0 @@
-// server/backend/src/api/__tests__/capabilities.router.test.ts
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { CapabilityRegistry } from '@camstack/kernel'
-import type { IScopedLogger } from '@camstack/types'
-
-function createMockLogger(): IScopedLogger {
-  return {
-    error: vi.fn(),
-    warn: vi.fn(),
-    info: vi.fn(),
-    debug: vi.fn(),
-    child: vi.fn().mockReturnThis(),
-  }
-}
-
-describe('capabilities tRPC router logic', () => {
-  let registry: CapabilityRegistry
-
-  beforeEach(() => {
-    registry = new CapabilityRegistry(createMockLogger())
-    registry.ready()
-  })
-
-  it('listCapabilities returns all declared capabilities', () => {
-    registry.declareCapability({ name: 'storage', scope: 'system', mode: 'singleton', methods: {} })
-    registry.declareCapability({
-      name: 'log-destination',
-      scope: 'system',
-      mode: 'collection',
-      methods: {},
-    })
-
-    const list = registry.listCapabilities()
-    expect(list).toHaveLength(2)
-    expect(list.map((c) => c.name)).toContain('storage')
-    expect(list.map((c) => c.name)).toContain('log-destination')
-  })
-
-  it('setActiveSingleton throws for unknown capability', async () => {
-    await expect(registry.setActiveSingleton('nonexistent', 'some-addon', true)).rejects.toThrow(
-      /[Uu]nknown/,
-    )
-  })
-
-  it('setActiveSingleton throws for collection capability', async () => {
-    registry.declareCapability({
-      name: 'log-destination',
-      scope: 'system',
-      mode: 'collection',
-      methods: {},
-    })
-    await expect(registry.setActiveSingleton('log-destination', 'winston', true)).rejects.toThrow(
-      /singleton/,
-    )
-  })
-})