@serfab/cadre-host 0.9.0 → 0.11.0

package/src/nat/__tests__/address-resolver.test.ts

@@ -1,82 +1,82 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildInviteAddresses } from '../address-resolver.js';
-
-const PEER = '12D3KooWHost';
-
-describe('buildInviteAddresses', () => {
-  it('returns dns4 when reachable and a DDNS hostname is configured', () => {
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: 'foo.duckdns.org',
-      externalIp: '1.2.3.4',
-      reachable: true,
-      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
-    });
-    expect(addrs).toEqual([`/dns4/foo.duckdns.org/tcp/4001/p2p/${PEER}`]);
-  });
-
-  it('falls back to ip4 when reachable but no DDNS hostname', () => {
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: null,
-      externalIp: '203.0.113.5',
-      reachable: true,
-      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
-    });
-    expect(addrs).toEqual([`/ip4/203.0.113.5/tcp/4001/p2p/${PEER}`]);
-  });
-
-  it('falls back to libp2p addrs when not reachable', () => {
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: 'foo.duckdns.org',
-      externalIp: '1.2.3.4',
-      reachable: false,
-      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001', '/p2p-circuit'],
-    });
-    expect(addrs.length).toBeGreaterThan(0);
-    expect(addrs.some((a) => a.startsWith('/dns4/'))).toBe(false);
-    expect(addrs.some((a) => a.startsWith('/ip4/'))).toBe(true);
-  });
-
-  it('appends peer suffix to libp2p addrs that lack one', () => {
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: null,
-      externalIp: null,
-      reachable: false,
-      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
-    });
-    expect(addrs).toEqual([`/ip4/192.168.1.10/tcp/4001/p2p/${PEER}`]);
-  });
-
-  it('preserves libp2p addrs that already have a /p2p/ suffix', () => {
-    const existing = `/ip4/192.168.1.10/tcp/4001/p2p/${PEER}`;
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: null,
-      externalIp: null,
-      reachable: false,
-      libp2pAddrs: [existing],
-    });
-    expect(addrs).toEqual([existing]);
-  });
-
-  it('does not emit /ip4/ for IPv6 external IP — falls back instead', () => {
-    const addrs = buildInviteAddresses({
-      peerId: PEER,
-      externalPort: 4001,
-      ddnsHostname: null,
-      externalIp: '2001:db8::1',
-      reachable: true,
-      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
-    });
-    expect(addrs.some((a) => a.startsWith('/ip4/192.168.1.10'))).toBe(true);
-  });
-});
+import { describe, expect, it } from 'vitest';
+
+import { buildInviteAddresses } from '../address-resolver.js';
+
+const PEER = '12D3KooWHost';
+
+describe('buildInviteAddresses', () => {
+  it('returns dns4 when reachable and a DDNS hostname is configured', () => {
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: 'foo.duckdns.org',
+      externalIp: '1.2.3.4',
+      reachable: true,
+      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
+    });
+    expect(addrs).toEqual([`/dns4/foo.duckdns.org/tcp/4001/p2p/${PEER}`]);
+  });
+
+  it('falls back to ip4 when reachable but no DDNS hostname', () => {
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: null,
+      externalIp: '203.0.113.5',
+      reachable: true,
+      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
+    });
+    expect(addrs).toEqual([`/ip4/203.0.113.5/tcp/4001/p2p/${PEER}`]);
+  });
+
+  it('falls back to libp2p addrs when not reachable', () => {
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: 'foo.duckdns.org',
+      externalIp: '1.2.3.4',
+      reachable: false,
+      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001', '/p2p-circuit'],
+    });
+    expect(addrs.length).toBeGreaterThan(0);
+    expect(addrs.some((a) => a.startsWith('/dns4/'))).toBe(false);
+    expect(addrs.some((a) => a.startsWith('/ip4/'))).toBe(true);
+  });
+
+  it('appends peer suffix to libp2p addrs that lack one', () => {
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: null,
+      externalIp: null,
+      reachable: false,
+      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
+    });
+    expect(addrs).toEqual([`/ip4/192.168.1.10/tcp/4001/p2p/${PEER}`]);
+  });
+
+  it('preserves libp2p addrs that already have a /p2p/ suffix', () => {
+    const existing = `/ip4/192.168.1.10/tcp/4001/p2p/${PEER}`;
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: null,
+      externalIp: null,
+      reachable: false,
+      libp2pAddrs: [existing],
+    });
+    expect(addrs).toEqual([existing]);
+  });
+
+  it('does not emit /ip4/ for IPv6 external IP — falls back instead', () => {
+    const addrs = buildInviteAddresses({
+      peerId: PEER,
+      externalPort: 4001,
+      ddnsHostname: null,
+      externalIp: '2001:db8::1',
+      reachable: true,
+      libp2pAddrs: ['/ip4/192.168.1.10/tcp/4001'],
+    });
+    expect(addrs.some((a) => a.startsWith('/ip4/192.168.1.10'))).toBe(true);
+  });
+});

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

