shadow-git 0.1.0 → 1.0.3

package/tests/core/repository.test.ts

@@ -1,9 +1,13 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { findRoot, validateShadowRepo } from '../../src/core/repository';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { findRoot, validateShadowRepo, validateGitIdentity } from '../../src/core/repository';
 import { createTempGitRepo, removeTempDir } from '../helpers';
 
+const execFileAsync = promisify(execFile);
+
 describe('findRoot', () => {
   let tempDir: string;
   const originalCwd = process.cwd();
@@ -18,15 +22,15 @@ describe('findRoot', () => {
     await removeTempDir(tempDir);
   });
 
-  it('returns the git root directory', async () => {
+  it('returns cwd when .git exists', async () => {
     expect(await findRoot()).toBe(tempDir);
   });
 
-  it('works from a subdirectory', async () => {
+  it('does not traverse up to parent git repo', async () => {
     const subdir = join(tempDir, 'subdir');
     await mkdir(subdir);
     process.chdir(subdir);
-    expect(await findRoot()).toBe(tempDir);
+    await expect(findRoot()).rejects.toThrow('no .git in current directory');
   });
 
   it('throws outside a git repo', async () => {
@@ -35,12 +39,42 @@ describe('findRoot', () => {
     const raw = await mkdtemp(join(tmpdir(), 'sgit-test-nogit-'));
     const nonGitDir = await realpath(raw);
     process.chdir(nonGitDir);
-    await expect(findRoot()).rejects.toThrow();
+    await expect(findRoot()).rejects.toThrow('no .git in current directory');
     process.chdir(tempDir);
     await rm(nonGitDir, { recursive: true });
   });
 });
 
+describe('validateGitIdentity', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    tempDir = await createTempGitRepo();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await removeTempDir(tempDir);
+  });
+
+  it('passes when user.name and user.email are configured', async () => {
+    await expect(validateGitIdentity(tempDir)).resolves.toBeUndefined();
+  });
+
+  it('throws when user.name is missing', async () => {
+    await execFileAsync('git', ['-C', tempDir, 'config', '--unset', 'user.name']);
+    // Also unset global to ensure test isolation
+    await expect(validateGitIdentity(tempDir)).rejects.toThrow('git user identity not configured');
+  });
+
+  it('throws when user.email is missing', async () => {
+    await execFileAsync('git', ['-C', tempDir, 'config', '--unset', 'user.email']);
+    await expect(validateGitIdentity(tempDir)).rejects.toThrow('git user identity not configured');
+  });
+});
+
 describe('validateShadowRepo', () => {
   let tempDir: string;
   const originalCwd = process.cwd();

package/tests/helpers/guard-child.mjs

@@ -0,0 +1,125 @@
+/**
+ * Child process helper for testing gitignore guard cleanup.
+ *
+ * Usage: node tests/helpers/guard-child.mjs <root> <exitMode>
+ *
+ * This script directly implements the guard's cleanup mechanism using plain
+ * node:fs so it can run without TypeScript transpilation. It renames
+ * .gitignore → .gitignore-sgit.bat, registers signal/exit handlers, then
+ * exits in the specified way.
+ */
+import {
+  readdirSync,
+  renameSync,
+  existsSync,
+  writeFileSync,
+  unlinkSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const [,, root, exitMode] = process.argv;
+const manifestPaths = ['secret/'];
+const DISABLED_NAME = '.gitignore-sgit.bat';
+
+// --- Minimal guard implementation (mirrors src/core/gitignore.ts) ---
+
+function walkSync(dir, targetName, results) {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries) {
+    if (entry.isDirectory() && (entry.name === '.git' || entry.name === '.sgit')) continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) walkSync(fullPath, targetName, results);
+    else if (entry.name === targetName) results.push(fullPath);
+  }
+}
+
+function findInTrackedDirs(targetName) {
+  const results = [];
+  for (const mPath of manifestPaths) {
+    if (!mPath.endsWith('/')) continue;
+    const dirAbs = join(root, mPath);
+    if (!existsSync(dirAbs)) continue;
+    walkSync(dirAbs, targetName, results);
+  }
+  return results;
+}
+
+function enableGitignores() {
+  const disabled = findInTrackedDirs(DISABLED_NAME);
+  for (const absPath of disabled) {
+    const restoredPath = absPath.substring(0, absPath.length - DISABLED_NAME.length) + '.gitignore';
+    renameSync(absPath, restoredPath);
+  }
+}
+
+// Disable gitignores
+const gitignores = findInTrackedDirs('.gitignore');
+for (const absPath of gitignores) {
+  const dir = absPath.substring(0, absPath.length - '.gitignore'.length);
+  renameSync(absPath, dir + DISABLED_NAME);
+}
+
+// Write lock
+const lockPath = join(root, '.sgit', '.gitignore-guard');
+try { writeFileSync(lockPath, String(process.pid)); } catch {}
+
+// Register cleanup handlers
+let cleaned = false;
+const cleanup = () => {
+  if (cleaned) return;
+  cleaned = true;
+  try { enableGitignores(); } catch {}
+  try { unlinkSync(lockPath); } catch {}
+};
+
+process.on('SIGINT', () => { cleanup(); process.exit(130); });
+process.on('SIGTERM', () => { cleanup(); process.exit(143); });
+process.on('exit', cleanup);
+
+// Now exit in the specified way
+switch (exitMode) {
+  case 'success':
+    // Normal cleanup then exit
+    cleanup();
+    process.exit(0);
+    break;
+
+  case 'throw':
+    // Uncaught exception — 'exit' handler should fire
+    throw new Error('simulated crash');
+
+  case 'exit1':
+    // process.exit(1) — 'exit' handler should fire
+    process.exit(1);
+    break;
+
+  case 'sigint':
+    // Send SIGINT to self
+    process.kill(process.pid, 'SIGINT');
+    break;
+
+  case 'sigterm':
+    // Send SIGTERM to self
+    process.kill(process.pid, 'SIGTERM');
+    break;
+
+  case 'timeout':
+    // Hang until killed externally
+    setTimeout(() => {}, 60000);
+    break;
+
+  case 'git-error':
+    // Simulate a git command that fails, then exit with error
+    spawnSync('git', ['--git-dir=/nonexistent', 'status'], { stdio: 'ignore' });
+    process.exit(1);
+    break;
+
+  case 'sgit-error':
+    // Simulate an error being thrown
+    throw new Error('simulated sgit error');
+
+  default:
+    process.exit(2);
+}

package/tests/helpers.ts

@@ -19,3 +19,40 @@ export async function createTempGitRepo(): Promise<string> {
 export async function removeTempDir(dir: string): Promise<void> {
   await rm(dir, { recursive: true, force: true });
 }
+
+export async function createBareRemoteRepo(
+  files: Record<string, string>,
+): Promise<string> {
+  // Create a temporary normal repo with content
+  const workRaw = await mkdtemp(join(tmpdir(), 'sgit-remote-work-'));
+  const workDir = await realpath(workRaw);
+  await execFileAsync('git', ['init'], { cwd: workDir });
+  await execFileAsync('git', ['-C', workDir, 'config', 'user.email', 'test@test.com']);
+  await execFileAsync('git', ['-C', workDir, 'config', 'user.name', 'Test']);
+
+  // Write .sgit.json manifest (file keys as paths)
+  const paths = Object.keys(files);
+  const { writeFile, mkdir: mkdirFs } = await import('node:fs/promises');
+  await writeFile(join(workDir, '.sgit.json'), JSON.stringify({ paths }, null, 2) + '\n');
+
+  // Write all files
+  for (const [filePath, content] of Object.entries(files)) {
+    const dir = join(workDir, filePath, '..');
+    await mkdirFs(dir, { recursive: true });
+    await writeFile(join(workDir, filePath), content);
+  }
+
+  await execFileAsync('git', ['add', '-A'], { cwd: workDir });
+  await execFileAsync('git', ['commit', '-m', 'initial'], { cwd: workDir });
+
+  // Create bare clone
+  const bareRaw = await mkdtemp(join(tmpdir(), 'sgit-remote-bare-'));
+  const bareDir = await realpath(bareRaw);
+  await rm(bareDir, { recursive: true }); // git clone --bare needs empty target
+  await execFileAsync('git', ['clone', '--bare', workDir, bareDir]);
+
+  // Clean up work dir
+  await rm(workDir, { recursive: true });
+
+  return bareDir;
+}