@serfab/cadre-host 0.10.0 → 0.12.0

package/src/nat/__tests__/external-ip.test.ts

@@ -1,124 +1,124 @@
-import { describe, expect, it } from 'vitest';
-
-import { ExternalIpDetector, isPlausibleIp } from '../external-ip.js';
-
-function makeFetchSequence(responses: Array<{ ok: boolean; body: string }>): typeof fetch {
-  let i = 0;
-  return (async () => {
-    const r = responses[i++] ?? { ok: false, body: '' };
-    return {
-      ok: r.ok,
-      status: r.ok ? 200 : 500,
-      async text() { return r.body; },
-    } as unknown as Response;
-  }) as typeof fetch;
-}
-
-describe('isPlausibleIp()', () => {
-  it('accepts IPv4', () => {
-    expect(isPlausibleIp('1.2.3.4')).toBe(true);
-    expect(isPlausibleIp('255.255.255.255')).toBe(true);
-  });
-  it('rejects bad IPv4', () => {
-    expect(isPlausibleIp('256.0.0.1')).toBe(false);
-    expect(isPlausibleIp('1.2.3')).toBe(false);
-  });
-  it('accepts IPv6 liberally', () => {
-    expect(isPlausibleIp('::1')).toBe(true);
-    expect(isPlausibleIp('2001:db8::1')).toBe(true);
-  });
-  it('rejects junk', () => {
-    expect(isPlausibleIp('not an ip')).toBe(false);
-    expect(isPlausibleIp('')).toBe(false);
-  });
-});
-
-describe('ExternalIpDetector', () => {
-  it('returns null routerIp when no probe configured', async () => {
-    const det = new ExternalIpDetector({
-      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
-      publicIpUrls: ['https://example.test'],
-    });
-    const r = await det.detect();
-    expect(r.routerIp).toBeNull();
-    expect(r.publicIp).toBe('1.2.3.4');
-    expect(r.cgnat).toBe(false);
-  });
-
-  it('detects CGNAT when router and public IP disagree', async () => {
-    const det = new ExternalIpDetector({
-      routerProbe: async () => '100.64.0.5',  // CGNAT space — fine for testing
-      fetch: makeFetchSequence([{ ok: true, body: '203.0.113.10' }]),
-      publicIpUrls: ['https://example.test'],
-    });
-    const r = await det.detect();
-    expect(r.routerIp).toBe('100.64.0.5');
-    expect(r.publicIp).toBe('203.0.113.10');
-    expect(r.cgnat).toBe(true);
-  });
-
-  it('does NOT flag CGNAT when IPs agree', async () => {
-    const det = new ExternalIpDetector({
-      routerProbe: async () => '1.2.3.4',
-      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
-      publicIpUrls: ['https://example.test'],
-    });
-    const r = await det.detect();
-    expect(r.cgnat).toBe(false);
-  });
-
-  it('does NOT flag CGNAT when one probe fails', async () => {
-    const det = new ExternalIpDetector({
-      routerProbe: async () => '1.2.3.4',
-      fetch: makeFetchSequence([{ ok: false, body: '' }]),
-      publicIpUrls: ['https://example.test'],
-    });
-    const r = await det.detect();
-    expect(r.routerIp).toBe('1.2.3.4');
-    expect(r.publicIp).toBeNull();
-    expect(r.cgnat).toBe(false);
-  });
-
-  it('falls through public probe URLs until one succeeds', async () => {
-    const det = new ExternalIpDetector({
-      fetch: makeFetchSequence([
-        { ok: false, body: '' },
-        { ok: true, body: '8.8.8.8' },
-      ]),
-      publicIpUrls: ['https://a.test', 'https://b.test'],
-    });
-    const r = await det.detect();
-    expect(r.publicIp).toBe('8.8.8.8');
-  });
-
-  it('treats router probe throw as null', async () => {
-    const det = new ExternalIpDetector({
-      routerProbe: async () => { throw new Error('upnp not reachable'); },
-      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
-      publicIpUrls: ['https://a.test'],
-    });
-    const r = await det.detect();
-    expect(r.routerIp).toBeNull();
-    expect(r.publicIp).toBe('1.2.3.4');
-    expect(r.cgnat).toBe(false);
-  });
-
-  it('rejects implausible router-probe IP', async () => {
-    const det = new ExternalIpDetector({
-      routerProbe: async () => 'not-an-ip',
-      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
-      publicIpUrls: ['https://a.test'],
-    });
-    const r = await det.detect();
-    expect(r.routerIp).toBeNull();
-  });
-
-  it('rejects non-IP public-service body', async () => {
-    const det = new ExternalIpDetector({
-      fetch: makeFetchSequence([{ ok: true, body: '<html>error</html>' }]),
-      publicIpUrls: ['https://a.test'],
-    });
-    const r = await det.detect();
-    expect(r.publicIp).toBeNull();
-  });
-});
+import { describe, expect, it } from 'vitest';
+
+import { ExternalIpDetector, isPlausibleIp } from '../external-ip.js';
+
+function makeFetchSequence(responses: Array<{ ok: boolean; body: string }>): typeof fetch {
+  let i = 0;
+  return (async () => {
+    const r = responses[i++] ?? { ok: false, body: '' };
+    return {
+      ok: r.ok,
+      status: r.ok ? 200 : 500,
+      async text() { return r.body; },
+    } as unknown as Response;
+  }) as typeof fetch;
+}
+
+describe('isPlausibleIp()', () => {
+  it('accepts IPv4', () => {
+    expect(isPlausibleIp('1.2.3.4')).toBe(true);
+    expect(isPlausibleIp('255.255.255.255')).toBe(true);
+  });
+  it('rejects bad IPv4', () => {
+    expect(isPlausibleIp('256.0.0.1')).toBe(false);
+    expect(isPlausibleIp('1.2.3')).toBe(false);
+  });
+  it('accepts IPv6 liberally', () => {
+    expect(isPlausibleIp('::1')).toBe(true);
+    expect(isPlausibleIp('2001:db8::1')).toBe(true);
+  });
+  it('rejects junk', () => {
+    expect(isPlausibleIp('not an ip')).toBe(false);
+    expect(isPlausibleIp('')).toBe(false);
+  });
+});
+
+describe('ExternalIpDetector', () => {
+  it('returns null routerIp when no probe configured', async () => {
+    const det = new ExternalIpDetector({
+      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
+      publicIpUrls: ['https://example.test'],
+    });
+    const r = await det.detect();
+    expect(r.routerIp).toBeNull();
+    expect(r.publicIp).toBe('1.2.3.4');
+    expect(r.cgnat).toBe(false);
+  });
+
+  it('detects CGNAT when router and public IP disagree', async () => {
+    const det = new ExternalIpDetector({
+      routerProbe: async () => '100.64.0.5',  // CGNAT space — fine for testing
+      fetch: makeFetchSequence([{ ok: true, body: '203.0.113.10' }]),
+      publicIpUrls: ['https://example.test'],
+    });
+    const r = await det.detect();
+    expect(r.routerIp).toBe('100.64.0.5');
+    expect(r.publicIp).toBe('203.0.113.10');
+    expect(r.cgnat).toBe(true);
+  });
+
+  it('does NOT flag CGNAT when IPs agree', async () => {
+    const det = new ExternalIpDetector({
+      routerProbe: async () => '1.2.3.4',
+      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
+      publicIpUrls: ['https://example.test'],
+    });
+    const r = await det.detect();
+    expect(r.cgnat).toBe(false);
+  });
+
+  it('does NOT flag CGNAT when one probe fails', async () => {
+    const det = new ExternalIpDetector({
+      routerProbe: async () => '1.2.3.4',
+      fetch: makeFetchSequence([{ ok: false, body: '' }]),
+      publicIpUrls: ['https://example.test'],
+    });
+    const r = await det.detect();
+    expect(r.routerIp).toBe('1.2.3.4');
+    expect(r.publicIp).toBeNull();
+    expect(r.cgnat).toBe(false);
+  });
+
+  it('falls through public probe URLs until one succeeds', async () => {
+    const det = new ExternalIpDetector({
+      fetch: makeFetchSequence([
+        { ok: false, body: '' },
+        { ok: true, body: '8.8.8.8' },
+      ]),
+      publicIpUrls: ['https://a.test', 'https://b.test'],
+    });
+    const r = await det.detect();
+    expect(r.publicIp).toBe('8.8.8.8');
+  });
+
+  it('treats router probe throw as null', async () => {
+    const det = new ExternalIpDetector({
+      routerProbe: async () => { throw new Error('upnp not reachable'); },
+      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
+      publicIpUrls: ['https://a.test'],
+    });
+    const r = await det.detect();
+    expect(r.routerIp).toBeNull();
+    expect(r.publicIp).toBe('1.2.3.4');
+    expect(r.cgnat).toBe(false);
+  });
+
+  it('rejects implausible router-probe IP', async () => {
+    const det = new ExternalIpDetector({
+      routerProbe: async () => 'not-an-ip',
+      fetch: makeFetchSequence([{ ok: true, body: '1.2.3.4' }]),
+      publicIpUrls: ['https://a.test'],
+    });
+    const r = await det.detect();
+    expect(r.routerIp).toBeNull();
+  });
+
+  it('rejects non-IP public-service body', async () => {
+    const det = new ExternalIpDetector({
+      fetch: makeFetchSequence([{ ok: true, body: '<html>error</html>' }]),
+      publicIpUrls: ['https://a.test'],
+    });
+    const r = await det.detect();
+    expect(r.publicIp).toBeNull();
+  });
+});

