vultr/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-04-28 09:33:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: tighten channel auth and network coverage

Browse Source
This commit is contained in:
Peter Steinberger
2026-03-13 18:06:39 +00:00
parent 572df97179
commit 8f4e77e72f
2 changed files with 172 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/telegram/network-errors.test.ts
View File

@@ -9,6 +9,11 @@ import {
tagTelegramNetworkError,
} from "./network-errors.js";
const errorWithCode = (message: string, code: string) =>
Object.assign(new Error(message), { code });
const errorWithTelegramCode = (message: string, error_code: number) =>
Object.assign(new Error(message), { error_code });
describe("isRecoverableTelegramNetworkError", () => {
it("tracks Telegram polling origin separately from generic network matching", () => {
const slackDnsError = Object.assign(
@@ -32,16 +37,12 @@ describe("isRecoverableTelegramNetworkError", () => {
expect(isTelegramPollingNetworkError(slackDnsError)).toBe(true);
});
it("detects recoverable error codes", () => {
const err = Object.assign(new Error("timeout"), { code: "ETIMEDOUT" });
expect(isRecoverableTelegramNetworkError(err)).toBe(true);
});
it("detects additional recoverable error codes", () => {
const aborted = Object.assign(new Error("aborted"), { code: "ECONNABORTED" });
const network = Object.assign(new Error("network"), { code: "ERR_NETWORK" });
expect(isRecoverableTelegramNetworkError(aborted)).toBe(true);
expect(isRecoverableTelegramNetworkError(network)).toBe(true);
it.each([
["ETIMEDOUT", "timeout"],
["ECONNABORTED", "aborted"],
["ERR_NETWORK", "network"],
])("detects recoverable error code %s", (code, message) => {
expect(isRecoverableTelegramNetworkError(errorWithCode(message, code))).toBe(true);
});
it("detects AbortError names", () => {
@@ -69,6 +70,19 @@ describe("isRecoverableTelegramNetworkError", () => {
expect(isRecoverableTelegramNetworkError(err, { context: "polling" })).toBe(true);
});
it("honors allowMessageMatch=false for broad snippet matches", () => {
expect(
isRecoverableTelegramNetworkError(new Error("Undici: socket failure"), {
allowMessageMatch: false,
}),
).toBe(false);
expect(
isRecoverableTelegramNetworkError(new Error("TypeError: fetch failed"), {
allowMessageMatch: false,
}),
).toBe(true);
});
it("skips broad message matches for send context", () => {
const networkRequestErr = new Error("Network request for 'sendMessage' failed!");
expect(isRecoverableTelegramNetworkError(networkRequestErr, { context: "send" })).toBe(false);
@@ -97,6 +111,14 @@ describe("isRecoverableTelegramNetworkError", () => {
expect(isRecoverableTelegramNetworkError(err)).toBe(true);
});
it("normalizes blank tagged origins to null and finds nested tags", () => {
const inner = new Error("inner");
tagTelegramNetworkError(inner, { method: " ", url: " " });
const outer = Object.assign(new Error("outer"), { cause: inner });
expect(getTelegramNetworkErrorOrigin(outer)).toEqual({ method: null, url: null });
expect(isTelegramPollingNetworkError(outer)).toBe(false);
});
// Grammy HttpError tests (issue #3815)
// Grammy wraps fetch errors in .error property, not .cause
describe("Grammy HttpError", () => {
@@ -138,49 +160,18 @@ describe("isRecoverableTelegramNetworkError", () => {
});
describe("isSafeToRetrySendError", () => {
it("allows retry for ECONNREFUSED (pre-connect, message not sent)", () => {
const err = Object.assign(new Error("connect ECONNREFUSED"), { code: "ECONNREFUSED" });
expect(isSafeToRetrySendError(err)).toBe(true);
});
it("allows retry for ENOTFOUND (DNS failure, message not sent)", () => {
const err = Object.assign(new Error("getaddrinfo ENOTFOUND"), { code: "ENOTFOUND" });
expect(isSafeToRetrySendError(err)).toBe(true);
});
it("allows retry for EAI_AGAIN (transient DNS, message not sent)", () => {
const err = Object.assign(new Error("getaddrinfo EAI_AGAIN"), { code: "EAI_AGAIN" });
expect(isSafeToRetrySendError(err)).toBe(true);
});
it("allows retry for ENETUNREACH (no route to host, message not sent)", () => {
const err = Object.assign(new Error("connect ENETUNREACH"), { code: "ENETUNREACH" });
expect(isSafeToRetrySendError(err)).toBe(true);
});
it("allows retry for EHOSTUNREACH (host unreachable, message not sent)", () => {
const err = Object.assign(new Error("connect EHOSTUNREACH"), { code: "EHOSTUNREACH" });
expect(isSafeToRetrySendError(err)).toBe(true);
});
it("does NOT allow retry for ECONNRESET (message may already be delivered)", () => {
const err = Object.assign(new Error("read ECONNRESET"), { code: "ECONNRESET" });
expect(isSafeToRetrySendError(err)).toBe(false);
});
it("does NOT allow retry for ETIMEDOUT (message may already be delivered)", () => {
const err = Object.assign(new Error("connect ETIMEDOUT"), { code: "ETIMEDOUT" });
expect(isSafeToRetrySendError(err)).toBe(false);
});
it("does NOT allow retry for EPIPE (connection broken mid-transfer, message may be delivered)", () => {
const err = Object.assign(new Error("write EPIPE"), { code: "EPIPE" });
expect(isSafeToRetrySendError(err)).toBe(false);
});
it("does NOT allow retry for UND_ERR_CONNECT_TIMEOUT (ambiguous timing)", () => {
const err = Object.assign(new Error("connect timeout"), { code: "UND_ERR_CONNECT_TIMEOUT" });
expect(isSafeToRetrySendError(err)).toBe(false);
it.each([
["ECONNREFUSED", "connect ECONNREFUSED", true],
["ENOTFOUND", "getaddrinfo ENOTFOUND", true],
["EAI_AGAIN", "getaddrinfo EAI_AGAIN", true],
["ENETUNREACH", "connect ENETUNREACH", true],
["EHOSTUNREACH", "connect EHOSTUNREACH", true],
["ECONNRESET", "read ECONNRESET", false],
["ETIMEDOUT", "connect ETIMEDOUT", false],
["EPIPE", "write EPIPE", false],
["UND_ERR_CONNECT_TIMEOUT", "connect timeout", false],
])("returns %s => %s", (code, message, expected) => {
expect(isSafeToRetrySendError(errorWithCode(message, code))).toBe(expected);
});
it("does NOT allow retry for non-network errors", () => {
@@ -196,19 +187,12 @@ describe("isSafeToRetrySendError", () => {
});
describe("isTelegramServerError", () => {
it("returns true for error_code 500", () => {
const err = Object.assign(new Error("Internal Server Error"), { error_code: 500 });
expect(isTelegramServerError(err)).toBe(true);
});
it("returns true for error_code 502", () => {
const err = Object.assign(new Error("Bad Gateway"), { error_code: 502 });
expect(isTelegramServerError(err)).toBe(true);
});
it("returns false for error_code 403", () => {
const err = Object.assign(new Error("Forbidden"), { error_code: 403 });
expect(isTelegramServerError(err)).toBe(false);
it.each([
["Internal Server Error", 500, true],
["Bad Gateway", 502, true],
["Forbidden", 403, false],
])("returns %s for error_code %s", (message, errorCode, expected) => {
expect(isTelegramServerError(errorWithTelegramCode(message, errorCode))).toBe(expected);
});
it("returns false for plain Error", () => {
@@ -217,19 +201,12 @@ describe("isTelegramServerError", () => {
});
describe("isTelegramClientRejection", () => {
it("returns true for error_code 400", () => {
const err = Object.assign(new Error("Bad Request"), { error_code: 400 });
expect(isTelegramClientRejection(err)).toBe(true);
});
it("returns true for error_code 403", () => {
const err = Object.assign(new Error("Forbidden"), { error_code: 403 });
expect(isTelegramClientRejection(err)).toBe(true);
});
it("returns false for error_code 502", () => {
const err = Object.assign(new Error("Bad Gateway"), { error_code: 502 });
expect(isTelegramClientRejection(err)).toBe(false);
it.each([
["Bad Request", 400, true],
["Forbidden", 403, true],
["Bad Gateway", 502, false],
])("returns %s for error_code %s", (message, errorCode, expected) => {
expect(isTelegramClientRejection(errorWithTelegramCode(message, errorCode))).toBe(expected);
});
it("returns false for plain Error", () => {