@cmflow/cli 3.3.0 → 3.4.0-alpha.3

package/src/common/cli/docker.js

@@ -1,66 +0,0 @@
-import axios from "axios";
-
-import { Cli } from "./cli.js";
-
-class DockerCli extends Cli {
-  constructor() {
-    super("docker");
-  }
-
-  tag(...args) {
-    return this.get("tag", ...args);
-  }
-
-  login(...args) {
-    return this.sync("login", ...args);
-  }
-
-  push(...args) {
-    return this.run("push", ...args);
-  }
-
-  async getToken(username, password) {
-    const {
-      data: { token }
-    } = await axios({
-      method: "POST",
-      url: "https://hub.docker.com/v2/users/login/",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json"
-      },
-      data: {
-        username,
-        password
-      }
-    });
-
-    return token;
-  }
-
-  async getTags({ token, repository }) {
-    const { data } = await axios({
-      method: "GET",
-      url: `https://hub.docker.com/v2/repositories/${repository}/tags/?page=1&page_size=500`,
-      headers: {
-        Accept: "application/json",
-        Authorization: `JWT ${token}`
-      }
-    });
-
-    return data.results;
-  }
-
-  async deleteTag(tag, { token, repository }) {
-    await axios({
-      method: "DELETE",
-      url: `https://hub.docker.com/v2/repositories/${repository}/tags/${tag}/`,
-      headers: {
-        Accept: "application/json",
-        Authorization: `JWT ${token}`
-      }
-    });
-  }
-}
-
-export const docker = new DockerCli();

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

