cj-tauri 1.1.2 → 2.1.0

package/src/tests/plugin_fs_test.cj

@@ -0,0 +1,207 @@
+package cjTauri.tests
+
+import cjTauri.*
+import cjTauri.plugins.fs.*
+import std.collection.*
+import std.fs.*
+import stdx.encoding.json.*
+import std.unittest.*
+import std.unittest.testmacro.*
+
+/*
+ * fs 插件单元测试：纯仓颉插件（零 C 桥），这里测到的是「真实落盘」。
+ * 覆盖新四条命令（mkdir / rename / copy / stat）+ 命名权限集闸门 + 参数校验。
+ * 临时目录固定 /tmp/fs-unit-test（按固定名复用，不在仓库里留测试产物）。
+ */
+
+const FS_T_BASE: String = "/tmp/fs-unit-test"
+
+/** 递归删除基座目录（用例前置清场）：上一轮跑完留下的树会让 mkdir / copy 撞「already exists」 */
+func fsWipeBase(dir: String): Unit {
+    if (!exists(dir)) {
+        return
+    }
+    if (FileInfo(dir).isDirectory()) {
+        for (info in Directory.readFrom(dir)) {
+            fsWipeBase("${dir}/${info.name}")
+        }
+    }
+    // std.fs 的 remove 同时管文件与空目录（fs:remove 的注释有说明），自底向上删到这里必然为空
+    remove(dir)
+}
+
+/** 取一条 fs 命令处理器 */
+func fsCmd(short: String): CommandHandler {
+    return FsPlugin().commands().get(short).getOrThrow()
+}
+
+/** 直接调命令，返回结果（抛 CommandException 就往上冒，由用例自己接） */
+func fsRun(short: String, args: JsonObject): JsonValue {
+    return fsCmd(short).handle("fs:${short}", args, IpcContext("main", IpcHub()))
+}
+
+/** 直接调命令，把 CommandException 的原文取出来（没抛就返回空串）*/
+func fsErrOf(short: String, args: JsonObject): String {
+    try {
+        fsRun(short, args)
+        return ""
+    } catch (e: CommandException) {
+        return e.message
+    }
+}
+
+/** 只有 path 一个参数的入参 */
+func fsArgs(path: String): JsonObject {
+    var o = JsonObject()
+    o.put("path", JsonString(path))
+    return o
+}
+
+/** path + newPath 两个路径的入参（rename / copy） */
+func fsArgsTo(path: String, newPath: String): JsonObject {
+    var o = JsonObject()
+    o.put("path", JsonString(path))
+    o.put("newPath", JsonString(newPath))
+    return o
+}
+
+/** path + recursive=true 的入参 */
+func fsArgsRecursive(path: String): JsonObject {
+    var o = JsonObject()
+    o.put("path", JsonString(path))
+    o.put("recursive", JsonBool(true))
+    return o
+}
+
+/** path + newPath + overwrite=true 的入参（撞既有目标时放行） */
+func fsArgsToOverwrite(path: String, newPath: String): JsonObject {
+    var o = JsonObject()
+    o.put("path", JsonString(path))
+    o.put("newPath", JsonString(newPath))
+    o.put("overwrite", JsonBool(true))
+    return o
+}
+
+@Test
+func testFsShimHasNewEntries(): Unit {
+    let js = FsPlugin().jsShim()
+    @Expect(js.contains("'fs:mkdir'"), true)
+    @Expect(js.contains("'fs:rename'"), true)
+    @Expect(js.contains("'fs:copy'"), true)
+    @Expect(js.contains("'fs:stat'"), true)
+}
+
+@Test
+func testFsPermissionSetsGateWrites(): Unit {
+    let sets = pluginPermissionSets(FsPlugin())
+    @Expect(sets.size, 2)
+    let ro = sets.get("fs:readonly").getOrThrow()
+    @Expect(ro.size, 4)
+    // readonly 只含读：stat 进得来，任何写命令都不许被顺带打开
+    var hasWrite = false
+    for (n in ro) {
+        if (n == "fs:writeText" || n == "fs:remove" || n == "fs:mkdir" || n == "fs:rename" || n == "fs:copy") {
+            hasWrite = true
+        }
+    }
+    @Expect(hasWrite, false)
+    // default 是全集
+    let all = sets.get("fs:default").getOrThrow()
+    @Expect(all.size, 9)
+}
+
+@Test
+func testFsMkdirCreatesAndRejectsDuplicate(): Unit {
+    // 基座目录先递归建出来（后面的用例都挂在这棵树上）；上一轮的残留先清掉，
+    // 否则第二次跑 test.sh 时 mkdir / copy 会撞「already exists」（固定目录复用的代价）
+    fsWipeBase(FS_T_BASE)
+    @Expect(fsRun("mkdir", fsArgsRecursive(FS_T_BASE)).asBool().getValue(), true)
+    let dir = "${FS_T_BASE}/mkdir-a"
+    @Expect(fsRun("mkdir", fsArgs(dir)).asBool().getValue(), true)
+    @Expect(fsRun("exists", fsArgs(dir)).asBool().getValue(), true)
+    // 已存在是错误不是成功：调用方要幂等就先 exists
+    @Expect(fsErrOf("mkdir", fsArgs(dir)).contains("fs:mkdir failed"), true)
+    // recursive=true 逐级建
+    @Expect(fsRun("mkdir", fsArgsRecursive("${FS_T_BASE}/mkdir-b/c/d")).asBool().getValue(), true)
+    // 缺省非递归：中间层不存在 → 报错
+    @Expect(fsErrOf("mkdir", fsArgs("${FS_T_BASE}/x1/x2")).contains("fs:mkdir failed"), true)
+}
+
+@Test
+func testFsRenameMovesAndHonorsOverwrite(): Unit {
+    let src = "${FS_T_BASE}/r-src.txt"
+    let dst = "${FS_T_BASE}/r-dst.txt"
+    File.writeTo(src, "hello".toArray())
+    File.writeTo(dst, "old".toArray())
+    // 目标已存在且没声明 overwrite：报错，两边都原样
+    @Expect(fsErrOf("rename", fsArgsTo(src, dst)).contains("fs:rename failed"), true)
+    @Expect(String.fromUtf8(File.readFrom(dst)), "old")
+    // overwrite=true：覆盖目标，源头消失
+    @Expect(fsRun("rename", fsArgsToOverwrite(src, dst)).asBool().getValue(), true)
+    @Expect(fsRun("exists", fsArgs(src)).asBool().getValue(), false)
+    @Expect(String.fromUtf8(File.readFrom(dst)), "hello")
+}
+
+@Test
+func testFsCopyKeepsSourceAndCopiesTrees(): Unit {
+    let src = "${FS_T_BASE}/c-src.txt"
+    let dst = "${FS_T_BASE}/c-dst.txt"
+    File.writeTo(src, "copy me".toArray())
+    @Expect(fsRun("copy", fsArgsTo(src, dst)).asBool().getValue(), true)
+    // 源还在、内容一致
+    @Expect(fsRun("exists", fsArgs(src)).asBool().getValue(), true)
+    @Expect(String.fromUtf8(File.readFrom(dst)), "copy me")
+    // 再拷一次撞既有目标：缺省报错；overwrite=true 才放行
+    @Expect(fsErrOf("copy", fsArgsTo(src, dst)).contains("fs:copy failed"), true)
+    @Expect(fsRun("copy", fsArgsToOverwrite(src, dst)).asBool().getValue(), true)
+    // 目录整树拷贝：copy 的目录语义是递归
+    let tree = "${FS_T_BASE}/c-tree"
+    fsRun("mkdir", fsArgsRecursive("${tree}/sub"))
+    File.writeTo("${tree}/sub/inner.txt", "deep".toArray())
+    @Expect(fsRun("copy", fsArgsTo(tree, "${FS_T_BASE}/c-tree2")).asBool().getValue(), true)
+    @Expect(String.fromUtf8(File.readFrom("${FS_T_BASE}/c-tree2/sub/inner.txt")), "deep")
+}
+
+/** JsonKind 转可比较的名字（JsonKind 没有 ==，比较要走 match 分支；分支体用表达式避免块解析歧义） */
+func fsKindName(v: JsonValue): String {
+    match (v.kind()) {
+        case JsonKind.JsObject => "object"
+        case JsonKind.JsArray => "array"
+        case JsonKind.JsString => "string"
+        case JsonKind.JsBool => "bool"
+        case JsonKind.JsNull => "null"
+        case _ => "other"
+    }
+}
+
+@Test
+func testFsStatReportsMetadata(): Unit {
+    let file = "${FS_T_BASE}/s.txt"
+    File.writeTo(file, "12345".toArray())
+    let r = fsRun("stat", fsArgs(file))
+    @Expect(fsKindName(r), "object")
+    let obj = r.asObject()
+    @Expect(obj.get("name").getOrThrow().asString().getValue(), "s.txt")
+    @Expect(obj.get("dir").getOrThrow().asBool().getValue(), false)
+    @Expect(obj.get("size").getOrThrow().asInt().getValue(), 5)
+    @Expect(obj.get("lastModified").getOrThrow().asString().getValue().size > 0, true)
+    // 目录也能 stat：dir=true
+    let dirInfo = fsRun("stat", fsArgs(FS_T_BASE))
+    @Expect(fsKindName(dirInfo), "object")
+    @Expect(dirInfo.asObject().get("dir").getOrThrow().asBool().getValue(), true)
+}
+
+@Test
+func testFsNewCommandsValidateArguments(): Unit {
+    // 缺 newPath
+    @Expect(fsErrOf("rename", fsArgs("${FS_T_BASE}/r-src.txt")).contains("missing argument"), true)
+    @Expect(fsErrOf("copy", fsArgs("${FS_T_BASE}/r-src.txt")).contains("missing argument"), true)
+    // 缺 path
+    @Expect(fsErrOf("mkdir", JsonObject()).contains("missing argument"), true)
+    // 可选布尔给了非布尔值：当场拒，不静默当 false
+    var bad = fsArgs("${FS_T_BASE}/mkdir-a")
+    bad.put("recursive", JsonInt(1))
+    @Expect(fsErrOf("mkdir", bad).contains("must be a boolean"), true)
+    // stat 不存在的路径：报错而不是返回空对象
+    @Expect(fsErrOf("stat", fsArgs("${FS_T_BASE}/no-such-file")).contains("fs:stat failed"), true)
+}

