cloudcc-cli 2.3.0 → 2.3.1

package/test/customSetting.cli.test.js

@@ -0,0 +1,84 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("自定义设置管理：get -> detail（可选 create/delete）", async (t) => {
+  let firstSettingId = null;
+  let createdSettingId = null;
+
+  t.test("1) 获取自定义设置列表", async () => {
+    const { stdout } = await runCc(["get", "customSetting", repoRoot]);
+    const list = JSON.parse(stdout.trim() || "[]");
+    assert.ok(Array.isArray(list), "get customSetting 应返回数组");
+    if (list.length > 0) {
+      firstSettingId = list[0].objid || list[0].id || null;
+    }
+  });
+
+  t.test("2) 查询详情（若存在 id）", async () => {
+    if (!firstSettingId) {
+      console.error("[customSetting-test] 无可用 settingId，跳过 detail");
+      return;
+    }
+    await assert.doesNotReject(() => runCc(["detail", "customSetting", repoRoot, firstSettingId]));
+  });
+
+  t.test("3) 创建自定义设置（可选能力校验）", async () => {
+    const stamp = Date.now();
+    const body = encodeURI(
+      JSON.stringify({
+        label: `CliSetting_${stamp}`,
+        schemetableName: `cli_setting_${stamp}`,
+        setType: "list",
+        shareType: "public",
+        description: "cli test",
+      })
+    );
+
+    let out = "";
+    try {
+      const res = await runCc(["create", "customSetting", repoRoot, body]);
+      out = `${res.stdout}\n${res.stderr}`.trim();
+      assert.match(out, /Success|成功/i, "create customSetting 应输出成功信息");
+    } catch (e) {
+      const msg = `${e.stderr || e.message || ""}`;
+      if (/500|NullPointerException|Create Custom Setting Failed/i.test(msg)) {
+        console.error("[customSetting-test] 当前环境不支持该最小创建体，跳过 create/delete 强校验");
+        return;
+      }
+      throw e;
+    }
+
+    // 回查列表，尽量拿到刚创建的 id（不同环境字段名可能有差异）
+    const { stdout: listOut } = await runCc(["get", "customSetting", repoRoot]);
+    const list = JSON.parse(listOut.trim() || "[]");
+    const hit = list.find((x) => `${x.label || ""}`.includes(`CliSetting_${stamp}`));
+    if (hit) {
+      createdSettingId = hit.objid || hit.id || null;
+    }
+  });
+
+  t.test("4) 删除刚创建自定义设置（若拿到 id）", async () => {
+    if (!createdSettingId) {
+      console.error("[customSetting-test] 未定位到新建记录 id，跳过 delete");
+      return;
+    }
+    const { stdout, stderr } = await runCc(["delete", "customSetting", repoRoot, createdSettingId]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete customSetting 应输出成功信息");
+  });
+});

package/test/fields.cli.test.js

@@ -16,11 +16,12 @@ async function runCc(args) {
   return execAsync(cmd, { cwd: repoRoot });
 }
 
-test("字段管理流程：获取对象列表→create 字段→get 字段列表", async (t) => {
+test("字段管理流程：获取对象列表→create 字段→get 字段列表→delete", async (t) => {
   let objPrefix = null;
   let objId = null;
   let objName = null;
   const fieldLabel = `AutoField_${Date.now()}`;
+  let fieldId = null;
 
   t.test("1) 获取对象列表（取第一个对象的 id 和 objprefix）", async () => {
     // 只取自定义对象，避免标准对象在部分环境下字段接口异常
@@ -62,8 +63,22 @@ test("字段管理流程：获取对象列表→create 字段→get 字段列表
     if (res.stdFields) assert.ok(Array.isArray(res.stdFields), "stdFields 应为数组");
     if (res.cusFields) assert.ok(Array.isArray(res.cusFields), "cusFields 应为数组");
 
-    // 尽量校验新字段是否已出现（不强制）
+    // 尽量校验新字段是否已出现，并记录 id
     const allCus = Array.isArray(res.cusFields) ? res.cusFields : [];
-    const hit = allCus.some((f) => f.fieldname === fieldLabel || f.apiname?.includes("_custom_s_field"));
+    const hit = allCus.find((f) => f.fieldname === fieldLabel);
+    if (hit && hit.id) {
+      fieldId = hit.id;
+    }
+  });
+
+  t.test("4) delete 删除刚创建字段", async () => {
+    // 个别环境字段列表刷新有延迟，找不到时跳过强校验
+    if (!fieldId) {
+      console.error("[fields-test] 未在列表中定位到新字段 id，跳过 delete");
+      return;
+    }
+    const { stdout, stderr } = await runCc(["delete", "fields", repoRoot, fieldId, objId]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete fields 应输出成功信息");
   });
 });

package/test/menu.cli.test.js

@@ -19,8 +19,10 @@ async function runCc(args) {
 test("菜单管理流程：获取对象列表→create menu object", async (t) => {
   let objectId = null;
   let objectName = null;
+  const tabName = `CC测试菜单Tab_${Date.now()}`;
+  let menuId = null;
 
-  t.test("1) 获取自定义对象列表（取第一个自定义对象 id 用于创建菜单）", async () => {
+  await t.test("1) 获取自定义对象列表（取第一个自定义对象 id 用于创建菜单）", async () => {
     const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
     const list = JSON.parse(stdout.trim());
     assert.ok(Array.isArray(list), "get object custom 应返回数组");
@@ -32,10 +34,38 @@ test("菜单管理流程：获取对象列表→create menu object", async (t) =
     console.error(`\n[menu-test] 目标自定义对象: ${objectName || "Unknown"} (id=${objectId})`);
   });
 
-  t.test("2) 创建对象类型菜单（create menu object）", async () => {
+  await t.test("2) 创建对象类型菜单（create menu object）", async () => {
     assert.ok(objectId, "需要 objectId");
-    await assert.doesNotReject(() =>
-      runCc(["create", "menu", "object", repoRoot, objectId, "CC测试菜单Tab"])
+    const { stdout, stderr } = await runCc(["create", "menu", "object", repoRoot, objectId, tabName]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "create menu object 应输出成功信息");
+  });
+
+  await t.test("3) 查询菜单列表（get menu）并匹配刚创建菜单", async () => {
+    const { stdout } = await runCc(["get", "menu", repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get menu 应返回数组");
+    const hit = list.find((item) =>
+      item.tabName === tabName ||
+      item.tabLabel === tabName ||
+      item.label === tabName ||
+      item.name === tabName
     );
+    if (!hit) {
+      console.error("[menu-test] 未在菜单列表定位到刚创建菜单，跳过删除步骤");
+      return;
+    }
+    menuId = hit.id;
+    assert.ok(menuId, "命中菜单应包含 id");
+  });
+
+  await t.test("4) 删除菜单（delete menu）", async () => {
+    if (!menuId) {
+      console.error("[menu-test] 无 menuId，跳过 delete menu");
+      return;
+    }
+    const { stdout, stderr } = await runCc(["delete", "menu", repoRoot, menuId]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete menu 应输出成功信息");
   });
 });

package/test/object.cli.test.js

@@ -16,10 +16,11 @@ async function runCc(args) {
   return execAsync(cmd, { cwd: repoRoot });
 }
 
-test("对象管理流程：get 对象列表→create 对象→get 列表校验", async (t) => {
+test("对象管理流程：get 对象列表→create 对象→get 列表校验→delete", async (t) => {
   const objectLabel = `TestObj${Date.now()}`;
   const labelNeedle = "testobj";
   let createdSlugHit = false;
+  let createdObjId = null;
 
   t.test("1) create 创建自定义对象", async () => {
     await assert.doesNotReject(() => runCc(["create", "object", repoRoot, objectLabel]));
@@ -46,6 +47,14 @@ test("对象管理流程：get 对象列表→create 对象→get 列表校验",
       return s.includes(labelNeedle) || l.includes(labelNeedle);
     });
     assert.ok(createdSlugHit, "custom 列表应包含刚创建的自定义对象（按 testobj 关键字匹配）");
+
+    const created = list.find((o) => {
+      const l = `${o.label || o.objname || ""}`.toLowerCase();
+      return l === objectLabel.toLowerCase();
+    });
+    if (created && created.id) {
+      createdObjId = created.id;
+    }
   });
 
   t.test("4) get 获取全部对象列表（both / 默认）并校验包含新对象", async () => {
@@ -61,4 +70,11 @@ test("对象管理流程：get 对象列表→create 对象→get 列表校验",
     });
     assert.ok(found || createdSlugHit, "both 列表应包含刚创建的自定义对象");
   });
+
+  t.test("5) delete 删除刚创建对象", async () => {
+    assert.ok(createdObjId, "delete object 前应有 createdObjId");
+    const { stdout, stderr } = await runCc(["delete", "object", repoRoot, createdObjId]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete object 应输出成功信息");
+  });
 });

package/test/scheduleJob.cli.test.js

@@ -0,0 +1,52 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("定时作业管理：get -> detail（可选 delete）", async (t) => {
+  let firstJobId = null;
+
+  t.test("1) 获取定时作业列表", async () => {
+    const { stdout } = await runCc(["get", "scheduleJob", repoRoot]);
+    const list = JSON.parse(stdout.trim() || "[]");
+    assert.ok(Array.isArray(list), "get scheduleJob 应返回数组");
+    if (list.length > 0 && list[0].id) {
+      firstJobId = list[0].id;
+    }
+  });
+
+  t.test("2) 获取定时作业详情（若存在 id）", async () => {
+    if (!firstJobId) {
+      console.error("[scheduleJob-test] 无可用 jobId，跳过 detail");
+      return;
+    }
+    await assert.doesNotReject(() => runCc(["detail", "scheduleJob", firstJobId, repoRoot]));
+  });
+
+  t.test("3) 删除定时作业（仅在 ENABLE_DESTRUCTIVE_TESTS=1 时执行）", async () => {
+    if (process.env.ENABLE_DESTRUCTIVE_TESTS !== "1") {
+      console.error("[scheduleJob-test] 默认跳过 delete（设置 ENABLE_DESTRUCTIVE_TESTS=1 可启用）");
+      return;
+    }
+    if (!firstJobId) {
+      console.error("[scheduleJob-test] 无可用 jobId，跳过 delete");
+      return;
+    }
+    const { stdout, stderr } = await runCc(["delete", "scheduleJob", firstJobId, repoRoot]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete scheduleJob 应输出成功信息");
+  });
+});

package/test/staticResource.cli.test.js

@@ -0,0 +1,78 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("静态资源管理：get -> detail -> count（可选 delete）", async (t) => {
+  let firstResourceId = null;
+
+  t.test("1) 获取静态资源列表", async () => {
+    try {
+      const { stdout } = await runCc(["get", "staticResource", repoRoot]);
+      const list = JSON.parse(stdout.trim() || "[]");
+      assert.ok(Array.isArray(list), "get staticResource 应返回数组");
+      if (list.length > 0) {
+        firstResourceId = list[0].id || list[0].objid || null;
+      }
+    } catch (e) {
+      const msg = `${e.stderr || e.message || ""}`;
+      if (/404|Get Static Resource Failed/i.test(msg)) {
+        console.error("[staticResource-test] 当前环境未开放 staticResource 接口，跳过相关强校验");
+        return;
+      }
+      throw e;
+    }
+  });
+
+  t.test("2) 查询静态资源详情（若存在 id）", async () => {
+    if (!firstResourceId) {
+      console.error("[staticResource-test] 无可用 resourceId，跳过 detail");
+      return;
+    }
+    await assert.doesNotReject(() =>
+      runCc(["detail", "staticResource", repoRoot, firstResourceId])
+    );
+  });
+
+  t.test("3) 统计静态资源容量（count）", async () => {
+    try {
+      const { stdout } = await runCc(["count", "staticResource", repoRoot]);
+      const data = JSON.parse(stdout.trim() || "{}");
+      assert.equal(typeof data, "object", "count staticResource 应返回对象");
+    } catch (e) {
+      const msg = `${e.stderr || e.message || ""}`;
+      if (/404|Count Static Resource Failed/i.test(msg)) {
+        console.error("[staticResource-test] 当前环境未开放 staticResource count 接口，跳过 count 强校验");
+        return;
+      }
+      throw e;
+    }
+  });
+
+  t.test("4) 删除静态资源（仅在 ENABLE_DESTRUCTIVE_TESTS=1 时执行）", async () => {
+    if (process.env.ENABLE_DESTRUCTIVE_TESTS !== "1") {
+      console.error("[staticResource-test] 默认跳过 delete（设置 ENABLE_DESTRUCTIVE_TESTS=1 可启用）");
+      return;
+    }
+    if (!firstResourceId) {
+      console.error("[staticResource-test] 无可用 resourceId，跳过 delete");
+      return;
+    }
+    const { stdout, stderr } = await runCc(["delete", "staticResource", repoRoot, firstResourceId]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete staticResource 应输出成功信息");
+  });
+});

package/test/timer.cli.test.js

@@ -18,7 +18,7 @@ async function runCc(args) {
   return execAsync(cmd, { cwd: repoRoot });
 }
 
-test("定时任务管理流程：创建→发布→拉取→线上详情→列表→批量拉取前2个→清空 schedule 文件夹", async (t) => {
+test("定时任务管理流程：创建→发布→拉取→线上详情→列表→批量拉取→delete→清空 schedule 文件夹", async (t) => {
   const timerName = `CCTimer${Date.now()}`;
   const timerDir = path.join(scheduleRoot, timerName);
   const configPath = path.join(timerDir, "config.json");
@@ -96,7 +96,13 @@ test("定时任务管理流程：创建→发布→拉取→线上详情→列
     assert.ok(afterCount >= beforeCount, "pullList 之后 schedule 目录应存在/可用");
   });
 
-  t.test("7) 清空 schedule 文件夹", async () => {
+  t.test("7) 删除当前创建定时类（delete timer）", async () => {
+    const { stdout, stderr } = await runCc(["delete", "timer", timerName, repoRoot]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete timer 应输出成功信息");
+  });
+
+  t.test("8) 清空 schedule 文件夹", async () => {
     if (fs.existsSync(scheduleRoot)) {
       fs.rmSync(scheduleRoot, { recursive: true, force: true });
     }

package/test/trigger.cli.test.js

@@ -18,7 +18,7 @@ async function runCc(args) {
   return execAsync(cmd, { cwd: repoRoot });
 }
 
-test("触发器管理流程：获取对象→创建→doc→发布→拉取→线上详情→列表→批量拉取前2个→清空 triggers 文件夹", async (t) => {
+test("触发器管理流程：获取对象→创建→doc→发布→拉取→线上详情→列表→批量拉取→delete→清空 triggers 文件夹", async (t) => {
   let schemetableName = "Account";
   let targetObjectId = null;
   let apiname = null;
@@ -135,7 +135,13 @@ test("触发器管理流程：获取对象→创建→doc→发布→拉取→
     assert.ok(afterCount >= beforeCount, "pullList 之后 triggers 目录应存在/可用");
   });
 
-  t.test("9) 清空 triggers 文件夹", async () => {
+  t.test("9) 删除当前创建触发器（delete triggers）", async () => {
+    const { stdout, stderr } = await runCc(["delete", "triggers", namePath, repoRoot]);
+    const out = `${stdout}\n${stderr}`.trim();
+    assert.match(out, /Success|成功/i, "delete triggers 应输出成功信息");
+  });
+
+  t.test("10) 清空 triggers 文件夹", async () => {
     if (fs.existsSync(triggersRoot)) {
       fs.rmSync(triggersRoot, { recursive: true, force: true });
     }