package/src/nat/__tests__/nat-service.test.ts

@@ -87,6 +87,21 @@ function makeDetector(opts: { router?: string | null; pub?: string | null }): Ex
   });
 }
 
+/**
+ * The provider call a `putDdns` lands on. Injected wherever a case configures a real
+ * provider, so no case here reaches www.duckdns.org — an outbound request in a unit
+ * test is a hang waiting for a machine without network. DuckDNS's own contract (the
+ * plain-text `OK`) is covered in the ddns specs.
+ */
+function okFetch(): typeof fetch {
+  return (async () => ({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    async text() { return 'OK'; },
+  })) as unknown as typeof fetch;
+}
+
 let tmpRoot: string;
 beforeEach(() => {
   tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-nat-svc-'));
@@ -169,6 +184,7 @@ describe('NatService', () => {
       secretsStore: secrets,
       portMapper: mapper,
       externalIpDetector: makeDetector({ pub: '1.2.3.4' }),
+      fetch: okFetch(),
     });
     await svc.start();
     await svc.putDdns({
@@ -218,6 +234,7 @@ describe('NatService', () => {
       secretsStore: secrets,
       portMapper: mapper,
       externalIpDetector: makeDetector({ pub: '1.2.3.4' }),
+      fetch: okFetch(),
     });
     await svc.start();
     const status = await svc.putDdns({
@@ -474,6 +491,7 @@ describe('createNatHandlers', () => {
       secretsStore: makeSecrets(),
       portMapper: mapper,
       externalIpDetector: makeDetector({ pub: '1.2.3.4' }),
+      fetch: okFetch(),
     });
     await svc.start();
     const h = createNatHandlers(svc);

package/src/nat/__tests__/nat-store.test.ts

@@ -1,93 +1,93 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { NatStore } from '../nat-store.js';
-import { NatError } from '../types.js';
-
-let tmpRoot: string;
-
-beforeEach(() => {
-  tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-nat-store-'));
-});
-
-afterEach(() => {
-  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
-});
-
-describe('NatStore', () => {
-  it('returns defaults when file is missing', () => {
-    const store = new NatStore(tmpRoot);
-    const s = store.load();
-    expect(s.externalPort).toBe(4001);
-    expect(s.internalPort).toBe(4001);
-    expect(s.upnpEnabled).toBe(true);
-    expect(s.ddns.providerId).toBeNull();
-    expect(s.ddns.externallyManaged).toBe(false);
-    expect(s.ddns.intervalMs).toBe(5 * 60 * 1000);
-  });
-
-  it('persists and reloads settings atomically', () => {
-    const store = new NatStore(tmpRoot);
-    store.update({ externalPort: 4002, upnpEnabled: false });
-
-    expect(existsSync(join(tmpRoot, 'nat.json'))).toBe(true);
-    expect(existsSync(join(tmpRoot, 'nat.json.tmp'))).toBe(false);
-
-    const reread = new NatStore(tmpRoot);
-    const s = reread.load();
-    expect(s.externalPort).toBe(4002);
-    expect(s.upnpEnabled).toBe(false);
-  });
-
-  it('merges ddns subtree on update', () => {
-    const store = new NatStore(tmpRoot);
-    store.update({
-      ddns: {
-        providerId: 'duckdns',
-        hostname: 'foo.duckdns.org',
-        externallyManaged: false,
-        intervalMs: 60_000,
-      },
-    });
-
-    store.update({ ddns: { externallyManaged: true } as never });
-
-    const s = store.load();
-    expect(s.ddns.providerId).toBe('duckdns');
-    expect(s.ddns.hostname).toBe('foo.duckdns.org');
-    expect(s.ddns.externallyManaged).toBe(true);
-    expect(s.ddns.intervalMs).toBe(60_000);
-  });
-
-  it('persists version field', () => {
-    const store = new NatStore(tmpRoot);
-    store.update({ externalPort: 4001 });
-    const raw = JSON.parse(readFileSync(join(tmpRoot, 'nat.json'), 'utf8'));
-    expect(raw.version).toBe(1);
-  });
-
-  it('throws on malformed JSON rather than silently wiping', () => {
-    writeFileSync(join(tmpRoot, 'nat.json'), 'not json', 'utf8');
-    const store = new NatStore(tmpRoot);
-    expect(() => store.load()).toThrow(NatError);
-  });
-
-  it('rejects invalid port', () => {
-    const store = new NatStore(tmpRoot);
-    expect(() => store.update({ externalPort: 0 })).toThrow(NatError);
-    expect(() => store.update({ externalPort: 70000 })).toThrow(NatError);
-  });
-
-  it('rejects too-small interval', () => {
-    const store = new NatStore(tmpRoot);
-    expect(() => store.update({ ddns: { intervalMs: 500 } as never })).toThrow(NatError);
-  });
-
-  it('rejects empty string providerId/hostname', () => {
-    const store = new NatStore(tmpRoot);
-    expect(() => store.update({ ddns: { providerId: '' } as never })).toThrow(NatError);
-    expect(() => store.update({ ddns: { hostname: '' } as never })).toThrow(NatError);
-  });
-});
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { NatStore } from '../nat-store.js';
+import { NatError } from '../types.js';
+
+let tmpRoot: string;
+
+beforeEach(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-nat-store-'));
+});
+
+afterEach(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe('NatStore', () => {
+  it('returns defaults when file is missing', () => {
+    const store = new NatStore(tmpRoot);
+    const s = store.load();
+    expect(s.externalPort).toBe(4001);
+    expect(s.internalPort).toBe(4001);
+    expect(s.upnpEnabled).toBe(true);
+    expect(s.ddns.providerId).toBeNull();
+    expect(s.ddns.externallyManaged).toBe(false);
+    expect(s.ddns.intervalMs).toBe(5 * 60 * 1000);
+  });
+
+  it('persists and reloads settings atomically', () => {
+    const store = new NatStore(tmpRoot);
+    store.update({ externalPort: 4002, upnpEnabled: false });
+
+    expect(existsSync(join(tmpRoot, 'nat.json'))).toBe(true);
+    expect(existsSync(join(tmpRoot, 'nat.json.tmp'))).toBe(false);
+
+    const reread = new NatStore(tmpRoot);
+    const s = reread.load();
+    expect(s.externalPort).toBe(4002);
+    expect(s.upnpEnabled).toBe(false);
+  });
+
+  it('merges ddns subtree on update', () => {
+    const store = new NatStore(tmpRoot);
+    store.update({
+      ddns: {
+        providerId: 'duckdns',
+        hostname: 'foo.duckdns.org',
+        externallyManaged: false,
+        intervalMs: 60_000,
+      },
+    });
+
+    store.update({ ddns: { externallyManaged: true } as never });
+
+    const s = store.load();
+    expect(s.ddns.providerId).toBe('duckdns');
+    expect(s.ddns.hostname).toBe('foo.duckdns.org');
+    expect(s.ddns.externallyManaged).toBe(true);
+    expect(s.ddns.intervalMs).toBe(60_000);
+  });
+
+  it('persists version field', () => {
+    const store = new NatStore(tmpRoot);
+    store.update({ externalPort: 4001 });
+    const raw = JSON.parse(readFileSync(join(tmpRoot, 'nat.json'), 'utf8'));
+    expect(raw.version).toBe(1);
+  });
+
+  it('throws on malformed JSON rather than silently wiping', () => {
+    writeFileSync(join(tmpRoot, 'nat.json'), 'not json', 'utf8');
+    const store = new NatStore(tmpRoot);
+    expect(() => store.load()).toThrow(NatError);
+  });
+
+  it('rejects invalid port', () => {
+    const store = new NatStore(tmpRoot);
+    expect(() => store.update({ externalPort: 0 })).toThrow(NatError);
+    expect(() => store.update({ externalPort: 70000 })).toThrow(NatError);
+  });
+
+  it('rejects too-small interval', () => {
+    const store = new NatStore(tmpRoot);
+    expect(() => store.update({ ddns: { intervalMs: 500 } as never })).toThrow(NatError);
+  });
+
+  it('rejects empty string providerId/hostname', () => {
+    const store = new NatStore(tmpRoot);
+    expect(() => store.update({ ddns: { providerId: '' } as never })).toThrow(NatError);
+    expect(() => store.update({ ddns: { hostname: '' } as never })).toThrow(NatError);
+  });
+});