@@ -1,83 +1,83 @@
-import { describe, expect, it } from 'vitest';
-
-import { duckDnsProvider } from '../ddns/duckdns.js';
-import { NatError } from '../types.js';
-
-function makeFetch(responses: Array<{ ok: boolean; status?: number; body: string }>): {
-  fetch: typeof fetch;
-  calls: string[];
-} {
-  const calls: string[] = [];
-  let i = 0;
-  const fetchImpl = (async (input: RequestInfo | URL) => {
-    calls.push(String(input));
-    const r = responses[i++] ?? { ok: false, body: '' };
-    return {
-      ok: r.ok,
-      status: r.status ?? (r.ok ? 200 : 500),
-      statusText: r.ok ? 'OK' : 'Server Error',
-      async text() { return r.body; },
-    } as unknown as Response;
-  }) as typeof fetch;
-  return { fetch: fetchImpl, calls };
-}
-
-describe('duckDnsProvider', () => {
-  it('exposes metadata', () => {
-    expect(duckDnsProvider.id).toBe('duckdns');
-    expect(duckDnsProvider.displayName).toBe('DuckDNS');
-    expect(duckDnsProvider.configFields).toHaveLength(1);
-    expect(duckDnsProvider.configFields[0]).toMatchObject({ key: 'token', secret: true });
-  });
-
-  it('OK response → resolves', async () => {
-    const f = makeFetch([{ ok: true, body: 'OK' }]);
-    await expect(
-      duckDnsProvider.update({ token: 'T' }, 'foo.duckdns.org', '1.2.3.4', { fetch: f.fetch }),
-    ).resolves.toBeUndefined();
-    expect(f.calls[0]).toContain('domains=foo');
-    expect(f.calls[0]).toContain('token=T');
-    expect(f.calls[0]).toContain('ip=1.2.3.4');
-  });
-
-  it('KO response → throws ddns_update_failed', async () => {
-    const f = makeFetch([{ ok: true, body: 'KO' }]);
-    await expect(
-      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f.fetch }),
-    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
-  });
-
-  it('HTTP error → throws ddns_update_failed', async () => {
-    const f = makeFetch([{ ok: false, status: 503, body: '' }]);
-    await expect(
-      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f.fetch }),
-    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
-  });
-
-  it('strips trailing .duckdns.org from hostname', async () => {
-    const f = makeFetch([{ ok: true, body: 'OK' }]);
-    await duckDnsProvider.update({ token: 'T' }, 'MyHost.DuckDNS.ORG', '1.2.3.4', { fetch: f.fetch });
-    expect(f.calls[0]).toContain('domains=myhost');
-  });
-
-  it('missing token → ddns_credentials_missing', async () => {
-    const f = makeFetch([]);
-    await expect(
-      duckDnsProvider.update({}, 'foo', '1.2.3.4', { fetch: f.fetch }),
-    ).rejects.toMatchObject({ code: 'ddns_credentials_missing' });
-  });
-
-  it('empty hostname → invalid_config', async () => {
-    const f = makeFetch([]);
-    await expect(
-      duckDnsProvider.update({ token: 'T' }, '   ', '1.2.3.4', { fetch: f.fetch }),
-    ).rejects.toBeInstanceOf(NatError);
-  });
-
-  it('network error → ddns_update_failed', async () => {
-    const f = (async () => { throw new Error('ENETUNREACH'); }) as typeof fetch;
-    await expect(
-      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f }),
-    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
-  });
-});
+import { describe, expect, it } from 'vitest';
+
+import { duckDnsProvider } from '../ddns/duckdns.js';
+import { NatError } from '../types.js';
+
+function makeFetch(responses: Array<{ ok: boolean; status?: number; body: string }>): {
+  fetch: typeof fetch;
+  calls: string[];
+} {
+  const calls: string[] = [];
+  let i = 0;
+  const fetchImpl = (async (input: RequestInfo | URL) => {
+    calls.push(String(input));
+    const r = responses[i++] ?? { ok: false, body: '' };
+    return {
+      ok: r.ok,
+      status: r.status ?? (r.ok ? 200 : 500),
+      statusText: r.ok ? 'OK' : 'Server Error',
+      async text() { return r.body; },
+    } as unknown as Response;
+  }) as typeof fetch;
+  return { fetch: fetchImpl, calls };
+}
+
+describe('duckDnsProvider', () => {
+  it('exposes metadata', () => {
+    expect(duckDnsProvider.id).toBe('duckdns');
+    expect(duckDnsProvider.displayName).toBe('DuckDNS');
+    expect(duckDnsProvider.configFields).toHaveLength(1);
+    expect(duckDnsProvider.configFields[0]).toMatchObject({ key: 'token', secret: true });
+  });
+
+  it('OK response → resolves', async () => {
+    const f = makeFetch([{ ok: true, body: 'OK' }]);
+    await expect(
+      duckDnsProvider.update({ token: 'T' }, 'foo.duckdns.org', '1.2.3.4', { fetch: f.fetch }),
+    ).resolves.toBeUndefined();
+    expect(f.calls[0]).toContain('domains=foo');
+    expect(f.calls[0]).toContain('token=T');
+    expect(f.calls[0]).toContain('ip=1.2.3.4');
+  });
+
+  it('KO response → throws ddns_update_failed', async () => {
+    const f = makeFetch([{ ok: true, body: 'KO' }]);
+    await expect(
+      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f.fetch }),
+    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
+  });
+
+  it('HTTP error → throws ddns_update_failed', async () => {
+    const f = makeFetch([{ ok: false, status: 503, body: '' }]);
+    await expect(
+      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f.fetch }),
+    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
+  });
+
+  it('strips trailing .duckdns.org from hostname', async () => {
+    const f = makeFetch([{ ok: true, body: 'OK' }]);
+    await duckDnsProvider.update({ token: 'T' }, 'MyHost.DuckDNS.ORG', '1.2.3.4', { fetch: f.fetch });
+    expect(f.calls[0]).toContain('domains=myhost');
+  });
+
+  it('missing token → ddns_credentials_missing', async () => {
+    const f = makeFetch([]);
+    await expect(
+      duckDnsProvider.update({}, 'foo', '1.2.3.4', { fetch: f.fetch }),
+    ).rejects.toMatchObject({ code: 'ddns_credentials_missing' });
+  });
+
+  it('empty hostname → invalid_config', async () => {
+    const f = makeFetch([]);
+    await expect(
+      duckDnsProvider.update({ token: 'T' }, '   ', '1.2.3.4', { fetch: f.fetch }),
+    ).rejects.toBeInstanceOf(NatError);
+  });
+
+  it('network error → ddns_update_failed', async () => {
+    const f = (async () => { throw new Error('ENETUNREACH'); }) as typeof fetch;
+    await expect(
+      duckDnsProvider.update({ token: 'T' }, 'foo', '1.2.3.4', { fetch: f }),
+    ).rejects.toMatchObject({ code: 'ddns_update_failed' });
+  });
+});