gitforest 0.1.0 → 1.0.0

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

@@ -1,293 +0,0 @@
-/**
- * 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

@@ -1,200 +0,0 @@
-/**
- * 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

@@ -1,217 +0,0 @@
-/**
- * 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();
-});