@wmfs/lerna-sync 1.37.1 → 1.39.0

package/test/utils-spec.js

@@ -0,0 +1,136 @@
+/* eslint-env mocha */
+
+const { expect } = require('chai')
+const { captureConsole } = require('./helpers/fixtures')
+const packageFoldersFromPatterns = require('../lib/utils/package-folders-from-patterns')
+const mapLimit = require('../lib/utils/map-limit')
+
+describe('packageFoldersFromPatterns', () => {
+  let output
+  beforeEach(() => { output = captureConsole() })
+  afterEach(() => output.restore())
+
+  it('turns "<folder>/*" patterns into folder names', () => {
+    expect(packageFoldersFromPatterns(['packages/*', 'plugins/*', 'blueprints/*']))
+      .to.deep.equal(['packages', 'plugins', 'blueprints'])
+  })
+
+  it('normalises leading ./, trailing slashes and Windows separators', () => {
+    expect(packageFoldersFromPatterns(['./plugins/*', 'blueprints\\*', 'apps/*/']))
+      .to.deep.equal(['plugins', 'blueprints', 'apps'])
+  })
+
+  it('keeps nested folders', () => {
+    expect(packageFoldersFromPatterns(['plugins/core/*'])).to.deep.equal(['plugins/core'])
+  })
+
+  it('skips negations silently', () => {
+    expect(packageFoldersFromPatterns(['packages/*', '!packages/legacy'])).to.deep.equal(['packages'])
+    expect(output.lines).to.have.length(0)
+  })
+
+  it('warns about and skips patterns that cannot be a clone target', () => {
+    expect(packageFoldersFromPatterns(['apps/**', 'apps/*/packages/*', 'packages'])).to.deep.equal([])
+    expect(output.lines).to.have.length(3)
+    expect(output.text()).to.include('apps/**')
+  })
+
+  it('de-duplicates', () => {
+    expect(packageFoldersFromPatterns(['plugins/*', './plugins/*'])).to.deep.equal(['plugins'])
+  })
+})
+
+describe('mapLimit', () => {
+  const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+  it('returns results in input order, not completion order', async () => {
+    const result = await mapLimit([30, 10, 20], 3, async ms => { await delay(ms); return ms })
+    expect(result).to.deep.equal([30, 10, 20])
+  })
+
+  it('never runs more than the limit at once', async () => {
+    let running = 0
+    let peak = 0
+    await mapLimit(Array.from({ length: 10 }, (_, i) => i), 3, async () => {
+      running++
+      peak = Math.max(peak, running)
+      await delay(5)
+      running--
+    })
+    expect(peak).to.equal(3)
+  })
+
+  it('handles an empty list', async () => {
+    expect(await mapLimit([], 4, async x => x)).to.deep.equal([])
+  })
+
+  it('passes the index to the callback', async () => {
+    expect(await mapLimit(['a', 'b'], 2, async (x, i) => `${x}${i}`)).to.deep.equal(['a0', 'b1'])
+  })
+
+  for (const bad of [0, -1, 1.5, NaN, undefined, '4']) {
+    it(`rejects a limit of ${String(bad)}`, async () => {
+      let error
+      try { await mapLimit([1, 2], bad, async x => x) } catch (e) { error = e }
+      expect(error).to.be.instanceOf(RangeError)
+    })
+  }
+})
+
+describe('git helper', () => {
+  const { git, tryGit } = require('../lib/utils/git')
+  const os = require('os')
+
+  // A git alias runs through sh, which Git for Windows also ships
+  const alias = command => ['-c', `alias.probe=!${command}`, 'probe']
+
+  it('resolves with trimmed stdout', async () => {
+    expect(await git(alias('printf "hello\\n\\n"'), os.tmpdir())).to.equal('hello')
+  })
+
+  it('kills a command that runs past the timeout', async () => {
+    let error
+    try {
+      await git(alias('sleep 5'), os.tmpdir(), { timeout: 300 })
+    } catch (e) {
+      error = e
+    }
+    expect(error.killed).to.equal(true)
+    expect(error.message).to.match(/timed out after 300ms/)
+  })
+
+  it('returns null from tryGit instead of throwing', async () => {
+    expect(await tryGit(alias('exit 1'), os.tmpdir())).to.equal(null)
+  })
+
+  describe('environment', () => {
+    const saved = {}
+    const keys = ['GIT_TERMINAL_PROMPT', 'GIT_SSH_COMMAND', 'GIT_SSH']
+
+    beforeEach(() => keys.forEach(k => { saved[k] = process.env[k]; delete process.env[k] }))
+    afterEach(() => keys.forEach(k => {
+      if (saved[k] === undefined) delete process.env[k]
+      else process.env[k] = saved[k]
+    }))
+
+    const envVar = name => git(alias(`printf %s "$${name}"`), os.tmpdir())
+
+    it('disables terminal credential prompts', async () => {
+      expect(await envVar('GIT_TERMINAL_PROMPT')).to.equal('0')
+    })
+
+    it('stops ssh prompting for passphrases or host keys', async () => {
+      expect(await envVar('GIT_SSH_COMMAND')).to.equal('ssh -o BatchMode=yes')
+    })
+
+    it('keeps a GIT_SSH_COMMAND the user already set', async () => {
+      process.env.GIT_SSH_COMMAND = 'ssh -i ~/.ssh/work_key'
+      expect(await envVar('GIT_SSH_COMMAND')).to.equal('ssh -i ~/.ssh/work_key')
+    })
+
+    it('does not change process.env itself', async () => {
+      await envVar('GIT_TERMINAL_PROMPT')
+      expect(process.env.GIT_TERMINAL_PROMPT).to.equal(undefined)
+    })
+  })
+})

