@wmfs/lerna-sync 1.37.1 → 1.39.0

package/test/execute-plan-spec.js

@@ -0,0 +1,233 @@
+/* eslint-env mocha */
+
+const fs = require('fs')
+const path = require('path')
+const { expect } = require('chai')
+const { Sandbox, git } = require('./helpers/git-sandbox')
+const { executePlan, OUTCOMES } = require('../lib/execute-plan')
+const { ACTIONS, REASONS } = require('../lib/plan-sync')
+
+describe('executePlan (real git)', function () {
+  this.timeout(30000)
+
+  let sandbox, mono, origin, options
+
+  beforeEach(() => {
+    sandbox = new Sandbox()
+    mono = sandbox.dir('mono')
+    origin = sandbox.createOrigin('tymly-test-plugin')
+    options = {
+      monorepoPath: mono,
+      gitHubOrgName: 'wmfs',
+      cloneUrl: (org, name) => path.join(sandbox.root, 'remotes', org, `${name}.git`)
+    }
+  })
+
+  afterEach(() => sandbox.cleanup())
+
+  const decision = (action, reason, repoPath, extra = {}) => ({
+    repoName: origin.name,
+    action,
+    reason,
+    folder: 'plugins',
+    defaultBranch: 'master',
+    remote: { name: origin.name },
+    local: repoPath ? { path: repoPath, branch: git(repoPath, 'rev-parse', '--abbrev-ref', 'HEAD') } : null,
+    warnings: [],
+    ...extra
+  })
+
+  const runOne = async d => {
+    const [result] = await executePlan({ decisions: [d], ignored: [] }, options)
+    return result
+  }
+
+  const head = (repo, ref = 'HEAD') => git(repo, 'rev-parse', ref)
+  const originHead = () => git(origin.bare, 'rev-parse', 'master')
+
+  describe('CLONE', () => {
+    it('clones into <folder>/<repo name>', async () => {
+      const result = await runOne(decision(ACTIONS.CLONE, REASONS.NEW, null))
+
+      const dest = path.join(mono, 'plugins', origin.name)
+      expect(result.outcome).to.equal(OUTCOMES.CLONED)
+      expect(head(dest)).to.equal(originHead())
+    })
+
+    it('reports a failure without throwing', async () => {
+      options.cloneUrl = () => path.join(sandbox.root, 'does-not-exist.git')
+      const result = await runOne(decision(ACTIONS.CLONE, REASONS.NEW, null))
+
+      expect(result.outcome).to.equal(OUTCOMES.FAILED)
+      expect(result.error).to.be.a('string').and.not.equal('')
+    })
+  })
+
+  describe('FAST_FORWARD', () => {
+    it('pulls new commits on a clean default branch', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      origin.push('a.txt', 'a', 'First new commit')
+      origin.push('b.txt', 'b', 'Second new commit')
+
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+
+      expect(result).to.include({ outcome: OUTCOMES.UPDATED, ahead: 0, behind: 2, packageJsonChanged: false })
+      expect(result.commits.map(c => c.subject)).to.deep.equal(['Second new commit', 'First new commit'])
+      expect(head(repo)).to.equal(originHead())
+    })
+
+    it('flags when package.json changed', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      origin.push('package.json', '{"name":"changed"}', 'Bump deps')
+
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+      expect(result.packageJsonChanged).to.equal(true)
+    })
+
+    it('reports current when there is nothing new', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+      expect(result).to.include({ outcome: OUTCOMES.CURRENT, ahead: 0, behind: 0 })
+    })
+
+    it('reports unpushed commits and leaves them alone', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const local = sandbox.commit(repo, 'mine.txt', 'mine', 'Not pushed yet')
+
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+      expect(result).to.include({ outcome: OUTCOMES.LOCAL_AHEAD, ahead: 1, behind: 0 })
+      expect(head(repo)).to.equal(local)
+    })
+
+    it('does not merge when the default branch has diverged', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const local = sandbox.commit(repo, 'mine.txt', 'mine', 'Local work')
+      origin.push('theirs.txt', 'theirs', 'Remote work')
+
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+      expect(result).to.include({ outcome: OUTCOMES.DIVERGED, ahead: 1, behind: 1 })
+      expect(result.commits.map(c => c.subject)).to.deep.equal(['Remote work'])
+      expect(head(repo)).to.equal(local)
+    })
+
+    it('does not overwrite an untracked file that is now tracked upstream', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      origin.push('notes.txt', 'from upstream', 'Add notes')
+      sandbox.write(repo, 'notes.txt', 'my local notes')
+      const before = head(repo)
+
+      const result = await runOne(decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo))
+      expect(result.outcome).to.equal(OUTCOMES.BLOCKED_BY_UNTRACKED)
+      expect(head(repo)).to.equal(before)
+      expect(fs.readFileSync(path.join(repo, 'notes.txt'), 'utf8')).to.equal('my local notes')
+    })
+  })
+
+  describe('FETCH_ONLY', () => {
+    it('leaves a feature branch alone and reports what the default branch has', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+      const branchHead = sandbox.commit(repo, 'feature.txt', 'wip', 'Feature work')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      const result = await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, repo))
+
+      expect(result).to.include({ outcome: OUTCOMES.BEHIND, ahead: 1, behind: 1 })
+      expect(result.commits.map(c => c.subject)).to.deep.equal(['Fix on master'])
+      expect(git(repo, 'rev-parse', '--abbrev-ref', 'HEAD')).to.equal('feature/x')
+      expect(head(repo)).to.equal(branchHead)
+      expect(fs.existsSync(path.join(repo, 'fix.txt'))).to.equal(false)
+    })
+
+    it('fast-forwards the local default branch without checking it out', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, repo))
+      expect(head(repo, 'master')).to.equal(originHead())
+    })
+
+    it('does not move a local default branch that has its own commits', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const localMaster = sandbox.commit(repo, 'mine.txt', 'mine', 'Unpushed on master')
+      git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, repo))
+      expect(head(repo, 'master')).to.equal(localMaster)
+    })
+
+    it('respects updateLocalDefaultBranch: false', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const before = head(repo, 'master')
+      git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      options.updateLocalDefaultBranch = false
+      await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, repo))
+      expect(head(repo, 'master')).to.equal(before)
+    })
+
+    it('reports current when the default branch has nothing new', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      git(repo, 'checkout', '--quiet', '-b', 'feature/x')
+
+      const result = await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.ON_BRANCH, repo))
+      expect(result).to.include({ outcome: OUTCOMES.CURRENT, behind: 0 })
+      expect(result.commits).to.deep.equal([])
+    })
+
+    it('does not touch a checked-out default branch with uncommitted changes', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      const before = head(repo)
+      sandbox.write(repo, 'package.json', '{"editing": true}')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      const result = await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.LOCAL_CHANGES, repo))
+      expect(result).to.include({ outcome: OUTCOMES.BEHIND, behind: 1 })
+      expect(head(repo)).to.equal(before)
+      expect(fs.readFileSync(path.join(repo, 'package.json'), 'utf8')).to.equal('{"editing": true}')
+    })
+
+    it('handles a detached HEAD', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      git(repo, 'checkout', '--quiet', '--detach')
+      origin.push('fix.txt', 'fix', 'Fix on master')
+
+      const result = await runOne(decision(ACTIONS.FETCH_ONLY, REASONS.DETACHED, repo))
+      expect(result).to.include({ outcome: OUTCOMES.BEHIND, behind: 1 })
+      expect(head(repo, 'master')).to.equal(originHead())
+    })
+  })
+
+  describe('running a whole plan', () => {
+    it('skips NONE decisions and isolates failures', async () => {
+      const repo = sandbox.cloneInto(origin, 'mono', 'plugins')
+      origin.push('a.txt', 'a', 'New commit')
+
+      const good = decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, repo)
+      const bad = decision(ACTIONS.FAST_FORWARD, REASONS.BEHIND, null, {
+        repoName: 'missing',
+        local: { path: path.join(mono, 'plugins', 'missing'), branch: 'master' }
+      })
+      const none = decision(ACTIONS.NONE, REASONS.ORPHANED, null, { repoName: 'gone' })
+
+      const seen = []
+      options.onResult = r => seen.push(r.decision.repoName)
+      const results = await executePlan({ decisions: [good, bad, none], ignored: [] }, options)
+
+      expect(results.map(r => [r.decision.repoName, r.outcome])).to.deep.equal([
+        [origin.name, OUTCOMES.UPDATED],
+        ['missing', OUTCOMES.FAILED]
+      ])
+      expect(seen).to.have.members([origin.name, 'missing'])
+    })
+
+    it('returns the same decision objects it was given', async () => {
+      const d = decision(ACTIONS.CLONE, REASONS.NEW, null)
+      const [result] = await executePlan({ decisions: [d], ignored: [] }, options)
+      expect(result.decision).to.equal(d)
+    })
+  })
+})

