gitforest 0.1.0 → 1.0.0

package/test/unit/utils/project-utils.test.ts

@@ -1,756 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { filterProjects, sortProjects } from "../../../src/utils/project-utils";
-import type { Project, GitStatus } from "../../../src/types/index";
-import { 
-  createMockProject, 
-  createCleanProject, 
-  createDirtyProject, 
-  createAheadProject,
-  createNonGitProject,
-  resetProjectIdCounter,
-  createBehindStatus,
-  createNoRemoteStatus,
-  createDirtyStatus,
-  defaultMockStatus
-} from "../mocks";
-
-// Reset project ID counter before each test
-beforeEach(() => {
-  resetProjectIdCounter();
-});
-
-describe("filterProjects", () => {
-  const mockProjects: Project[] = [
-    {
-      id: "1",
-      name: "React App",
-      path: "/home/user/projects/react-app",
-      type: "git",
-      projectMarker: "package.json",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "2",
-      name: "Vue Project",
-      path: "/home/user/projects/vue-project",
-      type: "git",
-      projectMarker: "package.json",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "3",
-      name: "Rust Project",
-      path: "/home/user/projects/rust-project",
-      type: "git",
-      projectMarker: "Cargo.toml",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "4",
-      name: "Python Scripts",
-      path: "/home/user/scripts/python",
-      type: "non-git",
-      projectMarker: "pyproject.toml",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-  ];
-
-  test("filters by name", () => {
-    const result = filterProjects(mockProjects, "react");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.name).toBe("React App");
-  });
-
-  test("filters by name case insensitive", () => {
-    const result = filterProjects(mockProjects, "REACT");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.name).toBe("React App");
-  });
-
-  test("filters by path", () => {
-    const result = filterProjects(mockProjects, "scripts");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.path).toBe("/home/user/scripts/python");
-  });
-
-  test("filters by project marker", () => {
-    const result = filterProjects(mockProjects, "cargo");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.projectMarker).toBe("Cargo.toml");
-  });
-
-  test("filters by type", () => {
-    const result = filterProjects(mockProjects, "non-git");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.type).toBe("non-git");
-  });
-
-  test("returns all for empty filter", () => {
-    const result = filterProjects(mockProjects, "");
-    expect(result).toHaveLength(4);
-  });
-
-  test("returns all for whitespace-only filter", () => {
-    const result = filterProjects(mockProjects, "   ");
-    expect(result).toHaveLength(4);
-  });
-
-  test("handles special characters", () => {
-    const specialProject: Project = {
-      id: "5",
-      name: "Project@2.0",
-      path: "/home/user/projects/project-2.0",
-      type: "git",
-      projectMarker: null,
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    };
-    const specialProjects = [...mockProjects, specialProject];
-    
-    const result = filterProjects(specialProjects, "@2.0");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.name).toBe("Project@2.0");
-  });
-
-  test("handles no matches", () => {
-    const result = filterProjects(mockProjects, "nonexistent");
-    expect(result).toHaveLength(0);
-  });
-
-  test("handles partial matches", () => {
-    const result = filterProjects(mockProjects, "proj");
-    expect(result).toHaveLength(4); // React App, Vue Project, Rust Project, Python Scripts (path contains "proj")
-  });
-});
-
-describe("sortProjects", () => {
-  const mockGitStatus: GitStatus = {
-    hasUnstagedChanges: false,
-    hasStagedChanges: false,
-    hasUntrackedFiles: false,
-    modifiedCount: 0,
-    stagedCount: 0,
-    untrackedCount: 0,
-    currentBranch: "main",
-    trackingBranch: "origin/main",
-    unpushedCommits: 0,
-    unpulledCommits: 0,
-    hasRemote: true,
-    remoteUrl: "https://github.com/user/repo.git",
-    lastLocalCommit: new Date("2024-01-15"),
-    lastRemoteActivity: new Date("2024-01-10"),
-    hasCommits: true,
-    isDirty: false,
-    isAhead: false,
-    isBehind: false,
-    isOutOfSync: false,
-  };
-
-  const mockProjects: Project[] = [
-    {
-      id: "1",
-      name: "Alpha Project",
-      path: "/home/user/projects/alpha",
-      type: "git",
-      projectMarker: "package.json",
-      status: { ...mockGitStatus, lastLocalCommit: new Date("2024-01-15") },
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "2",
-      name: "Beta Project",
-      path: "/home/user/projects/beta",
-      type: "git",
-      projectMarker: "package.json",
-      status: { ...mockGitStatus, isDirty: true, lastLocalCommit: new Date("2024-01-10") },
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "3",
-      name: "Gamma Project",
-      path: "/home/user/projects/gamma",
-      type: "git",
-      projectMarker: "package.json",
-      status: { ...mockGitStatus, isBehind: true, lastLocalCommit: new Date("2024-01-20") },
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: null,
-    },
-    {
-      id: "4",
-      name: "Delta Project",
-      path: "/home/user/projects/delta",
-      type: "non-git",
-      projectMarker: "package.json",
-      status: null,
-      submodule: null,
-      lastScanned: new Date(),
-      lastModified: new Date("2024-01-05"),
-    },
-  ];
-
-  describe("sort by name", () => {
-    test("sorts ascending", () => {
-      const result = sortProjects(mockProjects, "name", "asc");
-      expect(result[0]?.name).toBe("Alpha Project");
-      expect(result[1]?.name).toBe("Beta Project");
-      expect(result[2]?.name).toBe("Delta Project");
-      expect(result[3]?.name).toBe("Gamma Project");
-    });
-
-    test("sorts descending", () => {
-      const result = sortProjects(mockProjects, "name", "desc");
-      expect(result[0]?.name).toBe("Gamma Project");
-      expect(result[1]?.name).toBe("Delta Project");
-      expect(result[2]?.name).toBe("Beta Project");
-      expect(result[3]?.name).toBe("Alpha Project");
-    });
-  });
-
-  describe("sort by status", () => {
-    test("sorts by priority descending (most attention needed first)", () => {
-      const result = sortProjects(mockProjects, "status", "desc");
-      // Beta (dirty) should come first, then Gamma (behind), then Alpha (clean), then Delta (non-git)
-      expect(result[0]?.name).toBe("Beta Project"); // dirty
-      expect(result[1]?.name).toBe("Gamma Project"); // behind
-      expect(result[2]?.name).toBe("Alpha Project"); // clean
-      expect(result[3]?.name).toBe("Delta Project"); // non-git
-    });
-
-    test("sorts by priority ascending (least attention needed first)", () => {
-      const result = sortProjects(mockProjects, "status", "asc");
-      // Delta (non-git) should come first, then Alpha (clean), then Gamma (behind), then Beta (dirty)
-      expect(result[0]?.name).toBe("Delta Project"); // non-git
-      expect(result[1]?.name).toBe("Alpha Project"); // clean
-      expect(result[2]?.name).toBe("Gamma Project"); // behind
-      expect(result[3]?.name).toBe("Beta Project"); // dirty
-    });
-  });
-
-  describe("sort by lastActivity", () => {
-    test("sorts descending (most recent first)", () => {
-      const result = sortProjects(mockProjects, "lastActivity", "desc");
-      expect(result[0]?.name).toBe("Gamma Project"); // Jan 20
-      expect(result[1]?.name).toBe("Alpha Project"); // Jan 15
-      expect(result[2]?.name).toBe("Beta Project"); // Jan 10
-      expect(result[3]?.name).toBe("Delta Project"); // no status
-    });
-
-    test("sorts ascending (oldest first)", () => {
-      const result = sortProjects(mockProjects, "lastActivity", "asc");
-      expect(result[0]?.name).toBe("Delta Project"); // no status
-      expect(result[1]?.name).toBe("Beta Project"); // Jan 10
-      expect(result[2]?.name).toBe("Alpha Project"); // Jan 15
-      expect(result[3]?.name).toBe("Gamma Project"); // Jan 20
-    });
-
-    test("handles null dates", () => {
-      const projectsWithNulls: Project[] = [
-        ...mockProjects.slice(0, 3),
-        {
-          ...mockProjects[3]!,
-          status: null,
-        },
-      ];
-      
-      const result = sortProjects(projectsWithNulls, "lastActivity", "desc");
-      // Projects with null dates should be at the end for desc
-      expect(result[3]?.name).toBe("Delta Project");
-    });
-
-    test("handles string timestamps", () => {
-      const projectsWithStrings: Project[] = mockProjects.map(p => ({
-        ...p,
-        status: p.status ? {
-          ...p.status,
-          lastLocalCommit: p.status.lastLocalCommit ? new Date(p.status.lastLocalCommit) : null,
-        } : null,
-      }));
-      
-      const result = sortProjects(projectsWithStrings, "lastActivity", "desc");
-      expect(result[0]?.name).toBe("Gamma Project");
-      expect(result[3]?.name).toBe("Delta Project");
-    });
-  });
-
-  test("handles empty array", () => {
-    const result = sortProjects([], "name", "asc");
-    expect(result).toEqual([]);
-  });
-
-  test("handles single item", () => {
-    const result = sortProjects([mockProjects[0]!], "name", "asc");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.name).toBe("Alpha Project");
-  });
-});
-
-describe("Enhanced sortProjects tests", () => {
-  describe("sort by name", () => {
-    test("sorts by name ascending with mixed case", () => {
-      const projects = [
-        createMockProject({ name: "zebra" }),
-        createMockProject({ name: "Alpha" }),
-        createMockProject({ name: "beta" }),
-        createMockProject({ name: "Charlie" }),
-      ];
-      
-      const result = sortProjects(projects, "name", "asc");
-      expect(result[0]?.name).toBe("Alpha");
-      expect(result[1]?.name).toBe("beta");
-      expect(result[2]?.name).toBe("Charlie");
-      expect(result[3]?.name).toBe("zebra");
-    });
-
-    test("sorts by name descending with mixed case", () => {
-      const projects = [
-        createMockProject({ name: "zebra" }),
-        createMockProject({ name: "Alpha" }),
-        createMockProject({ name: "beta" }),
-        createMockProject({ name: "Charlie" }),
-      ];
-      
-      const result = sortProjects(projects, "name", "desc");
-      expect(result[0]?.name).toBe("zebra");
-      expect(result[1]?.name).toBe("Charlie");
-      expect(result[2]?.name).toBe("beta");
-      expect(result[3]?.name).toBe("Alpha");
-    });
-
-    test("handles projects with same name prefix", () => {
-      const projects = [
-        createMockProject({ name: "project-alpha" }),
-        createMockProject({ name: "project-beta" }),
-        createMockProject({ name: "project-gamma" }),
-      ];
-      
-      const result = sortProjects(projects, "name", "asc");
-      expect(result[0]?.name).toBe("project-alpha");
-      expect(result[1]?.name).toBe("project-beta");
-      expect(result[2]?.name).toBe("project-gamma");
-    });
-  });
-
-  describe("sort by status priority", () => {
-    test("dirty projects have highest priority in desc", () => {
-      const projects = [
-        createCleanProject("clean"),
-        createDirtyProject("dirty"),
-        createAheadProject("ahead", 2),
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      expect(result[0]?.name).toBe("dirty");
-      expect(result[1]?.name).toBe("ahead");
-      expect(result[2]?.name).toBe("clean");
-    });
-
-    test("behind projects have high priority in desc", () => {
-      const behindProject = createMockProject({
-        name: "behind",
-        type: "git",
-        status: {
-          ...createBehindStatus(3),
-          isBehind: true,
-          unpulledCommits: 3,
-        },
-      });
-      
-      const projects = [
-        createCleanProject("clean"),
-        behindProject,
-        createAheadProject("ahead", 1),
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      expect(result[0]?.name).toBe("behind");
-      expect(result[1]?.name).toBe("ahead");
-      expect(result[2]?.name).toBe("clean");
-    });
-
-    test("non-git projects have lowest priority", () => {
-      const projects = [
-        createCleanProject("clean"),
-        createDirtyProject("dirty"),
-        createNonGitProject("non-git"),
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      expect(result[0]?.name).toBe("dirty");
-      expect(result[1]?.name).toBe("clean");
-      expect(result[2]?.name).toBe("non-git");
-    });
-
-    test("projects without status have low priority", () => {
-      const noStatusProject = createMockProject({
-        name: "no-status",
-        type: "git",
-        status: null,
-      });
-      
-      const projects = [
-        createCleanProject("clean"),
-        noStatusProject,
-        createDirtyProject("dirty"),
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      expect(result[0]?.name).toBe("dirty");
-      expect(result[1]?.name).toBe("clean");
-      expect(result[2]?.name).toBe("no-status");
-    });
-
-    test("priority combines correctly (dirty + ahead)", () => {
-      const dirtyAheadProject = createMockProject({
-        name: "dirty-ahead",
-        type: "git",
-        status: {
-          ...createDirtyStatus(),
-          unpushedCommits: 5,
-          isAhead: true,
-          isOutOfSync: true,
-        },
-      });
-      
-      const justDirtyProject = createDirtyProject("just-dirty");
-      const justAheadProject = createAheadProject("just-ahead", 5);
-      
-      const projects = [
-        justAheadProject,
-        justDirtyProject,
-        dirtyAheadProject,
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      // dirty+ahead should come before just-dirty due to combined priority
-      expect(result[0]?.name).toBe("dirty-ahead");
-      expect(result[1]?.name).toBe("just-dirty");
-      expect(result[2]?.name).toBe("just-ahead");
-    });
-
-    test("no remote projects have medium priority", () => {
-      const noRemoteProject = createMockProject({
-        name: "no-remote",
-        type: "git",
-        status: createNoRemoteStatus(),
-      });
-      
-      const projects = [
-        createCleanProject("clean"),
-        noRemoteProject,
-        createDirtyProject("dirty"),
-      ];
-      
-      const result = sortProjects(projects, "status", "desc");
-      expect(result[0]?.name).toBe("dirty");
-      expect(result[1]?.name).toBe("no-remote");
-      expect(result[2]?.name).toBe("clean");
-    });
-  });
-
-  describe("sort by lastActivity", () => {
-    test("handles Date objects for lastLocalCommit", () => {
-      const projects = [
-        createMockProject({
-          name: "old",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-01-01"),
-          },
-        }),
-        createMockProject({
-          name: "new",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-12-31"),
-          },
-        }),
-      ];
-      
-      const result = sortProjects(projects, "lastActivity", "desc");
-      expect(result[0]?.name).toBe("new");
-      expect(result[1]?.name).toBe("old");
-    });
-
-    test("handles string timestamps for lastLocalCommit", () => {
-      const projects = [
-        createMockProject({
-          name: "old",
-          type: "git",
-          status: {
-            ...defaultMockStatus,
-            lastLocalCommit: new Date("2024-01-01T00:00:00Z"),
-          },
-        }),
-        createMockProject({
-          name: "new",
-          type: "git",
-          status: {
-            ...defaultMockStatus,
-            lastLocalCommit: new Date("2024-12-31T23:59:59Z"),
-          },
-        }),
-      ];
-      
-      const result = sortProjects(projects, "lastActivity", "desc");
-      expect(result[0]?.name).toBe("new");
-      expect(result[1]?.name).toBe("old");
-    });
-
-    test("handles null lastLocalCommit", () => {
-      const projects = [
-        createMockProject({
-          name: "no-commit-date",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: null,
-          },
-        }),
-        createMockProject({
-          name: "with-commit-date",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-06-15"),
-          },
-        }),
-      ];
-      
-      const result = sortProjects(projects, "lastActivity", "desc");
-      // Projects with null dates should be at the end for desc
-      expect(result[0]?.name).toBe("with-commit-date");
-      expect(result[1]?.name).toBe("no-commit-date");
-    });
-
-    test("sorts by lastActivity ascending (oldest first)", () => {
-      const projects = [
-        createMockProject({
-          name: "new",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-12-31"),
-          },
-        }),
-        createMockProject({
-          name: "old",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-01-01"),
-          },
-        }),
-        createMockProject({
-          name: "middle",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-06-15"),
-          },
-        }),
-      ];
-      
-      const result = sortProjects(projects, "lastActivity", "asc");
-      expect(result[0]?.name).toBe("old");
-      expect(result[1]?.name).toBe("middle");
-      expect(result[2]?.name).toBe("new");
-    });
-
-    test("non-git projects are sorted to the end", () => {
-      const projects = [
-        createNonGitProject("non-git-1"),
-        createMockProject({
-          name: "git-project",
-          type: "git",
-          status: {
-            ...createCleanProject("").status!,
-            lastLocalCommit: new Date("2024-01-01"),
-          },
-        }),
-        createNonGitProject("non-git-2"),
-      ];
-      
-      const result = sortProjects(projects, "lastActivity", "desc");
-      expect(result[0]?.name).toBe("git-project");
-      expect(result[1]?.type).toBe("non-git");
-      expect(result[2]?.type).toBe("non-git");
-    });
-  });
-});
-
-describe("Enhanced filterProjects tests", () => {
-  test("filter by name is case insensitive", () => {
-    const projects = [
-      createMockProject({ name: "ReactApp" }),
-      createMockProject({ name: "vueapp" }),
-      createMockProject({ name: "ANGULAR_APP" }),
-    ];
-    
-    const result = filterProjects(projects, "app");
-    expect(result).toHaveLength(3);
-    expect(result.map(p => p.name)).toEqual(["ReactApp", "vueapp", "ANGULAR_APP"]);
-  });
-
-  test("filter by path", () => {
-    const projects = [
-      createMockProject({ path: "/home/user/projects/react" }),
-      createMockProject({ path: "/home/user/work/vue" }),
-      createMockProject({ path: "/home/user/projects/angular" }),
-    ];
-    
-    const result = filterProjects(projects, "projects");
-    expect(result).toHaveLength(2);
-    expect(result.map(p => p.path)).toContain("/home/user/projects/react");
-    expect(result.map(p => p.path)).toContain("/home/user/projects/angular");
-  });
-
-  test("filter by projectMarker", () => {
-    const projects = [
-      createMockProject({ projectMarker: "package.json" }),
-      createMockProject({ projectMarker: "Cargo.toml" }),
-      createMockProject({ projectMarker: "pyproject.toml" }),
-    ];
-    
-    const result = filterProjects(projects, "toml");
-    expect(result).toHaveLength(2);
-    expect(result.map(p => p.projectMarker)).toContain("Cargo.toml");
-    expect(result.map(p => p.projectMarker)).toContain("pyproject.toml");
-  });
-
-  test("filter by type", () => {
-    const projects = [
-      createMockProject({ type: "git" }),
-      createMockProject({ type: "non-git" }),
-      createMockProject({ type: "git-submodule" }),
-    ];
-    
-    const result = filterProjects(projects, "git");
-    expect(result).toHaveLength(3); // Matches "git" in both "git" and "git-submodule" types
-    expect(result.map(p => p.type)).toContain("git");
-    expect(result.map(p => p.type)).toContain("git-submodule");
-  });
-
-  test("empty filter returns all projects", () => {
-    const projects = [
-      createMockProject({ name: "project1" }),
-      createMockProject({ name: "project2" }),
-      createMockProject({ name: "project3" }),
-    ];
-    
-    const result = filterProjects(projects, "");
-    expect(result).toHaveLength(3);
-  });
-
-  test("whitespace-only filter returns all projects", () => {
-    const projects = [
-      createMockProject({ name: "project1" }),
-      createMockProject({ name: "project2" }),
-    ];
-    
-    const result = filterProjects(projects, "   \n\t  ");
-    expect(result).toHaveLength(2);
-  });
-
-  test("no matches returns empty array", () => {
-    const projects = [
-      createMockProject({ name: "react" }),
-      createMockProject({ name: "vue" }),
-    ];
-    
-    const result = filterProjects(projects, "angular");
-    expect(result).toHaveLength(0);
-  });
-
-  test("partial matches work", () => {
-    const projects = [
-      createMockProject({ name: "my-react-app" }),
-      createMockProject({ name: "react-component" }),
-      createMockProject({ name: "vue-app" }),
-    ];
-    
-    const result = filterProjects(projects, "react");
-    expect(result).toHaveLength(2);
-    expect(result.map(p => p.name)).toContain("my-react-app");
-    expect(result.map(p => p.name)).toContain("react-component");
-  });
-
-  test("filters across multiple fields", () => {
-    const projects = [
-      createMockProject({ name: "react", path: "/apps/frontend", projectMarker: "package.json" }),
-      createMockProject({ name: "backend", path: "/apps/backend", projectMarker: "requirements.txt" }),
-      createMockProject({ name: "mobile", path: "/apps/react-native", projectMarker: "package.json" }),
-    ];
-    
-    // Should match both react projects (name and path)
-    const result = filterProjects(projects, "react");
-    expect(result).toHaveLength(2);
-  });
-
-  test("handles projects with null projectMarker", () => {
-    const projects = [
-      createMockProject({ projectMarker: null }),
-      createMockProject({ projectMarker: "package.json" }),
-    ];
-    
-    const result = filterProjects(projects, "package");
-    expect(result).toHaveLength(1);
-    expect(result[0]?.projectMarker).toBe("package.json");
-  });
-
-  test("handles special characters in filter", () => {
-    const projects = [
-      createMockProject({ name: "project@2.0" }),
-      createMockProject({ name: "project#1" }),
-      createMockProject({ name: "project$test" }),
-    ];
-    
-    const result1 = filterProjects(projects, "@2.0");
-    expect(result1).toHaveLength(1);
-    expect(result1[0]?.name).toBe("project@2.0");
-    
-    const result2 = filterProjects(projects, "#1");
-    expect(result2).toHaveLength(1);
-    expect(result2[0]?.name).toBe("project#1");
-    
-    const result3 = filterProjects(projects, "$test");
-    expect(result3).toHaveLength(1);
-    expect(result3[0]?.name).toBe("project$test");
-  });
-
-  test("handles unicode characters", () => {
-    const projects = [
-      createMockProject({ name: "项目" }),
-      createMockProject({ name: "プロジェクト" }),
-      createMockProject({ name: "project" }),
-    ];
-    
-    const result1 = filterProjects(projects, "项目");
-    expect(result1).toHaveLength(1);
-    expect(result1[0]?.name).toBe("项目");
-    
-    const result2 = filterProjects(projects, "プロ");
-    expect(result2).toHaveLength(1);
-    expect(result2[0]?.name).toBe("プロジェクト");
-  });
-});