gitforest 0.1.0 → 1.0.0

package/test/unit/db/index.test.ts

@@ -1,314 +0,0 @@
-/**
- * Tests for database module functions
- * Tests the actual exported functions from src/db/index.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { join } from "path";
-import { existsSync, rmSync } from "fs";
-import { eq } from "drizzle-orm";
-import * as dbModule from "../../../src/db/index.ts";
-
-describe("Database Module Functions", () => {
-  let originalEnv: Record<string, string | undefined>;
-  let tempDir: string;
-
-  beforeEach(() => {
-    // Save original environment
-    originalEnv = { ...process.env };
-    
-    // Create a temporary directory for test databases
-    tempDir = `/tmp/gitforest-test-${Date.now()}`;
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = originalEnv;
-    
-    // Clean up temp directory
-    if (existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    
-    // Close any open database connections
-    try {
-      dbModule.closeDb();
-    } catch {
-      // Ignore errors during cleanup
-    }
-  });
-
-  describe("getDbPath", () => {
-    test("returns correct path with XDG_DATA_HOME set", () => {
-      process.env.XDG_DATA_HOME = "/custom/data/home";
-      
-      const result = dbModule.getDbPath();
-      
-      expect(result).toBe(join("/custom/data/home", "gitforest", "cache.db"));
-    });
-
-    test("returns default path without XDG_DATA_HOME", () => {
-      // Remove XDG_DATA_HOME if it exists
-      delete process.env.XDG_DATA_HOME;
-      
-      const result = dbModule.getDbPath();
-      
-      // Should use homedir() + .local/share/gitforest/cache.db
-      expect(result).toContain(".local");
-      expect(result).toContain("share");
-      expect(result).toContain("gitforest");
-      expect(result).toContain("cache.db");
-    });
-
-    test("constructs path correctly on different platforms", () => {
-      // This test verifies the path construction logic
-      // The actual homedir() value depends on the test environment
-      delete process.env.XDG_DATA_HOME;
-      
-      const result = dbModule.getDbPath();
-      
-      expect(result).toMatch(/.*gitforest.*cache\.db$/);
-      expect(result).not.toContain("undefined");
-    });
-  });
-
-  describe("initDb", () => {
-    test("creates database file and directory", async () => {
-      // Set a custom temp directory for the database
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      expect(db).toBeDefined();
-      
-      // Verify database file was created
-      const dbPath = dbModule.getDbPath();
-      expect(existsSync(dbPath)).toBe(true);
-      
-      // Verify directory was created
-      const dbDir = join(dbPath, "..");
-      expect(existsSync(dbDir)).toBe(true);
-    });
-
-    test("enables WAL mode", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      
-      // WAL mode is enabled via PRAGMA, we can't easily test it directly
-      // but we can verify the database was created successfully
-      const dbPath = dbModule.getDbPath();
-      expect(existsSync(dbPath)).toBe(true);
-    });
-
-    test("creates all required tables", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      // Try to query each table to verify they exist
-      const tables = [
-        "projects",
-        "remote_status",
-        "github_repos",
-        "config_cache"
-      ];
-      
-      for (const table of tables) {
-        // This should not throw if table exists
-        const result = db.run(`SELECT 1 FROM ${table} LIMIT 1`);
-        expect(result).toBeDefined();
-      }
-    });
-
-    test("returns same instance on repeated calls (singleton)", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db1 = await dbModule.initDb();
-      const db2 = await dbModule.initDb();
-      
-      expect(db1).toBe(db2);
-    });
-
-    test("handles directory creation errors", async () => {
-      // Create a file where we want to create a directory
-      const conflictingPath = join(tempDir, "gitforest");
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      // Create a file with the same name as the directory we want
-      await Bun.write(conflictingPath, "conflict");
-      
-      // This should throw an error because mkdir -p will fail
-      await expect(dbModule.initDb()).rejects.toThrow();
-    });
-  });
-
-  describe("closeDb", () => {
-    test("closes database connection", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      dbModule.closeDb();
-      
-      // After closing, getDb() should throw an error
-      expect(() => dbModule.getDb()).toThrow("Database not initialized");
-    });
-
-    test("resets db and sqliteDb to null", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      dbModule.closeDb();
-      
-      // Initialize again to verify it works after closing
-      const db = await dbModule.initDb();
-      expect(db).toBeDefined();
-    });
-
-    test("handles already closed database gracefully", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      dbModule.closeDb();
-      
-      // Calling closeDb again should not throw
-      expect(() => dbModule.closeDb()).not.toThrow();
-    });
-  });
-
-  describe("getDb", () => {
-    test("throws error when database not initialized", () => {
-      expect(() => dbModule.getDb()).toThrow("Database not initialized. Call initDb() first.");
-    });
-
-    test("returns database instance after initDb", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      const db = dbModule.getDb();
-      
-      expect(db).toBeDefined();
-      expect(typeof db.select).toBe("function");
-      expect(typeof db.insert).toBe("function");
-      expect(typeof db.update).toBe("function");
-      expect(typeof db.delete).toBe("function");
-    });
-
-    test("returns same instance on multiple calls", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      await dbModule.initDb();
-      const db1 = dbModule.getDb();
-      const db2 = dbModule.getDb();
-      
-      expect(db1).toBe(db2);
-    });
-  });
-
-  describe("clearCache", () => {
-    test("deletes all projects", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      // Insert some test data
-      await db.insert(dbModule.schema.projects).values([
-        { id: "test-1", name: "Test 1", path: "/test/1", type: "git" },
-        { id: "test-2", name: "Test 2", path: "/test/2", type: "git" },
-      ]).run();
-      
-      // Verify data exists
-      let projects = await db.select().from(dbModule.schema.projects).all();
-      expect(projects).toHaveLength(2);
-      
-      // Clear cache
-      await dbModule.clearCache();
-      
-      // Verify projects are deleted
-      projects = await db.select().from(dbModule.schema.projects).all();
-      expect(projects).toHaveLength(0);
-    });
-
-    test("deletes all remoteStatus entries", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      // Insert a project first (foreign key constraint)
-      await db.insert(dbModule.schema.projects).values({
-        id: "test-1",
-        name: "Test 1",
-        path: "/test/1",
-        type: "git",
-      }).run();
-      
-      // Insert remote status
-      await db.insert(dbModule.schema.remoteStatus).values({
-        projectId: "test-1",
-        unpulledCommits: 5,
-      }).run();
-      
-      // Verify data exists
-      let remoteStatus = await db.select().from(dbModule.schema.remoteStatus).all();
-      expect(remoteStatus).toHaveLength(1);
-      
-      // Clear cache
-      await dbModule.clearCache();
-      
-      // Verify remote status is deleted
-      remoteStatus = await db.select().from(dbModule.schema.remoteStatus).all();
-      expect(remoteStatus).toHaveLength(0);
-    });
-
-    test("clears cache successfully", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      // Insert some test data
-      await db.insert(dbModule.schema.projects).values({
-        id: "clear-test",
-        name: "Clear Test",
-        path: "/clear/test",
-        type: "git",
-      }).run();
-      
-      // Verify data exists
-      let projects = await db.select().from(dbModule.schema.projects).all();
-      expect(projects).toHaveLength(1);
-      
-      // Clear cache
-      await dbModule.clearCache();
-      
-      // Verify projects are deleted
-      projects = await db.select().from(dbModule.schema.projects).all();
-      expect(projects).toHaveLength(0);
-    });
-  });
-
-  describe("Integration with existing schema tests", () => {
-    test("works with existing database operations", async () => {
-      process.env.XDG_DATA_HOME = tempDir;
-      
-      const db = await dbModule.initDb();
-      
-      // Test that we can use the database with the schema
-      const project = {
-        id: "integration-test",
-        name: "Integration Test",
-        path: "/integration/test",
-        type: "git" as const,
-      };
-      
-      await db.insert(dbModule.schema.projects).values(project).run();
-      
-      const result = await db.select()
-        .from(dbModule.schema.projects)
-        .where(eq(dbModule.schema.projects.id, "integration-test"))
-        .get();
-      
-      expect(result).toBeDefined();
-      expect(result!.name).toBe("Integration Test");
-    });
-  });
-});

package/test/unit/fixtures/setup.ts

@@ -1,186 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync, realpathSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { $ } from "bun";
-
-/**
- * Create a temporary directory for testing
- * Uses system temp directory to avoid being inside gitforest's git repo
- * Returns resolved real path to avoid macOS /var -> /private/var issues
- */
-export function createTempDir(name: string): string {
-  const tmpDir = join(tmpdir(), "gitforest-test", name);
-  rmSync(tmpDir, { recursive: true, force: true });
-  mkdirSync(tmpDir, { recursive: true });
-  // Return real path to handle macOS symlinks (/var -> /private/var)
-  return realpathSync(tmpDir);
-}
-
-/**
- * Clean up a temporary directory
- */
-export function cleanupTempDir(path: string): void {
-  rmSync(path, { recursive: true, force: true });
-}
-
-/**
- * Create a mock git repository
- */
-export async function createMockGitRepo(
-  basePath: string,
-  name: string,
-  options?: {
-    withRemote?: boolean;
-    withChanges?: boolean;
-    withUntracked?: boolean;
-    withStaged?: boolean;
-    commitCount?: number;
-  }
-): Promise<string> {
-  // Ensure the base path exists first
-  mkdirSync(basePath, { recursive: true });
-
-  // Use realpath for consistent paths on macOS
-  const baseReal = realpathSync(basePath);
-  const repoPath = join(baseReal, name);
-  mkdirSync(repoPath, { recursive: true });
-
-  // Initialize git repo
-  await $`git -C ${repoPath} init`.quiet();
-  await $`git -C ${repoPath} config user.email "test@test.com"`.quiet();
-  await $`git -C ${repoPath} config user.name "Test User"`.quiet();
-  // Disable hooks and GPG signing to ensure reliable testing
-  await $`git -C ${repoPath} config core.hooksPath /dev/null`.quiet();
-  await $`git -C ${repoPath} config commit.gpgsign false`.quiet();
-
-  // Create initial commit
-  writeFileSync(join(repoPath, "README.md"), `# ${name}\n`);
-  await $`git -C ${repoPath} add README.md`.quiet();
-  await $`git -C ${repoPath} commit -m "Initial commit"`.quiet();
-
-  // Add additional commits if requested
-  const commitCount = options?.commitCount ?? 0;
-  for (let i = 0; i < commitCount; i++) {
-    writeFileSync(join(repoPath, `file${i}.txt`), `Content ${i}\n`);
-    await $`git -C ${repoPath} add file${i}.txt`.quiet();
-    await $`git -C ${repoPath} commit -m "Commit ${i + 1}"`.quiet();
-  }
-
-  // Add unstaged changes
-  if (options?.withChanges) {
-    writeFileSync(join(repoPath, "README.md"), `# ${name}\n\nModified\n`);
-  }
-
-  // Add untracked files
-  if (options?.withUntracked) {
-    writeFileSync(join(repoPath, "untracked.txt"), "Untracked content\n");
-  }
-
-  // Add staged changes
-  if (options?.withStaged) {
-    writeFileSync(join(repoPath, "staged.txt"), "Staged content\n");
-    await $`git -C ${repoPath} add staged.txt`.quiet();
-  }
-
-  return repoPath;
-}
-
-/**
- * Create a mock non-git project with a marker file
- */
-export function createMockProject(
-  basePath: string,
-  name: string,
-  marker: string
-): string {
-  // Ensure the base path exists first
-  mkdirSync(basePath, { recursive: true });
-
-  // Use realpath for consistent paths on macOS
-  const baseReal = realpathSync(basePath);
-  const projectPath = join(baseReal, name);
-  mkdirSync(projectPath, { recursive: true });
-
-  // Create marker file based on type
-  switch (marker) {
-    case "package.json":
-      writeFileSync(
-        join(projectPath, "package.json"),
-        JSON.stringify({ name, version: "1.0.0" }, null, 2)
-      );
-      break;
-    case "Cargo.toml":
-      writeFileSync(
-        join(projectPath, "Cargo.toml"),
-        `[package]\nname = "${name}"\nversion = "0.1.0"\n`
-      );
-      break;
-    case "pyproject.toml":
-      writeFileSync(
-        join(projectPath, "pyproject.toml"),
-        `[project]\nname = "${name}"\nversion = "0.1.0"\n`
-      );
-      break;
-    case "go.mod":
-      writeFileSync(join(projectPath, "go.mod"), `module ${name}\n\ngo 1.21\n`);
-      break;
-    default:
-      writeFileSync(join(projectPath, marker), "");
-  }
-
-  return projectPath;
-}
-
-/**
- * Create a mock git repo with submodule
- */
-export async function createMockRepoWithSubmodule(
-  basePath: string,
-  parentName: string,
-  submoduleName: string
-): Promise<{ parentPath: string; submodulePath: string }> {
-  // Ensure the base path exists first
-  mkdirSync(basePath, { recursive: true });
-
-  // Create the submodule repo first (use realpath to ensure consistent paths)
-  const submoduleSource = await createMockGitRepo(basePath, `${submoduleName}-source`);
-  const submoduleSourceReal = realpathSync(submoduleSource);
-
-  // Create parent repo
-  const parentPath = await createMockGitRepo(basePath, parentName);
-  const parentPathReal = realpathSync(parentPath);
-
-  // Allow file:// protocol for submodule add (needed for local testing)
-  // Set in both the parent repo and globally for the submodule clone operation
-  await $`git -C ${parentPathReal} config --local protocol.file.allow always`.quiet();
-  await $`git config --global protocol.file.allow always`.quiet();
-
-  // Add submodule using real paths
-  await $`git -C ${parentPathReal} submodule add ${submoduleSourceReal} ${submoduleName}`.quiet();
-  await $`git -C ${parentPathReal} commit -m "Add submodule"`.quiet();
-
-  const submodulePath = join(parentPathReal, submoduleName);
-
-  return { parentPath: parentPathReal, submodulePath };
-}
-
-/**
- * Create a mock config file
- */
-export function createMockConfig(
-  basePath: string,
-  config: Record<string, unknown>
-): string {
-  const configPath = join(basePath, "gitforest.config.json");
-  writeFileSync(configPath, JSON.stringify(config, null, 2));
-  return configPath;
-}
-
-/**
- * Create a mock YAML config file
- */
-export function createMockYamlConfig(basePath: string, content: string): string {
-  const configPath = join(basePath, "gitforest.config.yaml");
-  writeFileSync(configPath, content);
-  return configPath;
-}