package/test/helpers/fixtures.js

@@ -0,0 +1,64 @@
+// Builders for the plain records each stage passes to the next.
+// Defaults describe the "boring" case; tests override only what they care about.
+
+const chalk = require('chalk')
+
+// Keep assertions on output free of colour codes
+chalk.level = 0
+
+const router = pkg => {
+  const keywords = pkg.keywords || []
+  if (!keywords.includes('tymly')) return null
+  if (pkg.config && pkg.config.tymly && pkg.config.tymly.sync === false) {
+    return { skip: 'Opted out (config.tymly.sync = false)' }
+  }
+  if (keywords.includes('blueprint')) return 'blueprints'
+  if (keywords.includes('plugin')) return 'plugins'
+  return null
+}
+
+function remote (name, overrides = {}) {
+  return {
+    name,
+    isPrivate: false,
+    defaultBranch: 'master',
+    sha: 'remote-sha',
+    messageHeadline: 'Latest commit',
+    author: { name: 'Someone', date: '2026-01-01T00:00:00Z' },
+    packageJson: { name: `@wmfs/${name}`, description: `${name} description`, keywords: ['tymly', 'plugin'] },
+    ...overrides
+  }
+}
+
+function local (name, overrides = {}) {
+  return {
+    path: `/mono/plugins/${name}`,
+    repoName: name,
+    folder: 'plugins',
+    isGitRepo: true,
+    branch: 'master',
+    isDetached: false,
+    headSha: 'local-sha',
+    statusKnown: true,
+    trackedChanges: 0,
+    untrackedFiles: 0,
+    operationInProgress: false,
+    origin: { owner: 'wmfs', name, url: `https://github.com/wmfs/${name}.git` },
+    packageJson: null,
+    ...overrides
+  }
+}
+
+function captureConsole () {
+  const lines = []
+  const original = { log: console.log, warn: console.warn }
+  console.log = (...args) => lines.push(args.join(' '))
+  console.warn = (...args) => lines.push(args.join(' '))
+  return {
+    lines,
+    text: () => lines.join('\n'),
+    restore: () => Object.assign(console, original)
+  }
+}
+
+module.exports = { router, remote, local, captureConsole }

