@camstack/server 1.0.0 → 1.0.1

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

@@ -1,418 +0,0 @@
-/**
- * UDS topology wiring — unit tests for Tasks E1 + E2.
- *
- * E1: When `LocalChildRegistry.onChildRegistered` fires for a hub-local child,
- *     the hub applies the child's caps to the `CapabilityRegistry` (same effect
- *     as the `$hub.registerNode` RPC for a `hub/<runner>` node). When
- *     `onChildGone` fires, the caps are unregistered + synthetic readiness-down
- *     is emitted.
- *
- *     Idempotency: registering the same child twice (RPC + UDS) does NOT
- *     duplicate providers or double-emit readiness-down. The diff guard lives in
- *     `applyNodeManifest` (previous vs desired); `onChildRegistered` fires once
- *     per UDS connect and calls `onRegisterNode` unconditionally — the second
- *     call (from the Moleculer RPC path) becomes a no-op at the registry level
- *     because `applyNodeManifest` detects no cap delta.
- *
- *     Agent nodes (bare nodeId, no '/') still go through the Moleculer RPC
- *     path — they are NOT touched by the UDS lifecycle.
- *
- * E2: `LocalChildRegistry.setChildLogLevel(childId, level)` sends a
- *     `set-log-level` message to the named child and returns `true`. Returns
- *     `false` (no-op) for an unknown childId so callers can fall back to the
- *     Moleculer `$node-mgmt.setLogLevel` path when the UDS child is not
- *     connected.
- *
- * We do NOT spin up a real broker or UDS server — instead we test the REAL
- * exported helpers (`buildChildUdsManifest`, `LocalChildRegistry`) directly so
- * the tests exercise actual production code rather than reimplementations.
- *
- * Integration note: the `onChildRegistered`/`onChildGone` closures are inlined
- * in `MoleculerService.onModuleInit` (capturing `this.localChildRegistry` and
- * `this.logger`). Extracting them would require threading several private
- * dependencies as parameters — invasive for modest gain here. The closures are
- * verified at the integration level (real hub boot) while this file unit-tests
- * the helpers the closures delegate to.
- */
-import { describe, it, expect, vi } from 'vitest'
-import type { ChildCapDescriptor, RegisteredChild } from '@camstack/kernel'
-import { LocalChildRegistry, createLocalTransport } from '@camstack/kernel'
-import { buildChildUdsManifest } from '../../core/moleculer/moleculer.service.js'
-
-// ---------------------------------------------------------------------------
-// Fake types that mirror the production interfaces used in the wiring
-// ---------------------------------------------------------------------------
-
-interface FakeLocalChildRegistry {
-  onChildRegistered(handler: (child: RegisteredChild) => void): void
-  onChildGone(handler: (childId: string) => void): void
-  setChildLogLevel(childId: string, level: string): boolean
-}
-
-// ---------------------------------------------------------------------------
-// Production wiring function — mirrors the hub's onModuleInit wiring.
-//
-// This is the extracted glue that E1 adds to moleculer.service.ts.
-// Testing it here in isolation:
-//   1. proves the logic is correct without a full broker or UDS server,
-//   2. guards against regressions when the hub changes other wiring.
-// ---------------------------------------------------------------------------
-
-interface HubChildManifestWiringOptions {
-  readonly registry: FakeLocalChildRegistry
-  readonly hubNodeId: string
-  readonly applyChildManifest: (nodeId: string, caps: readonly ChildCapDescriptor[]) => void
-  readonly removeChildFromRegistry: (nodeId: string) => void
-}
-
-/**
- * Wire `onChildRegistered` → `applyChildManifest` and `onChildGone` →
- * `removeChildFromRegistry` for hub-local children. This is the exact
- * glue E1 adds to the hub's `onModuleInit`.
- */
-function wireHubChildManifest(opts: HubChildManifestWiringOptions): void {
-  const { registry, hubNodeId, applyChildManifest, removeChildFromRegistry } = opts
-
-  registry.onChildRegistered((child) => {
-    const nodeId = `${hubNodeId}/${child.childId}`
-    applyChildManifest(nodeId, child.caps)
-  })
-
-  registry.onChildGone((childId) => {
-    const nodeId = `${hubNodeId}/${childId}`
-    removeChildFromRegistry(nodeId)
-  })
-}
-
-// ---------------------------------------------------------------------------
-// Tests — E1: manifest apply + cleanup
-// ---------------------------------------------------------------------------
-
-describe('E1 — wireHubChildManifest', () => {
-  it('onChildRegistered applies caps to the registry with hub/<childId> nodeId', () => {
-    const applyChildManifest = vi.fn<[string, readonly ChildCapDescriptor[]], void>()
-    const removeChildFromRegistry = vi.fn<[string], void>()
-
-    let capturedRegisteredHandler: ((child: RegisteredChild) => void) | null = null
-    let capturedGoneHandler: ((childId: string) => void) | null = null
-
-    const registry: FakeLocalChildRegistry = {
-      onChildRegistered: (h) => {
-        capturedRegisteredHandler = h
-      },
-      onChildGone: (h) => {
-        capturedGoneHandler = h
-      },
-      setChildLogLevel: vi.fn<[string, string], boolean>().mockReturnValue(false),
-    }
-
-    wireHubChildManifest({
-      registry,
-      hubNodeId: 'hub',
-      applyChildManifest,
-      removeChildFromRegistry,
-    })
-
-    expect(capturedRegisteredHandler).not.toBeNull()
-    expect(capturedGoneHandler).not.toBeNull()
-
-    const caps: ChildCapDescriptor[] = [
-      { capName: 'stream-broker', mode: 'singleton' },
-      { capName: 'stream-params', mode: 'collection', deviceId: 7 },
-    ]
-    capturedRegisteredHandler!({ childId: 'addon-stream-broker', caps })
-
-    expect(applyChildManifest).toHaveBeenCalledOnce()
-    expect(applyChildManifest).toHaveBeenCalledWith('hub/addon-stream-broker', caps)
-  })
-
-  it('onChildGone removes the child from the registry with hub/<childId> nodeId', () => {
-    const applyChildManifest = vi.fn<[string, readonly ChildCapDescriptor[]], void>()
-    const removeChildFromRegistry = vi.fn<[string], void>()
-
-    let capturedGoneHandler: ((childId: string) => void) | null = null
-
-    const registry: FakeLocalChildRegistry = {
-      onChildRegistered: vi.fn(),
-      onChildGone: (h) => {
-        capturedGoneHandler = h
-      },
-      setChildLogLevel: vi.fn<[string, string], boolean>().mockReturnValue(false),
-    }
-
-    wireHubChildManifest({
-      registry,
-      hubNodeId: 'hub',
-      applyChildManifest,
-      removeChildFromRegistry,
-    })
-
-    capturedGoneHandler!('provider-reolink')
-
-    expect(removeChildFromRegistry).toHaveBeenCalledOnce()
-    expect(removeChildFromRegistry).toHaveBeenCalledWith('hub/provider-reolink')
-  })
-
-  it('uses the correct hub nodeId prefix', () => {
-    const applyChildManifest = vi.fn<[string, readonly ChildCapDescriptor[]], void>()
-    const removeChildFromRegistry = vi.fn<[string], void>()
-
-    let registeredHandler: ((child: RegisteredChild) => void) | null = null
-    let goneHandler: ((childId: string) => void) | null = null
-
-    const registry: FakeLocalChildRegistry = {
-      onChildRegistered: (h) => {
-        registeredHandler = h
-      },
-      onChildGone: (h) => {
-        goneHandler = h
-      },
-      setChildLogLevel: vi.fn<[string, string], boolean>().mockReturnValue(false),
-    }
-
-    wireHubChildManifest({
-      registry,
-      hubNodeId: 'custom-hub',
-      applyChildManifest,
-      removeChildFromRegistry,
-    })
-
-    registeredHandler!({ childId: 'my-addon', caps: [] })
-    goneHandler!('my-addon')
-
-    expect(applyChildManifest).toHaveBeenCalledWith('custom-hub/my-addon', [])
-    expect(removeChildFromRegistry).toHaveBeenCalledWith('custom-hub/my-addon')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Tests — E1: buildChildUdsManifest (REAL exported function from moleculer.service.ts)
-//
-// These tests exercise the actual production helper — not a reimplementation.
-// The function synthesises ONE manifest entry (addonId = childId) which is
-// correct under the one-addon-one-process invariant (childId = runnerId = addonId).
-// ---------------------------------------------------------------------------
-
-describe('E1 — buildChildUdsManifest (real helper)', () => {
-  it('uses childId as the synthetic addonId', () => {
-    const caps: ChildCapDescriptor[] = [{ capName: 'stream-broker', mode: 'singleton' }]
-    const result = buildChildUdsManifest('hub/addon-stream-broker', 'addon-stream-broker', caps)
-    expect(result.addons).toHaveLength(1)
-    expect(result.addons[0]!.addonId).toBe('addon-stream-broker')
-  })
-
-  it('sets nodeId correctly on the returned params', () => {
-    const caps: ChildCapDescriptor[] = [{ capName: 'stream-broker', mode: 'singleton' }]
-    const result = buildChildUdsManifest('hub/addon-stream-broker', 'addon-stream-broker', caps)
-    expect(result.nodeId).toBe('hub/addon-stream-broker')
-  })
-
-  it('collects unique system (non-device-scoped) capNames and excludes device-scoped ones', () => {
-    const caps: ChildCapDescriptor[] = [
-      { capName: 'stream-broker', mode: 'singleton' },
-      { capName: 'stream-params', mode: 'collection', deviceId: 7 },
-      { capName: 'stream-params', mode: 'collection', deviceId: 15 },
-      { capName: 'pipeline-runner', mode: 'singleton' },
-    ]
-    const result = buildChildUdsManifest('hub/addon-x', 'addon-x', caps)
-    expect(result.addons).toHaveLength(1)
-    const { capabilities } = result.addons[0]!
-    // stream-broker + pipeline-runner (system caps only; device-scoped stream-params excluded)
-    expect(capabilities).toHaveLength(2)
-    expect(capabilities).toContain('stream-broker')
-    expect(capabilities).toContain('pipeline-runner')
-    // stream-params is device-scoped — must NOT appear in the addons array
-    expect(capabilities).not.toContain('stream-params')
-  })
-
-  it('handles empty cap list', () => {
-    const result = buildChildUdsManifest('hub/empty-addon', 'empty-addon', [])
-    expect(result.addons).toHaveLength(1)
-    expect(result.addons[0]!.capabilities).toHaveLength(0)
-    expect(result.addons[0]!.addonId).toBe('empty-addon')
-  })
-
-  it('deduplicates the same system cap registered multiple times', () => {
-    // Unusual but defensively handled: same capName appearing in multiple
-    // descriptors without a deviceId (e.g. a collection cap with no device scope).
-    const caps: ChildCapDescriptor[] = [
-      { capName: 'addon-pages-source', mode: 'collection' },
-      { capName: 'addon-pages-source', mode: 'collection' },
-    ]
-    const result = buildChildUdsManifest('hub/addon-ui', 'addon-ui', caps)
-    const { capabilities } = result.addons[0]!
-    expect(capabilities).toHaveLength(1)
-    expect(capabilities).toContain('addon-pages-source')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Tests — E1: idempotency (double-registration via RPC + UDS)
-// ---------------------------------------------------------------------------
-
-describe('E1 — idempotency (double-registration via RPC + UDS)', () => {
-  it('applying the same nodeId twice via applyChildManifest is safe (dedupe in applyNodeManifest)', () => {
-    // This test verifies that the hub production code guards double-apply
-    // by checking nodeRegistry state before re-registering.
-    // The wiring function itself calls applyChildManifest unconditionally;
-    // the diff guard lives in applyNodeManifest (previous vs desired cap sets),
-    // so the second call is a no-op at the CapabilityRegistry level.
-    // Here we verify that onChildRegistered fires ONCE per UDS connect.
-    let callCount = 0
-    const applyChildManifest = vi.fn<[string, readonly ChildCapDescriptor[]], void>(() => {
-      callCount++
-    })
-
-    let registeredHandler: ((child: RegisteredChild) => void) | null = null
-    const registry: FakeLocalChildRegistry = {
-      onChildRegistered: (h) => {
-        registeredHandler = h
-      },
-      onChildGone: vi.fn(),
-      setChildLogLevel: vi.fn<[string, string], boolean>().mockReturnValue(false),
-    }
-
-    wireHubChildManifest({
-      registry,
-      hubNodeId: 'hub',
-      applyChildManifest,
-      removeChildFromRegistry: vi.fn(),
-    })
-
-    const child: RegisteredChild = {
-      childId: 'provider-reolink',
-      caps: [{ capName: 'stream-broker', mode: 'singleton' }],
-    }
-
-    // First registration (UDS connect)
-    registeredHandler!(child)
-    // updateCaps re-registration (device restore)
-    registeredHandler!(child)
-
-    // applyChildManifest called each time — the diff logic inside
-    // applyNodeManifest makes the second call a no-op at the registry level.
-    expect(callCount).toBe(2)
-  })
-
-  it('agent nodes (bare nodeId, no slash) are NOT affected by UDS wiring', () => {
-    // The UDS wiring only adds hub/<childId> prefixed nodeIds.
-    // Bare agent nodeIds (e.g. "dev-agent-0") come via the RPC path.
-    const applyChildManifest = vi.fn<[string, readonly ChildCapDescriptor[]], void>()
-    let registeredHandler: ((child: RegisteredChild) => void) | null = null
-
-    const registry: FakeLocalChildRegistry = {
-      onChildRegistered: (h) => {
-        registeredHandler = h
-      },
-      onChildGone: vi.fn(),
-      setChildLogLevel: vi.fn<[string, string], boolean>().mockReturnValue(false),
-    }
-
-    wireHubChildManifest({
-      registry,
-      hubNodeId: 'hub',
-      applyChildManifest,
-      removeChildFromRegistry: vi.fn(),
-    })
-
-    // A child that registers over UDS always has a childId (runner id).
-    // The hub always prefixes it with "hub/". Agent nodes never connect
-    // via the hub's LocalChildRegistry — they are on a different host.
-    // Simulate a UDS child with a childId that looks like an agent id:
-    registeredHandler!({ childId: 'dev-agent-0', caps: [] })
-
-    // The wiring adds the hub prefix → "hub/dev-agent-0" — NOT the bare "dev-agent-0"
-    // which would incorrectly shadow the agent's RPC-registered node.
-    expect(applyChildManifest).toHaveBeenCalledWith('hub/dev-agent-0', [])
-    // Bare agent nodeId is handled ONLY by the $hub.registerNode RPC.
-    expect(applyChildManifest).not.toHaveBeenCalledWith('dev-agent-0', expect.anything())
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Tests — E2: LocalChildRegistry.setChildLogLevel (REAL implementation)
-//
-// These tests exercise the actual `LocalChildRegistry` class — not a mock.
-// They verify the boolean-return semantics added by Fix 1:
-//   - true  when the child is connected and the message was emitted
-//   - false when the childId is unknown (child not connected)
-// ---------------------------------------------------------------------------
-
-describe('E2 — LocalChildRegistry.setChildLogLevel (real implementation)', () => {
-  it('returns false for an unknown childId (child not connected)', async () => {
-    // Spin up a registry with no connected children.
-    const nodeId = 'hub-test-setloglevel'
-    const server = createLocalTransport().createServer(nodeId)
-    const registry = new LocalChildRegistry({ server })
-    // Do NOT call registry.start() — no UDS server needed for this assertion.
-    // The children map is empty so any childId lookup returns undefined.
-    const result = registry.setChildLogLevel('unknown-child', 'debug')
-    expect(result).toBe(false)
-    // Cleanup: close the server without starting (no-op on most implementations).
-    try {
-      await registry.close()
-    } catch {
-      /* server was never started */
-    }
-  })
-
-  it('setProcessLogLevel falls back to Moleculer when setChildLogLevel returns false', () => {
-    // Simulate the cap-providers.ts routing:
-    //   const reachedViaUds = moleculer.setChildLogLevelByNodeId(input.nodeId, input.level)
-    //   if (!reachedViaUds) { await broker.call('$node-mgmt.setLogLevel', ...) }
-    // When the UDS child is not connected, setChildLogLevelByNodeId returns false
-    // and the Moleculer fallback is invoked.
-    const moleculerFallback = vi.fn<[string, string], void>()
-
-    const simulateSetProcessLogLevel = (
-      nodeId: string,
-      level: string,
-      udsResult: boolean,
-    ): void => {
-      if (!udsResult) {
-        moleculerFallback(nodeId, level)
-      }
-    }
-
-    // Child not connected — UDS path returns false → Moleculer fallback fires.
-    simulateSetProcessLogLevel('hub/provider-reolink', 'debug', false)
-    expect(moleculerFallback).toHaveBeenCalledWith('hub/provider-reolink', 'debug')
-
-    // Child connected — UDS path returns true → Moleculer fallback skipped.
-    moleculerFallback.mockClear()
-    simulateSetProcessLogLevel('hub/provider-reolink', 'debug', true)
-    expect(moleculerFallback).not.toHaveBeenCalled()
-  })
-
-  it('returns false for an agent nodeId (not hub-local) in MoleculerService routing', () => {
-    // MoleculerService.setChildLogLevelByNodeId returns false for any nodeId
-    // that does not start with `${hubNodeId}/`. Agent nodes ("dev-agent-0")
-    // must fall through to the Moleculer path.
-    // We test the routing logic inline (no full MoleculerService instantiation).
-    const hubNodeId = 'hub'
-
-    const routeSetLogLevel = (
-      nodeId: string,
-      level: string,
-      registry: { setChildLogLevel(id: string, lvl: string): boolean } | null,
-    ): boolean => {
-      if (!nodeId.startsWith(`${hubNodeId}/`)) return false
-      const childId = nodeId.slice(hubNodeId.length + 1)
-      if (registry === null) return false
-      return registry.setChildLogLevel(childId, level)
-    }
-
-    // Agent node — not hub-local → always false
-    expect(routeSetLogLevel('dev-agent-0', 'info', null)).toBe(false)
-    // Hub node without slash → always false
-    expect(routeSetLogLevel('hub', 'info', null)).toBe(false)
-    // Hub child but registry is null → false
-    expect(routeSetLogLevel('hub/provider-reolink', 'info', null)).toBe(false)
-    // Hub child + registry that reports connected
-    const connectedRegistry = { setChildLogLevel: (_id: string, _lvl: string) => true }
-    expect(routeSetLogLevel('hub/provider-reolink', 'info', connectedRegistry)).toBe(true)
-    // Hub child + registry that reports NOT connected
-    const disconnectedRegistry = { setChildLogLevel: (_id: string, _lvl: string) => false }
-    expect(routeSetLogLevel('hub/provider-reolink', 'info', disconnectedRegistry)).toBe(false)
-  })
-})