gitforest 0.1.0

package/test/unit/scanner/errors.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Tests for scanner error handling
+ */
+import { describe, test, expect } from "bun:test";
+import { scanAllDirectories, scanWithCache } from "../../../src/scanner/index.ts";
+import type { GitforestConfig } from "../../../src/types/index.ts";
+import { mkdir, rmdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+
+describe("Scanner Error Handling", () => {
+  const createTestConfig = (paths: string[]): GitforestConfig => ({
+    directories: paths.map(path => ({ path, maxDepth: 3, label: "test" })),
+    scan: {
+      ignore: ["node_modules", ".git", "dist", "build"],
+      includeHidden: false,
+      concurrency: 5
+    },
+    github: {
+      defaultVisibility: "private" as const
+    },
+    display: {
+      showNonGitProjects: true,
+      showSubmodules: true,
+      sortBy: "status",
+      sortDirection: "asc"
+    },
+    cache: {
+      ttlSeconds: 300,
+      githubTtlSeconds: 600,
+      enableBackgroundRefresh: false,
+      backgroundRefreshIntervalSeconds: 3600
+    },
+    commands: []
+  });
+
+  describe("Inaccessible Directories", () => {
+    test("should handle non-existent directory gracefully", async () => {
+      const nonExistentPath = "/this/path/does/not/exist/at/all";
+      const config = createTestConfig([nonExistentPath]);
+
+      const projects = await scanAllDirectories(config);
+      
+      expect(projects).toEqual([]);
+    });
+
+    test("should handle directory that becomes inaccessible during scan", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const subDir = join(tempDir, "inaccessible");
+      
+      try {
+        // Create directory structure
+        await mkdir(subDir, { recursive: true });
+        await writeFile(join(subDir, "package.json"), '{"name": "test"}');
+        
+        const config = createTestConfig([tempDir]);
+        
+        // Make subdirectory inaccessible
+        if (process.platform !== "win32") {
+          const { chmod } = await import("fs/promises");
+          await chmod(subDir, 0o000);
+          
+          const projects = await scanAllDirectories(config);
+          
+          // Should still find the parent directory or handle gracefully
+          expect(projects).toBeDefined();
+          expect(Array.isArray(projects)).toBe(true);
+          
+          // Restore permissions for cleanup
+          await chmod(subDir, 0o755);
+        }
+      } finally {
+        // Cleanup
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+
+  describe("Permission Denied", () => {
+    test("should handle permission denied on root directory", async () => {
+      const restrictedPath = "/root";
+      const config = createTestConfig([restrictedPath]);
+
+      const projects = await scanAllDirectories(config);
+      
+      // Should handle gracefully without throwing
+      expect(projects).toBeDefined();
+      expect(Array.isArray(projects)).toBe(true);
+    });
+
+    test("should skip files that cannot be read", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const filePath = join(tempDir, "unreadable.txt");
+      
+      try {
+        await mkdir(tempDir, { recursive: true });
+        await writeFile(filePath, "test content");
+        
+        if (process.platform !== "win32") {
+          const { chmod } = await import("fs/promises");
+          await chmod(filePath, 0o000);
+          
+          const config = createTestConfig([tempDir]);
+          const projects = await scanAllDirectories(config);
+          
+          expect(projects).toBeDefined();
+          expect(Array.isArray(projects)).toBe(true);
+          
+          // Restore permissions for cleanup
+          await chmod(filePath, 0o644);
+        }
+      } finally {
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+
+  describe("Non-existent Paths", () => {
+    test("should handle empty directory list", async () => {
+      const config = createTestConfig([]);
+
+      const projects = await scanAllDirectories(config);
+      
+      expect(projects).toEqual([]);
+    });
+
+    test("should handle mixed valid and invalid paths", async () => {
+      const validPath = tmpdir();
+      const invalidPath = "/this/does/not/exist";
+      const config = createTestConfig([validPath, invalidPath]);
+
+      const projects = await scanAllDirectories(config);
+      
+      expect(projects).toBeDefined();
+      expect(Array.isArray(projects)).toBe(true);
+      // Should find projects from valid path only
+    });
+  });
+
+  describe("Graceful Degradation on Partial Failures", () => {
+    test("should continue scanning when some directories fail", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const validSubDir = join(tempDir, "valid");
+      
+      try {
+        await mkdir(validSubDir, { recursive: true });
+        await writeFile(join(validSubDir, "package.json"), '{"name": "valid-project"}');
+        
+        const config = createTestConfig([tempDir]);
+        const projects = await scanAllDirectories(config);
+        
+        expect(projects).toBeDefined();
+        expect(Array.isArray(projects)).toBe(true);
+        // Should find the valid project despite any issues
+      } finally {
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+
+    test("should handle corrupted cache gracefully", async () => {
+      const config = createTestConfig([tmpdir()]);
+      
+      // Force refresh to bypass cache
+      const projects = await scanWithCache(config, { forceRefresh: true });
+      
+      expect(projects).toBeDefined();
+      expect(Array.isArray(projects)).toBe(true);
+    });
+
+    test("should handle symlink loops", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const linkPath = join(tempDir, "loop");
+      
+      try {
+        await mkdir(tempDir, { recursive: true });
+        
+        if (process.platform !== "win32") {
+          const { symlink } = await import("fs/promises");
+          // Create a symlink that points to itself
+          await symlink(linkPath, linkPath);
+          
+          const config = createTestConfig([tempDir]);
+          const projects = await scanAllDirectories(config);
+          
+          expect(projects).toBeDefined();
+          expect(Array.isArray(projects)).toBe(true);
+          // Should not hang or crash
+        }
+      } finally {
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+
+  describe("Max Depth Protection", () => {
+    test("should respect max depth configuration", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const deepPath = join(tempDir, "a", "b", "c", "d", "e", "f");
+      
+      try {
+        await mkdir(deepPath, { recursive: true });
+        await writeFile(join(deepPath, "package.json"), '{"name": "deep-project"}');
+        
+        const config: GitforestConfig = {
+          directories: [{ path: tempDir, maxDepth: 3, label: "test" }],
+          scan: {
+            ignore: ["node_modules", ".git", "dist", "build"],
+            includeHidden: false,
+            concurrency: 5
+          },
+          github: {
+            defaultVisibility: "private"
+          },
+          display: {
+            showNonGitProjects: true,
+            showSubmodules: true,
+            sortBy: "status",
+            sortDirection: "asc"
+          },
+          cache: {
+            ttlSeconds: 300,
+            githubTtlSeconds: 600,
+            enableBackgroundRefresh: false,
+            backgroundRefreshIntervalSeconds: 3600
+          },
+          commands: []
+        };
+        
+        const projects = await scanAllDirectories(config);
+        
+        expect(projects).toBeDefined();
+        expect(Array.isArray(projects)).toBe(true);
+        // Should not find the project at depth 6 when maxDepth is 3
+      } finally {
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+
+  describe("Concurrent Access Errors", () => {
+    test("should handle directory removed during scan", async () => {
+      const tempDir = join(tmpdir(), `gitforest-test-${Date.now()}`);
+      const volatileDir = join(tempDir, "volatile");
+      
+      try {
+        await mkdir(volatileDir, { recursive: true });
+        await writeFile(join(volatileDir, "package.json"), '{"name": "volatile"}');
+        
+        const config = createTestConfig([tempDir]);
+        
+        // Start scanning and remove directory mid-scan
+        const scanPromise = scanAllDirectories(config);
+        
+        // Remove directory after a short delay
+        setTimeout(async () => {
+          try {
+            await rmdir(volatileDir, { recursive: true });
+          } catch {
+            // Ignore errors
+          }
+        }, 10);
+        
+        const projects = await scanPromise;
+        
+        expect(projects).toBeDefined();
+        expect(Array.isArray(projects)).toBe(true);
+        // Should handle the removal gracefully
+      } finally {
+        try {
+          await rmdir(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+  });
+});