@serfab/cadre-host 0.10.0 → 0.11.0

package/src/nat/__tests__/ddns-updater.test.ts

@@ -1,253 +1,253 @@
-import { describe, expect, it } from 'vitest';
-
-import { DdnsUpdater } from '../ddns/updater.js';
-import type { DdnsProvider } from '../ddns/index.js';
-import type { SecretsStore } from '../secrets/index.js';
-import { ddnsAccount } from '../secrets/index.js';
-import { NatError, type NatDdnsSettings } from '../types.js';
-
-function makeSecrets(seed: Record<string, string> = {}): SecretsStore {
-  const map = new Map(Object.entries(seed));
-  return {
-    async set(a, v) { map.set(a, v); },
-    async get(a) { return map.has(a) ? map.get(a)! : null; },
-    async delete(a) { return map.delete(a); },
-    async list() { return Array.from(map.keys()); },
-  };
-}
-
-function makeProvider(overrides: Partial<DdnsProvider> = {}): DdnsProvider & {
-  calls: Array<{ hostname: string; ip: string; config: Record<string, string> }>;
-  shouldThrow: Error | null;
-} {
-  const calls: Array<{ hostname: string; ip: string; config: Record<string, string> }> = [];
-  let shouldThrow: Error | null = null;
-  return {
-    id: 'duckdns',
-    displayName: 'DuckDNS',
-    configFields: [{ key: 'token', label: 'DuckDNS token', secret: true }],
-    async update(config, hostname, ip) {
-      calls.push({ hostname, ip, config });
-      if (shouldThrow) throw shouldThrow;
-    },
-    ...overrides,
-    get calls() { return calls; },
-    get shouldThrow() { return shouldThrow; },
-    set shouldThrow(e: Error | null) { shouldThrow = e; },
-  } as DdnsProvider & {
-    calls: Array<{ hostname: string; ip: string; config: Record<string, string> }>;
-    shouldThrow: Error | null;
-  };
-}
-
-function fakeIntervalTimers(): {
-  setInterval: (fn: () => void, ms: number) => NodeJS.Timeout;
-  clearInterval: (h: NodeJS.Timeout) => void;
-  fire(): Promise<void>;
-  cleared: number;
-} {
-  let cb: (() => void) | null = null;
-  let cleared = 0;
-  return {
-    setInterval: (fn) => { cb = fn; return { _id: 1 } as unknown as NodeJS.Timeout; },
-    clearInterval: () => { cb = null; cleared++; },
-    async fire() { const f = cb; if (f) { f(); await new Promise((r) => setTimeout(r, 0)); } },
-    get cleared() { return cleared; },
-  };
-}
-
-const baseSettings: NatDdnsSettings = {
-  providerId: 'duckdns',
-  hostname: 'foo.duckdns.org',
-  externallyManaged: false,
-  intervalMs: 60_000,
-};
-
-describe('DdnsUpdater', () => {
-  it('no-op when externallyManaged', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const ip: string | null = '1.2.3.4';
-    const u = new DdnsUpdater({
-      settings: { ...baseSettings, externallyManaged: true },
-      secrets,
-      getExternalIp: () => ip,
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    await u.start();
-    expect(provider.calls).toHaveLength(0);
-  });
-
-  it('no-op when providerId is null', async () => {
-    const provider = makeProvider();
-    const u = new DdnsUpdater({
-      settings: { ...baseSettings, providerId: null },
-      secrets: makeSecrets(),
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    await u.start();
-    expect(provider.calls).toHaveLength(0);
-  });
-
-  it('pushes the IP on start, records lastUpdateOk=true', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    const outcome = await u.start();
-    expect(outcome.ok).toBe(true);
-    expect(outcome.ip).toBe('1.2.3.4');
-    expect(provider.calls).toEqual([
-      { hostname: 'foo.duckdns.org', ip: '1.2.3.4', config: { token: 'T' } },
-    ]);
-    const status = u.getStatus();
-    expect(status.lastUpdateOk).toBe(true);
-    expect(status.lastError).toBeNull();
-  });
-
-  it('does not re-push when IP is unchanged', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const timers = fakeIntervalTimers();
-    let ip = '1.2.3.4';
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => ip,
-      resolveProvider: () => provider,
-      setInterval: timers.setInterval,
-      clearInterval: timers.clearInterval,
-    });
-    await u.start();
-    expect(provider.calls).toHaveLength(1);
-
-    await timers.fire();
-    expect(provider.calls).toHaveLength(1);
-
-    // Change the IP — next tick should call.
-    ip = '5.6.7.8';
-    await timers.fire();
-    expect(provider.calls).toHaveLength(2);
-    expect(provider.calls[1]?.ip).toBe('5.6.7.8');
-  });
-
-  it('records error but keeps timer running on provider throw', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const timers = fakeIntervalTimers();
-    let ip = '1.2.3.4';
-
-    provider.shouldThrow = new NatError('ddns_update_failed', 'boom');
-
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => ip,
-      resolveProvider: () => provider,
-      setInterval: timers.setInterval,
-      clearInterval: timers.clearInterval,
-    });
-
-    await u.start();
-    expect(u.getStatus().lastUpdateOk).toBe(false);
-    expect(u.getStatus().lastError).toContain('boom');
-
-    // Provider stops throwing — next change → success
-    provider.shouldThrow = null;
-    ip = '5.6.7.8';
-    await timers.fire();
-
-    expect(provider.calls.length).toBeGreaterThanOrEqual(2);
-    expect(u.getStatus().lastUpdateOk).toBe(true);
-    expect(u.getStatus().lastError).toBeNull();
-  });
-
-  it('reports ddns_credentials_missing when secrets are empty', async () => {
-    const provider = makeProvider();
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets: makeSecrets(),
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    const outcome = await u.start();
-    expect(outcome.ok).toBe(false);
-    expect(outcome.error).toMatch(/credential/i);
-    expect(provider.calls).toHaveLength(0);
-  });
-
-  it('forceUpdate ignores unchanged-IP shortcut', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    await u.start();
-    await u.forceUpdate();
-    expect(provider.calls).toHaveLength(2);
-  });
-
-  it('stop() clears the timer; idempotent', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const timers = fakeIntervalTimers();
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      setInterval: timers.setInterval,
-      clearInterval: timers.clearInterval,
-    });
-    await u.start();
-    u.stop();
-    u.stop();
-    expect(timers.cleared).toBe(1);
-  });
-
-  it('updateSettings restarts with new config', async () => {
-    const provider = makeProvider();
-    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets,
-      getExternalIp: () => '1.2.3.4',
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    await u.start();
-    expect(provider.calls).toHaveLength(1);
-
-    await u.updateSettings({ ...baseSettings, hostname: 'bar.duckdns.org' });
-    expect(provider.calls).toHaveLength(2);
-    expect(provider.calls[1]?.hostname).toBe('bar.duckdns.org');
-  });
-
-  it('records "external IP unknown" when getExternalIp returns null', async () => {
-    const provider = makeProvider();
-    const u = new DdnsUpdater({
-      settings: baseSettings,
-      secrets: makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' }),
-      getExternalIp: () => null,
-      resolveProvider: () => provider,
-      ...fakeIntervalTimers(),
-    });
-    const outcome = await u.start();
-    expect(outcome.attempted).toBe(false);
-    expect(outcome.error).toMatch(/unknown/i);
-    expect(provider.calls).toHaveLength(0);
-  });
-});
+import { describe, expect, it } from 'vitest';
+
+import { DdnsUpdater } from '../ddns/updater.js';
+import type { DdnsProvider } from '../ddns/index.js';
+import type { SecretsStore } from '../secrets/index.js';
+import { ddnsAccount } from '../secrets/index.js';
+import { NatError, type NatDdnsSettings } from '../types.js';
+
+function makeSecrets(seed: Record<string, string> = {}): SecretsStore {
+  const map = new Map(Object.entries(seed));
+  return {
+    async set(a, v) { map.set(a, v); },
+    async get(a) { return map.has(a) ? map.get(a)! : null; },
+    async delete(a) { return map.delete(a); },
+    async list() { return Array.from(map.keys()); },
+  };
+}
+
+function makeProvider(overrides: Partial<DdnsProvider> = {}): DdnsProvider & {
+  calls: Array<{ hostname: string; ip: string; config: Record<string, string> }>;
+  shouldThrow: Error | null;
+} {
+  const calls: Array<{ hostname: string; ip: string; config: Record<string, string> }> = [];
+  let shouldThrow: Error | null = null;
+  return {
+    id: 'duckdns',
+    displayName: 'DuckDNS',
+    configFields: [{ key: 'token', label: 'DuckDNS token', secret: true }],
+    async update(config, hostname, ip) {
+      calls.push({ hostname, ip, config });
+      if (shouldThrow) throw shouldThrow;
+    },
+    ...overrides,
+    get calls() { return calls; },
+    get shouldThrow() { return shouldThrow; },
+    set shouldThrow(e: Error | null) { shouldThrow = e; },
+  } as DdnsProvider & {
+    calls: Array<{ hostname: string; ip: string; config: Record<string, string> }>;
+    shouldThrow: Error | null;
+  };
+}
+
+function fakeIntervalTimers(): {
+  setInterval: (fn: () => void, ms: number) => NodeJS.Timeout;
+  clearInterval: (h: NodeJS.Timeout) => void;
+  fire(): Promise<void>;
+  cleared: number;
+} {
+  let cb: (() => void) | null = null;
+  let cleared = 0;
+  return {
+    setInterval: (fn) => { cb = fn; return { _id: 1 } as unknown as NodeJS.Timeout; },
+    clearInterval: () => { cb = null; cleared++; },
+    async fire() { const f = cb; if (f) { f(); await new Promise((r) => setTimeout(r, 0)); } },
+    get cleared() { return cleared; },
+  };
+}
+
+const baseSettings: NatDdnsSettings = {
+  providerId: 'duckdns',
+  hostname: 'foo.duckdns.org',
+  externallyManaged: false,
+  intervalMs: 60_000,
+};
+
+describe('DdnsUpdater', () => {
+  it('no-op when externallyManaged', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const ip: string | null = '1.2.3.4';
+    const u = new DdnsUpdater({
+      settings: { ...baseSettings, externallyManaged: true },
+      secrets,
+      getExternalIp: () => ip,
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    await u.start();
+    expect(provider.calls).toHaveLength(0);
+  });
+
+  it('no-op when providerId is null', async () => {
+    const provider = makeProvider();
+    const u = new DdnsUpdater({
+      settings: { ...baseSettings, providerId: null },
+      secrets: makeSecrets(),
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    await u.start();
+    expect(provider.calls).toHaveLength(0);
+  });
+
+  it('pushes the IP on start, records lastUpdateOk=true', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    const outcome = await u.start();
+    expect(outcome.ok).toBe(true);
+    expect(outcome.ip).toBe('1.2.3.4');
+    expect(provider.calls).toEqual([
+      { hostname: 'foo.duckdns.org', ip: '1.2.3.4', config: { token: 'T' } },
+    ]);
+    const status = u.getStatus();
+    expect(status.lastUpdateOk).toBe(true);
+    expect(status.lastError).toBeNull();
+  });
+
+  it('does not re-push when IP is unchanged', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const timers = fakeIntervalTimers();
+    let ip = '1.2.3.4';
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => ip,
+      resolveProvider: () => provider,
+      setInterval: timers.setInterval,
+      clearInterval: timers.clearInterval,
+    });
+    await u.start();
+    expect(provider.calls).toHaveLength(1);
+
+    await timers.fire();
+    expect(provider.calls).toHaveLength(1);
+
+    // Change the IP — next tick should call.
+    ip = '5.6.7.8';
+    await timers.fire();
+    expect(provider.calls).toHaveLength(2);
+    expect(provider.calls[1]?.ip).toBe('5.6.7.8');
+  });
+
+  it('records error but keeps timer running on provider throw', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const timers = fakeIntervalTimers();
+    let ip = '1.2.3.4';
+
+    provider.shouldThrow = new NatError('ddns_update_failed', 'boom');
+
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => ip,
+      resolveProvider: () => provider,
+      setInterval: timers.setInterval,
+      clearInterval: timers.clearInterval,
+    });
+
+    await u.start();
+    expect(u.getStatus().lastUpdateOk).toBe(false);
+    expect(u.getStatus().lastError).toContain('boom');
+
+    // Provider stops throwing — next change → success
+    provider.shouldThrow = null;
+    ip = '5.6.7.8';
+    await timers.fire();
+
+    expect(provider.calls.length).toBeGreaterThanOrEqual(2);
+    expect(u.getStatus().lastUpdateOk).toBe(true);
+    expect(u.getStatus().lastError).toBeNull();
+  });
+
+  it('reports ddns_credentials_missing when secrets are empty', async () => {
+    const provider = makeProvider();
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets: makeSecrets(),
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    const outcome = await u.start();
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toMatch(/credential/i);
+    expect(provider.calls).toHaveLength(0);
+  });
+
+  it('forceUpdate ignores unchanged-IP shortcut', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    await u.start();
+    await u.forceUpdate();
+    expect(provider.calls).toHaveLength(2);
+  });
+
+  it('stop() clears the timer; idempotent', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const timers = fakeIntervalTimers();
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      setInterval: timers.setInterval,
+      clearInterval: timers.clearInterval,
+    });
+    await u.start();
+    u.stop();
+    u.stop();
+    expect(timers.cleared).toBe(1);
+  });
+
+  it('updateSettings restarts with new config', async () => {
+    const provider = makeProvider();
+    const secrets = makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' });
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets,
+      getExternalIp: () => '1.2.3.4',
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    await u.start();
+    expect(provider.calls).toHaveLength(1);
+
+    await u.updateSettings({ ...baseSettings, hostname: 'bar.duckdns.org' });
+    expect(provider.calls).toHaveLength(2);
+    expect(provider.calls[1]?.hostname).toBe('bar.duckdns.org');
+  });
+
+  it('records "external IP unknown" when getExternalIp returns null', async () => {
+    const provider = makeProvider();
+    const u = new DdnsUpdater({
+      settings: baseSettings,
+      secrets: makeSecrets({ [ddnsAccount('duckdns', 'token')]: 'T' }),
+      getExternalIp: () => null,
+      resolveProvider: () => provider,
+      ...fakeIntervalTimers(),
+    });
+    const outcome = await u.start();
+    expect(outcome.attempted).toBe(false);
+    expect(outcome.error).toMatch(/unknown/i);
+    expect(provider.calls).toHaveLength(0);
+  });
+});