package/src/tests/plugin_http_test.cj

@@ -1,124 +1,124 @@
-package cjTauri.tests
-
-import cjTauri.*
-import cjTauri.plugins.http.*
-import std.collection.*
-import std.unittest.*
-import std.unittest.testmacro.*
-
-/*
- * http 插件的策略层用例（RFC-003 HTTP 白名单收口）。
- *
- * 只测**纯函数**（URL → host 提取、上限常量、插件声明面）：真的发请求那一段归
- * 实机 E2E——单测进程里起真 HTTP 服务会引入对环境的依赖，不符合「渐进目标」的口径。
- */
-
-@Test
-func testHttpHostOfExtractsHostLowercased(): Unit {
-    @Expect(httpHostOf("https://api.deepseek.com/v1/chat/completions"), "api.deepseek.com")
-    // host 大小写不敏感：统一小写，匹配口径才收得住
-    @Expect(httpHostOf("https://API.DeepSeek.COM/x"), "api.deepseek.com")
-}
-
-@Test
-func testHttpHostOfStripsPortAndUserinfo(): Unit {
-    // 端口不参与匹配（白名单声明「信这个主机」）
-    @Expect(httpHostOf("http://localhost:2375/docker"), "localhost")
-    // userinfo（user:pass@host）不许用来伪造白名单匹配
-    @Expect(httpHostOf("https://user:pass@api.example.com/"), "api.example.com")
-}
-
-@Test
-func testHttpHostOfRejectsNonHttpSchemes(): Unit {
-    // file: 不给出网语义；空 host（ftp://）也当解析不出
-    let f = match (httpHostOf("file:///etc/passwd")) {
-        case Some(_) => true
-        case None => false
-    }
-    @Expect(f, false)
-    let n = match (httpHostOf("notaurl")) {
-        case Some(_) => true
-        case None => false
-    }
-    @Expect(n, false)
-}
-
-@Test
-func testHttpHostOfIpv6Literal(): Unit {
-    // IPv6 字面量整体当 host（不拆端口）：去端口逻辑只在非 '[' 开头时走
-    @Expect(httpHostOf("http://[::1]:8080/x"), "[::1]")
-}
-
-@Test
-func testHttpPluginDeclarations(): Unit {
-    let p = HttpPlugin()
-    @Expect(p.name(), "http")
-    @Expect(p.scopeAware(), true)
-    // 权限集 default = get + post + delete + postStream：集声明 != 放行，清单引用才生效
-    @Expect(p.permissions().contains("default"), true)
-    let cmds = p.commands()
-    @Expect(cmds.contains("get"), true)
-    @Expect(cmds.contains("post"), true)
-    // delete 是给「带 JSON 体的 DELETE」用的（cjh 的工作区删除靠体传 path）：
-    // 少了它前端只能退化成无体 DELETE，对端拿不到要删哪个
-    @Expect(cmds.contains("delete"), true)
-    @Expect(cmds.contains("postStream"), true)
-    // 推一个事件（流式 http:chunk，短名登记）、无前端 shim
-    @Expect(p.events().size == 1, true)
-    @Expect(p.jsShim().size == 0, true)
-}
-
-@Test
-func testHttpHostOfRejectsWsSchemes(): Unit {
-    // http 插件的 host 提取转发核心 urlHostOf（ws/wss 是 ws 插件的合法目标），
-    // 但协议收紧到 http(s)：ws:// 不是可抓取目标，解析不出 host 按白名单未命中拒
-    let f = match (httpHostOf("ws://127.0.0.1:8765/ws")) {
-        case Some(_) => true
-        case None => false
-    }
-    @Expect(f, false)
-}
-
-@Test
-func testHttpLimitsAreSane(): Unit {
-    // 上限是「防撑爆」而非「功能」：8 MiB 与 60s 与既有插件（clipboard 8MiB）同量级
-    @Expect(CJ_HTTP_MAX_BYTES == 8 * 1024 * 1024, true)
-    @Expect(CJ_HTTP_TIMEOUT_SECONDS > 0, true)
-    @Expect(CJ_HTTP_MAX_HEADERS > 0, true)
-}
-
-/*
- * 流式分块的 UTF-8 边界（2026-10-16 实机 → 回归）：`takeCompleteUtf8` 取走完整序列后
- * 必须把 pending 里的**这些字节**全移掉。曾经写成 `remove(0..(cut-1))`（Range 是右开的，
- * 这样就少移 1 字节），上一个序列的末字节留在 pending 里，下一轮拼出的字节序列非法，
- * fromUtf8 抛 IllegalArgumentException，表现是「中文回复偶发整条 postStream 请求失败」。
- * 判据就一条：整块都是完整序列时，取完 pending 必须**空**。
- */
-
-@Test
-func testHttpTakeCompleteUtf8ConsumesWholeCompleteChunk(): Unit {
-    let pending = ArrayList<Byte>()
-    for (b in "abc你".toArray()) {
-        pending.add(b)
-    }
-    let cmds = HttpCommands()
-    @Expect(cmds.takeCompleteUtf8(pending), "abc你")
-    @Expect(pending.size, 0)
-}
-
-@Test
-func testHttpTakeCompleteUtf8KeepsPartialTail(): Unit {
-    // 尾巴不完整（汉字只到了前 2 字节）：留在 pending 里等下一块补齐，不能按原样解出来
-    let bytes = "你".toArray()
-    @Expect(bytes.size, 3)
-    let pending = ArrayList<Byte>()
-    pending.add(bytes[0])
-    pending.add(bytes[1])
-    let cmds = HttpCommands()
-    @Expect(cmds.takeCompleteUtf8(pending), "")
-    @Expect(pending.size, 2)
-    // 第 3 字节到了：跨块的字符拼回来，pending 随之清空
-    pending.add(bytes[2])
-    @Expect(cmds.takeCompleteUtf8(pending), "你")
-    @Expect(pending.size, 0)
-}
+package cjTauri.tests
+
+import cjTauri.*
+import cjTauri.plugins.http.*
+import std.collection.*
+import std.unittest.*
+import std.unittest.testmacro.*
+
+/*
+ * http 插件的策略层用例（RFC-003 HTTP 白名单收口）。
+ *
+ * 只测**纯函数**（URL → host 提取、上限常量、插件声明面）：真的发请求那一段归
+ * 实机 E2E——单测进程里起真 HTTP 服务会引入对环境的依赖，不符合「渐进目标」的口径。
+ */
+
+@Test
+func testHttpHostOfExtractsHostLowercased(): Unit {
+    @Expect(httpHostOf("https://api.deepseek.com/v1/chat/completions"), "api.deepseek.com")
+    // host 大小写不敏感：统一小写，匹配口径才收得住
+    @Expect(httpHostOf("https://API.DeepSeek.COM/x"), "api.deepseek.com")
+}
+
+@Test
+func testHttpHostOfStripsPortAndUserinfo(): Unit {
+    // 端口不参与匹配（白名单声明「信这个主机」）
+    @Expect(httpHostOf("http://localhost:2375/docker"), "localhost")
+    // userinfo（user:pass@host）不许用来伪造白名单匹配
+    @Expect(httpHostOf("https://user:pass@api.example.com/"), "api.example.com")
+}
+
+@Test
+func testHttpHostOfRejectsNonHttpSchemes(): Unit {
+    // file: 不给出网语义；空 host（ftp://）也当解析不出
+    let f = match (httpHostOf("file:///etc/passwd")) {
+        case Some(_) => true
+        case None => false
+    }
+    @Expect(f, false)
+    let n = match (httpHostOf("notaurl")) {
+        case Some(_) => true
+        case None => false
+    }
+    @Expect(n, false)
+}
+
+@Test
+func testHttpHostOfIpv6Literal(): Unit {
+    // IPv6 字面量整体当 host（不拆端口）：去端口逻辑只在非 '[' 开头时走
+    @Expect(httpHostOf("http://[::1]:8080/x"), "[::1]")
+}
+
+@Test
+func testHttpPluginDeclarations(): Unit {
+    let p = HttpPlugin()
+    @Expect(p.name(), "http")
+    @Expect(p.scopeAware(), true)
+    // 权限集 default = get + post + delete + postStream：集声明 != 放行，清单引用才生效
+    @Expect(p.permissions().contains("default"), true)
+    let cmds = p.commands()
+    @Expect(cmds.contains("get"), true)
+    @Expect(cmds.contains("post"), true)
+    // delete 是给「带 JSON 体的 DELETE」用的（cjh 的工作区删除靠体传 path）：
+    // 少了它前端只能退化成无体 DELETE，对端拿不到要删哪个
+    @Expect(cmds.contains("delete"), true)
+    @Expect(cmds.contains("postStream"), true)
+    // 推一个事件（流式 http:chunk，短名登记）、无前端 shim
+    @Expect(p.events().size == 1, true)
+    @Expect(p.jsShim().size == 0, true)
+}
+
+@Test
+func testHttpHostOfRejectsWsSchemes(): Unit {
+    // http 插件的 host 提取转发核心 urlHostOf（ws/wss 是 ws 插件的合法目标），
+    // 但协议收紧到 http(s)：ws:// 不是可抓取目标，解析不出 host 按白名单未命中拒
+    let f = match (httpHostOf("ws://127.0.0.1:8765/ws")) {
+        case Some(_) => true
+        case None => false
+    }
+    @Expect(f, false)
+}
+
+@Test
+func testHttpLimitsAreSane(): Unit {
+    // 上限是「防撑爆」而非「功能」：8 MiB 与 60s 与既有插件（clipboard 8MiB）同量级
+    @Expect(CJ_HTTP_MAX_BYTES == 8 * 1024 * 1024, true)
+    @Expect(CJ_HTTP_TIMEOUT_SECONDS > 0, true)
+    @Expect(CJ_HTTP_MAX_HEADERS > 0, true)
+}
+
+/*
+ * 流式分块的 UTF-8 边界（2026-10-16 实机 → 回归）：`takeCompleteUtf8` 取走完整序列后
+ * 必须把 pending 里的**这些字节**全移掉。曾经写成 `remove(0..(cut-1))`（Range 是右开的，
+ * 这样就少移 1 字节），上一个序列的末字节留在 pending 里，下一轮拼出的字节序列非法，
+ * fromUtf8 抛 IllegalArgumentException，表现是「中文回复偶发整条 postStream 请求失败」。
+ * 判据就一条：整块都是完整序列时，取完 pending 必须**空**。
+ */
+
+@Test
+func testHttpTakeCompleteUtf8ConsumesWholeCompleteChunk(): Unit {
+    let pending = ArrayList<Byte>()
+    for (b in "abc你".toArray()) {
+        pending.add(b)
+    }
+    let cmds = HttpCommands()
+    @Expect(cmds.takeCompleteUtf8(pending), "abc你")
+    @Expect(pending.size, 0)
+}
+
+@Test
+func testHttpTakeCompleteUtf8KeepsPartialTail(): Unit {
+    // 尾巴不完整（汉字只到了前 2 字节）：留在 pending 里等下一块补齐，不能按原样解出来
+    let bytes = "你".toArray()
+    @Expect(bytes.size, 3)
+    let pending = ArrayList<Byte>()
+    pending.add(bytes[0])
+    pending.add(bytes[1])
+    let cmds = HttpCommands()
+    @Expect(cmds.takeCompleteUtf8(pending), "")
+    @Expect(pending.size, 2)
+    // 第 3 字节到了：跨块的字符拼回来，pending 随之清空
+    pending.add(bytes[2])
+    @Expect(cmds.takeCompleteUtf8(pending), "你")
+    @Expect(pending.size, 0)
+}