package/test/unit/git/commands-untested.test.ts

@@ -1,205 +0,0 @@
-/**
- * Tests for untested functions in git/commands.ts
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import {
-  getTrackingBranch,
-  countUnpushedCommits,
-  countUnpulledCommits,
-  getRemoteLastCommitDate,
-  addRemote,
-  fetchRemote,
-  fetchAll,
-  pull,
-  push,
-  getSubmoduleParent,
-  hasCommits,
-} from "../../../src/git/commands.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockRepoWithSubmodule,
-} from "../fixtures/setup.ts";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { $ } from "bun";
-
-describe("Git Commands - Untested Functions", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-commands-untested");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  describe("getTrackingBranch", () => {
-    test("returns null when no tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-tracking");
-      
-      const result = await getTrackingBranch(repoPath);
-      expect(result).toBeNull();
-    });
-
-    test("returns null for non-git directory", async () => {
-      const nonGitPath = join(tempDir, "non-git");
-      await mkdir(nonGitPath, { recursive: true });
-      
-      const result = await getTrackingBranch(nonGitPath);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("countUnpushedCommits", () => {
-    test("returns 0 when no tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-tracking");
-      
-      const result = await countUnpushedCommits(repoPath);
-      expect(result).toBe(0);
-    });
-  });
-
-  describe("countUnpulledCommits", () => {
-    test("returns 0 when no unpulled commits", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-unpulled");
-      
-      const result = await countUnpulledCommits(repoPath);
-      expect(result).toBe(0);
-    });
-  });
-
-  describe("getRemoteLastCommitDate", () => {
-    test("returns null for non-existent remote branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-branch");
-      
-      const result = await getRemoteLastCommitDate(repoPath, "origin/nonexistent");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("addRemote", () => {
-    test("adds remote with default name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-remote");
-      
-      const result = await addRemote(repoPath, "https://github.com/test/repo.git");
-      
-      expect(result).toBe(true);
-      
-      // Verify remote was added
-      const remoteUrl = await $`git -C ${repoPath} config --get remote.origin.url`.text();
-      expect(remoteUrl.trim()).toBe("https://github.com/test/repo.git");
-    });
-
-    test("adds remote with custom name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-custom-remote");
-      
-      const result = await addRemote(repoPath, "https://github.com/test/repo.git", "upstream");
-      
-      expect(result).toBe(true);
-      
-      // Verify remote was added with custom name
-      const remoteUrl = await $`git -C ${repoPath} config --get remote.upstream.url`.text();
-      expect(remoteUrl.trim()).toBe("https://github.com/test/repo.git");
-    });
-
-    test("returns false when remote already exists", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "existing-remote");
-      
-      // Add remote first
-      await addRemote(repoPath, "https://github.com/test/repo.git", "origin");
-      
-      // Try to add again
-      const result = await addRemote(repoPath, "https://github.com/test/repo2.git", "origin");
-      
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("fetchRemote", () => {
-    test("returns false when remote doesn't exist", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-fetch");
-      
-      const result = await fetchRemote(repoPath, "nonexistent");
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("fetchAll", () => {
-    test("handles repos with no remotes", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remotes");
-      
-      const result = await fetchAll(repoPath);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe("pull", () => {
-    test("returns false on merge conflicts", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "conflict-repo");
-      
-      // Create a conflicting change
-      await writeFile(join(repoPath, "README.md"), "# Modified");
-      await $`git -C ${repoPath} add README.md`.quiet();
-      await $`git -C ${repoPath} commit -m "Local change"`.quiet();
-      
-      // Try to pull (will fail due to no remote)
-      const result = await pull(repoPath);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("push", () => {
-    test("returns false when no remote", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-no-remote");
-      
-      const result = await push(repoPath, false);
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("getSubmoduleParent", () => {
-    test("returns parent path for submodule", async () => {
-      const { submodulePath } = await createMockRepoWithSubmodule(
-        tempDir,
-        "parent",
-        "submodule"
-      );
-      
-      const result = await getSubmoduleParent(submodulePath);
-      expect(result).toBeTruthy();
-      expect(result).toContain("parent");
-    });
-
-    test("returns null for regular repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "regular-repo");
-      
-      const result = await getSubmoduleParent(repoPath);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("hasCommits", () => {
-    test("returns true for repo with commits", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "with-commits");
-      
-      const result = await hasCommits(repoPath);
-      expect(result).toBe(true);
-    });
-
-    test("returns false for empty repo", async () => {
-      // Create an empty repo without initial commit
-      const emptyRepoPath = join(tempDir, "empty-repo");
-      await mkdir(emptyRepoPath, { recursive: true });
-      await $`git -C ${emptyRepoPath} init`.quiet();
-      await $`git -C ${emptyRepoPath} config user.email "test@test.com"`.quiet();
-      await $`git -C ${emptyRepoPath} config user.name "Test"`.quiet();
-      
-      const result = await hasCommits(emptyRepoPath);
-      expect(result).toBe(false);
-    });
-  });
-});