gitforest 0.1.0

package/test/unit/state/store.test.tsx

@@ -0,0 +1,711 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import type { 
+  UnifiedAppState, 
+  Project, 
+  UnifiedRepo,
+  GitHubRepoInfo
+} from "../../../src/types/index.ts";
+import { 
+  createMockProject, 
+  createDirtyProject, 
+  createAheadProject, 
+  createNonGitProject,
+  createCleanProject,
+  resetProjectIdCounter
+} from "../mocks/project.ts";
+import { defaultMockStatus } from "../mocks/git-service";
+import { initialState } from "../../../src/state/reducer.ts";
+
+// Import utility functions directly instead of testing hooks
+import { filterProjects, sortProjects } from "../../../src/utils/project-utils.ts";
+import { filterByViewMode, filterUnifiedRepos, sortUnifiedRepos } from "../../../src/github/unified.ts";
+
+
+
+// Helper to create mock state
+function createMockState(overrides?: Partial<UnifiedAppState>): UnifiedAppState {
+  return { ...initialState, ...overrides };
+}
+
+// Helper to simulate hook behavior for filtered projects
+function simulateUseFilteredProjects(state: UnifiedAppState): Project[] {
+  const { projects, filterText, quickFilter, sortBy, sortDirection } = state;
+  
+  let result = projects;
+  
+  // Apply quick filter first
+  if (quickFilter !== "all") {
+    result = result.filter((p) => {
+      switch (quickFilter) {
+        case "dirty":
+          return p.status?.isDirty;
+        case "unpushed":
+          return p.status?.isAhead && p.status?.unpushedCommits > 0;
+        case "no-remote":
+          return p.type === "git" && !p.status?.hasRemote;
+        default:
+          return true;
+      }
+    });
+  }
+  
+  // Apply text filter
+  if (filterText) {
+    result = filterProjects(result, filterText);
+  }
+  
+  // Apply sort
+  result = sortProjects(result, sortBy, sortDirection);
+  
+  return result;
+}
+
+// Helper to simulate hook behavior for selected projects
+function simulateUseSelectedProjects(state: UnifiedAppState): Project[] {
+  const filteredProjects = simulateUseFilteredProjects(state);
+  const { selectedIndices, cursorIndex } = state;
+  
+  // If nothing selected, return the project at cursor
+  if (selectedIndices.size === 0) {
+    const current = filteredProjects[cursorIndex];
+    return current ? [current] : [];
+  }
+  
+  // Return selected projects (filter out undefined and properly type)
+  return [...selectedIndices]
+    .map((i) => filteredProjects[i])
+    .filter((p): p is NonNullable<typeof p> => p !== undefined);
+}
+
+// Helper to simulate hook behavior for filtered unified repos
+function simulateUseFilteredUnifiedRepos(state: UnifiedAppState): UnifiedRepo[] {
+  const { unifiedRepos, viewMode, filterText, quickFilter, sortBy, sortDirection, languageFilter } = state;
+  
+  let result = unifiedRepos;
+  
+  // Apply view mode filter first
+  result = filterByViewMode(result, viewMode);
+  
+  // Apply quick filter
+  if (quickFilter !== "all") {
+    result = result.filter((r) => {
+      switch (quickFilter) {
+        case "dirty":
+          return r.local?.status?.isDirty;
+        case "unpushed":
+          return r.local?.status?.isAhead && r.local?.status?.unpushedCommits > 0;
+        case "no-remote":
+          return r.local?.type === "git" && !r.local?.status?.hasRemote;
+        case "github-only":
+          return r.source === "github";
+        case "local-only":
+          return r.source === "local" || r.source === "both";
+        case "private":
+          return r.github?.isPrivate === true;
+        case "public":
+          return r.github?.isPrivate === false;
+        case "archived":
+          return r.github?.isArchived === true;
+        case "forks":
+          return r.github?.isFork === true;
+        default:
+          return true;
+      }
+    });
+  }
+  
+  // Apply text filter
+  if (filterText) {
+    result = filterUnifiedRepos(result, filterText);
+  }
+  
+  // Apply language filter
+  if (languageFilter) {
+    result = result.filter(r => 
+      r.github?.language?.toLowerCase() === languageFilter.toLowerCase()
+    );
+  }
+  
+  // Apply sort
+  result = sortUnifiedRepos(result, sortBy, sortDirection);
+  
+  return result;
+}
+
+// Helper to simulate hook behavior for selected unified repos
+function simulateUseSelectedUnifiedRepos(state: UnifiedAppState): UnifiedRepo[] {
+  const filteredRepos = simulateUseFilteredUnifiedRepos(state);
+  const { selectedIndices, cursorIndex } = state;
+  
+  // If nothing selected, return the repo at cursor
+  if (selectedIndices.size === 0) {
+    const current = filteredRepos[cursorIndex];
+    return current ? [current] : [];
+  }
+  
+  // Return selected repos (filter out undefined and properly type)
+  return [...selectedIndices]
+    .map((i) => filteredRepos[i])
+    .filter((r): r is NonNullable<typeof r> => r !== undefined);
+}
+
+// Create mock GitHub repo
+function createMockGitHubRepo(overrides?: Partial<GitHubRepoInfo>): GitHubRepoInfo {
+  return {
+    name: overrides?.name ?? "test-repo",
+    fullName: overrides?.fullName ?? "user/test-repo",
+    owner: overrides?.owner ?? "user",
+    description: overrides?.description ?? "Test repo",
+    htmlUrl: overrides?.htmlUrl ?? "https://github.com/user/test-repo",
+    sshUrl: overrides?.sshUrl ?? "git@github.com:user/test-repo.git",
+    cloneUrl: overrides?.cloneUrl ?? "https://github.com/user/test-repo.git",
+    isPrivate: overrides?.isPrivate ?? false,
+    isArchived: overrides?.isArchived ?? false,
+    isFork: overrides?.isFork ?? false,
+    pushedAt: overrides?.pushedAt ?? new Date(),
+    updatedAt: overrides?.updatedAt ?? new Date(),
+    defaultBranch: overrides?.defaultBranch ?? "main",
+    language: overrides?.language ?? "TypeScript",
+    size: overrides?.size ?? 1000,
+    stargazersCount: overrides?.stargazersCount ?? 0
+  };
+}
+
+// Create mock unified repo
+function createMockUnifiedRepo(overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  return {
+    id: overrides?.id ?? "repo-1",
+    name: overrides?.name ?? "test-repo",
+    source: overrides?.source ?? "both",
+    local: overrides?.local ?? createCleanProject("local"),
+    github: overrides?.github ?? createMockGitHubRepo(),
+    isCloned: overrides?.isCloned ?? !!overrides?.local,
+    isOnGitHub: overrides?.isOnGitHub ?? !!overrides?.github,
+    localPath: overrides?.localPath ?? overrides?.local?.path ?? null
+  };
+}
+
+// Reset project counter before each test
+describe("Store Hooks (Simulated)", () => {
+  beforeEach(() => {
+    resetProjectIdCounter();
+  });
+
+  describe("useFilteredProjects", () => {
+    const mockProjects: Project[] = [
+      createCleanProject("alpha"),
+      createDirtyProject("beta"),
+      createAheadProject("gamma", 2),
+      createNonGitProject("delta", "package.json"),
+      createMockProject({
+        name: "epsilon",
+        type: "git",
+        status: { ...defaultMockStatus, hasRemote: false }
+      })
+    ];
+
+    test("returns all projects when no filter", () => {
+      const state = createMockState({ projects: mockProjects });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(5);
+      // Sorting by status (desc) puts dirty/ahead projects first
+      expect(result.map(p => p.name)).toEqual(["beta", "gamma", "epsilon", "alpha", "delta"]);
+    });
+
+    test("filters by text (name)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        filterText: "alp"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("alpha");
+    });
+
+    test("filters by text (marker)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        filterText: "package.json"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("delta");
+    });
+
+    test("filters by text (type)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        filterText: "non-git"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.type).toBe("non-git");
+    });
+
+    test("applies quick filter (dirty)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        quickFilter: "dirty"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("beta");
+    });
+
+    test("applies quick filter (unpushed)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        quickFilter: "unpushed"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("gamma");
+    });
+
+    test("applies quick filter (no-remote)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        quickFilter: "no-remote"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("epsilon");
+    });
+
+    test("sorts by name (asc)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        sortBy: "name",
+        sortDirection: "asc"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result.map(p => p.name)).toEqual(["alpha", "beta", "delta", "epsilon", "gamma"]);
+    });
+
+    test("sorts by name (desc)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        sortBy: "name",
+        sortDirection: "desc"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result.map(p => p.name)).toEqual(["gamma", "epsilon", "delta", "beta", "alpha"]);
+    });
+
+    test("sorts by status (priority)", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        sortBy: "status",
+        sortDirection: "desc"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      // Status priority: dirty > ahead > behind > clean > non-git
+      expect(result[0]?.name).toBe("beta"); // dirty
+      expect(result[1]?.name).toBe("gamma"); // ahead
+    });
+
+    test("sorts by lastActivity", () => {
+      const projectsWithActivity = [
+        createMockProject({
+          name: "old-project",
+          status: { ...defaultMockStatus, lastLocalCommit: new Date("2023-01-01") }
+        }),
+        createMockProject({
+          name: "new-project",
+          status: { ...defaultMockStatus, lastLocalCommit: new Date("2024-01-01") }
+        })
+      ];
+      
+      const state = createMockState({ 
+        projects: projectsWithActivity,
+        sortBy: "lastActivity",
+        sortDirection: "desc"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result[0]?.name).toBe("new-project");
+      expect(result[1]?.name).toBe("old-project");
+    });
+
+    test("combines text filter and quick filter", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        filterText: "a",
+        quickFilter: "dirty"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("beta"); // dirty and contains "a"
+    });
+
+    test("combines filter and sort", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        filterText: "a",
+        sortBy: "name",
+        sortDirection: "asc"
+      });
+      const result = simulateUseFilteredProjects(state);
+      
+      // Projects with "a" in name: alpha, beta, delta, gamma
+      // Sorted by name asc: alpha, beta, delta, gamma
+      expect(result.map(p => p.name)).toEqual(["alpha", "beta", "delta", "gamma"]);
+    });
+  });
+
+  describe("useSelectedProjects", () => {
+    const mockProjects: Project[] = [
+      createCleanProject("first"),
+      createCleanProject("second"),
+      createCleanProject("third")
+    ];
+
+    test("returns project at cursor when nothing selected", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        cursorIndex: 1,
+        selectedIndices: new Set()
+      });
+      const result = simulateUseSelectedProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("second");
+    });
+
+    test("returns selected projects when indices selected", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        selectedIndices: new Set([0, 2])
+      });
+      const result = simulateUseSelectedProjects(state);
+      
+      expect(result).toHaveLength(2);
+      expect(result.map(p => p.name)).toEqual(["first", "third"]);
+    });
+
+    test("returns empty array when cursor out of bounds", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        cursorIndex: 10,
+        selectedIndices: new Set()
+      });
+      const result = simulateUseSelectedProjects(state);
+      
+      expect(result).toHaveLength(0);
+    });
+
+    test("filters out undefined indices", () => {
+      const state = createMockState({ 
+        projects: mockProjects,
+        selectedIndices: new Set([0, 5, 9]) // 5 and 9 are out of bounds
+      });
+      const result = simulateUseSelectedProjects(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("first");
+    });
+  });
+
+  describe("useFilteredUnifiedRepos", () => {
+    const mockRepos: UnifiedRepo[] = [
+      createMockUnifiedRepo({ 
+        id: "repo-1", 
+        name: "alpha", 
+        source: "local",
+        local: createCleanProject("alpha"),
+        github: null
+      }),
+      createMockUnifiedRepo({ 
+        id: "repo-2", 
+        name: "beta", 
+        source: "github",
+        local: null,
+        github: createMockGitHubRepo({ name: "beta", language: "JavaScript" })
+      }),
+      createMockUnifiedRepo({ 
+        id: "repo-3", 
+        name: "gamma", 
+        source: "both",
+        local: createDirtyProject("gamma"),
+        github: createMockGitHubRepo({ 
+          name: "gamma", 
+          language: "TypeScript",
+          isPrivate: true,
+          isArchived: false,
+          isFork: false
+        })
+      }),
+      createMockUnifiedRepo({ 
+        id: "repo-4", 
+        name: "delta", 
+        source: "both",
+        local: createCleanProject("delta"),
+        github: createMockGitHubRepo({ 
+          name: "delta", 
+          language: "Python",
+          isPrivate: false,
+          isArchived: true,
+          isFork: true
+        })
+      })
+    ];
+
+    test("filters by view mode (local)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        viewMode: "local"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(3);
+      expect(result.map(r => r.name)).toEqual(["alpha", "gamma", "delta"]);
+    });
+
+    test("filters by view mode (github)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        viewMode: "github"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(3);
+      expect(result.map(r => r.name)).toEqual(["beta", "gamma", "delta"]);
+    });
+
+    test("filters by view mode (combined)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        viewMode: "combined"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(4);
+    });
+
+    test("applies quick filter (github-only)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "github-only"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("beta");
+    });
+
+    test("applies quick filter (local-only)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "local-only"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(3);
+      expect(result.map(r => r.name)).toEqual(["alpha", "gamma", "delta"]);
+    });
+
+    test("applies quick filter (private)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "private"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("gamma");
+    });
+
+    test("applies quick filter (public)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "public"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(3);
+      expect(result.map(r => r.name)).toEqual(["beta", "alpha", "delta"]);
+    });
+
+    test("applies quick filter (archived)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "archived"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("delta");
+    });
+
+    test("applies quick filter (forks)", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        quickFilter: "forks"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("delta");
+    });
+
+    test("filters by text", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        filterText: "mma"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("gamma");
+    });
+
+    test("filters by language", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        languageFilter: "TypeScript"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(2);
+      expect(result.map(r => r.name)).toEqual(["alpha", "gamma"]);
+    });
+
+    test("sorts by stars", () => {
+      const reposWithStars = [
+        createMockUnifiedRepo({ 
+          id: "repo-1", 
+          name: "low-stars",
+          github: createMockGitHubRepo({ stargazersCount: 10 })
+        }),
+        createMockUnifiedRepo({ 
+          id: "repo-2", 
+          name: "high-stars",
+          github: createMockGitHubRepo({ stargazersCount: 1000 })
+        }),
+        createMockUnifiedRepo({ 
+          id: "repo-3", 
+          name: "medium-stars",
+          github: createMockGitHubRepo({ stargazersCount: 100 })
+        })
+      ];
+      
+      const state = createMockState({ 
+        unifiedRepos: reposWithStars,
+        sortBy: "stars",
+        sortDirection: "desc"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result.map(r => r.name)).toEqual(["high-stars", "medium-stars", "low-stars"]);
+    });
+
+    test("sorts by size", () => {
+      const reposWithSize = [
+        createMockUnifiedRepo({ 
+          id: "repo-1", 
+          name: "small",
+          github: createMockGitHubRepo({ size: 100 })
+        }),
+        createMockUnifiedRepo({ 
+          id: "repo-2", 
+          name: "large",
+          github: createMockGitHubRepo({ size: 10000 })
+        }),
+        createMockUnifiedRepo({ 
+          id: "repo-3", 
+          name: "medium",
+          github: createMockGitHubRepo({ size: 1000 })
+        })
+      ];
+      
+      const state = createMockState({ 
+        unifiedRepos: reposWithSize,
+        sortBy: "size",
+        sortDirection: "desc"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result.map(r => r.name)).toEqual(["large", "medium", "small"]);
+    });
+
+    test("combines all filters", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        viewMode: "combined",
+        quickFilter: "all",
+        filterText: "mma",
+        languageFilter: "TypeScript",
+        sortBy: "name",
+        sortDirection: "asc"
+      });
+      const result = simulateUseFilteredUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("gamma");
+    });
+  });
+
+  describe("useSelectedUnifiedRepos", () => {
+    const mockRepos: UnifiedRepo[] = [
+      createMockUnifiedRepo({ id: "repo-1", name: "first" }),
+      createMockUnifiedRepo({ id: "repo-2", name: "second" }),
+      createMockUnifiedRepo({ id: "repo-3", name: "third" })
+    ];
+
+    test("returns repo at cursor when nothing selected", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        cursorIndex: 1,
+        selectedIndices: new Set()
+      });
+      const result = simulateUseSelectedUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("second");
+    });
+
+    test("returns selected repos when indices selected", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        selectedIndices: new Set([0, 2])
+      });
+      const result = simulateUseSelectedUnifiedRepos(state);
+      
+      expect(result).toHaveLength(2);
+      expect(result.map(r => r.name)).toEqual(["first", "third"]);
+    });
+
+    test("returns empty array when cursor out of bounds", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        cursorIndex: 10,
+        selectedIndices: new Set()
+      });
+      const result = simulateUseSelectedUnifiedRepos(state);
+      
+      expect(result).toHaveLength(0);
+    });
+
+    test("filters out undefined indices", () => {
+      const state = createMockState({ 
+        unifiedRepos: mockRepos,
+        selectedIndices: new Set([0, 5, 9]) // 5 and 9 are out of bounds
+      });
+      const result = simulateUseSelectedUnifiedRepos(state);
+      
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe("first");
+    });
+  });
+});