package/lib/actions/clone.js

@@ -1,49 +0,0 @@
-const chalk = require('chalk')
-const path = require('path')
-const run = require('./../utils/run')
-
-module.exports = async function cloneAction (action, options, messages) {
-  const repoName = action.config.repoName
-  const destPath = path.join(
-    options.monorepoPath,
-    action.config.packageName,
-    repoName
-  )
-
-  const creds = `${options.gitHubUser}:${options.gitHubToken}@github.com`
-
-  // eg.g. cloneUrl = 'https://github.com/octocat/Hello-World.git'
-  const cloneUrl = `https://github.com/${options.gitHubOrgName}/${repoName}.git`
-  const cloneCmd = `git clone ${cloneUrl.replace('github.com', creds)} ${destPath}`
-
-  console.log(`${chalk.green('CLONE')} ${chalk.gray(`/${action.config.packageName}/`)}${repoName}`)
-
-  try {
-    await run(cloneCmd)
-  } catch (err) {
-    console.log(`${chalk.inverse(chalk.red('FAILED'))} - ${chalk.red(err.message)}`)
-    messages.addMessage(
-      repoName,
-      'Cloning',
-      'ERROR',
-      err
-    )
-  }
-}
-
-/*
-async function cloneRepo (cloneUrl, creds, destPath) {
-  const cloneCmd = `git clone ${cloneUrl.replace('github.com', creds)} ${destPath}`
-
-  try {
-    await run(cloneCmd)
-    return [true, 'cloned']
-  } catch (err) {
-    if (!err.message.includes('already exists and is not an empty directory')) {
-      throw err
-    }
-  }
-  return [false, 'cloned']
-}
-
- */

package/lib/actions/index.js

@@ -1,4 +0,0 @@
-module.exports = {
-  PULL: require('./pull'),
-  CLONE: require('./clone')
-}

package/lib/actions/pull.js

