@cmflow/cli 1.1.0 → 2.0.0-alpha.1

package/src/common/cli/git.test.js

@@ -1,209 +1,207 @@
-import { beforeEach, describe, expect, it, jest } from '@jest/globals'
-
-jest.unstable_mockModule('execa', () => {
-  const execaMock = jest.fn()
-  execaMock.sync = jest.fn()
-  return { default: execaMock }
-})
-const { default: execa } = await import('execa')
-const { git } = await import('./git.js')
-const { Cli } = await import('./cli.js')
+vi.mock("execa", () => {
+  const execaMock = vi.fn();
+  execaMock.sync = vi.fn();
+  return { default: execaMock };
+});
+const { default: execa } = await import("execa");
+const { git } = await import("./git.js");
+const { Cli } = await import("./cli.js");
 execa.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-  }
-})
+    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+  };
+});
 
-execa.mockReturnValue({})
+execa.mockReturnValue({});
 
-describe('GitCli', () => {
+describe("GitCli", () => {
   beforeEach(() => {
-    jest.spyOn(Cli, 'getRaw').mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-    })
-  })
-  describe('init', () => {
-    it('should run init cmd', () => {
-      const result = git.init('init-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git init init-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['init', 'init-arg'], {
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    });
+  });
+  describe("init", () => {
+    it("should run init cmd", () => {
+      const result = git.init("init-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git init init-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["init", "init-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('add', () => {
-    it('should run add cmd', () => {
-      const result = git.add('add-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git add add-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['add', 'add-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("add", () => {
+    it("should run add cmd", () => {
+      const result = git.add("add-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git add add-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["add", "add-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('branch', () => {
-    it('should run branch cmd', () => {
-      const result = git.branch('branch-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git branch branch-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['branch', 'branch-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("branch", () => {
+    it("should run branch cmd", () => {
+      const result = git.branch("branch-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git branch branch-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["branch", "branch-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('clean', () => {
-    it('should run branch cmd', () => {
-      const result = git.clean('clean-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git clean clean-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['clean', 'clean-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("clean", () => {
+    it("should run branch cmd", () => {
+      const result = git.clean("clean-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git clean clean-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["clean", "clean-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('config', () => {
-    it('should run config cmd', () => {
-      const result = git.config('config-arg')
-
-      expect(result).toEqual('CMD: git config config-arg')
-      expect(Cli.getRaw).toHaveBeenCalledWith('git', ['config', 'config-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("config", () => {
+    it("should run config cmd", () => {
+      const result = git.config("config-arg");
+
+      expect(result).toEqual("CMD: git config config-arg");
+      expect(Cli.getRaw).toHaveBeenCalledWith("git", ["config", "config-arg"], {
         cwd: process.cwd()
-      })
-    })
-  })
-  describe('checkout', () => {
-    it('should run checkout cmd', () => {
-      const result = git.checkout('checkout-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git checkout checkout-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['checkout', 'checkout-arg'], {
+      });
+    });
+  });
+  describe("checkout", () => {
+    it("should run checkout cmd", () => {
+      const result = git.checkout("checkout-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git checkout checkout-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["checkout", "checkout-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('commit', () => {
-    it('should run commit cmd', () => {
-      const result = git.commit('commit-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git commit commit-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['commit', 'commit-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("commit", () => {
+    it("should run commit cmd", () => {
+      const result = git.commit("commit-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git commit commit-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["commit", "commit-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('fetch', () => {
-    it('should run fetch cmd', () => {
-      const result = git.fetch('fetch-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git fetch fetch-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['fetch', 'fetch-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("fetch", () => {
+    it("should run fetch cmd", () => {
+      const result = git.fetch("fetch-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git fetch fetch-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["fetch", "fetch-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('prune', () => {
-    it('should run fetch cmd', () => {
-      const result = git.prune('prune-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git prune prune-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['prune', 'prune-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("prune", () => {
+    it("should run fetch cmd", () => {
+      const result = git.prune("prune-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git prune prune-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["prune", "prune-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('merge', () => {
-    it('should run fetch cmd', () => {
-      const result = git.merge('merge-arg')
-
-      expect(result.stdout).toEqual('CMD: git merge merge-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['merge', 'merge-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("merge", () => {
+    it("should run fetch cmd", () => {
+      const result = git.merge("merge-arg");
+
+      expect(result.stdout).toEqual("CMD: git merge merge-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["merge", "merge-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('reset', () => {
-    it('should run reset cmd', () => {
-      const result = git.reset('reset-arg')
-
-      expect(result.stdout).toEqual('CMD: git reset reset-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['reset', 'reset-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("reset", () => {
+    it("should run reset cmd", () => {
+      const result = git.reset("reset-arg");
+
+      expect(result.stdout).toEqual("CMD: git reset reset-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["reset", "reset-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('remote', () => {
-    it('should run remote cmd', () => {
-      const result = git.remote('remote-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git remote remote-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['remote', 'remote-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("remote", () => {
+    it("should run remote cmd", () => {
+      const result = git.remote("remote-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git remote remote-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["remote", "remote-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('rebase', () => {
-    it('should run rebase cmd', () => {
-      const result = git.rebase('rebase-arg').sync()
-
-      expect(result.stdout).toEqual('CMD: git rebase rebase-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['rebase', 'rebase-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("rebase", () => {
+    it("should run rebase cmd", () => {
+      const result = git.rebase("rebase-arg").sync();
+
+      expect(result.stdout).toEqual("CMD: git rebase rebase-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["rebase", "rebase-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('status', () => {
-    it('should run status cmd', () => {
-      const result = git.status('status-arg')
-
-      expect(result.stdout).toEqual('CMD: git status status-arg')
-      expect(execa.sync).toHaveBeenCalledWith('git', ['status', 'status-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("status", () => {
+    it("should run status cmd", () => {
+      const result = git.status("status-arg");
+
+      expect(result.stdout).toEqual("CMD: git status status-arg");
+      expect(execa.sync).toHaveBeenCalledWith("git", ["status", "status-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('getCommitTag', () => {
-    it('should run revParse cmd', () => {
-      const result = git.getCommitTag('ref')
-
-      expect(result).toEqual('CMD: git rev-parse --short ref')
-    })
-  })
-  describe('getBranchName', () => {
-    it('should run revParse cmd', () => {
-      const result = git.getBranchName('ref')
-
-      expect(result).toEqual('CMD: git rev-parse --abbrev-ref ref')
-    })
-  })
-  describe('getLastCommitMsg', () => {
-    it('should run revParse cmd', () => {
-      const result = git.getLastCommitMsg()
-
-      expect(result).toEqual('CMD: git log -1 --pretty=%B')
-    })
-  })
-  describe('push', () => {
-    it('should run push cmd', async () => {
-      await git.push('push-arg')
-
-      expect(execa).toHaveBeenCalledWith('git', ['push', 'push-arg'], {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("getCommitTag", () => {
+    it("should run revParse cmd", () => {
+      const result = git.getCommitTag("ref");
+
+      expect(result).toEqual("CMD: git rev-parse --short ref");
+    });
+  });
+  describe("getBranchName", () => {
+    it("should run revParse cmd", () => {
+      const result = git.getBranchName("ref");
+
+      expect(result).toEqual("CMD: git rev-parse --abbrev-ref ref");
+    });
+  });
+  describe("getLastCommitMsg", () => {
+    it("should run revParse cmd", () => {
+      const result = git.getLastCommitMsg();
+
+      expect(result).toEqual("CMD: git log -1 --pretty=%B");
+    });
+  });
+  describe("push", () => {
+    it("should run push cmd", async () => {
+      await git.push("push-arg");
+
+      expect(execa).toHaveBeenCalledWith("git", ["push", "push-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-})
+        stdio: "inherit"
+      });
+    });
+  });
+});

package/src/common/cli/lerna.js

@@ -1,25 +1,25 @@
-import { Cli } from './cli.js'
+import { Cli } from "./cli.js";
 
 class LernaCli extends Cli {
-  constructor () {
-    super('lerna')
+  constructor() {
+    super("lerna");
   }
 
-  newVersion (version) {
-    return this.version(version, '--exact', '--yes', '--no-git-tag-version', '--no-push')
+  newVersion(version) {
+    return this.version(version, "--exact", "--yes", "--no-git-tag-version", "--no-push");
   }
 
-  version (...args) {
-    return this.sync('version', ...args)
+  version(...args) {
+    return this.sync("version", ...args);
   }
 
-  run (...args) {
-    return super.run('run', ...args)
+  run(...args) {
+    return super.run("run", ...args);
   }
 
-  install (...args) {
-    return super.run('install', ...args)
+  install(...args) {
+    return super.run("install", ...args);
   }
 }
 
-export const lerna = new LernaCli()
+export const lerna = new LernaCli();

package/src/common/cli/lerna.test.js

@@ -1,53 +1,51 @@
-import { beforeEach, describe, expect, it, jest } from '@jest/globals'
-
-jest.unstable_mockModule('execa', () => {
-  const execaMock = jest.fn()
-  execaMock.sync = jest.fn()
-  return { default: execaMock }
-})
-const { default: execa } = await import('execa')
-const { lerna } = await import('./lerna.js')
-const { Cli } = await import('./cli.js')
+vi.mock("execa", () => {
+  const execaMock = vi.fn();
+  execaMock.sync = vi.fn();
+  return { default: execaMock };
+});
+const { default: execa } = await import("execa");
+const { lerna } = await import("./lerna.js");
+const { Cli } = await import("./cli.js");
 
 execa.sync.mockImplementation((...args) => {
   return {
-    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-  }
-})
+    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
+  };
+});
 
-execa.mockReturnValue({})
+execa.mockReturnValue({});
 
-describe('LernaCli', () => {
+describe("LernaCli", () => {
   beforeEach(() => {
-    jest.spyOn(Cli, 'getRaw').mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
-    })
-  })
-  describe('newVersion', () => {
-    it('should run add cmd', () => {
-      const result = lerna.newVersion('1.0.0')
+    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
+    });
+  });
+  describe("newVersion", () => {
+    it("should run add cmd", () => {
+      const result = lerna.newVersion("1.0.0");
 
-      expect(result.stdout).toEqual('CMD: lerna version 1.0.0 --exact --yes --no-git-tag-version --no-push')
-    })
-  })
-  describe('run', () => {
+      expect(result.stdout).toEqual("CMD: lerna version 1.0.0 --exact --yes --no-git-tag-version --no-push");
+    });
+  });
+  describe("run", () => {
     it('should run "run" cmd', async () => {
-      await lerna.run('run-arg')
+      await lerna.run("run-arg");
 
-      expect(execa).toHaveBeenCalledWith('lerna', ['run', 'run-arg'], {
+      expect(execa).toHaveBeenCalledWith("lerna", ["run", "run-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-  describe('install', () => {
+        stdio: "inherit"
+      });
+    });
+  });
+  describe("install", () => {
     it('should run "install" cmd', async () => {
-      await lerna.install('install-arg')
+      await lerna.install("install-arg");
 
-      expect(execa).toHaveBeenCalledWith('lerna', ['install', 'install-arg'], {
+      expect(execa).toHaveBeenCalledWith("lerna", ["install", "install-arg"], {
         cwd: process.cwd(),
-        stdio: 'inherit'
-      })
-    })
-  })
-})
+        stdio: "inherit"
+      });
+    });
+  });
+});

package/src/common/cli/npm.js

@@ -1,33 +1,33 @@
-import { Cli } from './cli.js'
+import { Cli } from "./cli.js";
 
 class NpmCli extends Cli {
-  constructor () {
-    super('npm')
+  constructor() {
+    super("npm");
   }
 
-  newVersion (version) {
-    return this.version('--no-git-tag-version', version)
+  newVersion(version) {
+    return this.version("--no-git-tag-version", version);
   }
 
-  version (...args) {
-    return this.sync('version', ...args)
+  version(...args) {
+    return this.sync("version", ...args);
   }
 
-  run (...args) {
-    return super.run('run', ...args)
+  run(...args) {
+    return super.run("run", ...args);
   }
 
-  install (...args) {
-    return super.run('install', ...args)
+  install(...args) {
+    return super.run("install", ...args);
   }
 
   /**
-     * Reinstall dependencies without package-lock mutation
-     * @returns {Promise<unknown>}
-     */
-  restore () {
-    return super.run('ci')
+   * Reinstall dependencies without package-lock mutation
+   * @returns {Promise<unknown>}
+   */
+  restore() {
+    return super.run("ci");
   }
 }
 
-export const npm = new NpmCli()
+export const npm = new NpmCli();