canopycms 0.0.0 → 0.0.2

package/src/git-manager.test.ts

@@ -1,552 +0,0 @@
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { simpleGit } from 'simple-git'
-
-import { GitManager } from './git-manager'
-import { initTestRepo } from './test-utils'
-
-describe('GitManager.ensureLocalSimulatedRemote', () => {
-  let tmpDir: string
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'canopy-git-test-'))
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-  })
-
-  it('creates bare remote and pushes baseBranch when remote does not exist', async () => {
-    // Setup: create a git repo with a commit on main
-    const git = await initTestRepo(tmpDir)
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'test.txt'), 'hello', 'utf8')
-    await git.add(['.'])
-    await git.commit('initial commit')
-
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    // Act
-    await GitManager.ensureLocalSimulatedRemote({
-      remotePath,
-      sourcePath: tmpDir,
-      baseBranch: 'main',
-    })
-
-    // Assert: remote exists and has main branch
-    const remoteStat = await fs.stat(remotePath)
-    expect(remoteStat.isDirectory()).toBe(true)
-
-    const remoteGit = simpleGit({ baseDir: remotePath })
-    const branches = await remoteGit.branch()
-    expect(branches.all).toContain('main')
-  })
-
-  it('is idempotent - does not recreate if remote already exists', async () => {
-    // Setup
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'test.txt'), 'hello', 'utf8')
-    await git.add(['.'])
-    await git.commit('initial commit')
-
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    // Create remote first time
-    await GitManager.ensureLocalSimulatedRemote({
-      remotePath,
-      sourcePath: tmpDir,
-      baseBranch: 'main',
-    })
-
-    // Get initial state
-    const initialStat = await fs.stat(remotePath)
-    const initialMtime = initialStat.mtimeMs
-
-    // Wait a bit to ensure mtime would change if recreated
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    // Act: call again
-    await GitManager.ensureLocalSimulatedRemote({
-      remotePath,
-      sourcePath: tmpDir,
-      baseBranch: 'main',
-    })
-
-    // Assert: directory wasn't recreated (mtime unchanged)
-    const finalStat = await fs.stat(remotePath)
-    expect(finalStat.mtimeMs).toBe(initialMtime)
-  })
-
-  it('throws error if sourcePath is not a git repo', async () => {
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    await expect(
-      GitManager.ensureLocalSimulatedRemote({
-        remotePath,
-        sourcePath: tmpDir,
-        baseBranch: 'main',
-      }),
-    ).rejects.toThrow('not a git repository')
-  })
-
-  it('throws error if git repo has no commits', async () => {
-    // Setup: init repo but don't commit
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    await expect(
-      GitManager.ensureLocalSimulatedRemote({
-        remotePath,
-        sourcePath: tmpDir,
-        baseBranch: 'main',
-      }),
-    ).rejects.toThrow('repository has no commits')
-  })
-
-  it('throws error if baseBranch does not exist locally', async () => {
-    // Setup: create repo with commit on main, but ask for develop
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'test.txt'), 'hello', 'utf8')
-    await git.add(['.'])
-    await git.commit('initial commit')
-
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    await expect(
-      GitManager.ensureLocalSimulatedRemote({
-        remotePath,
-        sourcePath: tmpDir,
-        baseBranch: 'develop',
-      }),
-    ).rejects.toThrow("base branch 'develop' does not exist locally")
-  })
-
-  it('pushes actual baseBranch content, not current HEAD', async () => {
-    // Setup: create main with one commit, then feature branch with different commit
-    const git = await initTestRepo(tmpDir)
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'main.txt'), 'main content', 'utf8')
-    await git.add(['.'])
-    await git.commit('main commit')
-
-    // Create feature branch with different content
-    await git.checkoutLocalBranch('feature')
-    await fs.writeFile(path.join(tmpDir, 'feature.txt'), 'feature content', 'utf8')
-    await git.add(['.'])
-    await git.commit('feature commit')
-
-    const remotePath = path.join(tmpDir, 'remote.git')
-
-    // Act: initialize remote while on feature branch, but specify main as baseBranch
-    await GitManager.ensureLocalSimulatedRemote({
-      remotePath,
-      sourcePath: tmpDir,
-      baseBranch: 'main',
-    })
-
-    // Assert: remote has main, not feature
-    const remoteGit = simpleGit({ baseDir: remotePath })
-    const branches = await remoteGit.branch()
-    expect(branches.all).toContain('main')
-    expect(branches.all).not.toContain('feature')
-
-    // Clone the remote to verify content
-    const clonePath = path.join(tmpDir, 'clone')
-    await simpleGit().clone(remotePath, clonePath)
-    const cloneFiles = await fs.readdir(clonePath)
-    expect(cloneFiles).toContain('main.txt')
-    expect(cloneFiles).not.toContain('feature.txt')
-  })
-})
-
-describe('GitManager.resolveRemoteUrl', () => {
-  let tmpDir: string
-  let originalEnv: string | undefined
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'canopy-resolve-test-'))
-    originalEnv = process.env.CANOPYCMS_REMOTE_URL
-    delete process.env.CANOPYCMS_REMOTE_URL
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-    if (originalEnv !== undefined) {
-      process.env.CANOPYCMS_REMOTE_URL = originalEnv
-    } else {
-      delete process.env.CANOPYCMS_REMOTE_URL
-    }
-  })
-
-  it('returns explicit remoteUrl when provided (highest priority)', async () => {
-    const result = await GitManager.resolveRemoteUrl({
-      mode: 'prod-sim',
-      remoteUrl: 'https://explicit.com/repo.git',
-      defaultRemoteUrl: 'https://default.com/repo.git',
-      baseBranch: 'main',
-    })
-
-    expect(result).toBe('https://explicit.com/repo.git')
-  })
-
-  it('returns defaultRemoteUrl when no explicit url', async () => {
-    const result = await GitManager.resolveRemoteUrl({
-      mode: 'prod-sim',
-      defaultRemoteUrl: 'https://default.com/repo.git',
-      baseBranch: 'main',
-    })
-
-    expect(result).toBe('https://default.com/repo.git')
-  })
-
-  it('returns env var CANOPYCMS_REMOTE_URL when no config', async () => {
-    process.env.CANOPYCMS_REMOTE_URL = 'https://env.com/repo.git'
-
-    const result = await GitManager.resolveRemoteUrl({
-      mode: 'prod-sim',
-      baseBranch: 'main',
-    })
-
-    expect(result).toBe('https://env.com/repo.git')
-  })
-
-  it('auto-initializes and returns local remote path for prod-sim', async () => {
-    // Setup: create git repo in tmpDir with commit
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'test.txt'), 'hello', 'utf8')
-    await git.add(['.'])
-    await git.commit('initial commit')
-
-    // Get the real git root path (handles symlinks on macOS)
-    const gitRootResult = await git.raw(['rev-parse', '--show-toplevel'])
-    const gitRoot = gitRootResult.trim()
-
-    // Mock process.cwd() to return tmpDir
-    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-
-    try {
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod-sim',
-        baseBranch: 'main',
-      })
-
-      expect(result).toBe(path.join(gitRoot, '.canopy-prod-sim/remote.git'))
-
-      // Verify remote was created
-      const remoteStat = await fs.stat(path.join(gitRoot, '.canopy-prod-sim/remote.git'))
-      expect(remoteStat.isDirectory()).toBe(true)
-    } finally {
-      cwdSpy.mockRestore()
-    }
-  })
-
-  it('returns undefined for dev mode', async () => {
-    const result = await GitManager.resolveRemoteUrl({
-      mode: 'dev',
-      baseBranch: 'main',
-    })
-
-    expect(result).toBeUndefined()
-  })
-
-  it('skips auto-init when explicit remoteUrl provided', async () => {
-    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-
-    try {
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod-sim',
-        remoteUrl: 'https://explicit.com/repo.git',
-        baseBranch: 'main',
-      })
-
-      expect(result).toBe('https://explicit.com/repo.git')
-
-      // Verify no local remote was created
-      await expect(fs.stat(path.join(tmpDir, '.canopycms/remote.git'))).rejects.toThrow()
-    } finally {
-      cwdSpy.mockRestore()
-    }
-  })
-
-  it('uses sourceRoot when provided for prod-sim', async () => {
-    // Setup: create git repo with subdirectory structure
-    const git = await initTestRepo(tmpDir)
-    await git.raw(['branch', '-M', 'main'])
-
-    // Create subdirectory with content
-    const subdir = path.join(tmpDir, 'packages/example')
-    await fs.mkdir(subdir, { recursive: true })
-    await fs.writeFile(path.join(subdir, 'test.txt'), 'hello', 'utf8')
-    await git.add(['.'])
-    await git.commit('initial commit')
-
-    // Get the real git root path (handles symlinks on macOS)
-    const gitRootResult = await git.raw(['rev-parse', '--show-toplevel'])
-    const gitRoot = gitRootResult.trim()
-
-    // Mock process.cwd() to return tmpDir (git root)
-    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(tmpDir)
-
-    try {
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod-sim',
-        baseBranch: 'main',
-        sourceRoot: 'packages/example',
-      })
-
-      // Should resolve to the subdirectory (using real git root path)
-      expect(result).toBe(path.join(gitRoot, 'packages/example/.canopy-prod-sim/remote.git'))
-
-      // Verify remote was created in the subdirectory
-      const actualSubdir = path.join(gitRoot, 'packages/example')
-      const remoteStat = await fs.stat(path.join(actualSubdir, '.canopy-prod-sim/remote.git'))
-      expect(remoteStat.isDirectory()).toBe(true)
-
-      // Verify remote contains main branch
-      const remoteGit = simpleGit({
-        baseDir: path.join(actualSubdir, '.canopy-prod-sim/remote.git'),
-      })
-      const branches = await remoteGit.branch()
-      expect(branches.all).toContain('main')
-
-      // Clone and verify only subdirectory content was pushed (via git subtree)
-      const clonePath = path.join(tmpDir, 'clone-test')
-      await simpleGit().clone(path.join(actualSubdir, '.canopy-prod-sim/remote.git'), clonePath)
-      const cloneFiles = await fs.readdir(clonePath)
-      expect(cloneFiles).toContain('test.txt')
-      // Should NOT contain packages/ dir since we used git subtree split
-      expect(cloneFiles).not.toContain('packages')
-    } finally {
-      cwdSpy.mockRestore()
-    }
-  })
-  it('auto-detects remote.git at workspace root in prod mode', async () => {
-    // Setup: create a bare repo at the expected workspace path
-    const workspaceRoot = path.join(tmpDir, 'workspace')
-    const remoteGitPath = path.join(workspaceRoot, 'remote.git')
-    await fs.mkdir(workspaceRoot, { recursive: true })
-    const bareGit = simpleGit()
-    await bareGit
-      .clone(tmpDir, remoteGitPath, ['--bare']) // needs a source, use tmpDir as dummy
-      .catch(async () => {
-        // If tmpDir isn't a repo, just init a bare repo directly
-        await fs.mkdir(remoteGitPath, { recursive: true })
-        await simpleGit({ baseDir: remoteGitPath }).init(true)
-      })
-
-    // Point CANOPYCMS_WORKSPACE_ROOT to our test workspace
-    const origWorkspace = process.env.CANOPYCMS_WORKSPACE_ROOT
-    process.env.CANOPYCMS_WORKSPACE_ROOT = workspaceRoot
-
-    try {
-      // Clear strategy cache so it picks up new env var
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod',
-        baseBranch: 'main',
-      })
-
-      expect(result).toBe(remoteGitPath)
-    } finally {
-      if (origWorkspace !== undefined) {
-        process.env.CANOPYCMS_WORKSPACE_ROOT = origWorkspace
-      } else {
-        delete process.env.CANOPYCMS_WORKSPACE_ROOT
-      }
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-    }
-  })
-
-  it('returns undefined for prod mode when remote.git does not exist', async () => {
-    // Point CANOPYCMS_WORKSPACE_ROOT to a directory without remote.git
-    const workspaceRoot = path.join(tmpDir, 'empty-workspace')
-    await fs.mkdir(workspaceRoot, { recursive: true })
-
-    const origWorkspace = process.env.CANOPYCMS_WORKSPACE_ROOT
-    process.env.CANOPYCMS_WORKSPACE_ROOT = workspaceRoot
-
-    try {
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod',
-        baseBranch: 'main',
-      })
-
-      expect(result).toBeUndefined()
-    } finally {
-      if (origWorkspace !== undefined) {
-        process.env.CANOPYCMS_WORKSPACE_ROOT = origWorkspace
-      } else {
-        delete process.env.CANOPYCMS_WORKSPACE_ROOT
-      }
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-    }
-  })
-
-  it('explicit remoteUrl takes priority over auto-detected remote.git in prod mode', async () => {
-    // Setup: create remote.git at workspace root
-    const workspaceRoot = path.join(tmpDir, 'workspace')
-    const remoteGitPath = path.join(workspaceRoot, 'remote.git')
-    await fs.mkdir(remoteGitPath, { recursive: true })
-    await simpleGit({ baseDir: remoteGitPath }).init(true)
-
-    const origWorkspace = process.env.CANOPYCMS_WORKSPACE_ROOT
-    process.env.CANOPYCMS_WORKSPACE_ROOT = workspaceRoot
-
-    try {
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod',
-        remoteUrl: 'https://explicit.com/repo.git',
-        baseBranch: 'main',
-      })
-
-      // Explicit URL should win over auto-detected path
-      expect(result).toBe('https://explicit.com/repo.git')
-    } finally {
-      if (origWorkspace !== undefined) {
-        process.env.CANOPYCMS_WORKSPACE_ROOT = origWorkspace
-      } else {
-        delete process.env.CANOPYCMS_WORKSPACE_ROOT
-      }
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-    }
-  })
-
-  it('env var CANOPYCMS_REMOTE_URL takes priority over auto-detected remote.git', async () => {
-    // Setup: create remote.git at workspace root
-    const workspaceRoot = path.join(tmpDir, 'workspace')
-    const remoteGitPath = path.join(workspaceRoot, 'remote.git')
-    await fs.mkdir(remoteGitPath, { recursive: true })
-    await simpleGit({ baseDir: remoteGitPath }).init(true)
-
-    const origWorkspace = process.env.CANOPYCMS_WORKSPACE_ROOT
-    process.env.CANOPYCMS_WORKSPACE_ROOT = workspaceRoot
-    process.env.CANOPYCMS_REMOTE_URL = 'https://env.com/repo.git'
-
-    try {
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-
-      const result = await GitManager.resolveRemoteUrl({
-        mode: 'prod',
-        baseBranch: 'main',
-      })
-
-      // Env var should win over auto-detected path
-      expect(result).toBe('https://env.com/repo.git')
-    } finally {
-      if (origWorkspace !== undefined) {
-        process.env.CANOPYCMS_WORKSPACE_ROOT = origWorkspace
-      } else {
-        delete process.env.CANOPYCMS_WORKSPACE_ROOT
-      }
-      const { clearStrategyCache } = await import('./operating-mode/client-unsafe-strategy')
-      clearStrategyCache()
-    }
-  })
-}, 10000)
-
-describe('GitManager.ensureAuthor', () => {
-  let tmpDir: string
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'canopy-git-test-'))
-  })
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true })
-  })
-
-  it('allows setting author in managed repository', async () => {
-    // Setup: create managed repo
-    const git = await initTestRepo(tmpDir)
-    await git.raw(['branch', '-M', 'main'])
-    await fs.writeFile(path.join(tmpDir, 'test.txt'), 'content', 'utf8')
-    await git.add(['.'])
-    await git.commit('Initial commit')
-
-    // Create GitManager and ensure author
-    const manager = new GitManager({ repoPath: tmpDir })
-    await expect(
-      manager.ensureAuthor({ name: 'Bot User', email: 'bot@example.com' }),
-    ).resolves.not.toThrow()
-
-    // Verify author was set
-    const config = await git.listConfig()
-    expect(config.all['user.name']).toBe('Bot User')
-    expect(config.all['user.email']).toBe('bot@example.com')
-  })
-
-  it('throws error when trying to set author in non-managed repository', async () => {
-    // Setup: create repo WITHOUT canopycms.managed marker
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-    await git.addConfig('user.name', 'Regular User')
-    await git.addConfig('user.email', 'user@example.com')
-
-    // Create GitManager and try to ensure author - should fail
-    const manager = new GitManager({ repoPath: tmpDir })
-    await expect(
-      manager.ensureAuthor({ name: 'Bot User', email: 'bot@example.com' }),
-    ).rejects.toThrow(/Cannot set git bot author in non-managed repository/)
-
-    // Verify author was NOT changed
-    const config = await git.listConfig()
-    expect(config.all['user.name']).toBe('Regular User')
-    expect(config.all['user.email']).toBe('user@example.com')
-  })
-
-  it('provides helpful error message for non-managed repos', async () => {
-    const git = simpleGit({ baseDir: tmpDir })
-    await git.init()
-
-    const manager = new GitManager({ repoPath: tmpDir })
-    await expect(manager.ensureAuthor({ name: 'Bot', email: 'bot@test.com' })).rejects.toThrow(
-      /Bot identity should only be set in CanopyCMS branch clones/,
-    )
-    await expect(manager.ensureAuthor({ name: 'Bot', email: 'bot@test.com' })).rejects.toThrow(
-      /If this is a test workspace, add "git config canopycms.managed true"/,
-    )
-  })
-
-  it('only updates author if values differ', async () => {
-    // Setup: managed repo with existing author
-    await initTestRepo(tmpDir)
-
-    const manager = new GitManager({ repoPath: tmpDir })
-    // Spy on the manager's internal git instance
-    const addConfigSpy = vi.spyOn(manager['git'], 'addConfig')
-
-    // First call: should update (values differ from Test Bot / test@canopycms.test)
-    await manager.ensureAuthor({ name: 'New Name', email: 'new@example.com' })
-    expect(addConfigSpy).toHaveBeenCalledWith('user.name', 'New Name')
-    expect(addConfigSpy).toHaveBeenCalledWith('user.email', 'new@example.com')
-
-    addConfigSpy.mockClear()
-
-    // Second call with same values: should NOT update
-    await manager.ensureAuthor({ name: 'New Name', email: 'new@example.com' })
-    expect(addConfigSpy).not.toHaveBeenCalled()
-  })
-})