package/test/helpers/git-sandbox.js

@@ -0,0 +1,87 @@
+// Throwaway git repositories in a temp directory, for tests that need real git.
+// No network: "origins" are local bare repos.
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { execFileSync } = require('child_process')
+
+// Isolate from the developer's own git config (signing, hooks, default branch, ...).
+// lib/utils/git.js inherits process.env, so this applies to the code under test too.
+process.env.GIT_CONFIG_GLOBAL = os.devNull
+process.env.GIT_CONFIG_NOSYSTEM = '1'
+process.env.GIT_AUTHOR_NAME = 'Test Author'
+process.env.GIT_AUTHOR_EMAIL = 'author@example.com'
+process.env.GIT_COMMITTER_NAME = 'Test Author'
+process.env.GIT_COMMITTER_EMAIL = 'author@example.com'
+process.env.GIT_TERMINAL_PROMPT = '0'
+
+function git (cwd, ...args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+}
+
+function tryGit (cwd, ...args) {
+  try {
+    return git(cwd, ...args)
+  } catch (e) {
+    return null
+  }
+}
+
+class Sandbox {
+  constructor () {
+    this.root = fs.mkdtempSync(path.join(os.tmpdir(), 'lerna-sync-test-'))
+  }
+
+  dir (...parts) {
+    const p = path.join(this.root, ...parts)
+    fs.mkdirSync(p, { recursive: true })
+    return p
+  }
+
+  write (repoPath, file, content) {
+    const full = path.join(repoPath, file)
+    fs.mkdirSync(path.dirname(full), { recursive: true })
+    fs.writeFileSync(full, content)
+  }
+
+  commit (repoPath, file, content, message = `Change ${file}`) {
+    this.write(repoPath, file, content)
+    git(repoPath, 'add', file)
+    git(repoPath, 'commit', '--quiet', '-m', message)
+    return git(repoPath, 'rev-parse', 'HEAD')
+  }
+
+  // A bare "GitHub" repo plus a working clone used to push new commits to it
+  createOrigin (name) {
+    const bare = this.dir('remotes', 'wmfs', `${name}.git`)
+    git(bare, 'init', '--quiet', '--bare', '-b', 'master')
+
+    const pusher = path.join(this.root, 'pushers', name)
+    git(this.root, 'clone', '--quiet', bare, pusher)
+    git(pusher, 'symbolic-ref', 'HEAD', 'refs/heads/master')
+    this.commit(pusher, 'package.json', JSON.stringify({ name, keywords: ['tymly', 'plugin'] }, null, 2), 'Initial commit')
+    git(pusher, 'push', '--quiet', 'origin', 'master')
+
+    const push = (file, content, message) => {
+      const sha = this.commit(pusher, file, content, message)
+      git(pusher, 'push', '--quiet', 'origin', 'master')
+      return sha
+    }
+
+    return { name, bare, pusher, push }
+  }
+
+  // A developer's clone of an origin, inside the monorepo husk
+  cloneInto (origin, ...folderParts) {
+    const dest = path.join(this.dir(...folderParts), origin.name)
+    git(this.root, 'clone', '--quiet', origin.bare, dest)
+    return dest
+  }
+
+  cleanup () {
+    fs.rmSync(this.root, { recursive: true, force: true })
+  }
+}
+
+module.exports = { Sandbox, git, tryGit }

