gitforest 0.1.0 → 1.0.0

package/test/integration/cli-validation.test.ts

@@ -1,264 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { $ } from "bun";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-import { mkdirSync, writeFileSync, unlinkSync, existsSync } from "fs";
-
-describe("CLI Argument Validation", () => {
-  // Use absolute path for mainPath
-  const mainPath = resolve(import.meta.dir, "../../src/index.tsx");
-  let testConfigPath: string;
-
-  beforeAll(async () => {
-    // Create a temporary test config directory
-    const testDir = join(tmpdir(), `gitforest-validation-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    // Create gitforest subdirectory for XDG config
-    const gitforestConfigDir = join(testDir, "gitforest");
-    mkdirSync(gitforestConfigDir, { recursive: true });
-
-    // Create a test config file in XDG config location
-    testConfigPath = join(gitforestConfigDir, "config.yaml");
-    writeFileSync(testConfigPath, `
-directories:
-  - path: ${testDir}
-    maxDepth: 1
-display:
-  sortBy: name
-  sortDirection: asc
-`);
-
-    // Set environment variables for testing
-    process.env.GITTY_IGNORE_GH = "true";
-    // Set config to our test config
-    process.env.XDG_CONFIG_HOME = testDir;
-  });
-
-  afterAll(() => {
-    // Cleanup
-    delete process.env.GITTY_IGNORE_GH;
-    delete process.env.XDG_CONFIG_HOME;
-
-    // Clean up test config file
-    if (testConfigPath && existsSync(testConfigPath)) {
-      unlinkSync(testConfigPath);
-    }
-  });
-
-  describe("unknown flags", () => {
-    test("rejects unknown long flags", async () => {
-      const result = await $`bun ${mainPath} list --unknown-flag`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Unknown flag: --unknown-flag");
-    });
-
-    test("rejects unknown short flags", async () => {
-      const result = await $`bun ${mainPath} list -x`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Unknown flag: -x");
-    });
-  });
-
-  describe("flag values", () => {
-    test("requires value for --filter flag", async () => {
-      const result = await $`bun ${mainPath} list --filter`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Flag --filter requires a value");
-    });
-
-    test("requires value for -f flag", async () => {
-      const result = await $`bun ${mainPath} list -f`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Flag -f requires a value");
-    });
-
-    test("requires value for --target flag", async () => {
-      const result = await $`bun ${mainPath} clone --target`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Flag --target requires a value");
-    });
-
-    test("requires value for -t flag", async () => {
-      const result = await $`bun ${mainPath} clone -t`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Flag -t requires a value");
-    });
-  });
-
-  describe("multiple errors", () => {
-    test("reports multiple unknown flags", async () => {
-      const result = await $`bun ${mainPath} list --unknown1 --unknown2`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Unknown flag: --unknown1");
-      expect(stderr).toContain("Error: Unknown flag: --unknown2");
-    });
-
-    test("reports multiple missing values", async () => {
-      const result = await $`bun ${mainPath} list --filter --target foo`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Flag --filter requires a value");
-    });
-  });
-
-  describe("flag combinations", () => {
-    test("rejects mixed valid and invalid flags", async () => {
-      const result = await $`bun ${mainPath} list --json --invalid-flag`.quiet().nothrow();
-      const stderr = result.stderr.toString();
-
-      expect(result.exitCode).toBe(1);
-      expect(stderr).toContain("Error: Unknown flag: --invalid-flag");
-    });
-  });
-
-  describe("help text", () => {
-    test("shows help for list command", async () => {
-      const result = await $`bun ${mainPath} list --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("list");
-    });
-
-    test("shows help for status command", async () => {
-      const result = await $`bun ${mainPath} status --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("status");
-    });
-
-    test("shows help for pull command", async () => {
-      const result = await $`bun ${mainPath} pull --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("pull");
-    });
-
-    test("shows help for push command", async () => {
-      const result = await $`bun ${mainPath} push --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("push");
-    });
-
-    test("shows help for fetch command", async () => {
-      const result = await $`bun ${mainPath} fetch --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("fetch");
-    });
-
-    test("shows help for dirty command", async () => {
-      const result = await $`bun ${mainPath} dirty --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("dirty");
-    });
-
-    test("shows help for init command", async () => {
-      const result = await $`bun ${mainPath} init --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("init");
-    });
-
-    test("shows help for clone command", async () => {
-      const result = await $`bun ${mainPath} clone --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("clone");
-    });
-
-    test("shows help for create command", async () => {
-      const result = await $`bun ${mainPath} create --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("create");
-    });
-
-    test("shows help for archive command", async () => {
-      const result = await $`bun ${mainPath} archive --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("archive");
-    });
-
-    test("shows help for auth command", async () => {
-      const result = await $`bun ${mainPath} auth --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("auth");
-    });
-
-    test("shows help for setup command", async () => {
-      const result = await $`bun ${mainPath} setup --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("setup");
-    });
-
-    test("shows help for github command", async () => {
-      const result = await $`bun ${mainPath} github --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("github");
-    });
-
-    test("shows help for unified-status command", async () => {
-      const result = await $`bun ${mainPath} unified-status --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("unified-status");
-    });
-  });
-
-  describe("error messages", () => {
-    test("shows appropriate error for invalid view mode", async () => {
-      // The github command should run without crashing
-      // It may show errors about no GitHub token or no repos, but shouldn't crash
-      const result = await $`bun ${mainPath} github --local`.quiet().nothrow();
-      const output = result.stdout.toString() + result.stderr.toString();
-
-      // Should produce some output (even if it's an error message)
-      expect(output.length).toBeGreaterThan(0);
-    });
-
-    test("shows appropriate error for missing GITHUB_TOKEN", async () => {
-      // Clear any existing token
-      const result = await $`bash -c 'GITHUB_TOKEN= bun ${mainPath} auth'`.quiet().nothrow();
-      const stdout = result.stdout.toString() + result.stderr.toString();
-
-      // Should show some kind of auth status
-      expect(stdout.length).toBeGreaterThan(0);
-    });
-  });
-});

package/test/integration/git-operations.test.ts

@@ -1,218 +0,0 @@
-/**
- * Integration tests for git operations
- * Tests actual git commands with real repositories
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { $ } from "bun";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-} from "../unit/fixtures/setup.ts";
-import {
-  pullProject,
-  pushProject,
-  fetchProject,
-  initGitInProject,
-} from "../../src/git/operations.ts";
-import { getGitStatus } from "../../src/git/status.ts";
-import { isGitRepo, getCurrentBranch } from "../../src/git/commands.ts";
-import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-
-describe("Git Operations Integration", () => {
-  let tempDir: string;
-  const testTimeout = 30000; // 30 second timeout for git operations
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-ops-integration");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  describe("initGitInProject", () => {
-    test("initializes git in non-git directory", async () => {
-      const projectPath = join(tempDir, "new-project");
-      mkdirSync(projectPath, { recursive: true });
-      writeFileSync(join(projectPath, "package.json"), "{}");
-
-      // Verify it's not a git repo
-      expect(await isGitRepo(projectPath)).toBe(false);
-
-      // Initialize git
-      const result = await initGitInProject(projectPath);
-
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("init");
-      expect(await isGitRepo(projectPath)).toBe(true);
-    }, { timeout: 15000 });
-
-    test("returns operation result with duration", async () => {
-      const projectPath = join(tempDir, "timed-project");
-      mkdirSync(projectPath, { recursive: true });
-
-      const result = await initGitInProject(projectPath);
-
-      expect(result.duration).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    }, { timeout: 15000 });
-  });
-
-  describe("getGitStatus", () => {
-    test("returns clean status for clean repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "clean-repo");
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.isDirty).toBe(false);
-      expect(status.hasUnstagedChanges).toBe(false);
-      expect(status.hasStagedChanges).toBe(false);
-      expect(status.hasUntrackedFiles).toBe(false);
-    });
-
-    test("detects modified files", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "modified-repo", {
-        withChanges: true,
-      });
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.isDirty).toBe(true);
-      expect(status.hasUnstagedChanges).toBe(true);
-      expect(status.modifiedCount).toBeGreaterThan(0);
-    });
-
-    test("detects untracked files", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "untracked-repo", {
-        withUntracked: true,
-      });
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.hasUntrackedFiles).toBe(true);
-      expect(status.untrackedCount).toBeGreaterThan(0);
-    });
-
-    test("detects staged changes", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "staged-repo", {
-        withStaged: true,
-      });
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.hasStagedChanges).toBe(true);
-      expect(status.stagedCount).toBeGreaterThan(0);
-    });
-
-    test("returns current branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "branch-repo");
-
-      const status = await getGitStatus(repoPath);
-
-      // Default branch is usually main or master
-      expect(["main", "master"]).toContain(status.currentBranch);
-    });
-
-    test("detects no remote", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-repo");
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.hasRemote).toBe(false);
-      expect(status.remoteUrl).toBeNull();
-    });
-
-    test("includes last commit date", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "dated-repo");
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.lastLocalCommit).toBeDefined();
-      expect(status.lastLocalCommit).toBeInstanceOf(Date);
-    });
-
-    test("hasCommits is true for repo with commits", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "repo-with-commits");
-
-      const status = await getGitStatus(repoPath);
-
-      expect(status.hasCommits).toBe(true);
-    });
-  });
-
-  describe("getCurrentBranch", () => {
-    test("returns branch name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "branch-test");
-
-      const branch = await getCurrentBranch(repoPath);
-
-      expect(["main", "master"]).toContain(branch);
-    });
-
-    test("returns new branch name after checkout", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "checkout-test");
-
-      // Create and checkout new branch
-      await $`git -C ${repoPath} checkout -b feature-branch`.quiet();
-
-      const branch = await getCurrentBranch(repoPath);
-
-      expect(branch).toBe("feature-branch");
-    });
-  });
-
-  describe("fetchProject", () => {
-    test("returns operation result", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "fetch-test");
-
-      const result = await fetchProject(repoPath);
-
-      // fetch --all succeeds even without remotes (just does nothing)
-      expect(result.operation).toBe("fetch-all");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("pullProject", () => {
-    test("returns operation result with correct metadata", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "pull-test");
-
-      const result = await pullProject(repoPath);
-
-      expect(result.operation).toBe("pull");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("pushProject", () => {
-    test("returns operation result with correct metadata", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-test");
-
-      const result = await pushProject(repoPath);
-
-      expect(result.operation).toBe("push");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("commit counting", () => {
-    test("counts commits correctly", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "commit-count", {
-        commitCount: 5,
-      });
-
-      // Verify we have multiple commits
-      const result = await $`git -C ${repoPath} rev-list --count HEAD`.quiet().text();
-      const commitCount = parseInt(result.trim(), 10);
-
-      // Initial commit + 5 additional = 6
-      expect(commitCount).toBe(6);
-    });
-  });
-});