@wmfs/lerna-sync 1.37.1 → 1.39.0

package/test/plan-sync-spec.js

@@ -0,0 +1,247 @@
+/* eslint-env mocha */
+
+const { expect } = require('chai')
+const { router, remote, local } = require('./helpers/fixtures')
+const { planSync, ACTIONS, REASONS } = require('../lib/plan-sync')
+
+const plan = (remoteRepos, localRepos, overrides = {}) => planSync({
+  remoteRepos,
+  localRepos,
+  router,
+  orgName: 'wmfs',
+  packageFolders: ['plugins', 'blueprints'],
+  ...overrides
+})
+
+const only = result => {
+  expect(result.decisions).to.have.length(1)
+  return result.decisions[0]
+}
+
+describe('planSync', () => {
+  describe('routing remote repos', () => {
+    it('ignores repos without a package.json', () => {
+      const { decisions, ignored } = plan([remote('a', { packageJson: null })], [])
+      expect(decisions).to.have.length(0)
+      expect(ignored).to.deep.equal([{ repoName: 'a', reason: 'No package.json' }])
+    })
+
+    it('ignores repos the router does not select', () => {
+      const { decisions, ignored } = plan([remote('a', { packageJson: { keywords: ['other'] } })], [])
+      expect(decisions).to.have.length(0)
+      expect(ignored[0].reason).to.equal('Not selected by router')
+    })
+
+    it('uses the skip reason a router returns', () => {
+      const optedOut = remote('a', { packageJson: { keywords: ['tymly', 'plugin'], config: { tymly: { sync: false } } } })
+      const { ignored } = plan([optedOut], [])
+      expect(ignored[0].reason).to.equal('Opted out (config.tymly.sync = false)')
+    })
+
+    it('ignores a repo when the router throws, instead of failing the sync', () => {
+      const throwing = () => { throw new Error('boom') }
+      const { decisions, ignored } = plan([remote('a'), remote('b')], [], { router: throwing })
+      expect(decisions).to.have.length(0)
+      expect(ignored.map(i => i.reason)).to.deep.equal(['Router threw: boom', 'Router threw: boom'])
+    })
+
+    it('rejects a folder that is not in lerna.json', () => {
+      const { decisions, ignored } = plan([remote('a')], [], { router: () => 'mods' })
+      expect(decisions).to.have.length(0)
+      expect(ignored[0].reason).to.include('"mods", which is not in lerna.json')
+    })
+
+    it('rejects router results that are not strings', () => {
+      const { ignored } = plan([remote('a')], [], { router: () => 42 })
+      expect(ignored[0].reason).to.equal('Router returned 42')
+    })
+
+    it('calls the router exactly once per remote repo', () => {
+      let calls = 0
+      const counting = pkg => { calls++; return router(pkg) }
+      plan([remote('a'), remote('b')], [local('a')], { router: counting })
+      expect(calls).to.equal(2)
+    })
+  })
+
+  describe('repos missing locally', () => {
+    it('clones a qualifying repo into its routed folder', () => {
+      const d = only(plan([remote('bp', { packageJson: { keywords: ['tymly', 'blueprint'] } })], []))
+      expect(d).to.include({ repoName: 'bp', action: ACTIONS.CLONE, reason: REASONS.NEW, folder: 'blueprints', defaultBranch: 'master' })
+      expect(d.local).to.equal(null)
+    })
+
+    it('carries a non-master default branch through', () => {
+      const d = only(plan([remote('a', { defaultBranch: 'main' })], []))
+      expect(d.defaultBranch).to.equal('main')
+    })
+  })
+
+  describe('repos on the default branch', () => {
+    it('does nothing when HEAD matches GitHub', () => {
+      const d = only(plan([remote('a', { sha: 'same' })], [local('a', { headSha: 'same' })]))
+      expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.UP_TO_DATE })
+    })
+
+    it('fast-forwards when clean and HEAD differs', () => {
+      const d = only(plan([remote('a')], [local('a')]))
+      expect(d).to.include({ action: ACTIONS.FAST_FORWARD, reason: REASONS.BEHIND })
+    })
+
+    it('only fetches when there are uncommitted changes', () => {
+      const d = only(plan([remote('a')], [local('a', { trackedChanges: 2 })]))
+      expect(d).to.include({ action: ACTIONS.FETCH_ONLY, reason: REASONS.LOCAL_CHANGES })
+    })
+
+    it('reports up to date, not local changes, when dirty but already current', () => {
+      const d = only(plan([remote('a', { sha: 'same' })], [local('a', { headSha: 'same', trackedChanges: 1 })]))
+      expect(d.reason).to.equal(REASONS.UP_TO_DATE)
+    })
+
+    it('does not treat untracked files alone as local changes', () => {
+      const d = only(plan([remote('a')], [local('a', { untrackedFiles: 3 })]))
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+    })
+
+    it('treats "main" as the default branch when GitHub says so', () => {
+      const d = only(plan([remote('a', { defaultBranch: 'main' })], [local('a', { branch: 'main' })]))
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+    })
+  })
+
+  describe('repos the developer is working in', () => {
+    it('only fetches when on a feature branch', () => {
+      const d = only(plan([remote('a')], [local('a', { branch: 'feature/x' })]))
+      expect(d).to.include({ action: ACTIONS.FETCH_ONLY, reason: REASONS.ON_BRANCH })
+    })
+
+    it('only fetches on a feature branch even if HEAD matches GitHub', () => {
+      const d = only(plan([remote('a', { sha: 'same' })], [local('a', { branch: 'feature/x', headSha: 'same' })]))
+      expect(d.reason).to.equal(REASONS.ON_BRANCH)
+    })
+
+    it('treats local "master" as a branch when the default is "main"', () => {
+      const d = only(plan([remote('a', { defaultBranch: 'main' })], [local('a', { branch: 'master' })]))
+      expect(d.reason).to.equal(REASONS.ON_BRANCH)
+    })
+
+    it('only fetches on a detached HEAD', () => {
+      const d = only(plan([remote('a')], [local('a', { branch: null, isDetached: true })]))
+      expect(d).to.include({ action: ACTIONS.FETCH_ONLY, reason: REASONS.DETACHED })
+    })
+  })
+
+  describe('unsafe local state', () => {
+    for (const [label, overrides] of [
+      ['mid-merge or mid-rebase', { operationInProgress: true }],
+      ['git status could not be read', { statusKnown: false }],
+      ['no commits yet', { headSha: null }]
+    ]) {
+      it(`does nothing when ${label}`, () => {
+        const d = only(plan([remote('a')], [local('a', overrides)]))
+        expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.UNSAFE_STATE })
+      })
+    }
+
+    it('checks unsafe state before branch state', () => {
+      const d = only(plan([remote('a')], [local('a', { branch: 'feature/x', operationInProgress: true })]))
+      expect(d.reason).to.equal(REASONS.UNSAFE_STATE)
+    })
+  })
+
+  describe('folders that are not plain clones of an org repo', () => {
+    it('does not clone over a plain folder where a qualifying repo would go', () => {
+      const d = only(plan([remote('a')], [local('a', { isGitRepo: false, origin: undefined })]))
+      expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.NOT_A_REPO })
+      expect(d.warnings).to.have.length(1)
+    })
+
+    it('notes an unrelated plain folder without a warning', () => {
+      const d = only(plan([], [local('scratch', { isGitRepo: false, origin: undefined })]))
+      expect(d.reason).to.equal(REASONS.NOT_A_REPO)
+      expect(d.warnings).to.deep.equal([])
+    })
+
+    it('leaves alone a repo whose origin is another owner', () => {
+      const fork = local('a', { origin: { owner: 'someone', name: 'a', url: 'https://github.com/someone/a.git' } })
+      const d = only(plan([remote('a')], [fork]))
+      expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.FOREIGN_ORIGIN })
+      expect(d.warnings[0]).to.include('github.com/someone/a.git')
+    })
+
+    it('compares the origin owner case-insensitively', () => {
+      const d = only(plan([remote('a')], [local('a', { origin: { owner: 'WMFS', name: 'a', url: 'x' } })]))
+      expect(d.reason).to.not.equal(REASONS.FOREIGN_ORIGIN)
+    })
+
+    it('reports local repos that are gone from the org', () => {
+      const d = only(plan([], [local('gone')]))
+      expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.ORPHANED })
+    })
+
+    it('reports local repos that no longer qualify, with the reason', () => {
+      const optedOut = remote('a', { packageJson: { keywords: ['tymly', 'plugin'], config: { tymly: { sync: false } } } })
+      const d = only(plan([optedOut], [local('a')]))
+      expect(d).to.include({ action: ACTIONS.NONE, reason: REASONS.NO_LONGER_QUALIFIES })
+      expect(d.warnings).to.deep.equal(['Opted out (config.tymly.sync = false)'])
+    })
+
+    it('still updates a misplaced repo, with a warning', () => {
+      const bp = remote('a', { packageJson: { keywords: ['tymly', 'blueprint'] } })
+      const d = only(plan([bp], [local('a', { folder: 'plugins' })]))
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+      expect(d.warnings).to.deep.equal(['Lives in /plugins but is now routed to /blueprints'])
+    })
+
+    it('reports a second clone of the same repo as a duplicate', () => {
+      const result = plan([remote('a')], [
+        local('a'),
+        local('a-copy', { folder: 'blueprints', origin: { owner: 'wmfs', name: 'a', url: 'x' } })
+      ])
+      const duplicate = result.decisions.find(d => d.reason === REASONS.DUPLICATE)
+      expect(duplicate).to.include({ repoName: 'a-copy', action: ACTIONS.NONE })
+      expect(duplicate.warnings[0]).to.equal('Also found at plugins/a')
+      expect(result.decisions.filter(d => d.action !== ACTIONS.NONE)).to.have.length(1)
+    })
+  })
+
+  describe('matching local folders to remote repos', () => {
+    it('matches on the origin name, not the folder name', () => {
+      const renamed = local('my-local-name', { origin: { owner: 'wmfs', name: 'a', url: 'x' } })
+      const result = plan([remote('a')], [renamed])
+      const d = only(result)
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+      expect(d.remote.name).to.equal('a')
+    })
+
+    it('falls back to the folder name when there is no origin', () => {
+      const d = only(plan([remote('a')], [local('a', { origin: null })]))
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+    })
+
+    it('matches names case-insensitively', () => {
+      const d = only(plan([remote('Tymly-Core')], [local('tymly-core')]))
+      expect(d.action).to.equal(ACTIONS.FAST_FORWARD)
+    })
+
+    it('never plans a clone for a repo that already exists locally', () => {
+      const result = plan([remote('a')], [local('a', { branch: 'feature/x' })])
+      expect(result.decisions.filter(d => d.action === ACTIONS.CLONE)).to.have.length(0)
+    })
+  })
+
+  it('sorts decisions by folder, then repo name', () => {
+    const bp = name => remote(name, { packageJson: { keywords: ['tymly', 'blueprint'] } })
+    const { decisions } = plan([remote('z'), bp('c'), remote('a'), bp('b')], [])
+    expect(decisions.map(d => `${d.folder}/${d.repoName}`))
+      .to.deep.equal(['blueprints/b', 'blueprints/c', 'plugins/a', 'plugins/z'])
+  })
+
+  it('does not mutate its inputs', () => {
+    const remotes = [remote('a'), remote('b')]
+    const locals = [local('a'), local('c')]
+    const before = JSON.stringify({ remotes, locals })
+    plan(remotes, locals)
+    expect(JSON.stringify({ remotes, locals })).to.equal(before)
+  })
+})