package/test/inspect-spec.js

@@ -0,0 +1,148 @@
+/* eslint-env mocha */
+
+const fs = require('fs')
+const path = require('path')
+const { expect } = require('chai')
+const { Sandbox, git, tryGit } = require('./helpers/git-sandbox')
+const { inspectLocalRepos, inspectRepo } = require('../lib/inspect')
+
+describe('inspect (real git)', function () {
+  this.timeout(30000)
+
+  let sandbox, mono, origin
+
+  beforeEach(() => {
+    sandbox = new Sandbox()
+    origin = sandbox.createOrigin('tymly-test-plugin')
+
+    // The husk is itself a git repo, as the real tymly monorepo is
+    mono = sandbox.dir('mono')
+    git(mono, 'init', '--quiet', '-b', 'master')
+    sandbox.dir('mono', 'plugins')
+    sandbox.dir('mono', 'blueprints')
+  })
+
+  afterEach(() => sandbox.cleanup())
+
+  const cloneAndPointAtGitHub = (...folder) => {
+    const repo = sandbox.cloneInto(origin, 'mono', ...folder)
+    git(repo, 'remote', 'set-url', 'origin', `https://github.com/wmfs/${origin.name}.git`)
+    return repo
+  }
+
+  it('finds one record per folder matched by the lerna patterns', async () => {
+    cloneAndPointAtGitHub('plugins')
+    sandbox.dir('mono', 'blueprints', 'scratch')
+    fs.writeFileSync(path.join(mono, 'plugins', 'README.md'), 'a file, not a package folder')
+
+    const records = await inspectLocalRepos(mono, ['plugins/*', 'blueprints/*'])
+
+    expect(records.map(r => `${r.folder}/${r.repoName}`))
+      .to.deep.equal(['blueprints/scratch', `plugins/${origin.name}`])
+  })
+
+  it('returns nothing for empty package folders', async () => {
+    expect(await inspectLocalRepos(mono, ['plugins/*', 'blueprints/*'])).to.deep.equal([])
+  })
+
+  it('reads a clean clone on the default branch', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    const record = await inspectRepo(mono, repo)
+
+    expect(record).to.include({
+      repoName: origin.name,
+      folder: 'plugins',
+      isGitRepo: true,
+      branch: 'master',
+      isDetached: false,
+      headSha: git(repo, 'rev-parse', 'HEAD'),
+      statusKnown: true,
+      trackedChanges: 0,
+      untrackedFiles: 0,
+      operationInProgress: false
+    })
+    expect(record.origin).to.include({ owner: 'wmfs', name: origin.name })
+    expect(record.packageJson.name).to.equal(origin.name)
+  })
+
+  it('does not mistake a plain folder for a repo, even inside the husk\'s repo', async () => {
+    const plain = sandbox.dir('mono', 'plugins', 'not-a-repo')
+    const record = await inspectRepo(mono, plain)
+
+    expect(record).to.deep.equal({
+      path: plain,
+      repoName: 'not-a-repo',
+      folder: 'plugins',
+      isGitRepo: false
+    })
+  })
+
+  it('reports the current feature branch', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    git(repo, 'checkout', '--quiet', '-b', 'feature/new-thing')
+
+    const record = await inspectRepo(mono, repo)
+    expect(record).to.include({ branch: 'feature/new-thing', isDetached: false })
+  })
+
+  it('reports a detached HEAD', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    git(repo, 'checkout', '--quiet', '--detach')
+
+    const record = await inspectRepo(mono, repo)
+    expect(record).to.include({ branch: null, isDetached: true })
+    expect(record.headSha).to.equal(git(repo, 'rev-parse', 'HEAD'))
+  })
+
+  it('counts tracked changes and untracked files separately', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    sandbox.write(repo, 'package.json', '{"changed": true}')
+    sandbox.write(repo, 'new-1.txt', 'x')
+    sandbox.write(repo, 'new-2.txt', 'x')
+
+    const record = await inspectRepo(mono, repo)
+    expect(record).to.include({ trackedChanges: 1, untrackedFiles: 2 })
+  })
+
+  it('detects a merge in progress', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    git(repo, 'checkout', '--quiet', '-b', 'other')
+    sandbox.commit(repo, 'conflict.txt', 'theirs')
+    git(repo, 'checkout', '--quiet', 'master')
+    sandbox.commit(repo, 'conflict.txt', 'ours')
+    tryGit(repo, 'merge', 'other') // conflicts, leaving MERGE_HEAD
+
+    const record = await inspectRepo(mono, repo)
+    expect(record.operationInProgress).to.equal(true)
+  })
+
+  it('handles a repo with no commits yet', async () => {
+    const repo = sandbox.dir('mono', 'plugins', 'brand-new')
+    git(repo, 'init', '--quiet', '-b', 'master')
+
+    const record = await inspectRepo(mono, repo)
+    expect(record).to.include({ isGitRepo: true, headSha: null, branch: 'master' })
+    expect(record.origin).to.equal(null)
+  })
+
+  it('parses SSH origin URLs', async () => {
+    const repo = cloneAndPointAtGitHub('plugins')
+    git(repo, 'remote', 'set-url', 'origin', 'git@github.com:wmfs/renamed-repo.git')
+
+    const record = await inspectRepo(mono, repo)
+    expect(record.origin).to.include({ owner: 'wmfs', name: 'renamed-repo' })
+  })
+
+  it('records a non-GitHub origin without an owner', async () => {
+    const repo = sandbox.cloneInto(origin, 'mono', 'plugins') // origin is a local path
+
+    const record = await inspectRepo(mono, repo)
+    expect(record.origin).to.include({ owner: null, name: null })
+  })
+
+  it('reports nested package folders relative to the husk', async () => {
+    const repo = cloneAndPointAtGitHub('plugins', 'core')
+    const record = await inspectRepo(mono, repo)
+    expect(record.folder).to.equal('plugins/core')
+  })
+})