@zjex/git-workflow 0.3.9 → 0.4.0

package/tests/clean.test.ts

@@ -0,0 +1,293 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { existsSync, unlinkSync, readdirSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+
+// Mock 所有外部依赖
+vi.mock("fs", () => ({
+  existsSync: vi.fn(),
+  unlinkSync: vi.fn(),
+  readdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+vi.mock("os", () => ({
+  homedir: vi.fn(),
+  tmpdir: vi.fn(),
+}));
+
+vi.mock("path", () => ({
+  join: vi.fn((...args) => args.join("/")),
+}));
+
+vi.mock("@inquirer/prompts", () => ({
+  select: vi.fn(),
+}));
+
+vi.mock("../src/update-notifier.js", () => ({
+  clearUpdateCache: vi.fn(),
+}));
+
+describe("Clean 命令测试", () => {
+  const mockExistsSync = vi.mocked(existsSync);
+  const mockUnlinkSync = vi.mocked(unlinkSync);
+  const mockReaddirSync = vi.mocked(readdirSync);
+  const mockHomedir = vi.mocked(homedir);
+  const mockTmpdir = vi.mocked(tmpdir);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockHomedir.mockReturnValue("/home/user");
+    mockTmpdir.mockReturnValue("/tmp");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("清理更新缓存", () => {
+    it("应该清理更新缓存文件", async () => {
+      const { clearUpdateCache } = await import("../src/update-notifier.js");
+
+      clearUpdateCache();
+
+      expect(clearUpdateCache).toHaveBeenCalled();
+    });
+  });
+
+  describe("清理全局配置文件", () => {
+    it("没有全局配置文件时不应该询问", async () => {
+      mockExistsSync.mockReturnValue(false);
+      mockReaddirSync.mockReturnValue([]);
+
+      const { select } = await import("@inquirer/prompts");
+
+      expect(mockExistsSync).not.toHaveBeenCalledWith("/home/user/.gwrc.json");
+    });
+
+    it("有全局配置文件时应该询问是否删除", async () => {
+      const globalConfig = "/home/user/.gwrc.json";
+      mockExistsSync.mockReturnValue(true);
+      mockReaddirSync.mockReturnValue([]);
+
+      const { select } = await import("@inquirer/prompts");
+      vi.mocked(select).mockResolvedValue(false);
+
+      // 模拟检查全局配置文件
+      const hasGlobalConfig = mockExistsSync(globalConfig);
+
+      expect(hasGlobalConfig).toBe(true);
+    });
+
+    it("选择删除时应该删除全局配置文件", async () => {
+      const globalConfig = "/home/user/.gwrc.json";
+      mockExistsSync.mockReturnValue(true);
+      mockReaddirSync.mockReturnValue([]);
+
+      const { select } = await import("@inquirer/prompts");
+      vi.mocked(select).mockResolvedValue(true);
+
+      // 模拟删除操作
+      if (mockExistsSync(globalConfig)) {
+        mockUnlinkSync(globalConfig);
+      }
+
+      expect(mockUnlinkSync).toHaveBeenCalledWith(globalConfig);
+    });
+
+    it("选择不删除时应该保留全局配置文件", async () => {
+      const globalConfig = "/home/user/.gwrc.json";
+      mockExistsSync.mockReturnValue(true);
+      mockReaddirSync.mockReturnValue([]);
+
+      const { select } = await import("@inquirer/prompts");
+      vi.mocked(select).mockResolvedValue(false);
+
+      // 模拟不删除的情况
+      const shouldDelete = await vi.mocked(select)();
+
+      if (!shouldDelete) {
+        expect(mockUnlinkSync).not.toHaveBeenCalledWith(globalConfig);
+      }
+    });
+  });
+
+  describe("清理临时 commit 文件", () => {
+    it("应该清理所有临时 commit 文件", () => {
+      mockReaddirSync.mockReturnValue([
+        ".gw-commit-msg-123456",
+        ".gw-commit-msg-789012",
+        "other-file.txt",
+      ] as any);
+
+      const tmpDir = mockTmpdir();
+      const files = mockReaddirSync(tmpDir);
+      const gwTmpFiles = files.filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+
+      expect(gwTmpFiles).toHaveLength(2);
+      expect(gwTmpFiles).toContain(".gw-commit-msg-123456");
+      expect(gwTmpFiles).toContain(".gw-commit-msg-789012");
+    });
+
+    it("应该忽略非 gw 临时文件", () => {
+      mockReaddirSync.mockReturnValue([
+        ".gw-commit-msg-123456",
+        "other-temp-file",
+        ".other-file",
+      ] as any);
+
+      const tmpDir = mockTmpdir();
+      const files = mockReaddirSync(tmpDir);
+      const gwTmpFiles = files.filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+
+      expect(gwTmpFiles).toHaveLength(1);
+      expect(gwTmpFiles).toContain(".gw-commit-msg-123456");
+    });
+
+    it("没有临时文件时不应该报错", () => {
+      mockReaddirSync.mockReturnValue([]);
+
+      const tmpDir = mockTmpdir();
+      const files = mockReaddirSync(tmpDir);
+      const gwTmpFiles = files.filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+
+      expect(gwTmpFiles).toHaveLength(0);
+    });
+
+    it("应该删除找到的临时文件", () => {
+      mockReaddirSync.mockReturnValue([
+        ".gw-commit-msg-123456",
+        ".gw-commit-msg-789012",
+      ] as any);
+
+      const tmpDir = mockTmpdir();
+      const files = mockReaddirSync(tmpDir);
+      const gwTmpFiles = files.filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+
+      gwTmpFiles.forEach((file: string) => {
+        mockUnlinkSync(join(tmpDir, file));
+      });
+
+      expect(mockUnlinkSync).toHaveBeenCalledTimes(2);
+      expect(mockUnlinkSync).toHaveBeenCalledWith("/tmp/.gw-commit-msg-123456");
+      expect(mockUnlinkSync).toHaveBeenCalledWith("/tmp/.gw-commit-msg-789012");
+    });
+  });
+
+  describe("清理统计", () => {
+    it("应该正确统计清理的文件数量", () => {
+      let cleanedCount = 0;
+
+      // 清理更新缓存
+      cleanedCount++;
+
+      // 清理全局配置
+      mockExistsSync.mockReturnValue(true);
+      if (mockExistsSync("/home/user/.gwrc.json")) {
+        cleanedCount++;
+      }
+
+      // 清理临时文件
+      mockReaddirSync.mockReturnValue([
+        ".gw-commit-msg-123456",
+        ".gw-commit-msg-789012",
+      ] as any);
+      const gwTmpFiles = mockReaddirSync("/tmp").filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+      cleanedCount += gwTmpFiles.length;
+
+      expect(cleanedCount).toBe(4); // 1 缓存 + 1 配置 + 2 临时文件
+    });
+
+    it("没有全局配置时应该统计正确", () => {
+      let cleanedCount = 0;
+
+      // 清理更新缓存
+      cleanedCount++;
+
+      // 没有全局配置
+      mockExistsSync.mockReturnValue(false);
+
+      // 清理临时文件
+      mockReaddirSync.mockReturnValue([".gw-commit-msg-123456"] as any);
+      const gwTmpFiles = mockReaddirSync("/tmp").filter((f: string) =>
+        f.startsWith(".gw-commit-msg-")
+      );
+      cleanedCount += gwTmpFiles.length;
+
+      expect(cleanedCount).toBe(2); // 1 缓存 + 1 临时文件
+    });
+
+    it("没有任何文件时应该只清理缓存", () => {
+      let cleanedCount = 0;
+
+      // 清理更新缓存
+      cleanedCount++;
+
+      // 没有全局配置
+      mockExistsSync.mockReturnValue(false);
+
+      // 没有临时文件
+      mockReaddirSync.mockReturnValue([]);
+
+      expect(cleanedCount).toBe(1); // 只有缓存
+    });
+  });
+
+  describe("错误处理", () => {
+    it("删除文件失败时应该静默处理", () => {
+      mockUnlinkSync.mockImplementation(() => {
+        throw new Error("Permission denied");
+      });
+
+      expect(() => {
+        try {
+          mockUnlinkSync("/home/user/.gwrc.json");
+        } catch {
+          // 静默失败
+        }
+      }).not.toThrow();
+    });
+
+    it("读取目录失败时应该静默处理", () => {
+      mockReaddirSync.mockImplementation(() => {
+        throw new Error("Directory not found");
+      });
+
+      expect(() => {
+        try {
+          mockReaddirSync("/tmp");
+        } catch {
+          // 静默失败
+        }
+      }).not.toThrow();
+    });
+  });
+
+  describe("文件路径", () => {
+    it("应该使用正确的全局配置路径", () => {
+      const globalConfig = join(mockHomedir(), ".gwrc.json");
+      expect(globalConfig).toBe("/home/user/.gwrc.json");
+    });
+
+    it("应该使用正确的临时目录路径", () => {
+      const tmpDir = mockTmpdir();
+      expect(tmpDir).toBe("/tmp");
+    });
+
+    it("应该正确拼接临时文件路径", () => {
+      const tmpFile = join(mockTmpdir(), ".gw-commit-msg-123456");
+      expect(tmpFile).toBe("/tmp/.gw-commit-msg-123456");
+    });
+  });
+});

package/tests/commands.test.ts

@@ -0,0 +1,409 @@
+import { describe, it, expect } from "vitest";
+
+describe("命令别名测试", () => {
+  describe("分支命令", () => {
+    it("应该支持 feature 命令及其别名", () => {
+      const commands = ["feature", "feat", "f"];
+      const expectedCommand = "feature";
+
+      commands.forEach((cmd) => {
+        // 验证命令映射
+        const isValid = cmd === "feature" || cmd === "feat" || cmd === "f";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 hotfix 命令及其别名", () => {
+      const commands = ["hotfix", "fix", "h"];
+      const expectedCommand = "hotfix";
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "hotfix" || cmd === "fix" || cmd === "h";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 br:del 命令及其别名", () => {
+      const commands = ["br:del", "brd"];
+      const expectedCommand = "br:del";
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "br:del" || cmd === "brd";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("br:del 命令应该替代旧的 delete 命令", () => {
+      const newCommands = ["br:del", "brd"];
+      const oldCommands = ["delete", "del", "d"];
+
+      // 新命令应该存在
+      expect(newCommands.length).toBeGreaterThan(0);
+
+      // 验证新命令格式
+      expect(newCommands[0]).toBe("br:del");
+      expect(newCommands[1]).toBe("brd");
+    });
+  });
+
+  describe("Tag 命令", () => {
+    it("应该支持 tag 命令及其别名", () => {
+      const commands = ["tag", "t"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "tag" || cmd === "t";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 tags 命令及其别名", () => {
+      const commands = ["tags", "ts"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "tags" || cmd === "ts";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 tag:del 命令及其别名", () => {
+      const commands = ["tag:del", "td"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "tag:del" || cmd === "td";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 tag:update 命令及其别名", () => {
+      const commands = ["tag:update", "tu"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "tag:update" || cmd === "tu";
+        expect(isValid).toBe(true);
+      });
+    });
+
+    it("应该支持 tag:clean 命令及其别名", () => {
+      const commands = ["tag:clean", "tc"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "tag:clean" || cmd === "tc";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("提交命令", () => {
+    it("应该支持 commit 命令及其别名", () => {
+      const commands = ["commit", "c", "cm"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "commit" || cmd === "c" || cmd === "cm";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("Stash 命令", () => {
+    it("应该支持 stash 命令及其别名", () => {
+      const commands = ["stash", "s", "st"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "stash" || cmd === "s" || cmd === "st";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("日志命令", () => {
+    it("应该支持 log 命令及其别名", () => {
+      const commands = ["log", "ls", "l"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "log" || cmd === "ls" || cmd === "l";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("版本命令", () => {
+    it("应该支持 release 命令及其别名", () => {
+      const commands = ["release", "r"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "release" || cmd === "r";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("更新命令", () => {
+    it("应该支持 update 命令及其别名", () => {
+      const commands = ["update", "upt"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "update" || cmd === "upt";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("清理命令", () => {
+    it("应该支持 clean 命令及其别名", () => {
+      const commands = ["clean", "cc"];
+
+      commands.forEach((cmd) => {
+        const isValid = cmd === "clean" || cmd === "cc";
+        expect(isValid).toBe(true);
+      });
+    });
+  });
+
+  describe("初始化命令", () => {
+    it("应该支持 init 命令", () => {
+      const command = "init";
+      expect(command).toBe("init");
+    });
+
+    it("init 命令不应该有别名", () => {
+      const aliases: string[] = [];
+      expect(aliases.length).toBe(0);
+    });
+  });
+
+  describe("命令命名规范", () => {
+    it("分支删除命令应该使用 br:del 格式", () => {
+      const command = "br:del";
+      expect(command).toMatch(/^br:del$/);
+      expect(command).toContain(":");
+    });
+
+    it("tag 删除命令应该使用 tag:del 格式", () => {
+      const command = "tag:del";
+      expect(command).toMatch(/^tag:del$/);
+      expect(command).toContain(":");
+    });
+
+    it("tag 更新命令应该使用 tag:update 格式", () => {
+      const command = "tag:update";
+      expect(command).toMatch(/^tag:update$/);
+      expect(command).toContain(":");
+    });
+
+    it("tag 清理命令应该使用 tag:clean 格式", () => {
+      const command = "tag:clean";
+      expect(command).toMatch(/^tag:clean$/);
+      expect(command).toContain(":");
+    });
+
+    it("子命令应该使用冒号分隔", () => {
+      const subCommands = ["br:del", "tag:del", "tag:update", "tag:clean"];
+
+      subCommands.forEach((cmd) => {
+        expect(cmd).toContain(":");
+        const parts = cmd.split(":");
+        expect(parts.length).toBe(2);
+        expect(parts[0].length).toBeGreaterThan(0);
+        expect(parts[1].length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe("别名简洁性", () => {
+    it("所有别名应该不超过 4 个字符", () => {
+      const aliases = [
+        "f",
+        "feat",
+        "h",
+        "fix",
+        "brd",
+        "t",
+        "ts",
+        "td",
+        "tu",
+        "tc",
+        "c",
+        "cm",
+        "s",
+        "st",
+        "l",
+        "ls",
+        "r",
+        "upt",
+        "cc",
+      ];
+
+      aliases.forEach((alias) => {
+        expect(alias.length).toBeLessThanOrEqual(4);
+      });
+    });
+
+    it("单字母别名应该是最常用的命令", () => {
+      const singleLetterAliases = {
+        f: "feature",
+        h: "hotfix",
+        t: "tag",
+        c: "commit",
+        s: "stash",
+        l: "log",
+        r: "release",
+      };
+
+      Object.entries(singleLetterAliases).forEach(([alias, command]) => {
+        expect(alias.length).toBe(1);
+        expect(command.length).toBeGreaterThan(1);
+      });
+    });
+
+    it("两字母别名应该是次常用的命令", () => {
+      const twoLetterAliases = {
+        ts: "tags",
+        td: "tag:del",
+        tu: "tag:update",
+        tc: "tag:clean",
+        cm: "commit",
+        st: "stash",
+        ls: "log",
+        cc: "clean",
+      };
+
+      Object.entries(twoLetterAliases).forEach(([alias, command]) => {
+        expect(alias.length).toBe(2);
+      });
+    });
+
+    it("三字母别名应该是较少使用的命令", () => {
+      const threeLetterAliases = {
+        brd: "br:del",
+        upt: "update",
+      };
+
+      Object.entries(threeLetterAliases).forEach(([alias, command]) => {
+        expect(alias.length).toBe(3);
+      });
+    });
+
+    it("四字母别名应该是完整单词缩写", () => {
+      const fourLetterAliases = {
+        feat: "feature",
+        fix: "hotfix",
+      };
+
+      Object.entries(fourLetterAliases).forEach(([alias, command]) => {
+        expect(alias.length).toBeGreaterThanOrEqual(3);
+        expect(alias.length).toBeLessThanOrEqual(4);
+      });
+    });
+  });
+
+  describe("命令一致性", () => {
+    it("删除操作应该使用统一的 del 后缀", () => {
+      const deleteCommands = ["br:del", "tag:del"];
+
+      deleteCommands.forEach((cmd) => {
+        expect(cmd).toMatch(/del$/);
+      });
+    });
+
+    it("删除操作的别名应该以 d 结尾", () => {
+      const deleteAliases = ["brd", "td"];
+
+      deleteAliases.forEach((alias) => {
+        expect(alias).toMatch(/d$/);
+      });
+    });
+
+    it("清理操作应该使用 clean 命名", () => {
+      const cleanCommands = ["clean", "tag:clean"];
+
+      cleanCommands.forEach((cmd) => {
+        expect(cmd).toContain("clean");
+      });
+    });
+
+    it("清理操作的别名应该以 c 结尾", () => {
+      const cleanAliases = ["cc", "tc"];
+
+      cleanAliases.forEach((alias) => {
+        expect(alias).toMatch(/c$/);
+      });
+    });
+  });
+
+  describe("命令分组", () => {
+    it("应该有分支管理命令组", () => {
+      const branchCommands = ["feature", "hotfix", "br:del"];
+      expect(branchCommands.length).toBe(3);
+    });
+
+    it("应该有 tag 管理命令组", () => {
+      const tagCommands = ["tag", "tags", "tag:del", "tag:update", "tag:clean"];
+      expect(tagCommands.length).toBe(5);
+    });
+
+    it("应该有提交管理命令组", () => {
+      const commitCommands = ["commit", "log"];
+      expect(commitCommands.length).toBe(2);
+    });
+
+    it("应该有工具管理命令组", () => {
+      const toolCommands = ["init", "update", "clean"];
+      expect(toolCommands.length).toBe(3);
+    });
+
+    it("应该有其他辅助命令组", () => {
+      const otherCommands = ["stash", "release"];
+      expect(otherCommands.length).toBe(2);
+    });
+  });
+
+  describe("命令总数统计", () => {
+    it("应该有正确数量的主命令", () => {
+      const mainCommands = [
+        "feature",
+        "hotfix",
+        "br:del",
+        "tag",
+        "tags",
+        "tag:del",
+        "tag:update",
+        "tag:clean",
+        "commit",
+        "log",
+        "stash",
+        "release",
+        "init",
+        "update",
+        "clean",
+      ];
+
+      expect(mainCommands.length).toBe(15);
+    });
+
+    it("应该有正确数量的别名", () => {
+      const aliases = [
+        "f",
+        "feat",
+        "h",
+        "fix",
+        "brd",
+        "t",
+        "ts",
+        "td",
+        "tu",
+        "tc",
+        "c",
+        "cm",
+        "l",
+        "ls",
+        "s",
+        "st",
+        "r",
+        "upt",
+        "cc",
+      ];
+
+      expect(aliases.length).toBe(19);
+    });
+  });
+});