Vito
69de20a427
* feat(system): report configured, effective and watched sources
GET /prompt_manager/settings adds settings.monitoring_enabled, a sources
block (configured roots with valid/code/reason, effective roots with their
listing index and watch state, auto_detected) and the monitor state
(present, observer_alive, scheduled). Every path is a public path.
A source is "watching" only while a live observer scheduled it, "manual"
when monitoring is off or the process has no monitor, and otherwise
"restart_pending".
POST accepts monitoring_enabled as a strict bool, saved under
gallery.monitoring.enabled; restart_required_fields names it when the
running observer does not already match. A save that changes the sources
runs as a "Source change" records hold, so it is refused with 409 busy
while a scan runs. Case variants of one folder are saved once.
POST /prompt_manager/settings/validate-source {path} checks a path
lexically (no "..", no control characters, native path forms only) and
then against the gallery-root rules, answering a code and reason, and
writes nothing.
* fix(system): no existence oracle in source validation
A gallery root's containment in the allowed ComfyUI folders is now
decided before its existence and type, so a path outside them answers
"outside-allowed" whether or not it exists. validate-source also folds
the filesystem-root and home-directory codes into "outside-allowed", with
one reason, and logs the detail server-side only. Paths inside the
allowed folders still say "not-found" or "not-directory". The legacy
settings save shares the same check.
* feat(scan): scan one selected source
POST /prompt_manager/jobs/scan accepts roots: indexes into the effective
sources, strict non-negative ints (no bools or floats), deduplicated, at
most 64, non-empty when present. An index past the sources is a 400
"unknown-source" and starts nothing. The job walks only the selected
sources, resolved when it was requested, and keeps each file's listing
root_index. Its scope records files, roots (null for every source) and
output_folders, the number of folders walked, which the log's first line
counts. The legacy /scan route still scans every source, and attaching to
a scoped job keeps its payload keys.
* feat(system): manage sources and start scans natively
System > Sources & scans renders the concept's section on the server's
sources: one row per effective source with its watch state and a scan
scoped to that source, the 3.2.0 update notice with the legacy dismissal,
Add source checked by validate-source, Remove, monitoring and worker
threads as host drafts behind the one Save row, and Refresh files.
A save refused by a running scan names the job. Thumbnail generation
hands off to the legacy gallery until S5.
Deviations D98, D113 and D-NEW-S4-1 are recorded in TESTING.md.
* fix(security): decide source containment as text before any filesystem access
Every caller (validate-source, POST /settings, config.json at load) now
refuses a source through one check, sources.source_problem: the form
check first, then GalleryConfig.gallery_root_problem, which compares the
normalised spelling with the allowed folders before anything resolves,
stats or opens the path. A UNC share, the \\?\ and \\.\ namespaces, a
device or any outside folder is refused with no SMB request, no
executor stall and no existence or timing oracle; only then is the path
resolved and contained again, which still catches a symlink out. The
filesystem root and the home directory answer outside-allowed with the
same reason as any outside path, so no caller learns the home path.
Also:
- POST /settings runs the form checks and parses the roots off the loop;
an unusable source is a coded 400 invalid-source naming its public
path (as text) and its index.
- ComfyUI folders outside the base directory are path anchors, so their
sources round-trip and never collide by folder name.
- A per-source scan sends each index with its public path; a stale or
shifted index is 409 sources-changed and starts nothing.
- A source still watched after monitoring was switched off is
"stopping".
- Roots are compared as folders, not spellings, so an unchanged legacy
resend takes no source-change hold.
- Tests: no realpath/stat/lstat of an outside path (native and Windows
forms with ntpath fakes), the alike answers with /, ~ and a link to ~,
an event instead of a timer wait, and a teardown that drains jobs
before the temporary database goes.
* fix(system): say what Sources saved, refused and still watches
- A per-source scan sends the source's public path; when the sources
changed since they were read the toast says the server's reason and
the list and saved values are read again.
- "watching until restart" for a source the running monitor still
watches after monitoring was saved off, and the status adds "Restart
ComfyUI to apply: Watch for new outputs." from restart_required_fields.
- A save refused for one unusable source marks that row and the status
is the server's message naming it.
- A valid configured source the effective list holds under another
spelling reads "same folder as another source".
- The busy toast names the job the 409 named (ApiError keeps a
validated running job and refused source), falling back to the list.
- The Add source dialog's listeners live on the page scope and Enter
adds; its markup is compared with the concept (D127).
- TESTING.md: D-NEW-S4-1 is D127; D-NEW-S4-2 records the new copy; the
Sources contract describes the lexical containment, invalid-source and
sources-changed.
* fix(security): guard the Windows form probes on a token of their own
The no-filesystem guard matched "C:", which on a Windows runner is also
the temporary ComfyUI tree the save may resolve for its trusted first
entry. The probe paths now carry a token no trusted directory holds.
* docs(system): number the Sources states deviation D128
375 lines
18 KiB
JavaScript
375 lines
18 KiB
JavaScript
// Run with: node --test tests/js/
|
|
const test = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
const { createApiClient, resolveUrl, fetchUrl, ApiError, latestOnly, STALE } = require("../../web/js/api-client.js");
|
|
|
|
test("Prompt Manager URLs follow the page's proxy mount without losing query strings", () => {
|
|
const url = "/prompt_manager/images/output?limit=100&subfolder=2025%2F04%2F02";
|
|
assert.equal(resolveUrl(url, "/ComfyBackendDirect/prompt_manager/gallery"),
|
|
"/ComfyBackendDirect" + url);
|
|
assert.equal(resolveUrl(url, "/prompt_manager/gallery"), url);
|
|
assert.equal(resolveUrl(url, "/nested/proxy/prompt_manager/admin"), "/nested/proxy" + url);
|
|
assert.equal(resolveUrl("/other/api?x=1", "/ComfyBackendDirect/prompt_manager/gallery"), "/other/api?x=1");
|
|
assert.equal(resolveUrl("/ComfyBackendDirect/prompt_manager/images/serve/a.png", "/ComfyBackendDirect/prompt_manager/gallery"),
|
|
"/ComfyBackendDirect/prompt_manager/images/serve/a.png");
|
|
assert.equal(resolveUrl("/prompt_manager/images/serve/a.png?root=1", "/ComfyBackendDirect/prompt_manager/gallery"),
|
|
"/ComfyBackendDirect/prompt_manager/images/serve/a.png?root=1");
|
|
});
|
|
|
|
test("fetchUrl sends Prompt Manager requests under the current proxy mount", async () => {
|
|
const previousFetch = globalThis.fetch;
|
|
const previousLocation = globalThis.location;
|
|
const calls = [];
|
|
globalThis.location = { pathname: "/ComfyBackendDirect/prompt_manager/admin" };
|
|
globalThis.fetch = async (url, init) => {
|
|
calls.push([url, init]);
|
|
return { ok: true };
|
|
};
|
|
try {
|
|
await fetchUrl("/prompt_manager/settings?show=all", { method: "GET" });
|
|
assert.deepEqual(calls, [["/ComfyBackendDirect/prompt_manager/settings?show=all", { method: "GET" }]]);
|
|
} finally {
|
|
globalThis.fetch = previousFetch;
|
|
globalThis.location = previousLocation;
|
|
}
|
|
});
|
|
|
|
/** A fetch stand-in whose responses the test resolves by hand, in any order. */
|
|
function fakeFetch() {
|
|
const calls = [];
|
|
const impl = (url, init = {}) =>
|
|
new Promise((resolve, reject) => {
|
|
const call = { url, init, resolve, reject, aborted: false };
|
|
if (init.signal) {
|
|
init.signal.addEventListener("abort", () => {
|
|
call.aborted = true;
|
|
reject(new DOMException("The operation was aborted.", "AbortError"));
|
|
});
|
|
}
|
|
calls.push(call);
|
|
});
|
|
impl.calls = calls;
|
|
return impl;
|
|
}
|
|
|
|
function jsonResponse(status, body, { invalid = false } = {}) {
|
|
return {
|
|
ok: status >= 200 && status < 300,
|
|
status,
|
|
statusText: status === 200 ? "OK" : `Status ${status}`,
|
|
json: async () => {
|
|
if (invalid) throw new SyntaxError("Unexpected token");
|
|
return body;
|
|
},
|
|
};
|
|
}
|
|
|
|
test("get returns the parsed body of a successful response", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.get("/prompt_manager/recent?page=1");
|
|
fetch.calls[0].resolve(jsonResponse(200, { success: true, results: [1, 2] }));
|
|
assert.deepEqual(await pending, { success: true, results: [1, 2] });
|
|
assert.equal(fetch.calls[0].init.method, "GET");
|
|
});
|
|
|
|
test("get forwards an AbortSignal to fetch", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const controller = new AbortController();
|
|
const pending = api.get("/x", { signal: controller.signal });
|
|
assert.equal(fetch.calls[0].init.signal, controller.signal);
|
|
controller.abort();
|
|
await assert.rejects(pending, (err) => err.name === "AbortError");
|
|
});
|
|
|
|
test("non-2xx responses throw ApiError carrying the status and server message", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.get("/x");
|
|
fetch.calls[0].resolve(jsonResponse(404, { success: false, error: "Prompt not found" }));
|
|
await assert.rejects(pending, (err) => {
|
|
assert.ok(err instanceof ApiError);
|
|
assert.ok(err instanceof Error);
|
|
assert.equal(err.status, 404);
|
|
assert.equal(err.message, "Prompt not found");
|
|
return true;
|
|
});
|
|
});
|
|
|
|
test("non-2xx responses without a JSON body fall back to the status text", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.get("/x");
|
|
fetch.calls[0].resolve(jsonResponse(500, null, { invalid: true }));
|
|
await assert.rejects(pending, (err) => err.status === 500 && err.message === "Status 500");
|
|
});
|
|
|
|
test("a 2xx body with success:false throws ApiError", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.post("/x", {});
|
|
fetch.calls[0].resolve(jsonResponse(200, { success: false, error: "Nope" }));
|
|
await assert.rejects(pending, (err) => err instanceof ApiError && err.status === 200 && err.message === "Nope");
|
|
});
|
|
|
|
test("ApiError preserves only a bounded machine code without changing status or message", async () => {
|
|
assert.equal(new ApiError(409, "unchanged").code, null);
|
|
for (const [code, expected] of [
|
|
["source-changed", "source-changed"], ["a".repeat(64), "a".repeat(64)],
|
|
[undefined, null], [null, null], [4, null], [{ code: "x" }, null],
|
|
["", null], ["Source-changed", null], ["source_changed", null],
|
|
["source-changed\n", null], ["a".repeat(65), null],
|
|
]) {
|
|
for (const status of [409, 200]) {
|
|
const api = createApiClient(async () => jsonResponse(status, {
|
|
success: false, error: "unchanged", code, private: "never expose",
|
|
}));
|
|
await assert.rejects(api.get("/x"), error => {
|
|
assert.ok(error instanceof ApiError);
|
|
assert.equal(error.status, status);
|
|
assert.equal(error.message, "unchanged");
|
|
assert.equal(error.code, expected);
|
|
assert.equal(error.private, undefined);
|
|
assert.equal(error.body, undefined);
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
test("a 2xx body that is not JSON throws ApiError", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.get("/x");
|
|
fetch.calls[0].resolve(jsonResponse(200, null, { invalid: true }));
|
|
await assert.rejects(pending, (err) => err instanceof ApiError && err.status === 200);
|
|
});
|
|
|
|
test("post, put and del send JSON bodies with the right method", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const p1 = api.post("/a", { text: "x" });
|
|
const p2 = api.put("/b", { rating: 3 });
|
|
const p3 = api.del("/c");
|
|
assert.equal(fetch.calls[0].init.method, "POST");
|
|
assert.equal(fetch.calls[0].init.body, JSON.stringify({ text: "x" }));
|
|
assert.equal(fetch.calls[0].init.headers["Content-Type"], "application/json");
|
|
assert.equal(fetch.calls[1].init.method, "PUT");
|
|
assert.equal(fetch.calls[1].init.body, JSON.stringify({ rating: 3 }));
|
|
assert.equal(fetch.calls[2].init.method, "DELETE");
|
|
assert.equal(fetch.calls[2].init.body, undefined);
|
|
for (const c of fetch.calls) c.resolve(jsonResponse(200, { success: true }));
|
|
await Promise.all([p1, p2, p3]);
|
|
});
|
|
|
|
test("del sends an optional JSON body", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const controller = new AbortController();
|
|
const pending = api.del("/prompt_manager/images/favorite", { body: { root_index: 1, path: "a/b.png" }, signal: controller.signal });
|
|
assert.equal(fetch.calls[0].init.method, "DELETE");
|
|
assert.equal(fetch.calls[0].init.body, JSON.stringify({ root_index: 1, path: "a/b.png" }));
|
|
assert.equal(fetch.calls[0].init.headers["Content-Type"], "application/json");
|
|
assert.equal(fetch.calls[0].init.signal, controller.signal);
|
|
fetch.calls[0].resolve(jsonResponse(200, { success: true }));
|
|
await pending;
|
|
});
|
|
|
|
test("network failures propagate as ordinary errors", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const pending = api.get("/x");
|
|
fetch.calls[0].reject(new TypeError("Failed to fetch"));
|
|
await assert.rejects(pending, (err) => err instanceof TypeError && !(err instanceof ApiError));
|
|
});
|
|
|
|
test("createApiClient without an argument uses the global fetch", async () => {
|
|
const original = globalThis.fetch;
|
|
globalThis.fetch = async () => jsonResponse(200, { success: true, via: "global" });
|
|
try {
|
|
assert.deepEqual(await createApiClient().get("/x"), { success: true, via: "global" });
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("latestOnly: a newer call aborts the older one and the older result is STALE", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const latest = latestOnly();
|
|
|
|
const first = latest((signal) => api.get("/search?q=a", { signal }));
|
|
const second = latest((signal) => api.get("/search?q=ab", { signal }));
|
|
|
|
assert.equal(fetch.calls[0].aborted, true, "first request aborted");
|
|
assert.equal(fetch.calls[1].aborted, false);
|
|
|
|
fetch.calls[1].resolve(jsonResponse(200, { success: true, q: "ab" }));
|
|
assert.deepEqual(await second, { success: true, q: "ab" });
|
|
assert.equal(await first, STALE);
|
|
});
|
|
|
|
test("latestOnly: an older response that arrives after a newer request is STALE even without abort", async () => {
|
|
const latest = latestOnly();
|
|
let resolveFirst;
|
|
const first = latest(() => new Promise((r) => { resolveFirst = r; }));
|
|
const second = latest(async () => "new");
|
|
assert.equal(await second, "new");
|
|
resolveFirst("old");
|
|
assert.equal(await first, STALE);
|
|
});
|
|
|
|
test("latestOnly: sequential calls each return their own result", async () => {
|
|
const latest = latestOnly();
|
|
assert.equal(await latest(async () => 1), 1);
|
|
assert.equal(await latest(async () => 2), 2);
|
|
});
|
|
|
|
test("latestOnly: errors from the current call propagate, errors from superseded calls do not", async () => {
|
|
const latest = latestOnly();
|
|
let rejectFirst;
|
|
const first = latest(() => new Promise((_, rej) => { rejectFirst = rej; }));
|
|
const second = latest(async () => { throw new Error("boom"); });
|
|
await assert.rejects(second, /boom/);
|
|
rejectFirst(new Error("old failure"));
|
|
assert.equal(await first, STALE);
|
|
});
|
|
|
|
test("latestOnly with a lifetime: once it ends, no request starts and the call is STALE", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const page = new AbortController();
|
|
const latest = latestOnly({ lifetime: page.signal });
|
|
page.abort();
|
|
assert.equal(await latest((signal) => api.get("/recent", { signal })), STALE);
|
|
assert.equal(fetch.calls.length, 0, "a leaving page starts no read");
|
|
});
|
|
|
|
test("latestOnly with a lifetime: its end aborts the request in flight, which is STALE, not an error", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const page = new AbortController();
|
|
const latest = latestOnly({ lifetime: page.signal });
|
|
const call = latest((signal) => api.get("/recent", { signal }));
|
|
page.abort();
|
|
assert.equal(fetch.calls[0].aborted, true, "the read in flight is aborted");
|
|
fetch.calls[0].reject(new DOMException("The operation was aborted.", "AbortError"));
|
|
assert.equal(await call, STALE);
|
|
});
|
|
|
|
test("latestOnly with a lifetime: real errors still propagate while the page lives", async () => {
|
|
const page = new AbortController();
|
|
const latest = latestOnly({ lifetime: page.signal });
|
|
await assert.rejects(latest(async () => { throw new Error("server down"); }), /server down/);
|
|
assert.equal(await latest(async () => "fine"), "fine");
|
|
});
|
|
|
|
test("ApiError exposes only validated history recovery actions on all error paths", async () => {
|
|
const permitted = [null, { action: "refresh-history" }, { action: "reload-outputs" },
|
|
{ action: "retry-read" }, { action: "smaller-limit", limit: 1 },
|
|
{ action: "smaller-limit", limit: 100 }];
|
|
const denied = [undefined, false, "refresh-history", [], {}, { action: "unknown" },
|
|
{ action: "refresh-history", private: "secret" }, { action: "retry-read", limit: 1 },
|
|
{ action: "smaller-limit" }, { action: "smaller-limit", limit: 0 },
|
|
{ action: "smaller-limit", limit: 101 }, { action: "smaller-limit", limit: true },
|
|
{ action: "smaller-limit", limit: "1" }, { action: "smaller-limit", limit: 1.5 },
|
|
{ action: "smaller-limit", limit: NaN }, { action: "smaller-limit", limit: Infinity },
|
|
{ action: "smaller-limit", limit: 10, url: "/private" },
|
|
Object.assign(Object.create({ action: "retry-read" }), { private: "secret" })];
|
|
assert.equal(new ApiError(409, "old caller").recovery, null);
|
|
for (const recovery of permitted.concat(denied)) {
|
|
for (const status of [409, 200]) {
|
|
const api = createApiClient(async () => jsonResponse(status, {
|
|
success: false, error: "bounded", code: "history-changed", recovery,
|
|
}));
|
|
await assert.rejects(api.get("/x"), error => {
|
|
assert.ok(error instanceof ApiError);
|
|
assert.equal(error.code, "history-changed");
|
|
assert.deepEqual(error.recovery, permitted.includes(recovery) ? recovery : null);
|
|
if (recovery && permitted.includes(recovery)) {
|
|
assert.notEqual(error.recovery, recovery, "server objects must be copied");
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
test("patch sends a JSON body with the PATCH method and forwards an AbortSignal", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
assert.equal(typeof api.patch, "function");
|
|
const controller = new AbortController();
|
|
const pending = api.patch("/prompt_manager/library/7", { metadata: { rating: null } }, { signal: controller.signal });
|
|
assert.equal(fetch.calls[0].init.method, "PATCH");
|
|
assert.equal(fetch.calls[0].init.body, JSON.stringify({ metadata: { rating: null } }));
|
|
assert.equal(fetch.calls[0].init.headers["Content-Type"], "application/json");
|
|
assert.equal(fetch.calls[0].init.signal, controller.signal);
|
|
fetch.calls[0].resolve(jsonResponse(409, { success: false, code: "metadata-conflict", error: "changed" }));
|
|
await assert.rejects(pending, error => error instanceof ApiError && error.status === 409 && error.code === "metadata-conflict");
|
|
});
|
|
|
|
test("get forwards an explicit cache mode and keeps the default request otherwise", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const fresh = api.get("/prompt_manager/library/options", { cache: "no-store" });
|
|
const plain = api.get("/prompt_manager/library/options");
|
|
assert.equal(fetch.calls[0].init.cache, "no-store");
|
|
assert.equal("cache" in fetch.calls[1].init, false);
|
|
assert.deepEqual(fetch.calls[1].init, { method: "GET", headers: {} });
|
|
for (const call of fetch.calls) call.resolve(jsonResponse(200, { success: true }));
|
|
await Promise.all([fresh, plain]);
|
|
const writes = api.post("/x", {}, { cache: "no-store" });
|
|
assert.equal("cache" in fetch.calls[2].init, false, "only reads take a cache mode");
|
|
fetch.calls[2].resolve(jsonResponse(200, { success: true }));
|
|
await writes;
|
|
});
|
|
|
|
test("ApiError exposes only a validated current tag set from a tag-conflict body", async () => {
|
|
const permitted = [{ tags: [], tag_revision: 0 }, { tags: ["warm", "Dune"], tag_revision: 7 }];
|
|
const denied = [undefined, null, { tags: ["a"] }, { tag_revision: 1 }, { tags: "a", tag_revision: 1 },
|
|
{ tags: [1], tag_revision: 1 }, { tags: ["a"], tag_revision: -1 }, { tags: ["a"], tag_revision: 1.5 },
|
|
{ tags: ["a"], tag_revision: true }, { tags: Array(101).fill("a"), tag_revision: 1 }];
|
|
assert.equal(new ApiError(409, "old caller").current, null);
|
|
for (const current of permitted.concat(denied)) {
|
|
const api = createApiClient(async () => jsonResponse(409, {
|
|
success: false, error: "changed", code: "tag-conflict", ...(current || {}),
|
|
}));
|
|
await assert.rejects(api.put("/x", {}), error => {
|
|
assert.ok(error instanceof ApiError);
|
|
assert.deepEqual(error.current, permitted.includes(current) ? current : null);
|
|
if (permitted.includes(current)) assert.notEqual(error.current.tags, current.tags, "server arrays must be copied");
|
|
return true;
|
|
});
|
|
}
|
|
});
|
|
|
|
test("keepalive is forwarded only when asked, so a request can outlive its page", async () => {
|
|
const fetch = fakeFetch();
|
|
const api = createApiClient(fetch);
|
|
const writes = [api.del("/x", { keepalive: true }), api.put("/x", {}, { keepalive: true }), api.post("/x", {}, { keepalive: true }),
|
|
api.del("/x"), api.put("/x", {}), api.get("/x")];
|
|
assert.deepEqual(fetch.calls.map(call => call.init.keepalive), [true, true, true, undefined, undefined, undefined]);
|
|
assert.equal("keepalive" in fetch.calls[3].init, false);
|
|
for (const call of fetch.calls) call.resolve(jsonResponse(200, { success: true }));
|
|
await Promise.all(writes);
|
|
});
|
|
|
|
test("ApiError keeps a validated running job on busy and a validated source on invalid-source", () => {
|
|
const body = { running: { id: "a".repeat(32), title: "Scan for metadata" }, source: "output/gone" };
|
|
const busy = new ApiError(409, "busy", "busy", null, body);
|
|
assert.deepEqual([busy.running, busy.source], [{ id: "a".repeat(32), title: "Scan for metadata" }, null]);
|
|
assert.notEqual(busy.running, body.running, "server objects must be copied");
|
|
const invalid = new ApiError(400, "refused", "invalid-source", null, body);
|
|
assert.deepEqual([invalid.running, invalid.source], [null, "output/gone"]);
|
|
for (const running of [null, "x", { id: 1, title: "t" }, { id: "a b", title: "t" }, { id: "a", title: "" },
|
|
{ id: "a", title: "x".repeat(201) }, { id: "a".repeat(65), title: "t" }]) {
|
|
assert.equal(new ApiError(409, "busy", "busy", null, { running }).running, null);
|
|
}
|
|
for (const source of [null, 7, "", "x".repeat(4097)]) {
|
|
assert.equal(new ApiError(400, "refused", "invalid-source", null, { source }).source, null);
|
|
}
|
|
assert.deepEqual([new ApiError(409, "old caller").running, new ApiError(409, "old caller").source], [null, null]);
|
|
});
|