@serfab/cadre-host 0.9.0 → 0.11.0

package/src/server/__tests__/publishers.test.ts

@@ -1,216 +1,216 @@
-/**
- * Verifies the publisher wiring inside createLocalUiServer:
- *   - orchestrator.onStateChange → 'node-state-changed'
- *   - NatService.getStatus() at boot → 'connectivity-changed'
- *   - UpdateService.getState() polling → 'update-available'
- */
-
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-
-import { createLocalUiServer } from '../index.js';
-import { EventBus } from '../events/bus.js';
-import type { LocalUiEvent } from '../events/types.js';
-import type { HostProcessOrchestrator } from '../../orchestrator/index.js';
-import type { ManagedNodeInfo, NodeStateListener } from '../../orchestrator/types.js';
-import type { TrustCircleService } from '../../auth/index.js';
-import type { NatService } from '../../nat/index.js';
-import type { NatStatusSnapshot } from '../../nat/types.js';
-import type { UpdateService } from '../../update/index.js';
-import type { UpdateState } from '../../update/types.js';
-
-const CONNECTIVITY: NatStatusSnapshot = {
-  portMode: 'auto-upnp',
-  externalPort: 4001,
-  internalPort: 4001,
-  routerExternalIp: '203.0.113.1',
-  mappingLeaseExpiresAt: null,
-  externalIp: '203.0.113.1',
-  externalIpDetectedAt: null,
-  cgnatDetected: false,
-  directReachability: 'reachable',
-  lastTestedAt: null,
-  ddns: {
-    providerId: null,
-    hostname: null,
-    externallyManaged: false,
-    lastUpdateAt: null,
-    lastUpdateOk: null,
-    lastError: null,
-  },
-};
-
-function fakeTrust(): TrustCircleService {
-  return {
-    list: async () => ({ members: [], pending: [] }),
-  } as unknown as TrustCircleService;
-}
-function fakeNat(): NatService {
-  return { getStatus: () => CONNECTIVITY, putSettings: async () => CONNECTIVITY } as unknown as NatService;
-}
-
-interface ManualOrchestrator extends HostProcessOrchestrator {
-  __emit: (info: ManagedNodeInfo) => void;
-}
-
-function manualOrchestrator(): ManualOrchestrator {
-  const listeners = new Set<NodeStateListener>();
-  const inst = {
-    listNodes: () => [],
-    getNode: () => undefined,
-    resolveDockerId: () => undefined,
-    onStateChange: (l: NodeStateListener) => { listeners.add(l); return () => { listeners.delete(l); }; },
-    __emit: (info: ManagedNodeInfo) => { for (const l of listeners) l(info); },
-  } as unknown as ManualOrchestrator;
-  return inst;
-}
-
-class FakeUpdate {
-  private state: UpdateState;
-  constructor(initial: UpdateState) { this.state = initial; }
-  setState(next: UpdateState): void { this.state = next; }
-  async getState(): Promise<UpdateState> { return this.state; }
-}
-
-function writeConfig(dir: string): void {
-  const cfg = {
-    version: 2,
-    installId: 'inst-x',
-    uiPort: 8765,
-    libp2pPort: 4001,
-    dataDir: dir,
-    identityPath: join(dir, 'identity.key'),
-    upnpEnabled: true,
-    installedAt: '2025-01-01T00:00:00Z',
-    installerVersion: '0.6.0',
-    updates: { autoApply: false },
-  };
-  writeFileSync(join(dir, 'host.config.json'), JSON.stringify(cfg, null, 2) + '\n', 'utf8');
-}
-
-describe('publisher wiring', () => {
-  let dataDir: string;
-  let bus: EventBus;
-  let received: LocalUiEvent[];
-  let server: ReturnType<typeof createLocalUiServer>;
-  let orchestrator: ManualOrchestrator;
-
-  beforeEach(async () => {
-    dataDir = mkdtempSync(join(tmpdir(), 'cadre-host-pub-'));
-    writeConfig(dataDir);
-    bus = new EventBus();
-    received = [];
-    bus.subscribe((e) => received.push(e));
-  });
-
-  afterEach(async () => {
-    if (server) await server.stop();
-    rmSync(dataDir, { recursive: true, force: true });
-  });
-
-  it('orchestrator.onStateChange → node-state-changed', async () => {
-    orchestrator = manualOrchestrator();
-    server = createLocalUiServer({
-      uiPort: 8765,
-      dataDir,
-      orchestrator,
-      trustCircle: fakeTrust(),
-      nat: fakeNat(),
-      events: bus,
-      forcePort: 0,
-    });
-    await server.start();
-    orchestrator.__emit({
-      id: 'alice',
-      dockerId: '111:abc',
-      partyId: 'p',
-      profile: 'storage',
-      status: 'stopped',
-      spawnedAt: 'x',
-      workdir: '/tmp',
-      ports: { health: 1, metrics: 2, p2p: 3, admin: 4 },
-    });
-    expect(received).toContainEqual({
-      type: 'node-state-changed',
-      nodeId: 'alice',
-      status: 'stopped',
-    });
-  });
-
-  it('emits an initial connectivity-changed at start', async () => {
-    orchestrator = manualOrchestrator();
-    server = createLocalUiServer({
-      uiPort: 8765,
-      dataDir,
-      orchestrator,
-      trustCircle: fakeTrust(),
-      nat: fakeNat(),
-      events: bus,
-      forcePort: 0,
-    });
-    await server.start();
-    const conn = received.filter((e) => e.type === 'connectivity-changed');
-    expect(conn).toHaveLength(1);
-    expect(conn[0]).toMatchObject({
-      type: 'connectivity-changed',
-      portMode: 'auto-upnp',
-      directReachability: 'reachable',
-    });
-  });
-
-  it('publishes update-available when UpdateService.getState() shows a new version', async () => {
-    orchestrator = manualOrchestrator();
-    const update = new FakeUpdate({ version: 1 });
-    server = createLocalUiServer({
-      uiPort: 8765,
-      dataDir,
-      orchestrator,
-      trustCircle: fakeTrust(),
-      nat: fakeNat(),
-      events: bus,
-      update: update as unknown as UpdateService,
-      forcePort: 0,
-    });
-    await server.start();
-    // The boot tick already happened — no available yet.
-    expect(received.filter((e) => e.type === 'update-available')).toHaveLength(0);
-    // Simulate the update store noticing a new version. Call start()'s
-    // internal tick by setting state and waiting briefly.
-    update.setState({
-      version: 1,
-      available: { version: '0.7.0', publishedAt: '2025-06-01T00:00:00Z', releaseNotesUrl: 'https://x' },
-    });
-    // The 60 s interval is too slow for a unit test — drive a second start
-    // cycle by re-invoking via the server's effective polling pattern: we
-    // expose nothing for tests, so wait briefly then simulate the boot tick
-    // by recreating the server with the same fake. Easier: assert the
-    // start-time tick (which we already covered above) and that putting an
-    // update in state before start() yields an event.
-    await server.stop();
-    server = createLocalUiServer({
-      uiPort: 8765,
-      dataDir,
-      orchestrator,
-      trustCircle: fakeTrust(),
-      nat: fakeNat(),
-      events: bus,
-      update: update as unknown as UpdateService,
-      forcePort: 0,
-    });
-    received.length = 0;
-    bus.subscribe((e) => received.push(e));
-    await server.start();
-    // Let the boot-time tick microtask flush.
-    await new Promise<void>((r) => setTimeout(r, 20));
-    const updateEvents = received.filter((e) => e.type === 'update-available');
-    expect(updateEvents.length).toBeGreaterThan(0);
-    expect(updateEvents[0]).toMatchObject({
-      type: 'update-available',
-      version: '0.7.0',
-      releaseNotesUrl: 'https://x',
-    });
-  });
-});
+/**
+ * Verifies the publisher wiring inside createLocalUiServer:
+ *   - orchestrator.onStateChange → 'node-state-changed'
+ *   - NatService.getStatus() at boot → 'connectivity-changed'
+ *   - UpdateService.getState() polling → 'update-available'
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+import { createLocalUiServer } from '../index.js';
+import { EventBus } from '../events/bus.js';
+import type { LocalUiEvent } from '../events/types.js';
+import type { HostProcessOrchestrator } from '../../orchestrator/index.js';
+import type { ManagedNodeInfo, NodeStateListener } from '../../orchestrator/types.js';
+import type { TrustCircleService } from '../../auth/index.js';
+import type { NatService } from '../../nat/index.js';
+import type { NatStatusSnapshot } from '../../nat/types.js';
+import type { UpdateService } from '../../update/index.js';
+import type { UpdateState } from '../../update/types.js';
+
+const CONNECTIVITY: NatStatusSnapshot = {
+  portMode: 'auto-upnp',
+  externalPort: 4001,
+  internalPort: 4001,
+  routerExternalIp: '203.0.113.1',
+  mappingLeaseExpiresAt: null,
+  externalIp: '203.0.113.1',
+  externalIpDetectedAt: null,
+  cgnatDetected: false,
+  directReachability: 'reachable',
+  lastTestedAt: null,
+  ddns: {
+    providerId: null,
+    hostname: null,
+    externallyManaged: false,
+    lastUpdateAt: null,
+    lastUpdateOk: null,
+    lastError: null,
+  },
+};
+
+function fakeTrust(): TrustCircleService {
+  return {
+    list: async () => ({ members: [], pending: [] }),
+  } as unknown as TrustCircleService;
+}
+function fakeNat(): NatService {
+  return { getStatus: () => CONNECTIVITY, putSettings: async () => CONNECTIVITY } as unknown as NatService;
+}
+
+interface ManualOrchestrator extends HostProcessOrchestrator {
+  __emit: (info: ManagedNodeInfo) => void;
+}
+
+function manualOrchestrator(): ManualOrchestrator {
+  const listeners = new Set<NodeStateListener>();
+  const inst = {
+    listNodes: () => [],
+    getNode: () => undefined,
+    resolveDockerId: () => undefined,
+    onStateChange: (l: NodeStateListener) => { listeners.add(l); return () => { listeners.delete(l); }; },
+    __emit: (info: ManagedNodeInfo) => { for (const l of listeners) l(info); },
+  } as unknown as ManualOrchestrator;
+  return inst;
+}
+
+class FakeUpdate {
+  private state: UpdateState;
+  constructor(initial: UpdateState) { this.state = initial; }
+  setState(next: UpdateState): void { this.state = next; }
+  async getState(): Promise<UpdateState> { return this.state; }
+}
+
+function writeConfig(dir: string): void {
+  const cfg = {
+    version: 2,
+    installId: 'inst-x',
+    uiPort: 8765,
+    libp2pPort: 4001,
+    dataDir: dir,
+    identityPath: join(dir, 'identity.key'),
+    upnpEnabled: true,
+    installedAt: '2025-01-01T00:00:00Z',
+    installerVersion: '0.6.0',
+    updates: { autoApply: false },
+  };
+  writeFileSync(join(dir, 'host.config.json'), JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
+describe('publisher wiring', () => {
+  let dataDir: string;
+  let bus: EventBus;
+  let received: LocalUiEvent[];
+  let server: ReturnType<typeof createLocalUiServer>;
+  let orchestrator: ManualOrchestrator;
+
+  beforeEach(async () => {
+    dataDir = mkdtempSync(join(tmpdir(), 'cadre-host-pub-'));
+    writeConfig(dataDir);
+    bus = new EventBus();
+    received = [];
+    bus.subscribe((e) => received.push(e));
+  });
+
+  afterEach(async () => {
+    if (server) await server.stop();
+    rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  it('orchestrator.onStateChange → node-state-changed', async () => {
+    orchestrator = manualOrchestrator();
+    server = createLocalUiServer({
+      uiPort: 8765,
+      dataDir,
+      orchestrator,
+      trustCircle: fakeTrust(),
+      nat: fakeNat(),
+      events: bus,
+      forcePort: 0,
+    });
+    await server.start();
+    orchestrator.__emit({
+      id: 'alice',
+      dockerId: '111:abc',
+      partyId: 'p',
+      profile: 'storage',
+      status: 'stopped',
+      spawnedAt: 'x',
+      workdir: '/tmp',
+      ports: { health: 1, metrics: 2, p2p: 3, admin: 4 },
+    });
+    expect(received).toContainEqual({
+      type: 'node-state-changed',
+      nodeId: 'alice',
+      status: 'stopped',
+    });
+  });
+
+  it('emits an initial connectivity-changed at start', async () => {
+    orchestrator = manualOrchestrator();
+    server = createLocalUiServer({
+      uiPort: 8765,
+      dataDir,
+      orchestrator,
+      trustCircle: fakeTrust(),
+      nat: fakeNat(),
+      events: bus,
+      forcePort: 0,
+    });
+    await server.start();
+    const conn = received.filter((e) => e.type === 'connectivity-changed');
+    expect(conn).toHaveLength(1);
+    expect(conn[0]).toMatchObject({
+      type: 'connectivity-changed',
+      portMode: 'auto-upnp',
+      directReachability: 'reachable',
+    });
+  });
+
+  it('publishes update-available when UpdateService.getState() shows a new version', async () => {
+    orchestrator = manualOrchestrator();
+    const update = new FakeUpdate({ version: 1 });
+    server = createLocalUiServer({
+      uiPort: 8765,
+      dataDir,
+      orchestrator,
+      trustCircle: fakeTrust(),
+      nat: fakeNat(),
+      events: bus,
+      update: update as unknown as UpdateService,
+      forcePort: 0,
+    });
+    await server.start();
+    // The boot tick already happened — no available yet.
+    expect(received.filter((e) => e.type === 'update-available')).toHaveLength(0);
+    // Simulate the update store noticing a new version. Call start()'s
+    // internal tick by setting state and waiting briefly.
+    update.setState({
+      version: 1,
+      available: { version: '0.7.0', publishedAt: '2025-06-01T00:00:00Z', releaseNotesUrl: 'https://x' },
+    });
+    // The 60 s interval is too slow for a unit test — drive a second start
+    // cycle by re-invoking via the server's effective polling pattern: we
+    // expose nothing for tests, so wait briefly then simulate the boot tick
+    // by recreating the server with the same fake. Easier: assert the
+    // start-time tick (which we already covered above) and that putting an
+    // update in state before start() yields an event.
+    await server.stop();
+    server = createLocalUiServer({
+      uiPort: 8765,
+      dataDir,
+      orchestrator,
+      trustCircle: fakeTrust(),
+      nat: fakeNat(),
+      events: bus,
+      update: update as unknown as UpdateService,
+      forcePort: 0,
+    });
+    received.length = 0;
+    bus.subscribe((e) => received.push(e));
+    await server.start();
+    // Let the boot-time tick microtask flush.
+    await new Promise<void>((r) => setTimeout(r, 20));
+    const updateEvents = received.filter((e) => e.type === 'update-available');
+    expect(updateEvents.length).toBeGreaterThan(0);
+    expect(updateEvents[0]).toMatchObject({
+      type: 'update-available',
+      version: '0.7.0',
+      releaseNotesUrl: 'https://x',
+    });
+  });
+});