package/test/report-spec.js

@@ -0,0 +1,178 @@
+/* eslint-env mocha */
+
+const { expect } = require('chai')
+const { router, remote, local, captureConsole } = require('./helpers/fixtures')
+const { planSync } = require('../lib/plan-sync')
+const { OUTCOMES } = require('../lib/execute-plan')
+const { report, printPlan, describeResult } = require('../lib/report')
+
+const makePlan = (remoteRepos, localRepos) => planSync({
+  remoteRepos,
+  localRepos,
+  router,
+  orgName: 'wmfs',
+  packageFolders: ['plugins', 'blueprints']
+})
+
+const find = (plan, repoName) => plan.decisions.find(d => d.repoName === repoName)
+
+describe('describeResult', () => {
+  const d = overrides => ({ repoName: 'a', folder: 'plugins', defaultBranch: 'master', local: { branch: 'master' }, ...overrides })
+
+  it('names the branch when on a feature branch with nothing new', () => {
+    const r = describeResult({ decision: d({ reason: 'ON_BRANCH', local: { branch: 'feature/x' } }), outcome: OUTCOMES.CURRENT })
+    expect(r.label).to.equal('On branch')
+    expect(r.detail).to.equal('feature/x, nothing new on master')
+  })
+
+  it('counts new commits on the default branch when on a feature branch', () => {
+    const r = describeResult({ decision: d({ reason: 'ON_BRANCH', local: { branch: 'feature/x' } }), outcome: OUTCOMES.BEHIND, behind: 3 })
+    expect(r.detail).to.equal('feature/x, master has 3 new commits')
+  })
+
+  it('uses the singular for one commit', () => {
+    const r = describeResult({ decision: d({ reason: 'BEHIND' }), outcome: OUTCOMES.UPDATED, behind: 1 })
+    expect(r).to.include({ label: 'Updated', detail: 'pulled 1 commit' })
+  })
+
+  it('uses the repo\'s default branch name', () => {
+    const r = describeResult({ decision: d({ reason: 'DETACHED', defaultBranch: 'main', local: { branch: null } }), outcome: OUTCOMES.BEHIND, behind: 2 })
+    expect(r.detail).to.equal('main has 2 new commits')
+  })
+
+  it('describes each outcome without falling back to the raw enum', () => {
+    const cases = [
+      [OUTCOMES.CLONED, 'NEW', 'Cloned'],
+      [OUTCOMES.CURRENT, 'BEHIND', 'Up to date'],
+      [OUTCOMES.CURRENT, 'LOCAL_CHANGES', 'Up to date'],
+      [OUTCOMES.CURRENT, 'DETACHED', 'Detached'],
+      [OUTCOMES.BEHIND, 'LOCAL_CHANGES', 'Not pulled'],
+      [OUTCOMES.LOCAL_AHEAD, 'BEHIND', 'Unpushed'],
+      [OUTCOMES.DIVERGED, 'BEHIND', 'Diverged'],
+      [OUTCOMES.BLOCKED_BY_UNTRACKED, 'BEHIND', 'Not pulled'],
+      [OUTCOMES.FAILED, 'BEHIND', 'Failed']
+    ]
+    for (const [outcome, reason, label] of cases) {
+      const r = describeResult({ decision: d({ reason }), outcome, ahead: 1, behind: 1, error: 'x' })
+      expect(r.label, `${outcome}/${reason}`).to.equal(label)
+    }
+  })
+
+  it('shows only the first line of an error', () => {
+    const r = describeResult({ decision: d({ reason: 'NEW' }), outcome: OUTCOMES.FAILED, error: 'fatal: nope\nmore detail' })
+    expect(r.detail).to.equal('fatal: nope')
+  })
+})
+
+describe('report', () => {
+  let output
+  beforeEach(() => { output = captureConsole() })
+  afterEach(() => output.restore())
+
+  it('counts errors and items needing attention', () => {
+    const plan = makePlan(
+      [remote('ok', { sha: 'same' }), remote('new'), remote('branch'), remote('broken')],
+      [local('ok', { headSha: 'same' }), local('branch', { branch: 'feature/x' }), local('broken'), local('mid', { operationInProgress: true })]
+    )
+    const results = [
+      { decision: find(plan, 'new'), outcome: OUTCOMES.CLONED },
+      { decision: find(plan, 'branch'), outcome: OUTCOMES.BEHIND, behind: 2, commits: [] },
+      { decision: find(plan, 'broken'), outcome: OUTCOMES.FAILED, error: 'fatal: boom' }
+    ]
+
+    const counts = report(plan, results)
+
+    // "branch" is behind (attention); "mid" is ORPHANED (not in remotes), so housekeeping
+    expect(counts).to.deep.equal({ errorCount: 1, attentionCount: 1 })
+    expect(output.text()).to.include('Errors (1)')
+    expect(output.text()).to.include('plugins/broken fatal: boom')
+  })
+
+  it('lists repos left alone on a branch, rather than counting them as up to date', () => {
+    const plan = makePlan([remote('a')], [local('a', { branch: 'feature/x' })])
+    report(plan, [{ decision: plan.decisions[0], outcome: OUTCOMES.CURRENT, ahead: 0, behind: 0, commits: [] }])
+
+    expect(output.text()).to.include('On branches (left alone) (1)')
+    expect(output.text()).to.include('plugins/a on feature/x, nothing new on master')
+    expect(output.text()).to.include('0 up to date')
+  })
+
+  it('shows incoming commits for a branch that is behind', () => {
+    const plan = makePlan([remote('a')], [local('a', { branch: 'feature/x' })])
+    report(plan, [{
+      decision: plan.decisions[0],
+      outcome: OUTCOMES.BEHIND,
+      behind: 1,
+      commits: [{ sha: 'abc123', subject: 'Fix the thing', author: 'Ann', when: '2 hours ago' }]
+    }])
+
+    expect(output.text()).to.include('Needs your attention (1)')
+    expect(output.text()).to.include('abc123 Fix the thing (Ann, 2 hours ago)')
+  })
+
+  it('prints warnings under the repo they belong to', () => {
+    const bp = remote('a', { packageJson: { keywords: ['tymly', 'blueprint'] } })
+    const plan = makePlan([bp], [local('a', { folder: 'plugins' })])
+    report(plan, [{ decision: plan.decisions[0], outcome: OUTCOMES.UPDATED, behind: 1, commits: [] }])
+
+    expect(output.text()).to.include('! Lives in /plugins but is now routed to /blueprints')
+  })
+
+  it('reports NONE decisions without needing a result', () => {
+    const plan = makePlan([], [local('gone'), local('scratch', { isGitRepo: false, origin: undefined })])
+    const counts = report(plan, [])
+
+    expect(counts).to.deep.equal({ errorCount: 0, attentionCount: 0 })
+    expect(output.text()).to.include('Housekeeping (2)')
+    expect(output.text()).to.include('No longer in the org')
+  })
+
+  it('suggests reinstalling only when dependencies may have changed', () => {
+    const plan = makePlan([remote('a'), remote('b')], [local('a'), local('b')])
+    report(plan, plan.decisions.map(d => ({ decision: d, outcome: OUTCOMES.UPDATED, behind: 1, commits: [], packageJsonChanged: false })))
+    expect(output.text()).to.not.include('Dependencies may have changed')
+
+    output.lines.length = 0
+    report(plan, [{ decision: plan.decisions[0], outcome: OUTCOMES.UPDATED, behind: 1, commits: [], packageJsonChanged: true }])
+    expect(output.text()).to.include('Dependencies may have changed')
+  })
+
+  it('lists ignored repos only when verbose', () => {
+    const plan = makePlan([remote('other', { packageJson: { keywords: [] } })], [])
+    report(plan, [])
+    expect(output.text()).to.not.include('Ignored')
+
+    report(plan, [], { verbose: true })
+    expect(output.text()).to.include('Ignored 1 repos')
+    expect(output.text()).to.include('other: Not selected by router')
+  })
+})
+
+describe('printPlan', () => {
+  let output
+  beforeEach(() => { output = captureConsole() })
+  afterEach(() => output.restore())
+
+  it('describes what would happen, grouped by action', () => {
+    const plan = makePlan(
+      [remote('new'), remote('behind'), remote('branch'), remote('ok', { sha: 'same' })],
+      [local('behind'), local('branch', { branch: 'feature/x' }), local('ok', { headSha: 'same' })]
+    )
+    printPlan(plan)
+    const text = output.text()
+
+    expect(text).to.include('Dry run: nothing has been changed')
+    expect(text).to.include('Would clone (1)')
+    expect(text).to.include('plugins/new new description')
+    expect(text).to.include('Would fast-forward (1)')
+    expect(text).to.include('Would fetch only (your branch is left alone) (1)')
+    expect(text).to.include('plugins/branch on feature/x')
+    expect(text).to.include('1 up to date, 1 to clone, 1 to fast-forward, 1 to fetch')
+  })
+
+  it('includes attention items from the plan itself', () => {
+    printPlan(makePlan([remote('a')], [local('a', { operationInProgress: true })]))
+    expect(output.text()).to.include('Needs your attention (1)')
+    expect(output.text()).to.include('Mid-merge/rebase')
+  })
+})

