@cmflow/cli 0.65.1

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

@@ -0,0 +1,128 @@
+import axios from 'axios'
+import execa from 'execa'
+import { docker } from './docker'
+import { Cli } from './cli'
+
+jest.mock('axios')
+jest.mock('execa')
+
+execa.mockReturnValue({})
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+
+describe('DockerCli', () => {
+  beforeEach(() => {
+    jest.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

@@ -0,0 +1,130 @@
+import { Cli } from './cli'
+
+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 (er) {
+          return undefined
+        }
+      })
+      .filter((b) => !!b)
+      .sort((info1, info2) => info1.date < info2.date)
+  }
+}
+
+export const git = new GitCli()

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

@@ -0,0 +1,205 @@
+import execa from 'execa'
+import { git } from './git'
+import { Cli } from './cli'
+
+jest.mock('execa')
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+
+execa.mockReturnValue({})
+
+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'], {
+        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/heroku.js

@@ -0,0 +1,21 @@
+import { Cli } from './cli'
+
+export class HerokuCli extends Cli {
+  constructor () {
+    super('heroku')
+  }
+
+  containerLogin (...args) {
+    return this.run('container:login', ...args)
+  }
+
+  containerPush (...args) {
+    return this.run('container:push', ...args)
+  }
+
+  containerRelease (...args) {
+    return this.run('container:release', ...args)
+  }
+}
+
+export const heroku = new HerokuCli()

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

@@ -0,0 +1,56 @@
+import execa from 'execa'
+import { Cli } from './cli'
+import { heroku } from './heroku'
+
+jest.mock('execa')
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+
+execa.mockReturnValue({})
+
+describe('HerokuCli', () => {
+  beforeEach(() => {
+    jest.spyOn(Cli, 'getRaw').mockImplementation((...args) => {
+      return `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+    })
+  })
+  describe('containerLogin', () => {
+    it('should run cmd', () => {
+      const result = heroku.containerLogin('arg').sync()
+
+      expect(result.stdout).toEqual('CMD: heroku container:login arg')
+      expect(execa.sync).toHaveBeenCalledWith('heroku', ['container:login', 'arg'], {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      })
+    })
+  })
+
+  describe('containerPush', () => {
+    it('should run cmd', () => {
+      const result = heroku.containerPush('arg').sync()
+
+      expect(result.stdout).toEqual('CMD: heroku container:push arg')
+      expect(execa.sync).toHaveBeenCalledWith('heroku', ['container:push', 'arg'], {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      })
+    })
+  })
+
+  describe('containerRelease', () => {
+    it('should run cmd', () => {
+      const result = heroku.containerRelease('arg').sync()
+
+      expect(result.stdout).toEqual('CMD: heroku container:release arg')
+      expect(execa.sync).toHaveBeenCalledWith('heroku', ['container:release', 'arg'], {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      })
+    })
+  })
+})

package/src/common/cli/lerna.js

@@ -0,0 +1,25 @@
+import { Cli } from './cli'
+
+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

@@ -0,0 +1,48 @@
+import execa from 'execa'
+import { lerna } from './lerna'
+import { Cli } from './cli'
+
+jest.mock('execa')
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+
+execa.mockReturnValue({})
+
+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')
+
+      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

@@ -0,0 +1,33 @@
+import { Cli } from './cli'
+
+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('install', '--no-package-lock', '--no-production')
+  }
+}
+
+export const npm = new NpmCli()

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

@@ -0,0 +1,47 @@
+import execa from 'execa'
+import { npm } from './npm'
+import { Cli } from './cli'
+
+jest.mock('execa')
+
+execa.sync.mockImplementation((...args) => {
+  return {
+    stdout: `CMD: ${[].concat(...args.filter(arg => typeof arg === 'string' || Array.isArray(arg))).join(' ')}`
+  }
+})
+execa.mockReturnValue({})
+
+describe('NpmCli', () => {
+  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 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'
+      })
+    })
+  })
+})