gitforest 0.1.0

package/test/unit/services/github-errors.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Tests for GitHub service error handling
+ */
+import { describe, test, expect } from "bun:test";
+import { shouldRetryGitHubError, withRetry } from "../../../src/utils/retry.ts";
+import { createMockGitHubService } from "../mocks/github-service.ts";
+
+describe("GitHub Error Handling", () => {
+  describe("shouldRetryGitHubError", () => {
+    test("should retry on rate limit (429)", () => {
+      const error = new Error("rate limit exceeded 429");
+      expect(shouldRetryGitHubError(error, 1)).toBe(true);
+    });
+
+    test("should retry on server errors (5xx)", () => {
+      expect(shouldRetryGitHubError(new Error("500 Internal Server Error"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("502 Bad Gateway"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("503 Service Unavailable"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("504 Gateway Timeout"), 1)).toBe(true);
+    });
+
+    test("should retry on network errors", () => {
+      expect(shouldRetryGitHubError(new Error("network error"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("ECONNRESET"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("ETIMEDOUT"), 1)).toBe(true);
+      expect(shouldRetryGitHubError(new Error("fetch failed"), 1)).toBe(true);
+    });
+
+    test("should NOT retry on client errors (4xx except 429)", () => {
+      expect(shouldRetryGitHubError(new Error("401 Unauthorized"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("403 Forbidden"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("404 Not Found"), 1)).toBe(false);
+      expect(shouldRetryGitHubError(new Error("422 Unprocessable Entity"), 1)).toBe(false);
+    });
+
+    test("should NOT retry on authentication failures with detailed message", () => {
+      const shouldRetry = shouldRetryGitHubError(new Error("401 Unauthorized: Bad credentials"), 1);
+      expect(shouldRetry).toBe(false);
+    });
+
+    test("should NOT retry on 404 with detailed message", () => {
+      const shouldRetry = shouldRetryGitHubError(new Error("404 Not Found"), 1);
+      expect(shouldRetry).toBe(false);
+    });
+  });
+
+  describe("Rate Limiting Recovery", () => {
+    test("should retry on rate limit error", async () => {
+      let attempts = 0;
+
+      const operation = async () => {
+        attempts++;
+        if (attempts < 3) {
+          throw new Error("API rate limit exceeded (429)");
+        }
+        // Return a mock user on success
+        return { login: "testuser", name: "Test User", type: "User" as const };
+      };
+
+      const result = await withRetry(operation, {
+        shouldRetry: shouldRetryGitHubError,
+        maxAttempts: 3,
+        initialDelay: 100
+      });
+
+      expect(result).toBeDefined();
+      expect(result.login).toBe("testuser");
+      expect(attempts).toBe(3);
+    });
+
+    test("should handle rate limit with retry-after header", async () => {
+      let attempts = 0;
+      
+      const operation = async () => {
+        attempts++;
+        throw new Error("rate limit exceeded 429");
+      };
+
+      await expect(
+        withRetry(operation, {
+          shouldRetry: shouldRetryGitHubError,
+          maxAttempts: 2,
+          initialDelay: 50
+        })
+      ).rejects.toThrow("Failed after 2 attempts");
+
+      expect(attempts).toBe(2);
+    });
+  });
+
+  describe("Authentication Failure Handling", () => {
+    test("should not retry on authentication failures", async () => {
+      let attempts = 0;
+      let retryCalls = 0;
+
+      const operation = async () => {
+        attempts++;
+        throw new Error("401 Unauthorized: Bad credentials");
+      };
+
+      // Test the retry function directly
+      const shouldRetry = shouldRetryGitHubError(new Error("401 Unauthorized: Bad credentials"), 1);
+      expect(shouldRetry).toBe(false);
+
+      try {
+        await withRetry(operation, {
+          shouldRetry: (error, attempt) => {
+            retryCalls++;
+            return shouldRetryGitHubError(error, attempt);
+          },
+          maxAttempts: 3,
+          initialDelay: 50
+        });
+      } catch (error: any) {
+        // Should fail after 1 attempt since 401 errors are not retryable
+        expect(retryCalls).toBe(1); // Only called once for the first error
+      }
+
+      expect(attempts).toBe(1);
+    });
+
+    test("should handle token expiration", async () => {
+      const githubService = createMockGitHubService({
+        hasToken: false,
+        token: null
+      });
+
+      expect(githubService.hasToken()).toBe(false);
+      expect(githubService.getToken()).toBeNull();
+    });
+  });
+
+  describe("Retry Logic with Different Error Types", () => {
+    test("should retry on server errors", async () => {
+      let attempts = 0;
+      
+      const operation = async () => {
+        attempts++;
+        if (attempts < 2) {
+          throw new Error("500 Internal Server Error");
+        }
+        return { success: true };
+      };
+
+      const result = await withRetry(operation, {
+        shouldRetry: shouldRetryGitHubError,
+        maxAttempts: 3,
+        initialDelay: 50
+      });
+
+      expect(result).toEqual({ success: true });
+      expect(attempts).toBe(2);
+    });
+
+    test("should retry on network errors", async () => {
+      let attempts = 0;
+      
+      const operation = async () => {
+        attempts++;
+        if (attempts < 2) {
+          throw new Error("ECONNRESET");
+        }
+        return { success: true };
+      };
+
+      const result = await withRetry(operation, {
+        shouldRetry: shouldRetryGitHubError,
+        maxAttempts: 3,
+        initialDelay: 50
+      });
+
+      expect(result).toEqual({ success: true });
+      expect(attempts).toBe(2);
+    });
+
+    test("should not retry on client errors", async () => {
+      // Test the retry function directly
+      const shouldRetry404 = shouldRetryGitHubError(new Error("404 Not Found"), 1);
+      expect(shouldRetry404).toBe(false);
+
+      let attempts = 0;
+      let retryCalls = 0;
+      
+      const operation = async () => {
+        attempts++;
+        throw new Error("404 Not Found");
+      };
+
+      try {
+        await withRetry(operation, {
+          shouldRetry: (error, attempt) => {
+            retryCalls++;
+            return shouldRetryGitHubError(error, attempt);
+          },
+          maxAttempts: 3,
+          initialDelay: 50
+        });
+      } catch (error: any) {
+        // Should fail after 1 attempt since 404 errors are not retryable
+        expect(retryCalls).toBe(1); // Only called once for the first error
+      }
+
+      expect(attempts).toBe(1);
+    });
+  });
+
+  describe("Max Retry Exhaustion", () => {
+    test("should fail after max attempts", async () => {
+      let attempts = 0;
+      
+      const operation = async () => {
+        attempts++;
+        throw new Error("503 Service Unavailable");
+      };
+
+      await expect(
+        withRetry(operation, {
+          shouldRetry: shouldRetryGitHubError,
+          maxAttempts: 3,
+          initialDelay: 50
+        })
+      ).rejects.toThrow("Failed after 3 attempts");
+
+      expect(attempts).toBe(3);
+    });
+
+    test("should include last error in retry error", async () => {
+      const lastError = new Error("504 Gateway Timeout");
+      
+      const operation = async () => {
+        throw lastError;
+      };
+
+      try {
+        await withRetry(operation, {
+          shouldRetry: shouldRetryGitHubError,
+          maxAttempts: 2,
+          initialDelay: 50
+        });
+      } catch (error: any) {
+        expect(error.message).toContain("Failed after 2 attempts");
+        expect(error.lastError).toBe(lastError);
+        expect(error.attempts).toBe(2);
+      }
+    });
+
+    test("should use exponential backoff", async () => {
+      const delays: number[] = [];
+      let lastTime = Date.now();
+      
+      const operation = async () => {
+        const now = Date.now();
+        delays.push(now - lastTime);
+        lastTime = now;
+        throw new Error("502 Bad Gateway");
+      };
+
+      await expect(
+        withRetry(operation, {
+          shouldRetry: shouldRetryGitHubError,
+          maxAttempts: 4,
+          initialDelay: 100,
+          backoffFactor: 2,
+          onRetry: (error, attempt, nextDelay) => {
+            // Verify exponential backoff
+            expect(nextDelay).toBe(100 * Math.pow(2, attempt - 1));
+          }
+        })
+      ).rejects.toThrow("Failed after 4 attempts");
+    });
+  });
+});
+
+describe("Token Validation", () => {
+  test("should validate classic token format", () => {
+    // Classic tokens are 40 hex characters
+    const validClassic = "a".repeat(40);
+    expect(validClassic).toMatch(/^[a-f0-9]{40}$/);
+  });
+
+  test("should validate new PAT format", () => {
+    // New PATs start with ghp_
+    const validPAT = "ghp_" + "a".repeat(36);
+    expect(validPAT).toMatch(/^ghp_[a-zA-Z0-9]{36}$/);
+  });
+
+  test("should validate fine-grained PAT format", () => {
+    // Fine-grained PATs have specific format
+    const pattern = /^github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}$/;
+    const validFineGrained = "github_pat_" + "a".repeat(22) + "_" + "b".repeat(59);
+    expect(validFineGrained).toMatch(pattern);
+  });
+});

package/test/unit/services/github.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Tests for GitHub service implementation
+ * Tests for token validation and basic functionality
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { apiGitHubService } from "../../../src/services/github.ts";
+
+describe("GitHub Service - apiGitHubService", () => {
+  let originalEnv: Record<string, string | undefined>;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("Token handling", () => {
+    test("hasToken returns true when GITHUB_TOKEN is set", () => {
+      process.env.GITHUB_TOKEN = "ghp_test123";
+      expect(apiGitHubService.hasToken()).toBe(true);
+    });
+
+    test("hasToken returns true when GH_TOKEN is set", () => {
+      process.env.GH_TOKEN = "ghp_test123";
+      expect(apiGitHubService.hasToken()).toBe(true);
+    });
+
+    test("hasToken returns false when no token is set", () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+      expect(apiGitHubService.hasToken()).toBe(false);
+    });
+
+    test("getToken returns GITHUB_TOKEN value", () => {
+      process.env.GITHUB_TOKEN = "ghp_test123";
+      expect(apiGitHubService.getToken()).toBe("ghp_test123");
+    });
+
+    test("getToken falls back to GH_TOKEN", () => {
+      process.env.GH_TOKEN = "ghp_fallback123";
+      expect(apiGitHubService.getToken()).toBe("ghp_fallback123");
+    });
+
+    test("getToken returns null when no token is set", () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+      expect(apiGitHubService.getToken()).toBeNull();
+    });
+
+    test("getToken warns on invalid token format", () => {
+      const originalWarn = console.warn;
+      const warnings: string[] = [];
+      console.warn = (message: string) => warnings.push(message);
+      
+      process.env.GITHUB_TOKEN = "invalid-token";
+      apiGitHubService.getToken();
+      
+      expect(warnings.length).toBeGreaterThan(0);
+      expect(warnings[0]).toContain("GITHUB_TOKEN format appears invalid");
+      
+      console.warn = originalWarn;
+    });
+  });
+
+  describe("Token format validation", () => {
+    test("validates classic 40-char hex tokens", () => {
+      const validToken = "a".repeat(40);
+      expect(validToken).toMatch(/^[a-f0-9]{40}$/);
+    });
+
+    test("validates ghp_ prefix tokens", () => {
+      const validToken = "ghp_" + "a".repeat(36);
+      expect(validToken).toMatch(/^ghp_[a-zA-Z0-9]{36}$/);
+    });
+
+    test("validates github_pat_ fine-grained tokens", () => {
+      const validToken = "github_pat_" + "a".repeat(22) + "_" + "b".repeat(59);
+      expect(validToken).toMatch(/^github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}$/);
+    });
+
+    test("validates gho_ OAuth tokens", () => {
+      const validToken = "gho_" + "a".repeat(40);
+      expect(validToken).toMatch(/^gho_[a-zA-Z0-9]{35,40}$/);
+    });
+
+    test("validates ghs_ GitHub App tokens", () => {
+      const validToken = "ghs_" + "a".repeat(36);
+      expect(validToken).toMatch(/^ghs_[a-zA-Z0-9]{36}$/);
+    });
+
+    test("validates ghr_ refresh tokens", () => {
+      const validToken = "ghr_" + "a".repeat(36);
+      expect(validToken).toMatch(/^ghr_[a-zA-Z0-9]{36}$/);
+    });
+
+    test("rejects invalid formats", () => {
+      const invalidTokens = [
+        "invalid",
+        "123",
+        "ghp_" + "a".repeat(35), // Too short
+        "github_pat_" + "a".repeat(21) + "_" + "b".repeat(58), // Too short
+      ];
+
+      for (const token of invalidTokens) {
+        const patterns = [
+          /^ghp_[a-zA-Z0-9]{36}$/,
+          /^github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}$/,
+          /^gho_[a-zA-Z0-9]{35,40}$/,
+          /^ghs_[a-zA-Z0-9]{36}$/,
+          /^ghr_[a-zA-Z0-9]{36}$/,
+          /^[a-f0-9]{40}$/,
+        ];
+        
+        const isValid = patterns.some(pattern => pattern.test(token));
+        expect(isValid).toBe(false);
+      }
+    });
+  });
+
+  describe("Error handling", () => {
+    test("handles missing token in createRepo", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.createRepo({
+        name: "test-repo",
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+    });
+  });
+
+  describe("Repository operations", () => {
+    test("createRepo handles missing token", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.createRepo({
+        name: "test-repo",
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+    });
+
+    test("archiveRepo handles missing token", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.archiveRepo("user/repo");
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+    });
+
+    test("unarchiveRepo handles missing token", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.unarchiveRepo("user/repo");
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+    });
+
+    test("deleteRepo handles missing token", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.deleteRepo("user/repo");
+      
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("GITHUB_TOKEN not set");
+    });
+  });
+
+  describe("cloneRepo", () => {
+    test("cloneRepo handles missing token", async () => {
+      delete process.env.GITHUB_TOKEN;
+      delete process.env.GH_TOKEN;
+
+      const result = await apiGitHubService.cloneRepo(
+        {
+          fullName: "user/repo",
+          sshUrl: "git@github.com:user/repo.git",
+          cloneUrl: "https://github.com/user/repo.git",
+        } as any,
+        { targetDir: "/tmp/clone-test" }
+      );
+
+      // cloneRepo doesn't require token, should work
+      expect(result.operation).toBe("clone");
+      expect(typeof result.duration).toBe("number");
+    });
+  });
+});

package/test/unit/state/actions.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Tests for state action creators
+ * 
+ * NOTE: This file must NOT have any module mocks as it tests real implementations.
+ * We restore any mocks at the start to ensure isolation.
+ */
+
+import { describe, test, expect, beforeAll, afterAll, mock } from "bun:test";
+
+// Restore any mocks from other test files before importing real modules
+mock.restore();
+
+import {
+  setProjects,
+  setLoading,
+  setError,
+  setMessage,
+  moveCursor,
+  toggleSelection,
+  selectAll,
+  deselectAll,
+  setFilter,
+  setSort,
+  cycleSort,
+  setMode,
+  startAction,
+  endAction,
+  setScrollOffset,
+  updateProject,
+} from "../../../src/state/actions.ts";
+import { createMockProject } from "../mocks/index.ts";
+
+describe("state action creators", () => {
+  describe("setProjects", () => {
+    test("creates SET_PROJECTS action", () => {
+      const projects = [createMockProject(), createMockProject()];
+      const action = setProjects(projects);
+
+      expect(action.type).toBe("SET_PROJECTS");
+      expect(action.payload).toBe(projects);
+    });
+  });
+
+  describe("setLoading", () => {
+    test("creates SET_LOADING action with true", () => {
+      const action = setLoading(true);
+
+      expect(action.type).toBe("SET_LOADING");
+      expect(action.payload).toBe(true);
+    });
+
+    test("creates SET_LOADING action with false", () => {
+      const action = setLoading(false);
+
+      expect(action.type).toBe("SET_LOADING");
+      expect(action.payload).toBe(false);
+    });
+  });
+
+  describe("setError", () => {
+    test("creates SET_ERROR action with error message", () => {
+      const action = setError("Something went wrong");
+
+      expect(action.type).toBe("SET_ERROR");
+      expect(action.payload).toBe("Something went wrong");
+    });
+
+    test("creates SET_ERROR action with null", () => {
+      const action = setError(null);
+
+      expect(action.type).toBe("SET_ERROR");
+      expect(action.payload).toBe(null);
+    });
+  });
+
+  describe("setMessage", () => {
+    test("creates SET_MESSAGE action", () => {
+      const action = setMessage("Operation successful");
+
+      expect(action.type).toBe("SET_MESSAGE");
+      expect(action.payload).toBe("Operation successful");
+    });
+  });
+
+  describe("moveCursor", () => {
+    test("creates MOVE_CURSOR action", () => {
+      const action = moveCursor(5);
+
+      expect(action.type).toBe("MOVE_CURSOR");
+      expect(action.payload).toBe(5);
+    });
+  });
+
+  describe("toggleSelection", () => {
+    test("creates TOGGLE_SELECTION action", () => {
+      const action = toggleSelection(3);
+
+      expect(action.type).toBe("TOGGLE_SELECTION");
+      expect(action.payload).toBe(3);
+    });
+  });
+
+  describe("selectAll", () => {
+    test("creates SELECT_ALL action", () => {
+      const action = selectAll();
+
+      expect(action.type).toBe("SELECT_ALL");
+    });
+  });
+
+  describe("deselectAll", () => {
+    test("creates DESELECT_ALL action", () => {
+      const action = deselectAll();
+
+      expect(action.type).toBe("DESELECT_ALL");
+    });
+  });
+
+  describe("setFilter", () => {
+    test("creates SET_FILTER action", () => {
+      const action = setFilter("my-project");
+
+      expect(action.type).toBe("SET_FILTER");
+      expect(action.payload).toBe("my-project");
+    });
+  });
+
+  describe("setSort", () => {
+    test("creates SET_SORT action", () => {
+      const action = setSort("name", "asc");
+
+      expect(action.type).toBe("SET_SORT");
+      expect(action.payload).toEqual({ by: "name", direction: "asc" });
+    });
+
+    test("creates SET_SORT action with status desc", () => {
+      const action = setSort("status", "desc");
+
+      expect(action.type).toBe("SET_SORT");
+      expect(action.payload).toEqual({ by: "status", direction: "desc" });
+    });
+  });
+
+  describe("cycleSort", () => {
+    test("creates CYCLE_SORT action", () => {
+      const action = cycleSort();
+
+      expect(action.type).toBe("CYCLE_SORT");
+    });
+  });
+
+  describe("setMode", () => {
+    test("creates SET_MODE action for normal", () => {
+      const action = setMode("normal");
+
+      expect(action.type).toBe("SET_MODE");
+      expect(action.payload).toBe("normal");
+    });
+
+    test("creates SET_MODE action for filter", () => {
+      const action = setMode("filter");
+
+      expect(action.type).toBe("SET_MODE");
+      expect(action.payload).toBe("filter");
+    });
+
+    test("creates SET_MODE action for help", () => {
+      const action = setMode("help");
+
+      expect(action.type).toBe("SET_MODE");
+      expect(action.payload).toBe("help");
+    });
+  });
+
+  describe("startAction", () => {
+    test("creates START_ACTION action", () => {
+      const action = startAction("Pushing 5 projects");
+
+      expect(action.type).toBe("START_ACTION");
+      expect(action.payload).toBe("Pushing 5 projects");
+    });
+  });
+
+  describe("endAction", () => {
+    test("creates END_ACTION action", () => {
+      const action = endAction();
+
+      expect(action.type).toBe("END_ACTION");
+    });
+  });
+
+  describe("setScrollOffset", () => {
+    test("creates SET_SCROLL_OFFSET action", () => {
+      const action = setScrollOffset(10);
+
+      expect(action.type).toBe("SET_SCROLL_OFFSET");
+      expect(action.payload).toBe(10);
+    });
+  });
+
+  describe("updateProject", () => {
+    test("creates UPDATE_PROJECT action", () => {
+      const action = updateProject("project-123", { name: "new-name" });
+
+      expect(action.type).toBe("UPDATE_PROJECT");
+      expect(action.payload).toEqual({
+        id: "project-123",
+        updates: { name: "new-name" },
+      });
+    });
+  });
+});
+
+// Restore all mocks after all tests complete
+afterAll(() => {
+  mock.restore();
+});