@@ -1,133 +0,0 @@
-vi.mock("axios", () => {
-  return { default: vi.fn() };
-});
-vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
-  return { default: execaMock };
-});
-const { default: execa } = await import("execa");
-const { default: axios } = await import("axios");
-const { docker } = await import("./docker.js");
-const { Cli } = await import("./cli.js");
-
-execa.mockReturnValue({});
-
-execa.sync.mockImplementation((...args) => {
-  return {
-    stdout: `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`
-  };
-});
-
-describe("DockerCli", () => {
-  beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
-    });
-  });
-  describe("tag", () => {
-    it("should run tag cmd", () => {
-      const result = docker.tag("tag-arg", "image");
-
-      expect(result).toEqual("CMD: docker tag tag-arg image");
-      expect(Cli.getRaw).toHaveBeenCalledWith("docker", ["tag", "tag-arg", "image"], {
-        cwd: process.cwd()
-      });
-    });
-  });
-  describe("login", () => {
-    it("should run login cmd", () => {
-      const result = docker.login("login-arg");
-
-      expect(result.stdout).toEqual("CMD: docker login login-arg");
-      expect(execa.sync).toHaveBeenCalledWith("docker", ["login", "login-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("push", () => {
-    it("should run push cmd", async () => {
-      await docker.push("push-arg");
-
-      expect(execa).toHaveBeenCalledWith("docker", ["push", "push-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("getToken", () => {
-    beforeEach(() => {
-      axios.mockReturnValue({ data: { token: "token" } });
-    });
-    it("should get token", async () => {
-      const token = await docker.getToken("username", "password");
-
-      expect(axios).toHaveBeenCalledWith({
-        method: "POST",
-        url: "https://hub.docker.com/v2/users/login/",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json"
-        },
-        data: {
-          password: "password",
-          username: "username"
-        }
-      });
-      expect(token).toEqual("token");
-    });
-  });
-  describe("getTags", () => {
-    beforeEach(() => {
-      axios.mockReturnValue({
-        data: {
-          results: [
-            {
-              name: "branch-1",
-              last_updated: new Date("2020-06-01")
-            }
-          ]
-        }
-      });
-    });
-    it("should get token", async () => {
-      const tags = await docker.getTags({
-        token: "token",
-        repository: "owner"
-      });
-
-      expect(tags).toEqual([
-        {
-          name: "branch-1",
-          last_updated: new Date("2020-06-01")
-        }
-      ]);
-      expect(axios).toHaveBeenCalledWith({
-        method: "GET",
-        url: "https://hub.docker.com/v2/repositories/owner/tags/?page=1&page_size=500",
-        headers: {
-          Accept: "application/json",
-          Authorization: "JWT token"
-        }
-      });
-    });
-  });
-  describe("deleteTag", () => {
-    it("should run delete Tag", async () => {
-      await docker.deleteTag("my-tag", {
-        token: "token",
-        repository: "owner"
-      });
-
-      expect(axios).toHaveBeenCalledWith({
-        headers: {
-          Accept: "application/json",
-          Authorization: "JWT token"
-        },
-        method: "DELETE",
-        url: "https://hub.docker.com/v2/repositories/owner/tags/my-tag/"
-      });
-    });
-  });
-});

package/src/common/cli/git.js

@@ -1,121 +0,0 @@
-import { Cli } from "./cli.js";
-
-class GitCli extends Cli {
-  constructor() {
-    super("git");
-  }
-
-  init(...args) {
-    return this.run("init", ...args);
-  }
-
-  add(...args) {
-    return this.run("add", ...args);
-  }
-
-  status(...args) {
-    return this.sync("status", ...args);
-  }
-
-  branch(...args) {
-    return this.run("branch", ...args);
-  }
-
-  clean(...args) {
-    return this.run("clean", ...args);
-  }
-
-  config(...args) {
-    return this.run("config", ...args).get();
-  }
-
-  checkout(...args) {
-    return this.run("checkout", ...args);
-  }
-
-  commit(...args) {
-    return this.run("commit", ...args);
-  }
-
-  fetch(...args) {
-    return this.run("fetch", ...args);
-  }
-
-  prune(...args) {
-    return this.run("prune", ...args);
-  }
-
-  merge(...args) {
-    return this.sync("merge", ...args);
-  }
-
-  reset(...args) {
-    return this.sync("reset", ...args);
-  }
-
-  remote(...args) {
-    return this.run("remote", ...args);
-  }
-
-  rebase(...args) {
-    return this.run("rebase", ...args);
-  }
-
-  getCommitTag(ref = "HEAD") {
-    return this.get("rev-parse", "--short", ref);
-  }
-
-  getBranchName(ref = "HEAD") {
-    return this.get("rev-parse", "--abbrev-ref", ref);
-  }
-
-  getLastCommitMsg() {
-    return this.get("log", "-1", "--pretty=%B");
-  }
-
-  push(...args) {
-    return this.run("push", ...args);
-  }
-
-  branchExists(branch, origin = "origin") {
-    return this.branch("-a").getRaw().trim().includes(`remotes/${origin}/${branch}`);
-  }
-
-  checkBranchRemoteStatus(branch, origin = "origin") {
-    return this.run("cherry", branch, `${origin}/${branch}`).get();
-  }
-
-  branches(...args) {
-    return this.branch(...args)
-      .get()
-      .split("\n")
-      .map((branch) => branch.trim().replace("* ", ""))
-      .filter((branch) => !!branch)
-      .filter((branch) => !String(branch).includes("/HEAD"));
-  }
-
-  show(branch) {
-    return this.run("show", '--format="%ci|%cr|%an"', branch, "--").getRaw().split("\n")[0].trim();
-  }
-
-  branchesInfos(...args) {
-    return this.branches(...args)
-      .map((branch) => {
-        try {
-          const [date, creation, author] = this.show(branch).split("|");
-          return {
-            branch,
-            date,
-            creation,
-            author
-          };
-        } catch {
-          return undefined;
-        }
-      })
-      .filter((b) => !!b)
-      .sort((info1, info2) => info1.date < info2.date);
-  }
-}
-
-export const git = new GitCli();

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

@@ -1,207 +0,0 @@
-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(" ")}`
-  };
-});
-
-execa.mockReturnValue({});
-
-describe("GitCli", () => {
-  beforeEach(() => {
-    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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        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"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/lerna.js

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

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

@@ -1,51 +0,0 @@
-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(" ")}`
-  };
-});
-
-execa.mockReturnValue({});
-
-describe("LernaCli", () => {
-  beforeEach(() => {
-    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", () => {
-    it('should run "run" cmd', async () => {
-      await lerna.run("run-arg");
-
-      expect(execa).toHaveBeenCalledWith("lerna", ["run", "run-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("install", () => {
-    it('should run "install" cmd', async () => {
-      await lerna.install("install-arg");
-
-      expect(execa).toHaveBeenCalledWith("lerna", ["install", "install-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});

package/src/common/cli/npm.js

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

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

@@ -1,51 +0,0 @@
-vi.mock("execa", () => {
-  const execaMock = vi.fn();
-  execaMock.sync = vi.fn();
-  return { default: execaMock };
-});
-
-const { default: execa } = await import("execa");
-const { npm } = await import("./npm.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(" ")}`
-  };
-});
-execa.mockReturnValue({});
-
-describe("NpmCli", () => {
-  beforeEach(() => {
-    vi.spyOn(Cli, "getRaw").mockImplementation((...args) => {
-      return `CMD: ${[].concat(...args.filter((arg) => typeof arg === "string" || Array.isArray(arg))).join(" ")}`;
-    });
-  });
-  describe("newVersion", () => {
-    it("should run newVersion cmd", () => {
-      const result = npm.newVersion("1.0.0");
-
-      expect(result.stdout).toEqual("CMD: npm version --no-git-tag-version 1.0.0");
-    });
-  });
-  describe("run", () => {
-    it('should run "run" cmd', async () => {
-      await npm.run("run-arg");
-
-      expect(execa).toHaveBeenCalledWith("npm", ["run", "run-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-  describe("install", () => {
-    it('should run "install" cmd', async () => {
-      await npm.install("install-arg");
-
-      expect(execa).toHaveBeenCalledWith("npm", ["install", "install-arg"], {
-        cwd: process.cwd(),
-        stdio: "inherit"
-      });
-    });
-  });
-});