package/test/sync-spec.js

@@ -1,12 +1,134 @@
 /* eslint-env mocha */
 
-const process = require('process')
-describe('Test sync', function () {
-  this.timeout(process.env.TIMEOUT || 5000)
-  it('oh dear...', () => {
-    // TODO: Sort this.
-    console.log('Not sure what to do')
-    console.log('requiring @octokit/graphql inside Mocha causes the following on Windows (at least)')
-    console.log('--> spawnSync cmd.exe ENOENT')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { expect } = require('chai')
+const { Sandbox, git } = require('./helpers/git-sandbox')
+const { router, captureConsole } = require('./helpers/fixtures')
+const LernaSync = require('../lib')
+const { ACTIONS, REASONS } = require('../lib/plan-sync')
+const { OUTCOMES } = require('../lib/execute-plan')
+
+// Answers the org query from the sandbox's bare repos, as GitHub would
+function fakeGitHub (origins) {
+  return async () => ({
+    organization: {
+      repositories: {
+        pageInfo: { hasNextPage: false, endCursor: null },
+        nodes: origins.map(o => ({
+          name: o.name,
+          isArchived: false,
+          isPrivate: false,
+          packageJson: { text: git(o.bare, 'show', 'master:package.json'), isTruncated: false },
+          defaultBranchRef: {
+            name: 'master',
+            target: {
+              oid: git(o.bare, 'rev-parse', 'master'),
+              messageHeadline: git(o.bare, 'log', '-1', '--format=%s', 'master'),
+              author: { name: 'Test Author', date: new Date().toISOString() }
+            }
+          }
+        }))
+      }
+    }
   })
+}
+
+describe('LernaSync.sync (end to end)', function () {
+  this.timeout(30000)
+
+  let sandbox, mono, output, existing, fresh, lernaSync
+
+  beforeEach(() => {
+    sandbox = new Sandbox()
+    mono = sandbox.dir('mono')
+    fs.writeFileSync(path.join(mono, 'lerna.json'), JSON.stringify({ packages: ['plugins/*', 'blueprints/*'] }))
+    sandbox.dir('mono', 'plugins')
+    sandbox.dir('mono', 'blueprints')
+
+    existing = sandbox.createOrigin('tymly-existing-plugin')
+    fresh = sandbox.createOrigin('tymly-fresh-plugin')
+
+    // The developer already has one repo, on a feature branch.
+    // Its origin is the local bare repo, so fetches work offline.
+    const repo = sandbox.cloneInto(existing, 'mono', 'plugins')
+    git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+
+    lernaSync = new LernaSync({
+      monorepoPath: mono,
+      gitHubToken: 'not-used',
+      gitHubOrgName: 'wmfs',
+      lernaPackageRouterFunction: router,
+      cloneUrl: (org, name) => path.join(sandbox.root, 'remotes', org, `${name}.git`)
+    })
+    lernaSync.graphql = fakeGitHub([existing, fresh])
+
+    output = captureConsole()
+  })
+
+  afterEach(() => {
+    output.restore()
+    sandbox.cleanup()
+  })
+
+  it('plans without changing anything on a dry run', async () => {
+    lernaSync.dryRun = true
+    const { plan, results } = await lernaSync.sync()
+
+    expect(plan.decisions.map(d => [d.repoName, d.action, d.reason])).to.deep.equal([
+      [existing.name, ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH],
+      [fresh.name, ACTIONS.CLONE, REASONS.NEW]
+    ])
+    expect(results).to.deep.equal([])
+    expect(fs.existsSync(path.join(mono, 'plugins', fresh.name))).to.equal(false)
+    expect(output.text()).to.include('Dry run')
+  })
+
+  it('clones new repos and leaves feature branches alone', async () => {
+    const { results, errorCount } = await lernaSync.sync()
+
+    expect(errorCount).to.equal(0)
+    expect(results.map(r => [r.decision.repoName, r.outcome])).to.deep.equal([
+      [existing.name, OUTCOMES.CURRENT],
+      [fresh.name, OUTCOMES.CLONED]
+    ])
+    expect(fs.existsSync(path.join(mono, 'plugins', fresh.name, 'package.json'))).to.equal(true)
+    expect(git(path.join(mono, 'plugins', existing.name), 'rev-parse', '--abbrev-ref', 'HEAD')).to.equal('feature/x')
+    expect(output.text()).to.include('On branches (left alone) (1)')
+  })
+})
+
+describe('LernaSync options', () => {
+  let dir
+
+  before(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lerna-sync-opts-'))
+    fs.writeFileSync(path.join(dir, 'lerna.json'), JSON.stringify({ packages: ['packages/*'] }))
+  })
+
+  after(() => fs.rmSync(dir, { recursive: true, force: true }))
+
+  const create = concurrency => new LernaSync({
+    monorepoPath: dir,
+    gitHubToken: 'not-used',
+    gitHubOrgName: 'wmfs',
+    lernaPackageRouterFunction: () => null,
+    concurrency
+  })
+
+  it('leaves concurrency unset when not given, so each stage uses its default', () => {
+    expect(create(undefined).concurrency).to.equal(undefined)
+    expect(create(null).concurrency).to.equal(undefined)
+  })
+
+  it('accepts a positive integer', () => {
+    expect(create(4).concurrency).to.equal(4)
+  })
+
+  for (const bad of [0, -2, 2.5, NaN, '4']) {
+    it(`rejects a concurrency of ${String(bad)}`, () => {
+      expect(() => create(bad)).to.throw(TypeError, /concurrency must be a positive integer/)
+    })
+  }
 })