gitforest 0.1.0

package/test/unit/state/reducer.test.ts

@@ -0,0 +1,745 @@
+import { describe, test, expect } from "bun:test";
+import type { UnifiedAppState, UnifiedAppAction, Project, ViewMode, CloneDialogState, DetailModalState, GitHubRepoInfo, UnifiedRepo, QuickFilter } from "../../../src/types/index.ts";
+import { appReducer, initialState } from "../../../src/state/reducer.ts";
+
+// Create a test initial state (can be customized for testing)
+function createInitialState(): UnifiedAppState {
+  return { ...initialState };
+}
+
+function createMockProject(overrides?: Partial<Project>): Project {
+  return {
+    id: "test-id",
+    name: "test-project",
+    path: "/test/project",
+    type: "git",
+    projectMarker: null,
+    status: null,
+    submodule: null,
+    lastScanned: new Date(),
+    lastModified: null,
+    ...overrides,
+  };
+}
+
+function createMockGitHubRepo(overrides?: Partial<GitHubRepoInfo>): GitHubRepoInfo {
+  return {
+    name: "test-repo",
+    fullName: "user/test-repo",
+    owner: "user",
+    description: "Test repository",
+    htmlUrl: "https://github.com/user/test-repo",
+    sshUrl: "git@github.com:user/test-repo.git",
+    cloneUrl: "https://github.com/user/test-repo.git",
+    isPrivate: false,
+    isArchived: false,
+    isFork: false,
+    pushedAt: new Date(),
+    updatedAt: new Date(),
+    defaultBranch: "main",
+    language: "TypeScript",
+    size: 1000,
+    ...overrides,
+  };
+}
+
+function createMockUnifiedRepo(overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  return {
+    id: "test-repo-id",
+    name: "test-repo",
+    source: "both",
+    local: null,
+    github: createMockGitHubRepo(),
+    isCloned: false,
+    isOnGitHub: true,
+    localPath: null,
+    ...overrides,
+  };
+}
+
+describe("appReducer", () => {
+  describe("SET_PROJECTS", () => {
+    test("sets projects array", () => {
+      const state = createInitialState();
+      const projects = [createMockProject({ id: "1" }), createMockProject({ id: "2" })];
+
+      const newState = appReducer(state, { type: "SET_PROJECTS", payload: projects });
+
+      expect(newState.projects).toHaveLength(2);
+      expect(newState.projects[0]?.id).toBe("1");
+    });
+
+    test("adjusts cursor if out of bounds", () => {
+      const state = { ...createInitialState(), cursorIndex: 5 };
+      const projects = [createMockProject()];
+
+      const newState = appReducer(state, { type: "SET_PROJECTS", payload: projects });
+
+      expect(newState.cursorIndex).toBe(0);
+    });
+
+    test("keeps cursor in bounds", () => {
+      const state = { ...createInitialState(), cursorIndex: 1 };
+      const projects = [createMockProject({ id: "1" }), createMockProject({ id: "2" }), createMockProject({ id: "3" })];
+
+      const newState = appReducer(state, { type: "SET_PROJECTS", payload: projects });
+
+      expect(newState.cursorIndex).toBe(1);
+    });
+  });
+
+  describe("SET_LOADING", () => {
+    test("sets loading true", () => {
+      const state = { ...createInitialState(), isLoading: false };
+      const newState = appReducer(state, { type: "SET_LOADING", payload: true });
+      expect(newState.isLoading).toBe(true);
+    });
+
+    test("sets loading false", () => {
+      const state = createInitialState();
+      const newState = appReducer(state, { type: "SET_LOADING", payload: false });
+      expect(newState.isLoading).toBe(false);
+    });
+  });
+
+  describe("SET_ERROR", () => {
+    test("sets error message", () => {
+      const state = createInitialState();
+      const newState = appReducer(state, { type: "SET_ERROR", payload: "Test error" });
+      expect(newState.error).toBe("Test error");
+    });
+
+    test("clears error message", () => {
+      const state = { ...createInitialState(), error: "Previous error" };
+      const newState = appReducer(state, { type: "SET_ERROR", payload: null });
+      expect(newState.error).toBeNull();
+    });
+  });
+
+  describe("SET_MESSAGE", () => {
+    test("sets message", () => {
+      const state = createInitialState();
+      const newState = appReducer(state, { type: "SET_MESSAGE", payload: "Test message" });
+      expect(newState.message).toBe("Test message");
+    });
+
+    test("clears message", () => {
+      const state = { ...createInitialState(), message: "Previous message" };
+      const newState = appReducer(state, { type: "SET_MESSAGE", payload: null });
+      expect(newState.message).toBeNull();
+    });
+  });
+
+  describe("MOVE_CURSOR", () => {
+    test("uses unifiedRepos length for cursor bounds when available", () => {
+      const repos = [
+        { id: "1", name: "repo1", source: "local" as const, local: createMockProject({ id: "1" }), github: null, isCloned: true, isOnGitHub: false, localPath: "/path1" },
+        { id: "2", name: "repo2", source: "local" as const, local: createMockProject({ id: "2" }), github: null, isCloned: true, isOnGitHub: false, localPath: "/path2" },
+      ] as UnifiedRepo[];
+      const state = { ...createInitialState(), unifiedRepos: repos };
+
+      const newState = appReducer(state, { type: "MOVE_CURSOR", payload: 1 });
+
+      expect(newState.cursorIndex).toBe(1);
+    });
+
+    test("clamps cursor at minimum (0)", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "MOVE_CURSOR", payload: -5 });
+
+      expect(newState.cursorIndex).toBe(0);
+    });
+
+    test("clamps cursor at maximum", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "MOVE_CURSOR", payload: 10 });
+
+      expect(newState.cursorIndex).toBe(0); // unifiedRepos is empty, so clamped to 0
+    });
+  });
+
+  describe("TOGGLE_SELECTION", () => {
+    test("adds index to selection", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "TOGGLE_SELECTION", payload: 0 });
+
+      expect(newState.selectedIndices.has(0)).toBe(true);
+    });
+
+    test("removes index from selection", () => {
+      const state = { ...createInitialState(), selectedIndices: new Set([0, 1, 2]) };
+
+      const newState = appReducer(state, { type: "TOGGLE_SELECTION", payload: 1 });
+
+      expect(newState.selectedIndices.has(1)).toBe(false);
+      expect(newState.selectedIndices.has(0)).toBe(true);
+      expect(newState.selectedIndices.has(2)).toBe(true);
+    });
+  });
+
+  describe("SELECT_ALL", () => {
+    test("selects all unified repos", () => {
+      const repos = [createMockUnifiedRepo({ id: "1" }), createMockUnifiedRepo({ id: "2" }), createMockUnifiedRepo({ id: "3" })];
+      const state = { ...createInitialState(), unifiedRepos: repos };
+
+      const newState = appReducer(state, { type: "SELECT_ALL" });
+
+      expect(newState.selectedIndices.size).toBe(3);
+      expect(newState.selectedIndices.has(0)).toBe(true);
+      expect(newState.selectedIndices.has(1)).toBe(true);
+      expect(newState.selectedIndices.has(2)).toBe(true);
+    });
+  });
+
+  describe("DESELECT_ALL", () => {
+    test("clears all selections", () => {
+      const state = { ...createInitialState(), selectedIndices: new Set([0, 1, 2]) };
+
+      const newState = appReducer(state, { type: "DESELECT_ALL" });
+
+      expect(newState.selectedIndices.size).toBe(0);
+    });
+  });
+
+  describe("SET_FILTER", () => {
+    test("sets filter text", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "SET_FILTER", payload: "test" });
+
+      expect(newState.filterText).toBe("test");
+    });
+
+    test("resets cursor to 0", () => {
+      const state = { ...createInitialState(), cursorIndex: 5 };
+
+      const newState = appReducer(state, { type: "SET_FILTER", payload: "test" });
+
+      expect(newState.cursorIndex).toBe(0);
+    });
+  });
+
+  describe("SET_QUICK_FILTER", () => {
+    test("sets quick filter", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "SET_QUICK_FILTER", payload: "dirty" });
+
+      expect(newState.quickFilter).toBe("dirty");
+    });
+
+    test("resets cursor and clears selection", () => {
+      const state = {
+        ...createInitialState(),
+        cursorIndex: 5,
+        selectedIndices: new Set([1, 2, 3])
+      };
+
+      const newState = appReducer(state, { type: "SET_QUICK_FILTER", payload: "all" });
+
+      expect(newState.cursorIndex).toBe(0);
+      expect(newState.selectedIndices.size).toBe(0);
+    });
+  });
+
+  describe("SET_SORT", () => {
+    test("sets sort field and direction", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, {
+        type: "SET_SORT",
+        payload: { by: "name", direction: "asc" },
+      });
+
+      expect(newState.sortBy).toBe("name");
+      expect(newState.sortDirection).toBe("asc");
+    });
+  });
+
+  describe("CYCLE_SORT", () => {
+    test("cycles from status to name", () => {
+      const state = { ...createInitialState(), sortBy: "status" as const };
+
+      const newState = appReducer(state, { type: "CYCLE_SORT" });
+
+      expect(newState.sortBy).toBe("name");
+    });
+
+    test("cycles from name to branch", () => {
+      const state = { ...createInitialState(), sortBy: "name" as const };
+
+      const newState = appReducer(state, { type: "CYCLE_SORT" });
+
+      expect(newState.sortBy).toBe("branch");
+    });
+
+    test("cycles from lastActivity to size", () => {
+      const state = { ...createInitialState(), sortBy: "lastActivity" as const };
+
+      const newState = appReducer(state, { type: "CYCLE_SORT" });
+
+      expect(newState.sortBy).toBe("size");
+    });
+
+    test("cycles from forks to lastActivity", () => {
+      const state = { ...createInitialState(), sortBy: "forks" as const };
+
+      const newState = appReducer(state, { type: "CYCLE_SORT" });
+
+      expect(newState.sortBy).toBe("lastActivity");
+    });
+
+    test("cycles from size back to status", () => {
+      const state = { ...createInitialState(), sortBy: "size" as const };
+
+      const newState = appReducer(state, { type: "CYCLE_SORT" });
+
+      expect(newState.sortBy).toBe("status");
+    });
+  });
+
+  describe("SET_MODE", () => {
+    test("sets mode to filter", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "SET_MODE", payload: "filter" });
+
+      expect(newState.mode).toBe("filter");
+    });
+
+    test("sets mode to help", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "SET_MODE", payload: "help" });
+
+      expect(newState.mode).toBe("help");
+    });
+
+    test("sets mode back to normal", () => {
+      const state = { ...createInitialState(), mode: "filter" as const };
+
+      const newState = appReducer(state, { type: "SET_MODE", payload: "normal" });
+
+      expect(newState.mode).toBe("normal");
+    });
+  });
+
+  describe("START_ACTION / END_ACTION / UPDATE_PROGRESS", () => {
+    test("starts action", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "START_ACTION", payload: "Pulling" });
+
+      expect(newState.actionInProgress).toBe("Pulling");
+      expect(newState.actionProgress).toBeNull();
+    });
+
+    test("ends action", () => {
+      const state = { ...createInitialState(), actionInProgress: "Pulling" };
+
+      const newState = appReducer(state, { type: "END_ACTION" });
+
+      expect(newState.actionInProgress).toBeNull();
+      expect(newState.actionProgress).toBeNull();
+    });
+
+    test("updates progress", () => {
+      const state = { ...createInitialState(), actionInProgress: "Processing" };
+      const progress = { current: 5, total: 10 };
+
+      const newState = appReducer(state, { type: "UPDATE_PROGRESS", payload: progress });
+
+      expect(newState.actionProgress).toEqual(progress);
+    });
+  });
+
+  describe("SET_SCROLL_OFFSET", () => {
+    test("sets scroll offset", () => {
+      const state = createInitialState();
+
+      const newState = appReducer(state, { type: "SET_SCROLL_OFFSET", payload: 10 });
+
+      expect(newState.scrollOffset).toBe(10);
+    });
+  });
+
+  describe("UPDATE_PROJECT", () => {
+    test("updates specific project", () => {
+      const projects = [
+        createMockProject({ id: "1", name: "old-name" }),
+        createMockProject({ id: "2", name: "other" }),
+      ];
+      const state = { ...createInitialState(), projects };
+
+      const newState = appReducer(state, {
+        type: "UPDATE_PROJECT",
+        payload: { id: "1", updates: { name: "new-name" } },
+      });
+
+      expect(newState.projects[0]?.name).toBe("new-name");
+      expect(newState.projects[1]?.name).toBe("other");
+    });
+
+    test("does not modify projects when id not found", () => {
+      const projects = [createMockProject({ id: "1" })];
+      const state = { ...createInitialState(), projects };
+
+      const newState = appReducer(state, {
+        type: "UPDATE_PROJECT",
+        payload: { id: "nonexistent", updates: { name: "new-name" } },
+      });
+
+      expect(newState.projects[0]?.name).toBe("test-project");
+    });
+  });
+
+  describe("SHOW_CONFIRM_DIALOG / HIDE_CONFIRM_DIALOG", () => {
+    test("shows confirm dialog", () => {
+      const state = createInitialState();
+      const dialog = {
+        operation: "setup" as const,
+        title: "Confirm Setup",
+        message: "Setup these projects?",
+        items: ["project1", "project2"],
+        projectPaths: ["/path1", "/path2"],
+        showVisibilityToggle: false,
+      };
+
+      const newState = appReducer(state, { type: "SHOW_CONFIRM_DIALOG", payload: dialog });
+
+      expect(newState.mode).toBe("confirm");
+      expect(newState.confirmDialog).toEqual(dialog);
+    });
+
+    test("hides confirm dialog", () => {
+      const state = {
+        ...createInitialState(),
+        mode: "confirm" as const,
+        confirmDialog: {
+          operation: "setup" as const,
+          title: "Confirm Setup",
+          message: "Setup these projects?",
+          items: ["project1"],
+          projectPaths: ["/path1"],
+          showVisibilityToggle: false,
+        },
+      };
+
+      const newState = appReducer(state, { type: "HIDE_CONFIRM_DIALOG" });
+
+      expect(newState.mode).toBe("normal");
+      expect(newState.confirmDialog).toBeNull();
+    });
+  });
+
+  describe("Unified View Actions", () => {
+    describe("SET_VIEW_MODE", () => {
+      test("sets view mode", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "SET_VIEW_MODE", payload: "github" });
+
+        expect(newState.viewMode).toBe("github");
+      });
+
+      test("resets cursor when changing view mode", () => {
+        const state = { ...createInitialState(), cursorIndex: 5 };
+
+        const newState = appReducer(state, { type: "SET_VIEW_MODE", payload: "local" });
+
+        expect(newState.cursorIndex).toBe(0);
+      });
+    });
+
+    describe("SET_GITHUB_REPOS", () => {
+      test("sets GitHub repos", () => {
+        const state = createInitialState();
+        const repos = [
+          {
+            name: "repo1",
+            fullName: "user/repo1",
+            owner: "user",
+            description: null,
+            htmlUrl: "https://github.com/user/repo1",
+            sshUrl: "git@github.com:user/repo1.git",
+            cloneUrl: "https://github.com/user/repo1.git",
+            isPrivate: false,
+            isArchived: false,
+            isFork: false,
+            pushedAt: null,
+            updatedAt: null,
+            defaultBranch: "main",
+            language: "TypeScript",
+            size: 100,
+          },
+        ] as GitHubRepoInfo[];
+
+        const newState = appReducer(state, { type: "SET_GITHUB_REPOS", payload: repos });
+
+        expect(newState.githubRepos).toEqual(repos);
+      });
+    });
+
+    describe("SET_UNIFIED_REPOS", () => {
+      test("sets unified repos", () => {
+        const state = createInitialState();
+        const repos = [
+          {
+            id: "repo1",
+            name: "repo1",
+            source: "both" as const,
+            local: createMockProject({ id: "repo1" }),
+            github: null,
+            isCloned: true,
+            isOnGitHub: false,
+            localPath: "/path/to/repo1",
+          },
+        ] as UnifiedRepo[];
+
+        const newState = appReducer(state, { type: "SET_UNIFIED_REPOS", payload: repos });
+
+        expect(newState.unifiedRepos).toEqual(repos);
+      });
+    });
+
+    describe("SET_GITHUB_LOADING", () => {
+      test("sets GitHub loading state", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "SET_GITHUB_LOADING", payload: true });
+
+        expect(newState.isLoadingGitHub).toBe(true);
+      });
+    });
+
+    describe("SET_GITHUB_ERROR", () => {
+      test("sets GitHub error", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "SET_GITHUB_ERROR", payload: "API Error" });
+
+        expect(newState.githubError).toBe("API Error");
+      });
+
+      test("clears GitHub error", () => {
+        const state = { ...createInitialState(), githubError: "Previous Error" };
+
+        const newState = appReducer(state, { type: "SET_GITHUB_ERROR", payload: null });
+
+        expect(newState.githubError).toBeNull();
+      });
+    });
+
+    describe("SET_REFRESHING", () => {
+      test("sets refreshing state", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "SET_REFRESHING", payload: true });
+
+        expect(newState.isRefreshing).toBe(true);
+      });
+    });
+
+    describe("Clone Dialog Actions", () => {
+      test("shows clone dialog", () => {
+        const state = createInitialState();
+        const dialog = {
+          repos: [],
+          directories: [],
+          selectedDirIndex: 0,
+          useSSH: false,
+        } as CloneDialogState;
+
+        const newState = appReducer(state, { type: "SHOW_CLONE_DIALOG", payload: dialog });
+
+        expect(newState.mode).toBe("clone");
+        expect(newState.cloneDialog).toEqual(dialog);
+      });
+
+      test("hides clone dialog", () => {
+        const state = {
+          ...createInitialState(),
+          mode: "clone" as const,
+          cloneDialog: {
+            repos: [],
+            directories: [],
+            selectedDirIndex: 0,
+            useSSH: false,
+          } as CloneDialogState,
+        };
+
+        const newState = appReducer(state, { type: "HIDE_CLONE_DIALOG" });
+
+        expect(newState.mode).toBe("normal");
+        expect(newState.cloneDialog).toBeNull();
+      });
+
+      test("updates clone dialog", () => {
+        const state = {
+          ...createInitialState(),
+          cloneDialog: {
+            repos: [],
+            directories: [],
+            selectedDirIndex: 0,
+            useSSH: false,
+          } as CloneDialogState,
+        };
+
+        const newState = appReducer(state, {
+          type: "UPDATE_CLONE_DIALOG",
+          payload: { selectedDirIndex: 1, useSSH: true }
+        });
+
+        expect(newState.cloneDialog?.selectedDirIndex).toBe(1);
+        expect(newState.cloneDialog?.useSSH).toBe(true);
+      });
+    });
+
+    describe("Clone Repo Actions", () => {
+      test("starts clone repo", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "CLONE_REPO_START", payload: "repo1" });
+
+        expect(newState.actionInProgress).toBe("Cloning repo1...");
+        expect(newState.actionProgress).toBeNull();
+      });
+
+      test("completes clone repo", () => {
+        const repos = [
+          {
+            id: "repo1",
+            name: "repo1",
+            source: "github" as const,
+            local: null,
+            github: null,
+            isCloned: false,
+            isOnGitHub: true,
+            localPath: null,
+          },
+        ] as UnifiedRepo[];
+        const state = { ...createInitialState(), unifiedRepos: repos };
+
+        const newState = appReducer(state, {
+          type: "CLONE_REPO_COMPLETE",
+          payload: { id: "repo1", localPath: "/path/to/repo1" }
+        });
+
+        expect(newState.unifiedRepos[0]?.isCloned).toBe(true);
+        expect(newState.unifiedRepos[0]?.localPath).toBe("/path/to/repo1");
+        expect(newState.actionInProgress).toBeNull();
+        expect(newState.actionProgress).toBeNull();
+      });
+
+      test("fails clone repo", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, {
+          type: "CLONE_REPO_FAILED",
+          payload: { id: "repo1", error: "Permission denied" }
+        });
+
+        expect(newState.error).toBe("Failed to clone repo1: Permission denied");
+        expect(newState.actionInProgress).toBeNull();
+        expect(newState.actionProgress).toBeNull();
+      });
+    });
+
+    describe("Detail Modal Actions", () => {
+      test("shows detail modal", () => {
+        const state = createInitialState();
+        const repo = {
+          id: "repo1",
+          name: "repo1",
+          source: "local" as const,
+          local: createMockProject({ id: "repo1" }),
+          github: null,
+          isCloned: true,
+          isOnGitHub: false,
+          localPath: "/path/to/repo1",
+        } as UnifiedRepo;
+        const modal = {
+          repo,
+          readmeContent: null,
+          readmeLoading: false,
+          readmeError: null,
+          readmeScrollOffset: 0,
+        } as DetailModalState;
+
+        const newState = appReducer(state, { type: "SHOW_DETAIL_MODAL", payload: modal });
+
+        expect(newState.mode).toBe("detail");
+        expect(newState.detailModal).toEqual(modal);
+      });
+
+      test("hides detail modal", () => {
+        const state = {
+          ...createInitialState(),
+          mode: "detail" as const,
+          detailModal: {
+            repo: {} as UnifiedRepo,
+            readmeContent: null,
+            readmeLoading: false,
+            readmeError: null,
+            readmeScrollOffset: 0,
+          } as DetailModalState,
+        };
+
+        const newState = appReducer(state, { type: "HIDE_DETAIL_MODAL" });
+
+        expect(newState.mode).toBe("normal");
+        expect(newState.detailModal).toBeNull();
+      });
+
+      test("updates detail modal", () => {
+        const state = {
+          ...createInitialState(),
+          detailModal: {
+            repo: {} as UnifiedRepo,
+            readmeContent: null,
+            readmeLoading: false,
+            readmeError: null,
+            readmeScrollOffset: 0,
+          } as DetailModalState,
+        };
+
+        const newState = appReducer(state, {
+          type: "UPDATE_DETAIL_MODAL",
+          payload: { readmeLoading: true, readmeScrollOffset: 100 }
+        });
+
+        expect(newState.detailModal?.readmeLoading).toBe(true);
+        expect(newState.detailModal?.readmeScrollOffset).toBe(100);
+      });
+    });
+
+    describe("SET_LANGUAGE_FILTER", () => {
+      test("sets language filter", () => {
+        const state = createInitialState();
+
+        const newState = appReducer(state, { type: "SET_LANGUAGE_FILTER", payload: "TypeScript" });
+
+        expect(newState.languageFilter).toBe("TypeScript");
+      });
+
+      test("resets cursor when setting language filter", () => {
+        const state = { ...createInitialState(), cursorIndex: 5 };
+
+        const newState = appReducer(state, { type: "SET_LANGUAGE_FILTER", payload: "JavaScript" });
+
+        expect(newState.cursorIndex).toBe(0);
+      });
+
+      test("clears language filter", () => {
+        const state = { ...createInitialState(), languageFilter: "TypeScript" };
+
+        const newState = appReducer(state, { type: "SET_LANGUAGE_FILTER", payload: null });
+
+        expect(newState.languageFilter).toBeNull();
+      });
+    });
+  });
+});