@aiti-ai/ddns-mocks 0.0.0-stage → 0.1.0

package/dist/dyndns.d.ts

@@ -0,0 +1,26 @@
+/** Generic dyndns2 mock — serves any of the update-only services: checks
+ *  basic auth (when configured), records hostname/myip, and returns a
+ *  configurable body so success/nochg/error semantics can be tested. */
+export interface DyndnsMockOptions {
+    /** Require this basic-auth credential ("user:pass"). Empty = skip auth. */
+    auth?: string;
+    /** Response body (default "good 1.2.3.4"). */
+    okText?: string;
+    /** Response body when no basic auth matches (default "badauth"). */
+    badAuthText?: string;
+    port?: number;
+}
+export interface DyndnsMockState {
+    requests: Array<{
+        url: string;
+        hostname: string | null;
+        myip: string | null;
+        auth: string | null;
+    }>;
+}
+export interface DyndnsMockHandle {
+    url: string;
+    state: DyndnsMockState;
+    stop(): Promise<void>;
+}
+export declare function startDyndnsMock(opts?: DyndnsMockOptions): Promise<DyndnsMockHandle>;

package/dist/dyndns.js

@@ -0,0 +1,30 @@
+/** Generic dyndns2 mock — serves any of the update-only services: checks
+ *  basic auth (when configured), records hostname/myip, and returns a
+ *  configurable body so success/nochg/error semantics can be tested. */
+import { createServer } from "node:http";
+export async function startDyndnsMock(opts = {}) {
+    const state = { requests: [] };
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const auth = req.headers.authorization ?? null;
+        const expected = opts.auth ? `Basic ${Buffer.from(opts.auth).toString("base64")}` : null;
+        state.requests.push({
+            url: url.pathname + url.search,
+            hostname: url.searchParams.get("hostname"),
+            myip: url.searchParams.get("myip"),
+            auth,
+        });
+        res.writeHead(200, { "content-type": "text/plain" });
+        if (expected && auth !== expected)
+            return res.end(opts.badAuthText ?? "badauth");
+        res.end(opts.okText ?? "good 203.0.113.1");
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/freedns.d.ts

@@ -0,0 +1,23 @@
+/** freedns mock — in-memory sync.afraid.org (Go ddns-updater shape:
+ *  GET /u/<token>/, response text decides success). Also accepts the
+ *  optional ?value= param (the classic afraid.org update API) for clients
+ *  that push arbitrary values. */
+export interface FreednsMockOptions {
+    token?: string;
+    /** Response body on success (default "updated 203.0.113.1"). */
+    okText?: string;
+    port?: number;
+}
+export interface FreednsMockState {
+    requests: Array<{
+        url: string;
+        token: string | null;
+        value: string | null;
+    }>;
+}
+export interface FreednsMockHandle {
+    url: string;
+    state: FreednsMockState;
+    stop(): Promise<void>;
+}
+export declare function startFreednsMock(opts?: FreednsMockOptions): Promise<FreednsMockHandle>;

package/dist/freedns.js

@@ -0,0 +1,28 @@
+/** freedns mock — in-memory sync.afraid.org (Go ddns-updater shape:
+ *  GET /u/<token>/, response text decides success). Also accepts the
+ *  optional ?value= param (the classic afraid.org update API) for clients
+ *  that push arbitrary values. */
+import { createServer } from "node:http";
+export async function startFreednsMock(opts = {}) {
+    const token = opts.token ?? "freedns-token";
+    const state = { requests: [] };
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const m = /^\/u\/([^/]+)\/?$/.exec(url.pathname);
+        const tok = m?.[1] ?? null;
+        const value = url.searchParams.get("value");
+        state.requests.push({ url: url.pathname + url.search, token: tok, value });
+        res.writeHead(200, { "content-type": "text/plain" });
+        if (tok !== token)
+            return res.end("invalid token");
+        res.end(opts.okText ?? "updated 203.0.113.1");
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+/** mocks — one in-memory mock per provider, mirroring the REAL provider
+ *  HTTP APIs closely enough that third-party implementations (Go
+ *  ddns-updater, Python lexicon) pointed at the mock also work:
+ *
+ *    cloudflare → api.cloudflare.com/client/v4 (REST, Bearer token)
+ *    dnspod     → dnsapi.cn Record.* (form POST, login_token)
+ *    aliyun     → alidns.aliyuncs.com (signed RPC; signature verified when
+ *                 the mock is given the AccessKeySecret)
+ *    duckdns    → www.duckdns.org/v3/update ("OK"/"KO")
+ *    custom     → arbitrary webhook URL (success regex semantics)
+ *
+ *  Every mock returns a handle with `url` to inject as the provider's
+ *  baseUrl and a `state` object to assert on. Start one with
+ *  startMockProvider(name, opts), or all of them with startAllMocks().
+ */
+export type MockProviderName = string;
+import { type CloudflareMockHandle, type CloudflareMockOptions } from "./cloudflare.ts";
+import { type DnspodMockHandle, type DnspodMockOptions } from "./dnspod.ts";
+import { type AliyunMockHandle, type AliyunMockOptions } from "./aliyun.ts";
+import { type DuckdnsMockHandle, type DuckdnsMockOptions } from "./duckdns.ts";
+import { type CustomMockHandle, type CustomMockOptions } from "./custom.ts";
+import { type FreednsMockHandle, type FreednsMockOptions } from "./freedns.ts";
+import { type RestMockHandle } from "./rest.ts";
+import { type DyndnsMockHandle } from "./dyndns.ts";
+import { type LooseMockHandle } from "./loose.ts";
+import { type Route53MockHandle } from "./route53.ts";
+export type AnyMockHandle = CloudflareMockHandle | DnspodMockHandle | AliyunMockHandle | DuckdnsMockHandle | CustomMockHandle | FreednsMockHandle | RestMockHandle | DyndnsMockHandle | LooseMockHandle | Route53MockHandle;
+export type MockOptionsMap = {
+    cloudflare: CloudflareMockOptions;
+    dnspod: DnspodMockOptions;
+    aliyun: AliyunMockOptions;
+    duckdns: DuckdnsMockOptions;
+    custom: CustomMockOptions;
+    freedns: FreednsMockOptions;
+};
+/** Start a mock for ANY registered provider name (rest specs + dyndns
+ *  services get their generic mocks automatically). */
+export declare function startMockFor(name: string, opts?: {
+    zone?: string;
+    cred?: string;
+    records?: Array<{
+        type: string;
+        name: string;
+        value: string;
+        ttl?: number;
+    }>;
+    port?: number;
+}): Promise<AnyMockHandle>;
+export declare function startMockProvider(name: MockProviderName, opts?: Record<string, unknown>): Promise<AnyMockHandle>;
+export interface AllMocksHandle {
+    handles: Record<MockProviderName, AnyMockHandle>;
+    stopAll(): Promise<void>;
+}
+/** Start every provider mock (aliyun needs a zone). */
+export declare function startAllMocks(opts?: {
+    aliyunZone: string;
+}): Promise<AllMocksHandle>;
+export { startCloudflareMock } from "./cloudflare.ts";
+export { startDnspodMock } from "./dnspod.ts";
+export { startAliyunMock } from "./aliyun.ts";
+export { startDuckdnsMock } from "./duckdns.ts";
+export { startCustomMock } from "./custom.ts";
+export { startFreednsMock } from "./freedns.ts";
+export { startRestMock } from "./rest.ts";
+export { startDyndnsMock } from "./dyndns.ts";
+export { startTlsProxy, caCertPath, serverCertPath, MOCK_HOSTS } from "./tls.ts";
+export type { CloudflareMockHandle, CloudflareMockOptions, CloudflareMockState } from "./cloudflare.ts";
+export type { DnspodMockHandle, DnspodMockOptions, DnspodMockState } from "./dnspod.ts";
+export type { AliyunMockHandle, AliyunMockOptions, AliyunMockState } from "./aliyun.ts";
+export type { DuckdnsMockHandle, DuckdnsMockOptions, DuckdnsMockState } from "./duckdns.ts";
+export type { CustomMockHandle, CustomMockOptions, CustomMockState } from "./custom.ts";
+export type { FreednsMockHandle, FreednsMockOptions, FreednsMockState } from "./freedns.ts";
+export type { RestMockHandle, RestMockOptions, RestMockState } from "./rest.ts";
+export type { DyndnsMockHandle, DyndnsMockOptions, DyndnsMockState } from "./dyndns.ts";

package/dist/index.js

@@ -0,0 +1,83 @@
+/** mocks — one in-memory mock per provider, mirroring the REAL provider
+ *  HTTP APIs closely enough that third-party implementations (Go
+ *  ddns-updater, Python lexicon) pointed at the mock also work:
+ *
+ *    cloudflare → api.cloudflare.com/client/v4 (REST, Bearer token)
+ *    dnspod     → dnsapi.cn Record.* (form POST, login_token)
+ *    aliyun     → alidns.aliyuncs.com (signed RPC; signature verified when
+ *                 the mock is given the AccessKeySecret)
+ *    duckdns    → www.duckdns.org/v3/update ("OK"/"KO")
+ *    custom     → arbitrary webhook URL (success regex semantics)
+ *
+ *  Every mock returns a handle with `url` to inject as the provider's
+ *  baseUrl and a `state` object to assert on. Start one with
+ *  startMockProvider(name, opts), or all of them with startAllMocks().
+ */
+import { startCloudflareMock } from "./cloudflare.js";
+import { startDnspodMock } from "./dnspod.js";
+import { startAliyunMock } from "./aliyun.js";
+import { startDuckdnsMock } from "./duckdns.js";
+import { startCustomMock } from "./custom.js";
+import { startFreednsMock } from "./freedns.js";
+import { startRestMock } from "./rest.js";
+import { startDyndnsMock } from "./dyndns.js";
+import { startLooseZoneMock } from "./loose.js";
+import { startRoute53Mock } from "./route53.js";
+import { registry } from "@aiti-ai/ddns/plugins";
+/** Start a mock for ANY registered provider name (rest specs + dyndns
+ *  services get their generic mocks automatically). */
+export async function startMockFor(name, opts = {}) {
+    const { REST_SPECS } = await import("@aiti-ai/ddns/rest-specs");
+    const { DYNDNS_SERVICES } = await import("@aiti-ai/ddns/dyndns-services");
+    const rest = REST_SPECS.find((s) => s.name === name);
+    if (rest)
+        return startRestMock({ spec: rest, zone: opts.zone ?? "example.com", cred: opts.cred, records: opts.records, port: opts.port });
+    const dyn = DYNDNS_SERVICES.find((s) => s.name === name);
+    if (dyn)
+        return startDyndnsMock({ auth: dyn.tokenOnly ? undefined : "user:pass", okText: `${dyn.successPrefixes[0] ?? "good"} 1.2.3.4`, port: opts.port });
+    // hand-written providers without a dedicated mock: loose zone REST mock
+    return startLooseZoneMock({ provider: name, auth: "none", cred: "test-token", ...(opts.zone ? { zone: opts.zone } : {}), ...(opts.records ? { records: opts.records } : {}), ...(opts.port ? { port: opts.port } : {}) });
+}
+export async function startMockProvider(name, opts = {}) {
+    switch (name) {
+        case "cloudflare": return startCloudflareMock(opts);
+        case "dnspod": return startDnspodMock(opts);
+        case "aliyun": return startAliyunMock(opts);
+        case "duckdns": return startDuckdnsMock(opts);
+        case "custom": return startCustomMock(opts);
+        case "freedns": return startFreednsMock(opts);
+        case "route53": return startRoute53Mock(opts);
+        default: {
+            const pluginMock = registry.getMock(name);
+            if (pluginMock)
+                return pluginMock(opts);
+            return startMockFor(name, opts);
+        }
+    }
+}
+/** Start every provider mock (aliyun needs a zone). */
+export async function startAllMocks(opts = { aliyunZone: "example.com" }) {
+    const [cloudflare, dnspod, aliyun, duckdns, custom, freedns] = await Promise.all([
+        startCloudflareMock(),
+        startDnspodMock(),
+        startAliyunMock({ zone: opts.aliyunZone }),
+        startDuckdnsMock(),
+        startCustomMock(),
+        startFreednsMock(),
+    ]);
+    return {
+        handles: { cloudflare, dnspod, aliyun, duckdns, custom, freedns },
+        stopAll: async () => {
+            await Promise.all([cloudflare.stop(), dnspod.stop(), aliyun.stop(), duckdns.stop(), custom.stop(), freedns.stop()]);
+        },
+    };
+}
+export { startCloudflareMock } from "./cloudflare.js";
+export { startDnspodMock } from "./dnspod.js";
+export { startAliyunMock } from "./aliyun.js";
+export { startDuckdnsMock } from "./duckdns.js";
+export { startCustomMock } from "./custom.js";
+export { startFreednsMock } from "./freedns.js";
+export { startRestMock } from "./rest.js";
+export { startDyndnsMock } from "./dyndns.js";
+export { startTlsProxy, caCertPath, serverCertPath, MOCK_HOSTS } from "./tls.js";

package/dist/loose.d.ts

@@ -0,0 +1,58 @@
+/** Loose zone REST mock — one shared mock for the hand-written providers
+ *  whose CRUD follows the common zone-REST pattern (GET list, POST create,
+ *  PUT update, DELETE by id) with varying paths/auth. It answers ANY path:
+ *
+ *    GET    → returns stored records (superset apiShape — every fields
+ *             mapping in rest-specs can read name/content/data/…)
+ *    POST   → creates a record (parses name/value/type from any common
+ *             body field via stdRec: name/host/domain, data/content/value)
+ *    PUT    → updates by trailing id segment
+ *    DELETE → removes by trailing id segment
+ *
+ *  Auth is checked per kind: bearer / basic / none / token-in-body.
+ *  This is what makes every hand-written provider verifiable through
+ *  verify-all.mjs (ours + lexicon over HTTPS_PROXY).
+ */
+export interface LooseMockOptions {
+    /** Provider name for response-shape adaptation. */
+    provider?: string;
+    /** Authentication the mock enforces. Default "bearer". */
+    auth?: "bearer" | "basic" | "none";
+    /** Credential to accept. Default "test-token"; basic = "user:pass". */
+    cred?: string;
+    /** Pre-seeded records ({type,name,value,ttl}). */
+    records?: Array<{
+        type: string;
+        name: string;
+        value: string;
+        ttl?: number;
+    }>;
+    /** Extra auth key the provider must include (e.g. custom header). */
+    header?: {
+        key: string;
+        value: string;
+    };
+    port?: number;
+}
+export interface LooseMockState {
+    records: Array<{
+        id: string;
+        type: string;
+        name: string;
+        value: string;
+        ttl?: number;
+    }>;
+    requests: Array<{
+        method: string;
+        url: string;
+        body?: unknown;
+    }>;
+}
+export interface LooseMockHandle {
+    url: string;
+    state: LooseMockState;
+    stop(): Promise<void>;
+}
+declare const defaultFetchLike: null;
+export declare function startLooseZoneMock(opts?: LooseMockOptions): Promise<LooseMockHandle>;
+export { defaultFetchLike };