@@ -1,52 +0,0 @@
-const path = require('path')
-const STATUS_CMD = 'git -c core.quotepath=false status'
-const MERGE_CMD = 'git -c core.quotepath=false merge origin/master --no-stat -v'
-const COMMIT_OR_STASH = /commit your changes or stash them /
-const ALREADY_UP_TO_DATE = /Already up to date./
-const UNMERGED_CHANGES = /not possible because you have unmerged files/
-const FETCH_CMD = 'git -c core.quotepath=false fetch origin --progress --prune'
-const run = require('./../utils/run')
-const chalk = require('chalk')
-module.exports = async function pullAction (action, options, messages) {
-  const repoName = action.config.repoName
-  const destPath = path.join(
-    options.monorepoPath,
-    action.config.packageName,
-    repoName
-  )
-
-  try {
-    await run(FETCH_CMD, destPath)
-    const mergeResult = await run(MERGE_CMD, destPath)
-    if (ALREADY_UP_TO_DATE.test(mergeResult)) {
-      await run(STATUS_CMD, destPath)
-      action.type = 'SKIP'
-      // TODO: Study what's returned and regex to victory, if such a thing is possible.
-      messages.addMessage(
-        repoName,
-        'Pulling',
-        'INFO',
-        new Error('You may have untracked files that need adding.')
-      )
-      console.log(`${chalk.blue(' INFO')} ${chalk.gray(`/${action.config.packageName}/`)}${repoName}`)
-    } else {
-      console.log(`${chalk.cyan(' PULL')} ${chalk.gray(`/${action.config.packageName}/`)}${repoName}`)
-    }
-  } catch (err) {
-    if (COMMIT_OR_STASH.test(err.message) || UNMERGED_CHANGES.test(err.message)) {
-      messages.addMessage(
-        repoName,
-        'Pulling',
-        'WARNING',
-        new Error('Failed to fetch/pull because there are local changes afoot.\nYou\'ll need to push/stash them before this repo can be synced.')
-      )
-    } else {
-      messages.addMessage(
-        repoName,
-        'Pulling',
-        'ERROR',
-        err
-      )
-    }
-  }
-}

package/lib/utils/Messages.js

@@ -1,69 +0,0 @@
-const chalk = require('chalk')
-
-module.exports = class Messages {
-  constructor () {
-    this.messages = {}
-    this.errorCount = 0
-    this.messageCount = 0
-  }
-
-  addMessage (repoName, domain, level, err) {
-    this.messageCount++
-    if (!this.messages[domain]) {
-      this.messages[domain] = []
-    }
-    this.messages[domain].push(
-      {
-        repoName,
-        level,
-        err
-      }
-    )
-    if (level === 'ERROR') {
-      this.errorCount++
-    }
-  }
-
-  output () {
-    if (this.messageCount > 0) {
-      console.log('')
-      console.log(`Messages ${chalk.blue(`(${this.messageCount})`)}`)
-
-      Object.entries(this.messages).forEach(([domain, messages]) => {
-        console.log('')
-        console.log(`  ${chalk.underline(domain)}`)
-        console.log('')
-        messages.forEach(
-          message => {
-            let title = message.level
-            title = `[${title}]`
-            switch (message.level) {
-              case 'ERROR':
-                title = chalk.red(`${title} ${message.repoName}`)
-                break
-              case 'WARNING':
-                title = chalk.yellow(`${title} ${message.repoName}`)
-                break
-              case 'INFO':
-                title = chalk.blue(`${title} ${message.repoName}`)
-                break
-            }
-            title = chalk.bold(title)
-            let messageBody = message.err.toString().replace(/\n/g, '\n      ')
-            if (messageBody.slice(0, 7) === 'Error: ') {
-              messageBody = messageBody.slice(7)
-            }
-
-            console.log(`    ${title}`)
-            console.log(`      ${messageBody}`)
-            console.log('')
-          }
-        )
-      })
-
-      if (this.errorCount > 0) {
-        console.log(chalk.inverse(chalk.red(`SYNCING FINISHED WITH ${this.errorCount} ERROR${this.errorCount === 1 ? '' : 'S'}`)))
-      }
-    }
-  }
-}

package/lib/utils/run.js

@@ -1,11 +0,0 @@
-const { exec } = require('child_process')
-
-module.exports = function run (cmd, cwd = null) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, { cwd }, (err, stdout, stderr) => {
-      // console.log(stdout)
-      if (err) reject(err)
-      else resolve(stdout)
-    })
-  })
-}