@sleep2agi/commhub-server 0.9.0-preview.258 → 0.9.0-preview.259
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build-info.json +2 -2
- package/package.json +1 -1
- package/src/api-nodes-shape.test.ts +38 -2
- package/src/auth-abuse-counters.ts +11 -0
- package/src/create-node-error-domain.test.ts +124 -0
- package/src/departments-mcp-error-domain.test.ts +135 -0
- package/src/list-ack-error-domain.test.ts +108 -0
- package/src/probe-provider-error-domain.test.ts +141 -0
- package/src/provider-skill-error-domain.test.ts +130 -0
- package/src/server.ts +11 -0
- package/src/start-request-error-domain.test.ts +182 -0
- package/src/start-skill-error-domain.test.ts +122 -0
- package/src/task-not-found-error-domain.test.ts +76 -0
- package/src/update-node-config-error-domain.test.ts +107 -0
package/build-info.json
CHANGED
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@sleep2agi/commhub-server",
|
|
3
|
-
"version": "0.9.0-preview.
|
|
3
|
+
"version": "0.9.0-preview.259",
|
|
4
4
|
"description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"main": "src/index.ts",
|
|
@@ -38,6 +38,7 @@ function mapRow(r: Record<string, unknown>): Record<string, unknown> {
|
|
|
38
38
|
let role: string | null = null;
|
|
39
39
|
// #2293 —— 与 handler 同一套读法:快照可能是文本或对象;解析失败/形状不对 = 这一格没有。
|
|
40
40
|
let opencodeCatalog: string[] | null = null;
|
|
41
|
+
let opencodeCatalogSeenAt: string | null = null;
|
|
41
42
|
let opencodeGeneration: "v1" | "v2" | null = null;
|
|
42
43
|
let opencodeMode: string | null = null;
|
|
43
44
|
let opencodeServer: string | null = null;
|
|
@@ -50,6 +51,9 @@ function mapRow(r: Record<string, unknown>): Record<string, unknown> {
|
|
|
50
51
|
const raw = parsed?.opencode_catalog;
|
|
51
52
|
if (Array.isArray(raw) && raw.every((m: unknown) => typeof m === "string" && m.length <= 400)) {
|
|
52
53
|
opencodeCatalog = raw.slice(0, 400);
|
|
54
|
+
// #3144 —— 目录是快照:没有采集时刻的话,51 个模型是刚才的还是三周前的分不出。
|
|
55
|
+
const seen = parsed?.opencode_catalog_seen_at;
|
|
56
|
+
opencodeCatalogSeenAt = typeof seen === "string" && seen.length > 0 && seen.length <= 40 ? seen : null;
|
|
53
57
|
}
|
|
54
58
|
const flags = parsed?.flags;
|
|
55
59
|
if (flags?.opencodeGeneration === "v1" || flags?.opencodeGeneration === "v2") opencodeGeneration = flags.opencodeGeneration;
|
|
@@ -63,12 +67,42 @@ function mapRow(r: Record<string, unknown>): Record<string, unknown> {
|
|
|
63
67
|
attrs_revision: Number(r.attrs_revision ?? 0),
|
|
64
68
|
role,
|
|
65
69
|
opencode_catalog: opencodeCatalog,
|
|
70
|
+
opencode_catalog_seen_at: opencodeCatalogSeenAt,
|
|
66
71
|
opencode_generation: opencodeGeneration,
|
|
67
72
|
opencode_mode: opencodeMode,
|
|
68
73
|
opencode_server: opencodeServer,
|
|
69
74
|
};
|
|
70
75
|
}
|
|
71
76
|
|
|
77
|
+
describe("#3144 opencode_catalog_seen_at —— 三态,不塌成两种", () => {
|
|
78
|
+
// daemon 报了就带出来;没报就是 null。null 的含义是「未上报」,**不是**「很久以前」,
|
|
79
|
+
// 也不是「刚刚」——把两者塌成同一个值,客户端就只能显示一个它并不知道的时刻。
|
|
80
|
+
test("有 opencode_catalog_seen_at ⇒ 原样投影", () => {
|
|
81
|
+
const row = mapRow({
|
|
82
|
+
node_id: "n1", node_name: "n", alias: "n", runtime: "opencode-sdk", model: "m",
|
|
83
|
+
config_path: null, channels: null, server: null, hostname: null,
|
|
84
|
+
network_id: "net", created_at: "x", updated_at: "x", display_name: null,
|
|
85
|
+
team: null, tags: null, attrs_revision: 0,
|
|
86
|
+
config_snapshot: JSON.stringify({
|
|
87
|
+
opencode_catalog: ["a/b"], opencode_catalog_seen_at: "2026-11-01T02:00:00Z",
|
|
88
|
+
}),
|
|
89
|
+
});
|
|
90
|
+
expect(row.opencode_catalog_seen_at).toBe("2026-11-01T02:00:00Z");
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
test("没有那个字段 ⇒ null(不是空串、不是当前时间)", () => {
|
|
94
|
+
const row = mapRow({
|
|
95
|
+
node_id: "n2", node_name: "n", alias: "n", runtime: "opencode-sdk", model: "m",
|
|
96
|
+
config_path: null, channels: null, server: null, hostname: null,
|
|
97
|
+
network_id: "net", created_at: "x", updated_at: "x", display_name: null,
|
|
98
|
+
team: null, tags: null, attrs_revision: 0,
|
|
99
|
+
config_snapshot: JSON.stringify({ opencode_catalog: ["a/b"] }),
|
|
100
|
+
});
|
|
101
|
+
expect(row.opencode_catalog).toEqual(["a/b"]);
|
|
102
|
+
expect(row.opencode_catalog_seen_at).toBeNull();
|
|
103
|
+
});
|
|
104
|
+
});
|
|
105
|
+
|
|
72
106
|
describe("RFC-024 regression — GET /api/nodes response shape (no SELECT *)", () => {
|
|
73
107
|
test("explicit columns + role extracted: config_snapshot NOT in response, role IS", () => {
|
|
74
108
|
// Insert a row with the leak-prone columns populated. Use INSERT OR
|
|
@@ -102,7 +136,8 @@ describe("RFC-024 regression — GET /api/nodes response shape (no SELECT *)", (
|
|
|
102
136
|
// Expected fields present (13 = 12 contract + new role)
|
|
103
137
|
for (const k of ["node_id", "node_name", "alias", "runtime", "model",
|
|
104
138
|
"config_path", "channels", "server", "hostname",
|
|
105
|
-
"network_id", "created_at", "updated_at", "role", "opencode_catalog"
|
|
139
|
+
"network_id", "created_at", "updated_at", "role", "opencode_catalog",
|
|
140
|
+
"opencode_catalog_seen_at"]) {
|
|
106
141
|
expect(row).toHaveProperty(k);
|
|
107
142
|
}
|
|
108
143
|
// Internal fields NOT present
|
|
@@ -119,7 +154,8 @@ describe("RFC-024 regression — GET /api/nodes response shape (no SELECT *)", (
|
|
|
119
154
|
expect(Object.keys(row).sort()).toEqual([
|
|
120
155
|
"alias", "attrs_revision", "channels", "config_path", "created_at",
|
|
121
156
|
"display_name", "hostname", "model", "network_id", "node_id",
|
|
122
|
-
"node_name", "opencode_catalog", "
|
|
157
|
+
"node_name", "opencode_catalog", "opencode_catalog_seen_at",
|
|
158
|
+
"opencode_generation", "opencode_mode",
|
|
123
159
|
"opencode_server", "role", "runtime", "server", "tags", "team",
|
|
124
160
|
"updated_at",
|
|
125
161
|
]);
|
|
@@ -17,6 +17,17 @@
|
|
|
17
17
|
// 已知偏差(写在读数旁边,不写在文档里):
|
|
18
18
|
// · 进程内计数,重启归零 ⇒ 与 /health 的 counters_since 同源,读之前先看 since。
|
|
19
19
|
// · 去重集合有上限(512)⇒ capped=true 时 distinct_* 是**下界**,不是真值。
|
|
20
|
+
// · 🔴 **本机来源下这三个计数恒为 0,而且那不是「没有被滥用」。**
|
|
21
|
+
// `checkRateLimit()` 对 `127.0.0.1` / `::1` / `""` / `"unknown"` 直接 `return true`
|
|
22
|
+
// (server.ts:249,为 dev/test 留的口子),于是 register 的限流分支根本不会走到。
|
|
23
|
+
// 实测(`0.9.0-preview.258` 的制品,本地起在 9311):
|
|
24
|
+
// · 不带 X-Forwarded-For 打 36 次注册 ⇒ 全部 200,register_rate_limited_total 仍是 0
|
|
25
|
+
// · 带 `X-Forwarded-For: 203.0.113.9` 打 34 次 ⇒ 30×200 + 4×429,
|
|
26
|
+
// register_rate_limited_total = 4、distinct_register_limited_ips = 1(**逐次对得上**)
|
|
27
|
+
// · 带 `X-Forwarded-For: 203.0.113.77` 用同一个用户名错 8 次 ⇒ 5×401 + 3×429,
|
|
28
|
+
// login_locked_total = 3、distinct_locked_usernames = 1
|
|
29
|
+
// ⇒ 所以「本地读到 0」是一个结构性假阴性:要见证必须模拟外部来源(XFF),
|
|
30
|
+
// 否则 0 会被读成「没有滥用」,而它其实只说明「限流器跳过了本机」。
|
|
20
31
|
|
|
21
32
|
export const DISTINCT_CAP = 512;
|
|
22
33
|
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
// #3309 读数覆盖第四批 —— `create_node` 的 3 个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// insufficient_role_for_create_node / runtime_not_in_local_allowlist / daemon_max_children
|
|
4
|
+
//
|
|
5
|
+
// 现有 create_node 测试覆盖的是成功建节点、blocked gate、network_id 回传 ——
|
|
6
|
+
// 这三条**拒绝**分支都没被走过。
|
|
7
|
+
//
|
|
8
|
+
// 三条的共同点:它们都发生在「请求已经合法、但**这台 daemon 现在不能接**」这一刻。
|
|
9
|
+
// 只断言 ok===false 时,它们与「名字非法」「网络不对」完全同形,而处置完全不同:
|
|
10
|
+
// 权限不够 ⇒ 换人 / 提权
|
|
11
|
+
// runtime 不支持 ⇒ 换 runtime,或在 daemon 侧放开 allowlist(要动那台机器)
|
|
12
|
+
// 子节点满了 ⇒ 等,或调大 max_concurrent_children
|
|
13
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
14
|
+
import "./require-explicit-test-db.js";
|
|
15
|
+
import { db } from "./db.js";
|
|
16
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
17
|
+
import { registerTools } from "./tools.js";
|
|
18
|
+
|
|
19
|
+
const NET = "net_cn_err";
|
|
20
|
+
const OWNER = "u_cn_err_owner";
|
|
21
|
+
const MEMBER = "u_cn_err_member";
|
|
22
|
+
const DAEMON = "node_cn_err_daemon";
|
|
23
|
+
const DAEMON_ALIAS = "cn-err-daemon";
|
|
24
|
+
|
|
25
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
26
|
+
type Reply = { ok?: boolean; error?: string; [k: string]: unknown };
|
|
27
|
+
|
|
28
|
+
function tools(callerUserId: string): Record<string, ToolHandler> {
|
|
29
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
30
|
+
const out: Record<string, ToolHandler> = {};
|
|
31
|
+
const orig = server.tool.bind(server);
|
|
32
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
33
|
+
registerTools(server, undefined, NET, callerUserId, null, false, null);
|
|
34
|
+
return out;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
// 精确键集 = 集合相等(不是计数、也不是「有这几个字段」)。
|
|
38
|
+
function expectKeys(obj: Record<string, unknown>, want: string[]) {
|
|
39
|
+
expect(Object.keys(obj).sort(), "键集合必须完全等于期望").toEqual([...want].sort());
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
async function callCreate(userId: string, spec: Record<string, unknown> = {}) {
|
|
43
|
+
const h = tools(userId).create_node;
|
|
44
|
+
const r = await h({
|
|
45
|
+
daemon_node_id: DAEMON,
|
|
46
|
+
node_spec: { name: "cn-err-child", runtime: "opencode-cli", model: null, flags: {}, ...spec },
|
|
47
|
+
});
|
|
48
|
+
return JSON.parse(r.content[0].text) as Reply;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
function cleanup() {
|
|
52
|
+
for (const t of ["node_create_requests", "audit_log", "nodes", "sessions", "api_tokens", "network_members"]) {
|
|
53
|
+
try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
|
|
54
|
+
}
|
|
55
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
56
|
+
try { db.run("DELETE FROM users WHERE user_id IN (?1, ?2)", [OWNER, MEMBER]); } catch {}
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
function seed(caps: Record<string, unknown>) {
|
|
60
|
+
cleanup();
|
|
61
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [OWNER]);
|
|
62
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MEMBER]);
|
|
63
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, OWNER]);
|
|
64
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET]);
|
|
65
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'member', datetime('now'))", [MEMBER, NET]);
|
|
66
|
+
db.run(
|
|
67
|
+
`INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot,
|
|
68
|
+
hostname, created_at, updated_at, lifecycle_state)
|
|
69
|
+
VALUES (?1, ?2, ?2, ?3, 'opencode-cli', 'm', '[]', ?4, 'host-cn', datetime('now'), datetime('now'), 'active')`,
|
|
70
|
+
[DAEMON, DAEMON_ALIAS, NET, JSON.stringify({ role: "host_supervisor", daemon_capabilities: caps })],
|
|
71
|
+
);
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
beforeEach(() => seed({ runtimes_supported: ["opencode-cli"] }));
|
|
75
|
+
afterAll(cleanup);
|
|
76
|
+
|
|
77
|
+
describe("#3309 create_node 错误值域:三条「这台 daemon 现在不能接」的拒绝", () => {
|
|
78
|
+
test("成员建节点 ⇒ insufficient_role_for_create_node(带 required_role / caller_role)", async () => {
|
|
79
|
+
const r = await callCreate(MEMBER);
|
|
80
|
+
expect(r.ok).toBe(false);
|
|
81
|
+
expect(r.error).toBe("insufficient_role_for_create_node");
|
|
82
|
+
expect(r.required_role).toBe("admin");
|
|
83
|
+
expect(r.caller_role).toBe("member");
|
|
84
|
+
expectKeys(r, ["ok", "error", "required_role", "caller_role"]);
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
test("daemon 只支持 codex,却要求 opencode-cli ⇒ runtime_not_in_local_allowlist(回显 allowed)", async () => {
|
|
88
|
+
seed({ runtimes_supported: ["codex"] });
|
|
89
|
+
const r = await callCreate(OWNER, { runtime: "opencode-cli" });
|
|
90
|
+
expect(r.ok).toBe(false);
|
|
91
|
+
expect(r.error).toBe("runtime_not_in_local_allowlist");
|
|
92
|
+
expect(r.runtime).toBe("opencode-cli");
|
|
93
|
+
// 回显这台机器**允许**什么,否则读的人只知道"不行",要回 daemon 上自己查。
|
|
94
|
+
expect(r.allowed).toEqual(["codex"]);
|
|
95
|
+
expectKeys(r, ["ok", "error", "runtime", "allowed"]);
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
test("子节点已达上限 ⇒ daemon_max_children(带 current / max)", async () => {
|
|
99
|
+
seed({ runtimes_supported: ["opencode-cli"], max_concurrent_children: 1 });
|
|
100
|
+
// 手工放一条 active 子请求,把额度占满
|
|
101
|
+
db.run(
|
|
102
|
+
`INSERT INTO node_create_requests (request_id, daemon_node_id, child_name, network_id, runtime, model,
|
|
103
|
+
flags_json, env_keys, status, created_at, created_by_token)
|
|
104
|
+
VALUES ('cr_cn_err_seed', ?1, 'cn-err-occupied', ?2, 'opencode-cli', NULL, '{}', '[]', 'pending', ?3, ?4)`,
|
|
105
|
+
[DAEMON, NET, Date.now(), "tok_seed"],
|
|
106
|
+
);
|
|
107
|
+
const r = await callCreate(OWNER);
|
|
108
|
+
expect(r.ok).toBe(false);
|
|
109
|
+
expect(r.error).toBe("daemon_max_children");
|
|
110
|
+
expect(r.current).toBe(1);
|
|
111
|
+
expect(r.max).toBe(1);
|
|
112
|
+
expectKeys(r, ["ok", "error", "current", "max"]);
|
|
113
|
+
});
|
|
114
|
+
|
|
115
|
+
test("三条的载荷都没有 code 字段(现状,不是契约)", async () => {
|
|
116
|
+
const member = await callCreate(MEMBER);
|
|
117
|
+
seed({ runtimes_supported: ["codex"] });
|
|
118
|
+
const runtime = await callCreate(OWNER);
|
|
119
|
+
for (const r of [member, runtime]) {
|
|
120
|
+
expect(r.ok).toBe(false);
|
|
121
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
122
|
+
}
|
|
123
|
+
});
|
|
124
|
+
});
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
// #3309 第四条口径 —— `departments` 的 4 个 error 字面量此前在测试里**一次都没出现过**:
|
|
2
|
+
//
|
|
3
|
+
// network_required / department_required / agent_required / agent_not_found
|
|
4
|
+
//
|
|
5
|
+
// 它们不是「没被测到」,而是「违反了也不会有任何读数」:四条都是入口处的参数/上下文校验,
|
|
6
|
+
// 而现有 departments 测试全部从**合法调用**出发(有网络、有 department_id、有 agent),
|
|
7
|
+
// 所以这四条分支从来没被走过。
|
|
8
|
+
//
|
|
9
|
+
// 这里逐个把它们**真的触发一次**,并断言 `error` 的**确切值** —— 不是 `ok === false`
|
|
10
|
+
// (那只证明「被拒了」,不证明「拒的理由是这一个」;两个不同的理由在 ok===false 下同形)。
|
|
11
|
+
//
|
|
12
|
+
// 同时钉住一件事:这四条的错误形状是 `{ ok: false, error }` 而**没有** `code` 字段。
|
|
13
|
+
// 客户端若按 code 分支,这四条会全部落进 unknown —— 记在这里,不假装它们已经是契约。
|
|
14
|
+
|
|
15
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
16
|
+
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
|
|
17
|
+
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
|
|
18
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
19
|
+
import { db } from "./db.js";
|
|
20
|
+
import { registerTools } from "./tools.js";
|
|
21
|
+
|
|
22
|
+
const NET = "net_dept_err";
|
|
23
|
+
// 第二个网络:`getNetworkId()` 在「上下文没有网络」时会退到「这个人只有一个网络就用它」。
|
|
24
|
+
// 所以要让 `network_required` 真的可达,OWNER 必须**属于多个**网络 —— 否则它会被自动补上,
|
|
25
|
+
// 而「补上」与「本来就该拒」在结果上同形(都是 ok:true)。
|
|
26
|
+
const NET2 = "net_dept_err_2";
|
|
27
|
+
const OWNER = "u_dept_err_owner";
|
|
28
|
+
const AGENT = "n_dept_err_a";
|
|
29
|
+
|
|
30
|
+
function cleanup() {
|
|
31
|
+
for (const [table, col] of [
|
|
32
|
+
["audit_log", "network_id"], ["nodes", "network_id"], ["network_departments", "network_id"],
|
|
33
|
+
["network_members", "network_id"], ["networks", "network_id"],
|
|
34
|
+
] as const) {
|
|
35
|
+
try { db.run(`DELETE FROM ${table} WHERE ${col} IN (?1, ?2)`, [NET, NET2]); } catch {}
|
|
36
|
+
}
|
|
37
|
+
try { db.run("DELETE FROM users WHERE user_id = ?1", [OWNER]); } catch {}
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function seed() {
|
|
41
|
+
cleanup();
|
|
42
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [OWNER]);
|
|
43
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, OWNER]);
|
|
44
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET]);
|
|
45
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET2, OWNER]);
|
|
46
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [OWNER, NET2]);
|
|
47
|
+
db.run("INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, 'dept-err-a', 'dept-err-a', ?2, datetime('now'), datetime('now'))", [AGENT, NET]);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/** networkId 传 null 才能走到 `network_required`:工具从上下文取网络,取不到就拒。 */
|
|
51
|
+
async function connect(callerUserId: string, networkId: string | null) {
|
|
52
|
+
const server = new McpServer({ name: "dept-err-test", version: "1" });
|
|
53
|
+
registerTools(server, undefined, networkId, callerUserId, "dept-err-a", true, null);
|
|
54
|
+
const client = new Client({ name: "dept-err-client", version: "1" });
|
|
55
|
+
const [ct, st] = InMemoryTransport.createLinkedPair();
|
|
56
|
+
await server.connect(st);
|
|
57
|
+
await client.connect(ct);
|
|
58
|
+
return { client, server };
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
type Result = { content: Array<{ type: string; text?: string }>; isError?: boolean };
|
|
62
|
+
const json = (r: Result) => JSON.parse(String(r.content[0]?.text ?? "{}"));
|
|
63
|
+
|
|
64
|
+
beforeEach(seed);
|
|
65
|
+
afterAll(cleanup);
|
|
66
|
+
|
|
67
|
+
describe("#3309 departments 错误值域:四个入口校验各有一条会红的断言", () => {
|
|
68
|
+
test("没有网络上下文 ⇒ error === network_required", async () => {
|
|
69
|
+
const { client, server } = await connect(OWNER, null);
|
|
70
|
+
try {
|
|
71
|
+
const r = json(await client.callTool({ name: "departments", arguments: { action: "list" } }) as Result);
|
|
72
|
+
expect(r.ok).toBe(false);
|
|
73
|
+
expect(r.error).toBe("network_required");
|
|
74
|
+
} finally { await server.close(); }
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
test("update 不带 department_id ⇒ error === department_required", async () => {
|
|
78
|
+
const { client, server } = await connect(OWNER, NET);
|
|
79
|
+
try {
|
|
80
|
+
const r = json(await client.callTool({ name: "departments", arguments: { action: "update", name: "x" } }) as Result);
|
|
81
|
+
expect(r.ok).toBe(false);
|
|
82
|
+
expect(r.error).toBe("department_required");
|
|
83
|
+
} finally { await server.close(); }
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
test("delete 不带 department_id ⇒ error === department_required", async () => {
|
|
87
|
+
const { client, server } = await connect(OWNER, NET);
|
|
88
|
+
try {
|
|
89
|
+
const r = json(await client.callTool({ name: "departments", arguments: { action: "delete" } }) as Result);
|
|
90
|
+
expect(r.ok).toBe(false);
|
|
91
|
+
expect(r.error).toBe("department_required");
|
|
92
|
+
} finally { await server.close(); }
|
|
93
|
+
});
|
|
94
|
+
|
|
95
|
+
test("assign_agent 既不给 node_id 也不给 alias ⇒ error === agent_required", async () => {
|
|
96
|
+
const { client, server } = await connect(OWNER, NET);
|
|
97
|
+
try {
|
|
98
|
+
const r = json(await client.callTool({ name: "departments", arguments: { action: "assign_agent" } }) as Result);
|
|
99
|
+
expect(r.ok).toBe(false);
|
|
100
|
+
expect(r.error).toBe("agent_required");
|
|
101
|
+
} finally { await server.close(); }
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
test("assign_agent 给的 alias 不存在 ⇒ error === agent_not_found(不是 agent_required)", async () => {
|
|
105
|
+
const { client, server } = await connect(OWNER, NET);
|
|
106
|
+
try {
|
|
107
|
+
const r = json(await client.callTool({
|
|
108
|
+
name: "departments", arguments: { action: "assign_agent", alias: "no-such-alias-xyz" },
|
|
109
|
+
}) as Result);
|
|
110
|
+
expect(r.ok).toBe(false);
|
|
111
|
+
// 这两个值的区别就是这张测试存在的理由:alias 给了但查不到 ≠ 什么也没给。
|
|
112
|
+
// 只断言 ok===false 时,两者同形,而调用方要做的补救完全不同。
|
|
113
|
+
expect(r.error).toBe("agent_not_found");
|
|
114
|
+
expect(r.error).not.toBe("agent_required");
|
|
115
|
+
} finally { await server.close(); }
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
test("这四个错误形状都**没有** code 字段(记下来,不假装是契约)", async () => {
|
|
119
|
+
const { client, server } = await connect(OWNER, NET);
|
|
120
|
+
try {
|
|
121
|
+
const cases = [
|
|
122
|
+
{ action: "update", name: "x" },
|
|
123
|
+
{ action: "delete" },
|
|
124
|
+
{ action: "assign_agent" },
|
|
125
|
+
{ action: "assign_agent", alias: "no-such-alias-xyz" },
|
|
126
|
+
];
|
|
127
|
+
for (const args of cases) {
|
|
128
|
+
const r = json(await client.callTool({ name: "departments", arguments: args }) as Result);
|
|
129
|
+
expect(r.ok).toBe(false);
|
|
130
|
+
// 现状:只有 error 字符串。按 code 分支的客户端会把这四条全落进 unknown。
|
|
131
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
132
|
+
}
|
|
133
|
+
} finally { await server.close(); }
|
|
134
|
+
});
|
|
135
|
+
});
|
|
@@ -0,0 +1,108 @@
|
|
|
1
|
+
// #3309 读数覆盖第七批 —— 两个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// list_tasks : durable_cursor_required
|
|
4
|
+
// ack_inbox : message not found or already acknowledged
|
|
5
|
+
//
|
|
6
|
+
// 两条都是「调用协议用错了」,而不是「权限/状态不对」:
|
|
7
|
+
// durable_cursor_required ⇒ 打开了「按序号读终态日志」这个模式,却没给游标
|
|
8
|
+
// (这只在 durable_terminal_cursor=true 时才要求,
|
|
9
|
+
// 所以它是一条**条件性必需参数**的错误)
|
|
10
|
+
// already acknowledged ⇒ 这条消息已经被 ack 过(或 id 根本不在你的待办里)
|
|
11
|
+
//
|
|
12
|
+
// ⚠ 故意没测 `ack_inbox` 的第二个出口 "message not found or not yours":
|
|
13
|
+
// 它只在「SELECT 找到了、UPDATE 影响 0 行」时发生,也就是**并发**下另一个
|
|
14
|
+
// ack 抢先提交的那一刻。本仓没有可注入的并发点,造一个不算真。
|
|
15
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
16
|
+
import { db } from "./db.js";
|
|
17
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
18
|
+
import { registerTools } from "./tools.js";
|
|
19
|
+
|
|
20
|
+
const NET = "net_7th_err";
|
|
21
|
+
const USER = "u_7th_user";
|
|
22
|
+
const ALIAS = "7th-node";
|
|
23
|
+
|
|
24
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
25
|
+
|
|
26
|
+
function handlers(): Record<string, ToolHandler> {
|
|
27
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
28
|
+
const out: Record<string, ToolHandler> = {};
|
|
29
|
+
const orig = server.tool.bind(server);
|
|
30
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
31
|
+
registerTools(server, undefined, NET, USER, ALIAS, false, null);
|
|
32
|
+
return out;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
async function call(name: string, args: Record<string, unknown>) {
|
|
36
|
+
const r = await handlers()[name](args);
|
|
37
|
+
return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function cleanup() {
|
|
41
|
+
try { db.run("DELETE FROM inbox WHERE network_id = ?1", [NET]); } catch {}
|
|
42
|
+
try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
|
|
43
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
44
|
+
try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
function seed() {
|
|
48
|
+
cleanup();
|
|
49
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
|
|
50
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
|
|
51
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function seedInbox(acked: number) {
|
|
55
|
+
db.run(
|
|
56
|
+
`INSERT INTO inbox (id, session_name, type, content, created_at, acked, network_id)
|
|
57
|
+
VALUES ('inbox_7th_1', ?1, 'message', 'hello', ?2, ?3, ?4)`,
|
|
58
|
+
[ALIAS, Date.now(), acked, NET],
|
|
59
|
+
);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
beforeEach(seed);
|
|
63
|
+
afterAll(cleanup);
|
|
64
|
+
|
|
65
|
+
describe("#3309 list_tasks / ack_inbox 的错误值域", () => {
|
|
66
|
+
test("durable_terminal_cursor=true 但没给 durable_cursor ⇒ durable_cursor_required", async () => {
|
|
67
|
+
const r = await call("list_tasks", { durable_terminal_cursor: true });
|
|
68
|
+
expect(r.ok).toBe(false);
|
|
69
|
+
expect(r.error).toBe("durable_cursor_required");
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
test("不给 durable_terminal_cursor 时不要求游标(条件性必需)", async () => {
|
|
73
|
+
// ⚠ 本 harness 直接调 handler,**绕过了 zod** ⇒ `.default(20)` 不会生效。
|
|
74
|
+
// 第一次没给 limit,SQL 里 `LIMIT ?` 绑到 undefined ⇒ SQLITE_MISMATCH。
|
|
75
|
+
// 那是夹具的事,不是产品的事 —— 所以这里显式补上默认值。
|
|
76
|
+
const r = await call("list_tasks", { limit: 20 });
|
|
77
|
+
// 这条不是为了「成功」,而是为了证明上一条是**条件**触发的:
|
|
78
|
+
// 若改成无条件要求游标,这条会红。
|
|
79
|
+
expect(r.ok).toBe(true);
|
|
80
|
+
});
|
|
81
|
+
|
|
82
|
+
test("ack 一条已 ack 过的消息 ⇒ message not found or already acknowledged", async () => {
|
|
83
|
+
seedInbox(1);
|
|
84
|
+
const r = await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_1" });
|
|
85
|
+
expect(r.ok).toBe(false);
|
|
86
|
+
expect(r.error).toBe("message not found or already acknowledged");
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
test("ack 一个根本不存在的 id ⇒ 同一句(两种成因**故意**不区分)", async () => {
|
|
90
|
+
seedInbox(0);
|
|
91
|
+
const r = await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_does_not_exist" });
|
|
92
|
+
expect(r.ok).toBe(false);
|
|
93
|
+
// 「没见过这个 id」与「已经 ack 过」对调用方是同一种处置:不要重试。
|
|
94
|
+
// 而服务端**不区分**它们是有意的(避免用错误码探测别人有没有这条消息)。
|
|
95
|
+
expect(r.error).toBe("message not found or already acknowledged");
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
test("两条载荷都没有 code 字段(现状,不是契约)", async () => {
|
|
99
|
+
const replies = [
|
|
100
|
+
await call("list_tasks", { durable_terminal_cursor: true, limit: 20 }),
|
|
101
|
+
await call("ack_inbox", { alias: ALIAS, message_id: "inbox_7th_nope" }),
|
|
102
|
+
];
|
|
103
|
+
for (const r of replies) {
|
|
104
|
+
expect(r.ok).toBe(false);
|
|
105
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
106
|
+
}
|
|
107
|
+
});
|
|
108
|
+
});
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
// #3309 第四条口径 —— `probe_provider_model` 的 4 个 error 字面量此前在测试里**一次都没出现过**:
|
|
2
|
+
//
|
|
3
|
+
// insufficient_role_for_probe / provider_not_found / provider_disabled / secret_not_in_vault
|
|
4
|
+
//
|
|
5
|
+
// 现有的 provider-tools-shape.test.ts 覆盖的是**成功路径**(provider 存在、model 存在、
|
|
6
|
+
// daemon 存在、vault 里有 key)—— 于是这四条拒绝分支从来没被走过。
|
|
7
|
+
//
|
|
8
|
+
// 这里逐个真的触发一次,并断言 `error` 的**确切值**。特别钉住相邻两条不能混:
|
|
9
|
+
//
|
|
10
|
+
// provider 不存在 ⇒ provider_not_found
|
|
11
|
+
// provider 存在但停用 ⇒ provider_disabled
|
|
12
|
+
//
|
|
13
|
+
// 只断言 ok===false 时两者同形,而处置相反(前者要建,后者只要启用)。
|
|
14
|
+
// 代码注释里也写了这条意图("Distinguish not found from disabled so the dashboard
|
|
15
|
+
// can render the right error")—— 注释没有读数,断言才有。
|
|
16
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
17
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
18
|
+
import { db } from "./db.js";
|
|
19
|
+
import { registerTools } from "./tools.js";
|
|
20
|
+
import { stopBackgroundProbeTimersForTest } from "./probe.js";
|
|
21
|
+
|
|
22
|
+
// vault 根密钥存在时 vaultGet 才会「查而不得」(返回 null),否则它自己抛错走另一个分支。
|
|
23
|
+
process.env.ANET_HUB_SECRET_VAULT_KEY ||= "43".repeat(32);
|
|
24
|
+
|
|
25
|
+
const NET = "net_probe_err";
|
|
26
|
+
const ADMIN = "u_probe_err_admin";
|
|
27
|
+
const MEMBER = "u_probe_err_member";
|
|
28
|
+
const PROVIDER = "prov_err";
|
|
29
|
+
const DAEMON = "node_probe_err_daemon";
|
|
30
|
+
|
|
31
|
+
type ToolHandler = (args: any) => Promise<any>;
|
|
32
|
+
|
|
33
|
+
function handlers(userId: string): Record<string, ToolHandler> {
|
|
34
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
35
|
+
const tools: Record<string, ToolHandler> = {};
|
|
36
|
+
const orig = server.tool.bind(server);
|
|
37
|
+
server.tool = (name: string, desc: string, schema: any, handler: ToolHandler) => {
|
|
38
|
+
tools[name] = handler;
|
|
39
|
+
return orig(name, desc, schema, handler);
|
|
40
|
+
};
|
|
41
|
+
registerTools(server, undefined, NET, userId, null, false, null);
|
|
42
|
+
return tools;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
async function callProbe(userId: string, args: Record<string, unknown>) {
|
|
46
|
+
const r = await handlers(userId).probe_provider_model(args);
|
|
47
|
+
return JSON.parse(r.content[0].text);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
const base = { provider_id: PROVIDER, model_name: "probe-model", daemon_node_id: DAEMON };
|
|
51
|
+
|
|
52
|
+
// 2026-11-01 —— **精确键集,写成集合相等**(不是计数、也不是「有这几个字段」)。
|
|
53
|
+
// 计数可以被换名满足;字段级断言放过多给的键。两者都放过「换名 + 少给」这种最常见的结构变动。
|
|
54
|
+
function expectKeys(obj: Record<string, unknown>, want: string[]) {
|
|
55
|
+
expect(Object.keys(obj).sort(), "键集合必须完全等于期望").toEqual([...want].sort());
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
function cleanup() {
|
|
59
|
+
db.run("DELETE FROM provider_models WHERE provider_id = ?1", [PROVIDER]);
|
|
60
|
+
db.run("DELETE FROM providers WHERE network_id = ?1", [NET]);
|
|
61
|
+
db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]);
|
|
62
|
+
db.run("DELETE FROM nodes WHERE network_id = ?1", [NET]);
|
|
63
|
+
db.run("DELETE FROM networks WHERE network_id = ?1", [NET]);
|
|
64
|
+
db.run("DELETE FROM users WHERE user_id IN (?1, ?2)", [ADMIN, MEMBER]);
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
function seed(opts: { enabled: number; secretKey: string }) {
|
|
68
|
+
cleanup();
|
|
69
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [ADMIN]);
|
|
70
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MEMBER]);
|
|
71
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, ADMIN]);
|
|
72
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [ADMIN, NET]);
|
|
73
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'member', datetime('now'))", [MEMBER, NET]);
|
|
74
|
+
db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot,
|
|
75
|
+
hostname, created_at, updated_at, lifecycle_state)
|
|
76
|
+
VALUES (?1, 'probe-err-daemon', 'probe-err-daemon', ?2, 'claude-agent-sdk', 'm', '[]', '{}', 'host-e',
|
|
77
|
+
datetime('now'), datetime('now'), 'active')`, [DAEMON, NET]);
|
|
78
|
+
db.run(`INSERT INTO providers (provider_id, network_id, name, vendor, base_url, secret_key_ref, created_at, created_by, enabled)
|
|
79
|
+
VALUES (?1, ?2, 'err-provider', 'anthropic', 'https://api.anthropic.com', ?3, ?4, ?5, ?6)`,
|
|
80
|
+
[PROVIDER, NET, opts.secretKey, Date.now(), ADMIN, opts.enabled]);
|
|
81
|
+
db.run(`INSERT INTO provider_models (model_id, provider_id, model_name, display_name, created_at)
|
|
82
|
+
VALUES ('pm_err', ?1, 'probe-model', 'Probe Model', ?2)`, [PROVIDER, Date.now()]);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
beforeEach(() => seed({ enabled: 1, secretKey: "PROBE_ERR_ABSENT" }));
|
|
86
|
+
afterAll(() => { stopBackgroundProbeTimersForTest(); cleanup(); });
|
|
87
|
+
|
|
88
|
+
describe("#3309 probe_provider_model 错误值域:四条拒绝各有一条会红的断言", () => {
|
|
89
|
+
test("成员(非 owner/admin)⇒ error === insufficient_role_for_probe", async () => {
|
|
90
|
+
const r = await callProbe(MEMBER, base);
|
|
91
|
+
expect(r.ok).toBe(false);
|
|
92
|
+
expect(r.error).toBe("insufficient_role_for_probe");
|
|
93
|
+
// 拒绝体还带着「需要什么角色 / 调用者是什么角色」—— 否则读的人只知道被拒,不知道为什么。
|
|
94
|
+
expect(r.required_role).toBe("admin");
|
|
95
|
+
expect(r.caller_role).toBe("member");
|
|
96
|
+
expectKeys(r, ["ok", "error", "required_role", "caller_role"]);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
test("provider 不存在 ⇒ error === provider_not_found", async () => {
|
|
100
|
+
const r = await callProbe(ADMIN, { ...base, provider_id: "prov_does_not_exist" });
|
|
101
|
+
expect(r.ok).toBe(false);
|
|
102
|
+
expect(r.error).toBe("provider_not_found");
|
|
103
|
+
expect(r.provider_id).toBe("prov_does_not_exist");
|
|
104
|
+
expectKeys(r, ["ok", "error", "provider_id"]);
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
test("provider 存在但停用 ⇒ error === provider_disabled(**不是** provider_not_found)", async () => {
|
|
108
|
+
seed({ enabled: 0, secretKey: "PROBE_ERR_ABSENT" });
|
|
109
|
+
const r = await callProbe(ADMIN, base);
|
|
110
|
+
expect(r.ok).toBe(false);
|
|
111
|
+
expect(r.error).toBe("provider_disabled");
|
|
112
|
+
// 这两条的区别就是这张测试存在的理由:一个要建、一个只要启用。
|
|
113
|
+
expect(r.error).not.toBe("provider_not_found");
|
|
114
|
+
expect(r.hint).toContain("enabled:true");
|
|
115
|
+
expectKeys(r, ["ok", "error", "provider_id", "hint"]);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
test("provider 引用的密钥不在 vault ⇒ error === secret_not_in_vault,且带上键名", async () => {
|
|
119
|
+
const r = await callProbe(ADMIN, base);
|
|
120
|
+
expect(r.ok).toBe(false);
|
|
121
|
+
expect(r.error).toBe("secret_not_in_vault");
|
|
122
|
+
expect(r.key).toBe("PROBE_ERR_ABSENT");
|
|
123
|
+
expectKeys(r, ["ok", "error", "key"]);
|
|
124
|
+
// 键名是标识不是凭据:报出来才能让人去补哪一把。
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
test("四条的形状都**没有** code 字段(现状,不是契约)", async () => {
|
|
128
|
+
const cases = [
|
|
129
|
+
await callProbe(MEMBER, base),
|
|
130
|
+
await callProbe(ADMIN, { ...base, provider_id: "prov_does_not_exist" }),
|
|
131
|
+
];
|
|
132
|
+
seed({ enabled: 0, secretKey: "PROBE_ERR_ABSENT" });
|
|
133
|
+
cases.push(await callProbe(ADMIN, base));
|
|
134
|
+
seed({ enabled: 1, secretKey: "PROBE_ERR_ABSENT" });
|
|
135
|
+
cases.push(await callProbe(ADMIN, base));
|
|
136
|
+
for (const r of cases) {
|
|
137
|
+
expect(r.ok).toBe(false);
|
|
138
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
139
|
+
}
|
|
140
|
+
});
|
|
141
|
+
});
|
|
@@ -0,0 +1,130 @@
|
|
|
1
|
+
// #3309 读数覆盖第六批 —— 四个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// upsert_provider : insufficient_role_for_provider / provider_name_conflict
|
|
4
|
+
// review_skill : skill_review_admin_required / skill_not_pending
|
|
5
|
+
//
|
|
6
|
+
// 两对各有一个「只差一层」的近邻,而处置完全不同:
|
|
7
|
+
// insufficient_role_for_provider ↔ provider_name_conflict
|
|
8
|
+
// 换人提权 ↔ 换个名字(或先删旧的)
|
|
9
|
+
// skill_review_admin_required ↔ skill_not_pending
|
|
10
|
+
// 换人提权 ↔ 这个技能已经被审过,不必再审
|
|
11
|
+
//
|
|
12
|
+
// 只断言 ok===false 时,四条与「网络不通」「id 不存在」同形。
|
|
13
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
14
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
15
|
+
import { db } from "./db.js";
|
|
16
|
+
import { registerTools } from "./tools.js";
|
|
17
|
+
|
|
18
|
+
// vault 根密钥必须存在,否则 upsert_network_secret 直接失败(与 provider-tools-shape.test.ts 同一做法)。
|
|
19
|
+
process.env.ANET_HUB_SECRET_VAULT_KEY ||= "44".repeat(32);
|
|
20
|
+
|
|
21
|
+
const NET = "net_6th_err";
|
|
22
|
+
const ADMIN = "u_6th_admin";
|
|
23
|
+
const MEMBER = "u_6th_member";
|
|
24
|
+
const SKILL = "skill_6th_pending";
|
|
25
|
+
|
|
26
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
27
|
+
|
|
28
|
+
function handlers(userId: string): Record<string, ToolHandler> {
|
|
29
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
30
|
+
const out: Record<string, ToolHandler> = {};
|
|
31
|
+
const orig = server.tool.bind(server);
|
|
32
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
33
|
+
registerTools(server, undefined, NET, userId, null, false, null);
|
|
34
|
+
return out;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
async function call(userId: string, name: string, args: Record<string, unknown>) {
|
|
38
|
+
const r = await handlers(userId)[name](args as any);
|
|
39
|
+
return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
function cleanup() {
|
|
43
|
+
try { db.run("DELETE FROM provider_models WHERE provider_id IN (SELECT provider_id FROM providers WHERE network_id = ?1)", [NET]); } catch {}
|
|
44
|
+
try { db.run("DELETE FROM providers WHERE network_id = ?1", [NET]); } catch {}
|
|
45
|
+
try { db.run("DELETE FROM skillhub_skills WHERE network_id = ?1", [NET]); } catch {}
|
|
46
|
+
try { db.run("DELETE FROM network_secrets WHERE network_id = ?1", [NET]); } catch {}
|
|
47
|
+
try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
|
|
48
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
49
|
+
try { db.run("DELETE FROM users WHERE user_id IN (?1, ?2)", [ADMIN, MEMBER]); } catch {}
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
function seed() {
|
|
53
|
+
cleanup();
|
|
54
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [ADMIN]);
|
|
55
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MEMBER]);
|
|
56
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, ADMIN]);
|
|
57
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [ADMIN, NET]);
|
|
58
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'member', datetime('now'))", [MEMBER, NET]);
|
|
59
|
+
db.run(
|
|
60
|
+
`INSERT INTO skillhub_skills (skill_id, network_id, slug, name, description, content, content_hash, version,
|
|
61
|
+
status, source_type, created_at, updated_at)
|
|
62
|
+
VALUES (?1, ?2, 'sixth', 'Sixth', 'd', 'body', 'h', '1.0.0', 'published', 'user',
|
|
63
|
+
datetime('now'), datetime('now'))`,
|
|
64
|
+
[SKILL, NET],
|
|
65
|
+
);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
beforeEach(seed);
|
|
69
|
+
afterAll(cleanup);
|
|
70
|
+
|
|
71
|
+
describe("#3309 upsert_provider / review_skill 的错误值域", () => {
|
|
72
|
+
test("成员建 provider ⇒ insufficient_role_for_provider(带 required_role / caller_role)", async () => {
|
|
73
|
+
const r = await call(MEMBER, "upsert_provider", {
|
|
74
|
+
name: "sixth-provider", vendor: "anthropic", base_url: "https://api.anthropic.com",
|
|
75
|
+
secret_key_ref: "SIXTH_KEY", models: [],
|
|
76
|
+
});
|
|
77
|
+
expect(r.ok).toBe(false);
|
|
78
|
+
expect(r.error).toBe("insufficient_role_for_provider");
|
|
79
|
+
expect(r.required_role).toBe("admin");
|
|
80
|
+
expect(r.caller_role).toBe("member");
|
|
81
|
+
});
|
|
82
|
+
|
|
83
|
+
test("同名 provider 第二次入库 ⇒ provider_name_conflict(带 name)", async () => {
|
|
84
|
+
// 先把 vault key 备好,否则会先撞 secret_not_in_vault,走不到 UNIQUE 那一步。
|
|
85
|
+
const sec = await call(ADMIN, "upsert_network_secret", { key: "SIXTH_KEY", value: "sk-sixth-not-real" });
|
|
86
|
+
expect(sec.ok).toBe(true);
|
|
87
|
+
const args = {
|
|
88
|
+
name: "sixth-dup", vendor: "anthropic", base_url: "https://api.anthropic.com",
|
|
89
|
+
secret_key_ref: "SIXTH_KEY", models: [],
|
|
90
|
+
};
|
|
91
|
+
const first = await call(ADMIN, "upsert_provider", args);
|
|
92
|
+
expect(first.ok).toBe(true);
|
|
93
|
+
const second = await call(ADMIN, "upsert_provider", args);
|
|
94
|
+
expect(second.ok).toBe(false);
|
|
95
|
+
expect(second.error).toBe("provider_name_conflict");
|
|
96
|
+
expect(second.name).toBe("sixth-dup");
|
|
97
|
+
// 与 insufficient_role 的区别:这不是权限问题,换个名字就好。
|
|
98
|
+
expect(second.error).not.toBe("insufficient_role_for_provider");
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
test("成员审技能 ⇒ skill_review_admin_required", async () => {
|
|
102
|
+
const r = await call(MEMBER, "review_skill", { skill_id: SKILL, decision: "published" });
|
|
103
|
+
expect(r.ok).toBe(false);
|
|
104
|
+
expect(r.error).toBe("skill_review_admin_required");
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
test("审一个已发布的技能 ⇒ skill_not_pending(带当前 status)", async () => {
|
|
108
|
+
const r = await call(ADMIN, "review_skill", { skill_id: SKILL, decision: "rejected" });
|
|
109
|
+
expect(r.ok).toBe(false);
|
|
110
|
+
expect(r.error).toBe("skill_not_pending");
|
|
111
|
+
expect(r.status).toBe("published");
|
|
112
|
+
// 与 skill_review_admin_required 的区别:权限没问题,是这个对象的状态不该再审。
|
|
113
|
+
expect(r.error).not.toBe("skill_review_admin_required");
|
|
114
|
+
});
|
|
115
|
+
|
|
116
|
+
test("四条载荷都没有 code 字段(现状,不是契约)", async () => {
|
|
117
|
+
const replies = [
|
|
118
|
+
await call(MEMBER, "upsert_provider", {
|
|
119
|
+
name: "x", vendor: "anthropic", base_url: "https://api.anthropic.com",
|
|
120
|
+
secret_key_ref: "K", models: [],
|
|
121
|
+
}),
|
|
122
|
+
await call(MEMBER, "review_skill", { skill_id: SKILL, decision: "published" }),
|
|
123
|
+
await call(ADMIN, "review_skill", { skill_id: SKILL, decision: "published" }),
|
|
124
|
+
];
|
|
125
|
+
for (const r of replies) {
|
|
126
|
+
expect(r.ok).toBe(false);
|
|
127
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
128
|
+
}
|
|
129
|
+
});
|
|
130
|
+
});
|
package/src/server.ts
CHANGED
|
@@ -6974,6 +6974,8 @@ return Bun.serve({
|
|
|
6974
6974
|
// 客户端在**没有 daemon 绑定**时用它当建议列表。读法同 role:快照可能是文本或对象;
|
|
6975
6975
|
// 解析失败/形状不对 = 这一格没有(null),不影响整行。
|
|
6976
6976
|
let opencodeCatalog: string[] | null = null;
|
|
6977
|
+
// null = daemon 没报采集时刻(不是「很久以前」,也不是「刚刚」)
|
|
6978
|
+
let opencodeCatalogSeenAt: string | null = null;
|
|
6977
6979
|
let opencodeGeneration: "v1" | "v2" | null = null;
|
|
6978
6980
|
let opencodeMode: string | null = null;
|
|
6979
6981
|
let opencodeServer: string | null = null;
|
|
@@ -6986,6 +6988,13 @@ return Bun.serve({
|
|
|
6986
6988
|
const raw = parsed?.opencode_catalog;
|
|
6987
6989
|
if (Array.isArray(raw) && raw.every((m: unknown) => typeof m === "string" && m.length <= 400)) {
|
|
6988
6990
|
opencodeCatalog = raw.slice(0, 400);
|
|
6991
|
+
// #3144 —— 目录是**快照**:51 个模型是刚才采集的还是三周前的,
|
|
6992
|
+
// 读的人此前分不出(`last_seen_at` 是节点心跳,不是采集时刻)。
|
|
6993
|
+
// 这里只做**投影**:daemon 报了 `opencode_catalog_seen_at` 就带出来,
|
|
6994
|
+
// 没报就是 null(显式三态,不塌成「很久以前」也不塌成「刚刚」)。
|
|
6995
|
+
const seen = parsed?.opencode_catalog_seen_at;
|
|
6996
|
+
opencodeCatalogSeenAt =
|
|
6997
|
+
typeof seen === "string" && seen.length > 0 && seen.length <= 40 ? seen : null;
|
|
6989
6998
|
}
|
|
6990
6999
|
// #2293 —— 客户端「Runtime · V2」和「OpenCode Server」两行要的正是快照里这三格标量。
|
|
6991
7000
|
// PR #1092 之前从 `node.config_snapshot` 读,但这个端点**刻意不带整个快照**
|
|
@@ -7013,6 +7022,8 @@ return Bun.serve({
|
|
|
7013
7022
|
attrs_revision: Number(r.attrs_revision ?? 0),
|
|
7014
7023
|
role,
|
|
7015
7024
|
opencode_catalog: opencodeCatalog,
|
|
7025
|
+
// 见上:null 表示 daemon 未上报;非 null 是它自己给的采集时刻
|
|
7026
|
+
opencode_catalog_seen_at: opencodeCatalogSeenAt,
|
|
7016
7027
|
opencode_generation: opencodeGeneration,
|
|
7017
7028
|
opencode_mode: opencodeMode,
|
|
7018
7029
|
opencode_server: opencodeServer,
|
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
// #3309 读数覆盖第五批 —— 四个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// ack_start_request : request_not_ackable / child_pid_required
|
|
4
|
+
// get_create_request: not_a_clone / env_blob_unavailable
|
|
5
|
+
//
|
|
6
|
+
// 这四条有一个共同形状:**请求存在、也确实是发给你的,但当前这一刻的载荷/状态不对**。
|
|
7
|
+
// 只断言 ok===false 时,它们与 request_not_found / not_your_request / cross_network_request
|
|
8
|
+
// 完全同形 —— 而前三者的处置是「换个 id / 换台机器 / 换网络」,后两者的处置是
|
|
9
|
+
// 「按当前状态重发」或「别按 clone 流程要」。所以必须断言确切值。
|
|
10
|
+
//
|
|
11
|
+
// ⚠ 故意没测 `request_vanished` 与 `finalize_tx_failed`:
|
|
12
|
+
// · 前者在代码里标着 "Should never happen given the earlier row read" ——
|
|
13
|
+
// 要让它发生只能伪造一个不可能的中间态(先读到行、再让行消失),
|
|
14
|
+
// 那种测试证明不了真实系统里的任何东西;
|
|
15
|
+
// · 后者要求事务里的 SQL 真的失败,而本仓没有可注入的失败点。
|
|
16
|
+
// 宁可写明「这两条没有读数」,也不写一条用手段造出来的绿。
|
|
17
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
18
|
+
import { db } from "./db.js";
|
|
19
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
20
|
+
import { registerTools } from "./tools.js";
|
|
21
|
+
|
|
22
|
+
const NET = "net_5th_err";
|
|
23
|
+
const DAEMON_NODE = "node_5th_daemon";
|
|
24
|
+
const DAEMON_ALIAS = "5th-daemon";
|
|
25
|
+
const DAEMON_USER = "u_5th_owner";
|
|
26
|
+
const DAEMON_TOKEN = "tok_5th_daemon";
|
|
27
|
+
|
|
28
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
29
|
+
|
|
30
|
+
function cleanup() {
|
|
31
|
+
for (const t of ["audit_log", "node_start_requests", "node_create_requests", "nodes", "api_tokens", "network_members"]) {
|
|
32
|
+
try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
|
|
33
|
+
}
|
|
34
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
35
|
+
try { db.run("DELETE FROM users WHERE user_id = ?1", [DAEMON_USER]); } catch {}
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
function seedDaemon() {
|
|
39
|
+
cleanup();
|
|
40
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [DAEMON_USER]);
|
|
41
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, DAEMON_USER]);
|
|
42
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [DAEMON_USER, NET]);
|
|
43
|
+
db.run(
|
|
44
|
+
`INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at)
|
|
45
|
+
VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'))`,
|
|
46
|
+
[DAEMON_NODE, DAEMON_ALIAS, NET],
|
|
47
|
+
);
|
|
48
|
+
db.run(
|
|
49
|
+
`INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
|
|
50
|
+
VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
|
|
51
|
+
[DAEMON_TOKEN, DAEMON_USER, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOKEN}`],
|
|
52
|
+
);
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
function handlers(): Record<string, ToolHandler> {
|
|
56
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
57
|
+
const out: Record<string, ToolHandler> = {};
|
|
58
|
+
const orig = server.tool.bind(server);
|
|
59
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
60
|
+
const origReg = server.registerTool?.bind(server);
|
|
61
|
+
if (origReg) server.registerTool = (n: string, cfg: any, h: ToolHandler) => { out[n] = h; return origReg(n, cfg, h); };
|
|
62
|
+
registerTools(server, undefined, NET, DAEMON_USER, DAEMON_ALIAS, true, DAEMON_TOKEN);
|
|
63
|
+
return out;
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
async function call(name: string, args: Record<string, unknown>) {
|
|
67
|
+
const r = await handlers()[name](args);
|
|
68
|
+
return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
function seedStartRequest(request_id: string, status: string) {
|
|
72
|
+
db.run(
|
|
73
|
+
`INSERT INTO node_start_requests (request_id, network_id, daemon_node_id, child_node_id, child_alias,
|
|
74
|
+
created_by_token, status, created_at)
|
|
75
|
+
VALUES (?1, ?2, ?3, ?4, 'child-5th', ?5, ?6, ?7)`,
|
|
76
|
+
[request_id, NET, DAEMON_NODE, `n_5th_child_${request_id}`, DAEMON_TOKEN, status, Date.now()],
|
|
77
|
+
);
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
function seedCreateRequest(request_id: string, opts: { status?: string; clone?: boolean } = {}) {
|
|
81
|
+
db.run(
|
|
82
|
+
`INSERT INTO node_create_requests (request_id, daemon_node_id, child_name, network_id, runtime, model,
|
|
83
|
+
flags_json, env_keys, status, created_at, created_by_token)
|
|
84
|
+
VALUES (?1, ?2, ?1, ?3, 'opencode-cli', NULL, '{}', '[]', ?4, ?5, ?6)`,
|
|
85
|
+
// child_name 用 request_id 本身:表上有 (daemon_node_id, child_name) 的唯一约束,
|
|
86
|
+
// 两条测试行共用同一个名字会 SQLITE_CONSTRAINT_UNIQUE。
|
|
87
|
+
[request_id, DAEMON_NODE, NET, opts.status ?? "pending", Date.now(), DAEMON_TOKEN],
|
|
88
|
+
);
|
|
89
|
+
}
|
|
90
|
+
|
|
91
|
+
beforeEach(seedDaemon);
|
|
92
|
+
afterAll(cleanup);
|
|
93
|
+
|
|
94
|
+
describe("#3309 ack_start_request / get_create_request 的错误值域", () => {
|
|
95
|
+
test("ack 一个已结束的启动请求 ⇒ request_not_ackable(带当前 status)", async () => {
|
|
96
|
+
seedStartRequest("sr_done", "succeeded");
|
|
97
|
+
const r = await call("ack_start_request", { request_id: "sr_done", status: "started", child_pid: 1234 });
|
|
98
|
+
expect(r.ok).toBe(false);
|
|
99
|
+
expect(r.error).toBe("request_not_ackable");
|
|
100
|
+
// 带上当前状态:只看「不可 ack」时,读的人还得回查库里那行现在是什么。
|
|
101
|
+
expect(r.status).toBe("succeeded");
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
test("ack started 但不给 child_pid ⇒ child_pid_required", async () => {
|
|
105
|
+
seedStartRequest("sr_nopid", "pending");
|
|
106
|
+
const r = await call("ack_start_request", { request_id: "sr_nopid", status: "started" });
|
|
107
|
+
expect(r.ok).toBe(false);
|
|
108
|
+
expect(r.error).toBe("child_pid_required");
|
|
109
|
+
// 与 request_not_ackable 的区别:这个请求**本来可以** ack,只是少了一个字段。
|
|
110
|
+
expect(r.error).not.toBe("request_not_ackable");
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
// 2026-11-01 —— **两侧写在同一条测试里**(而不是两条):
|
|
114
|
+
// 分在两条里时,「一条红一条绿」会产生「有一个通过」的假象;
|
|
115
|
+
// 而合成一条之后,互补性由这条测试自己保证。
|
|
116
|
+
// 代价在失败信息:所以每一条断言都带一句**指名是哪一侧**的消息。
|
|
117
|
+
test("clone 与 non-clone 两侧互斥(各一例,同一条测试)", async () => {
|
|
118
|
+
seedCreateRequest("cr_plain", { status: "pending" });
|
|
119
|
+
const asClone = await call("get_create_request", { request_id: "cr_plain", expect_clone: true });
|
|
120
|
+
expect(asClone.ok, "非 clone 请求被当成 clone 要 ⇒ 应当拒绝").toBe(false);
|
|
121
|
+
expect(asClone.error).toBe("not_a_clone");
|
|
122
|
+
|
|
123
|
+
seedCreateRequest("cr_isclone", { status: "pending" });
|
|
124
|
+
db.run("UPDATE node_create_requests SET clone_json = ?1 WHERE request_id = 'cr_isclone'",
|
|
125
|
+
[JSON.stringify({ from_node_id: "n_src" })]);
|
|
126
|
+
const asPlain = await call("get_create_request", { request_id: "cr_isclone" });
|
|
127
|
+
expect(asPlain.ok, "clone 请求被当成非 clone 要 ⇒ 应当拒绝").toBe(false);
|
|
128
|
+
expect(asPlain.error).toBe("clone_request");
|
|
129
|
+
|
|
130
|
+
// 互斥:两侧的 error 必须不同 —— 相同说明「区分」这件事根本没发生。
|
|
131
|
+
expect(asPlain.error).not.toBe(asClone.error);
|
|
132
|
+
});
|
|
133
|
+
|
|
134
|
+
test("「缺 blob」与「状态不对」两侧互斥(各一例,同一条测试)", async () => {
|
|
135
|
+
seedCreateRequest("cr_noblob", { status: "pending" });
|
|
136
|
+
const noBlob = await call("get_create_request", { request_id: "cr_noblob" });
|
|
137
|
+
expect(noBlob.ok, "pending 但没有 blob ⇒ 应当拒绝").toBe(false);
|
|
138
|
+
expect(noBlob.error).toBe("env_blob_unavailable");
|
|
139
|
+
|
|
140
|
+
seedCreateRequest("cr_delivered", { status: "delivered" });
|
|
141
|
+
const notPending = await call("get_create_request", { request_id: "cr_delivered" });
|
|
142
|
+
expect(notPending.ok, "状态不是 pending ⇒ 应当拒绝").toBe(false);
|
|
143
|
+
expect(notPending.error).toBe("request_not_pending");
|
|
144
|
+
expect(notPending.current_status).toBe("delivered");
|
|
145
|
+
|
|
146
|
+
expect(notPending.error).not.toBe(noBlob.error);
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
test("launch_verified=true 却不给有效 pid ⇒ verified_child_pid_required", async () => {
|
|
150
|
+
seedCreateRequest("cr_verified", { status: "delivered" });
|
|
151
|
+
const r = await call("ack_create_request", {
|
|
152
|
+
request_id: "cr_verified", status: "started", launch_verified: true,
|
|
153
|
+
});
|
|
154
|
+
expect(r.ok).toBe(false);
|
|
155
|
+
expect(r.error).toBe("verified_child_pid_required");
|
|
156
|
+
// 与 child_pid_required(ack_start_request 的那条)区别:这条只在**声明已验证**时才要求 pid,
|
|
157
|
+
// 不声明验证时 pid 可以缺 —— 两种「缺 pid」处置完全不同。
|
|
158
|
+
expect(r.error).not.toBe("child_pid_required");
|
|
159
|
+
});
|
|
160
|
+
|
|
161
|
+
test("不声明 launch_verified 时不要求 pid(证明上一条是条件触发的)", async () => {
|
|
162
|
+
seedCreateRequest("cr_unverified", { status: "delivered" });
|
|
163
|
+
const r = await call("ack_create_request", { request_id: "cr_unverified", status: "started" });
|
|
164
|
+
expect(r.error).not.toBe("verified_child_pid_required");
|
|
165
|
+
});
|
|
166
|
+
|
|
167
|
+
test("这四条载荷都没有 code 字段(现状,不是契约)", async () => {
|
|
168
|
+
seedStartRequest("sr_done2", "succeeded");
|
|
169
|
+
seedStartRequest("sr_nopid2", "pending");
|
|
170
|
+
seedCreateRequest("cr_plain2", { status: "pending" });
|
|
171
|
+
const replies = [
|
|
172
|
+
await call("ack_start_request", { request_id: "sr_done2", status: "started", child_pid: 1 }),
|
|
173
|
+
await call("ack_start_request", { request_id: "sr_nopid2", status: "started" }),
|
|
174
|
+
await call("get_create_request", { request_id: "cr_plain2", expect_clone: true }),
|
|
175
|
+
await call("get_create_request", { request_id: "cr_plain2" }),
|
|
176
|
+
];
|
|
177
|
+
for (const r of replies) {
|
|
178
|
+
expect(r.ok).toBe(false);
|
|
179
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
180
|
+
}
|
|
181
|
+
});
|
|
182
|
+
});
|
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
// #3309 读数覆盖第八批 —— 两个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// get_start_request : request_not_startable
|
|
4
|
+
// submit_skill : node_identity_unbound
|
|
5
|
+
//
|
|
6
|
+
// 两条都是「身份/状态对了,但这一格不允许」:
|
|
7
|
+
// request_not_startable ⇒ 这份启动请求已经结束(succeeded/failed),不能再拉
|
|
8
|
+
// node_identity_unbound ⇒ 令牌自称是节点,却没有绑定任何别名 ⇒ 身份不可追溯
|
|
9
|
+
//
|
|
10
|
+
// 后者尤其值得钉住:它是**唯一一条「拒绝写入」的身份校验**,
|
|
11
|
+
// 而 SkillHub 的内容是永久快照 —— 让一个无法追溯身份的写入进来,
|
|
12
|
+
// 事后没法回答「这份技能是谁提交的」。
|
|
13
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
14
|
+
import { db } from "./db.js";
|
|
15
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
16
|
+
import { registerTools } from "./tools.js";
|
|
17
|
+
|
|
18
|
+
const NET = "net_8th_err";
|
|
19
|
+
const USER = "u_8th_owner";
|
|
20
|
+
const DAEMON_NODE = "node_8th_daemon";
|
|
21
|
+
const DAEMON_ALIAS = "8th-daemon";
|
|
22
|
+
const DAEMON_TOKEN = "tok_8th_daemon";
|
|
23
|
+
|
|
24
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
25
|
+
|
|
26
|
+
/** callerAlias 传 null 才能走到 node_identity_unbound:那是「自称节点却没绑定别名」。 */
|
|
27
|
+
function handlers(opts: { alias?: string | null } = {}): Record<string, ToolHandler> {
|
|
28
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
29
|
+
const out: Record<string, ToolHandler> = {};
|
|
30
|
+
const orig = server.tool.bind(server);
|
|
31
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
32
|
+
registerTools(server, undefined, NET, USER, opts.alias === undefined ? DAEMON_ALIAS : opts.alias, true, DAEMON_TOKEN);
|
|
33
|
+
return out;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
async function call(name: string, args: Record<string, unknown>, opts: { alias?: string | null } = {}) {
|
|
37
|
+
const r = await handlers(opts)[name](args);
|
|
38
|
+
return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function cleanup() {
|
|
42
|
+
for (const t of ["skillhub_skills", "node_start_requests", "nodes", "api_tokens", "network_members"]) {
|
|
43
|
+
try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
|
|
44
|
+
}
|
|
45
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
46
|
+
try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
function seed() {
|
|
50
|
+
cleanup();
|
|
51
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
|
|
52
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
|
|
53
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
|
|
54
|
+
db.run(
|
|
55
|
+
`INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at)
|
|
56
|
+
VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'))`,
|
|
57
|
+
[DAEMON_NODE, DAEMON_ALIAS, NET],
|
|
58
|
+
);
|
|
59
|
+
db.run(
|
|
60
|
+
`INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
|
|
61
|
+
VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
|
|
62
|
+
[DAEMON_TOKEN, USER, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOKEN}`],
|
|
63
|
+
);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
function seedStart(request_id: string, status: string) {
|
|
67
|
+
db.run(
|
|
68
|
+
`INSERT INTO node_start_requests (request_id, network_id, daemon_node_id, child_node_id, child_alias,
|
|
69
|
+
created_by_token, status, created_at)
|
|
70
|
+
VALUES (?1, ?2, ?3, ?4, 'child-8th', ?5, ?6, ?7)`,
|
|
71
|
+
[request_id, NET, DAEMON_NODE, `n_8th_child_${request_id}`, DAEMON_TOKEN, status, Date.now()],
|
|
72
|
+
);
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
const skill = {
|
|
76
|
+
slug: "eighth-skill", name: "Eighth", version: "1.0.0", content: "# body",
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
beforeEach(seed);
|
|
80
|
+
afterAll(cleanup);
|
|
81
|
+
|
|
82
|
+
describe("#3309 get_start_request / submit_skill 的错误值域", () => {
|
|
83
|
+
test("拉一份已结束的启动请求 ⇒ request_not_startable(带当前 status)", async () => {
|
|
84
|
+
seedStart("sr_8th_done", "succeeded");
|
|
85
|
+
const r = await call("get_start_request", { request_id: "sr_8th_done" });
|
|
86
|
+
expect(r.ok).toBe(false);
|
|
87
|
+
expect(r.error).toBe("request_not_startable");
|
|
88
|
+
expect(r.status).toBe("succeeded");
|
|
89
|
+
// 与 request_not_found 的区别:它确实存在、也确实发给这台机器,只是已经结束了。
|
|
90
|
+
expect(r.error).not.toBe("request_not_found");
|
|
91
|
+
});
|
|
92
|
+
|
|
93
|
+
test("反向:pending 的启动请求可以拉(证明上一条是「状态」而不是「总被拒」)", async () => {
|
|
94
|
+
seedStart("sr_8th_pending", "pending");
|
|
95
|
+
const r = await call("get_start_request", { request_id: "sr_8th_pending" });
|
|
96
|
+
// 会不会成功取决于后续 hydration,但**不该**再是 request_not_startable。
|
|
97
|
+
expect(r.error).not.toBe("request_not_startable");
|
|
98
|
+
});
|
|
99
|
+
|
|
100
|
+
test("节点令牌却没有绑定别名 ⇒ node_identity_unbound", async () => {
|
|
101
|
+
const r = await call("submit_skill", skill, { alias: null });
|
|
102
|
+
expect(r.ok).toBe(false);
|
|
103
|
+
expect(r.error).toBe("node_identity_unbound");
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
test("反向:绑定了别名的节点可以提交(证明上一条是「身份」而不是「节点不能写」)", async () => {
|
|
107
|
+
const r = await call("submit_skill", skill);
|
|
108
|
+
expect(r.error).not.toBe("node_identity_unbound");
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
test("两条载荷都没有 code 字段(现状,不是契约)", async () => {
|
|
112
|
+
seedStart("sr_8th_done2", "succeeded");
|
|
113
|
+
const replies = [
|
|
114
|
+
await call("get_start_request", { request_id: "sr_8th_done2" }),
|
|
115
|
+
await call("submit_skill", skill, { alias: null }),
|
|
116
|
+
];
|
|
117
|
+
for (const r of replies) {
|
|
118
|
+
expect(r.ok).toBe(false);
|
|
119
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
120
|
+
}
|
|
121
|
+
});
|
|
122
|
+
});
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
// #3309 读数覆盖第九批 —— 一个错误字面量,三个工具共用:
|
|
2
|
+
//
|
|
3
|
+
// "task not found" ← retry_task / get_task / reassign_task
|
|
4
|
+
//
|
|
5
|
+
// 它此前在测试里一次都没出现过。而它正是最容易一直没人断言的那一类:
|
|
6
|
+
// **一句读起来像文案的英文短语**。所有人都会以为它「肯定被测过」,
|
|
7
|
+
// 而按字符串去找,一次都没有。
|
|
8
|
+
//
|
|
9
|
+
// 为什么值得单独钉:这三个工具在「id 打错了」时都落到同一句话,
|
|
10
|
+
// 而它们的补救完全不同(重试另一个 id / 查另一个 id / 把它派给别人)。
|
|
11
|
+
// 一旦有人为了「更友好」把其中一处改成 `task_not_found`,只有断言能发现。
|
|
12
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
13
|
+
import { db } from "./db.js";
|
|
14
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
15
|
+
import { registerTools } from "./tools.js";
|
|
16
|
+
|
|
17
|
+
const NET = "net_9th_err";
|
|
18
|
+
const USER = "u_9th_owner";
|
|
19
|
+
const ALIAS = "9th-node";
|
|
20
|
+
|
|
21
|
+
type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
|
|
22
|
+
|
|
23
|
+
function handlers(): Record<string, ToolHandler> {
|
|
24
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
25
|
+
const out: Record<string, ToolHandler> = {};
|
|
26
|
+
const orig = server.tool.bind(server);
|
|
27
|
+
server.tool = (n: string, d: string, s: any, h: ToolHandler) => { out[n] = h; return orig(n, d, s, h); };
|
|
28
|
+
registerTools(server, undefined, NET, USER, ALIAS, false, null);
|
|
29
|
+
return out;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
async function call(name: string, args: Record<string, unknown>) {
|
|
33
|
+
const r = await handlers()[name](args);
|
|
34
|
+
return JSON.parse(r.content[0].text) as { ok?: boolean; error?: string; [k: string]: unknown };
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function cleanup() {
|
|
38
|
+
try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
|
|
39
|
+
try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
|
|
40
|
+
try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
function seed() {
|
|
44
|
+
cleanup();
|
|
45
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
|
|
46
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
|
|
47
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
beforeEach(seed);
|
|
51
|
+
afterAll(cleanup);
|
|
52
|
+
|
|
53
|
+
describe('#3309 「task not found」:三个工具共用同一句话', () => {
|
|
54
|
+
test("三个工具在不存在的 id 上给出**同一句**(逐字相同)", async () => {
|
|
55
|
+
const missing = "task_9th_does_not_exist";
|
|
56
|
+
const got = [
|
|
57
|
+
await call("get_task", { task_id: missing }),
|
|
58
|
+
await call("retry_task", { task_id: missing }),
|
|
59
|
+
await call("reassign_task", { task_id: missing, to_name: "someone-else" }),
|
|
60
|
+
];
|
|
61
|
+
for (const [i, r] of got.entries()) {
|
|
62
|
+
expect(r.ok, `第 ${i + 1} 个工具应当拒绝`).toBe(false);
|
|
63
|
+
// 逐字相同是**故意的**:调用方按这一句分支;改一处就多出一种拼写。
|
|
64
|
+
expect(r.error, `第 ${i + 1} 个工具的 error 应当是同一句`).toBe("task not found");
|
|
65
|
+
}
|
|
66
|
+
// 三处必须真的同一个字符串 —— 任何一个被「统一成 code」都会让这条红。
|
|
67
|
+
expect(new Set(got.map((r) => r.error)).size, "三个工具不该给出不同拼写").toBe(1);
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
test("这句话**带空格**(不是 code 风格)—— 现状,记下来", async () => {
|
|
71
|
+
const r = await call("get_task", { task_id: "task_9th_missing" });
|
|
72
|
+
// 带空格的值最容易被当成文案而没人断言;这条测试存在的理由是把它钉成契约。
|
|
73
|
+
expect(String(r.error)).toContain(" ");
|
|
74
|
+
expect(String(r.error)).not.toMatch(/^[a-z0-9_]+$/);
|
|
75
|
+
});
|
|
76
|
+
});
|
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
// #3309 读数覆盖第三批 —— `update_node_config` 的 3 个 error 字面量此前在测试里一次都没出现过:
|
|
2
|
+
//
|
|
3
|
+
// channels_all_invalid / insufficient_role_for_security_flag / invalid_patch
|
|
4
|
+
//
|
|
5
|
+
// 现有测试覆盖的是**成功改配置**与**响应键集**,所以这三条拒绝分支从来没被走过。
|
|
6
|
+
//
|
|
7
|
+
// 三条的处置完全不同,这也是它们必须各有断言的理由:
|
|
8
|
+
// channels_all_invalid ⇒ 调用方发来的渠道**全不认识**(可能是拼错,也可能是客户端版本旧)
|
|
9
|
+
// —— 绝不能静默当成「停用全部」,那会灭掉用户已有的 worker
|
|
10
|
+
// insufficient_role_for_security_flag ⇒ 权限不足;换个人来做或升级角色
|
|
11
|
+
// invalid_patch ⇒ 载荷本身不合法;改载荷
|
|
12
|
+
//
|
|
13
|
+
// 特别注意三条里 **两条的 error 都是 invalid_patch 家族之外的东西** ——
|
|
14
|
+
// 只按 ok===false 断言时,它们与「网络不通」「节点不存在」完全同形。
|
|
15
|
+
import { afterAll, beforeEach, describe, expect, test } from "bun:test";
|
|
16
|
+
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
|
|
17
|
+
import { db } from "./db.js";
|
|
18
|
+
import { registerTools } from "./tools.js";
|
|
19
|
+
|
|
20
|
+
const NET = "net_unc";
|
|
21
|
+
const ADMIN = "u_unc_admin";
|
|
22
|
+
const MEMBER = "u_unc_member";
|
|
23
|
+
const NODE = "n_unc_node";
|
|
24
|
+
|
|
25
|
+
type ToolHandler = (args: any) => Promise<any>;
|
|
26
|
+
|
|
27
|
+
function handlers(userId: string): Record<string, ToolHandler> {
|
|
28
|
+
const server = new McpServer({ name: "t", version: "0" }) as any;
|
|
29
|
+
const tools: Record<string, ToolHandler> = {};
|
|
30
|
+
const orig = server.tool.bind(server);
|
|
31
|
+
server.tool = (name: string, desc: string, schema: any, handler: ToolHandler) => {
|
|
32
|
+
tools[name] = handler;
|
|
33
|
+
return orig(name, desc, schema, handler);
|
|
34
|
+
};
|
|
35
|
+
registerTools(server, undefined, NET, userId, "unc-node", false, null);
|
|
36
|
+
return tools;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
async function patch(userId: string, p: Record<string, unknown>, baseRevision = 0) {
|
|
40
|
+
const r = await handlers(userId).update_node_config({
|
|
41
|
+
node_id: NODE, base_revision: baseRevision, patch: p,
|
|
42
|
+
});
|
|
43
|
+
return JSON.parse(r.content[0].text);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
function cleanup() {
|
|
47
|
+
db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]);
|
|
48
|
+
db.run("DELETE FROM nodes WHERE network_id = ?1", [NET]);
|
|
49
|
+
db.run("DELETE FROM networks WHERE network_id = ?1", [NET]);
|
|
50
|
+
db.run("DELETE FROM users WHERE user_id IN (?1, ?2)", [ADMIN, MEMBER]);
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function seed() {
|
|
54
|
+
cleanup();
|
|
55
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [ADMIN]);
|
|
56
|
+
db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MEMBER]);
|
|
57
|
+
db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, ADMIN]);
|
|
58
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [ADMIN, NET]);
|
|
59
|
+
db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'member', datetime('now'))", [MEMBER, NET]);
|
|
60
|
+
db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, runtime, model, channels, config_snapshot,
|
|
61
|
+
hostname, created_at, updated_at, lifecycle_state)
|
|
62
|
+
VALUES (?1, 'unc-node', 'unc-node', ?2, 'claude-agent-sdk', 'm', '["commhub"]', '{}', 'host-u',
|
|
63
|
+
datetime('now'), datetime('now'), 'active')`, [NODE, NET]);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
beforeEach(seed);
|
|
67
|
+
afterAll(cleanup);
|
|
68
|
+
|
|
69
|
+
describe("#3309 update_node_config 错误值域:三条拒绝各有一条会红的断言", () => {
|
|
70
|
+
test("渠道全不认识 ⇒ channels_all_invalid(且回显 requested,**不是** invalid_patch)", async () => {
|
|
71
|
+
const r = await patch(ADMIN, { channels: ["telegarm"] });
|
|
72
|
+
expect(r.ok).toBe(false);
|
|
73
|
+
expect(r.error).toBe("channels_all_invalid");
|
|
74
|
+
// 回显调用方发来的原值:只说「全不合法」时,读的人还得自己猜发了什么。
|
|
75
|
+
expect(r.requested).toEqual(["telegarm"]);
|
|
76
|
+
// 与 invalid_patch 的区别是本条的重点:一个要改渠道名,一个要改载荷结构。
|
|
77
|
+
expect(r.error).not.toBe("invalid_patch");
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
test("成员改安全敏感 flag ⇒ insufficient_role_for_security_flag(带 field 与 required_role)", async () => {
|
|
81
|
+
const r = await patch(MEMBER, { flags: { permissionMode: "restricted" } });
|
|
82
|
+
expect(r.ok).toBe(false);
|
|
83
|
+
expect(r.error).toBe("insufficient_role_for_security_flag");
|
|
84
|
+
expect(r.field).toBe("flags.permissionMode");
|
|
85
|
+
expect(r.required_role).toBe("admin");
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
test("模型名非法 ⇒ invalid_patch(带 field=model 与 reason)", async () => {
|
|
89
|
+
// zod 只限 max(200),空串能过 zod、被 validatePatch 拦下 ⇒ 正好走到这条分支。
|
|
90
|
+
const r = await patch(ADMIN, { model: "" });
|
|
91
|
+
expect(r.ok).toBe(false);
|
|
92
|
+
expect(r.error).toBe("invalid_patch");
|
|
93
|
+
expect(r.field).toBe("model");
|
|
94
|
+
expect(typeof r.reason).toBe("string");
|
|
95
|
+
});
|
|
96
|
+
|
|
97
|
+
test("三条的载荷都**没有** code 字段(现状,不是契约)", async () => {
|
|
98
|
+
for (const r of [
|
|
99
|
+
await patch(ADMIN, { channels: ["telegarm"] }),
|
|
100
|
+
await patch(MEMBER, { flags: { permissionMode: "restricted" } }),
|
|
101
|
+
await patch(ADMIN, { model: "" }),
|
|
102
|
+
]) {
|
|
103
|
+
expect(r.ok).toBe(false);
|
|
104
|
+
expect(Object.prototype.hasOwnProperty.call(r, "code")).toBe(false);
|
|
105
|
+
}
|
|
106
|
+
});
|
|
107
|
+
});
|