cf-yoyo 1.0.0

package/__tests__/filesystem.test.ts

@@ -0,0 +1,453 @@
+/**
+ * filesystem.ts 模組測試
+ * 測試檔案系統操作功能
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import {
+  directoryExists,
+  fileExists,
+  isEmptyDir,
+  createDirectory,
+  deleteDirectory,
+  writeFile,
+  readFile,
+  copyFile,
+  copyDirectory,
+  deleteFile,
+  checkDirectoryConflict,
+  createProjectStructure,
+  listDirectory,
+  getFileSize,
+  getFileModifiedDate,
+} from '../src/core/filesystem';
+import { ConflictResolution } from '../src/types';
+
+describe('FileSystem', () => {
+  let testBaseDir: string;
+
+  beforeEach(() => {
+    // 創建一個基礎臨時目錄供測試使用
+    testBaseDir = fs.mkdtempSync(path.join(process.cwd(), '__tests__', 'temp-'));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testBaseDir)) {
+      fs.rmSync(testBaseDir, { recursive: true, force: true });
+    }
+  });
+
+  // ==================== Basic Queries ====================
+
+  describe('directoryExists', () => {
+    it('should return true for existing directory', () => {
+      const testDir = path.join(testBaseDir, 'existing-dir');
+      fs.mkdirSync(testDir);
+      expect(directoryExists(testDir)).toBe(true);
+    });
+
+    it('should return false for non-existing directory', () => {
+      expect(directoryExists(path.join(testBaseDir, 'nope'))).toBe(false);
+    });
+
+    it('should return false for file path', () => {
+      const testFile = path.join(testBaseDir, 'file.txt');
+      fs.writeFileSync(testFile, 'content');
+      expect(directoryExists(testFile)).toBe(false);
+    });
+  });
+
+  describe('fileExists', () => {
+    it('should return true for existing file', () => {
+      const testFile = path.join(testBaseDir, 'file.txt');
+      fs.writeFileSync(testFile, 'content');
+      expect(fileExists(testFile)).toBe(true);
+    });
+
+    it('should return false for non-existing file', () => {
+      expect(fileExists(path.join(testBaseDir, 'nope.txt'))).toBe(false);
+    });
+
+    it('should return false for directory path', () => {
+      const testDir = path.join(testBaseDir, 'some-dir');
+      fs.mkdirSync(testDir);
+      expect(fileExists(testDir)).toBe(false);
+    });
+  });
+
+  describe('isEmptyDir', () => {
+    it('should return true for empty directory', () => {
+      const testDir = path.join(testBaseDir, 'empty-dir');
+      fs.mkdirSync(testDir);
+      expect(isEmptyDir(testDir)).toBe(true);
+    });
+
+    it('should return false for non-empty directory', () => {
+      const testDir = path.join(testBaseDir, 'non-empty-dir');
+      fs.mkdirSync(testDir);
+      fs.writeFileSync(path.join(testDir, 'file.txt'), 'content');
+      expect(isEmptyDir(testDir)).toBe(false);
+    });
+
+    it('should return true for non-existing directory', () => {
+      expect(isEmptyDir(path.join(testBaseDir, 'nope'))).toBe(true);
+    });
+  });
+
+  // ==================== Directory Operations ====================
+
+  describe('createDirectory', () => {
+    it('should create directory successfully', () => {
+      const testDir = path.join(testBaseDir, 'new-dir');
+      const result = createDirectory(testDir);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testDir)).toBe(true);
+    });
+
+    it('should return true when directory already exists (recursive mode)', () => {
+      const testDir = path.join(testBaseDir, 'existing-dir');
+      fs.mkdirSync(testDir);
+      const result = createDirectory(testDir);
+      expect(result).toBe(true);
+    });
+
+    it('should create nested directories', () => {
+      const nested = path.join(testBaseDir, 'a', 'b', 'c');
+      const result = createDirectory(nested);
+      expect(result).toBe(true);
+      expect(fs.existsSync(nested)).toBe(true);
+    });
+
+    it('should create parent directories when writing to nested path', () => {
+      const nested = path.join(testBaseDir, 'parent', 'child');
+      const result = createDirectory(nested, { recursive: true });
+      expect(result).toBe(true);
+      expect(fs.existsSync(nested)).toBe(true);
+    });
+  });
+
+  describe('deleteDirectory', () => {
+    it('should delete directory successfully', () => {
+      const testDir = path.join(testBaseDir, 'to-delete');
+      fs.mkdirSync(testDir);
+      const result = deleteDirectory(testDir);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testDir)).toBe(false);
+    });
+
+    it('should return true for non-existing directory', () => {
+      const result = deleteDirectory(path.join(testBaseDir, 'nope'));
+      expect(result).toBe(true);
+    });
+
+    it('should delete directory with contents', () => {
+      const testDir = path.join(testBaseDir, 'with-contents');
+      fs.mkdirSync(testDir);
+      fs.mkdirSync(path.join(testDir, 'sub'));
+      fs.writeFileSync(path.join(testDir, 'file.txt'), 'content');
+      const result = deleteDirectory(testDir);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testDir)).toBe(false);
+    });
+  });
+
+  describe('checkDirectoryConflict', () => {
+    it('should return no conflict when directory does not exist', () => {
+      const result = checkDirectoryConflict(path.join(testBaseDir, 'new'), () => {
+        // Should not be called
+      });
+      expect(result.hasConflict).toBe(false);
+      expect(result.resolution).toBeUndefined();
+    });
+
+    it('should return no conflict when directory is empty', () => {
+      const testDir = path.join(testBaseDir, 'empty');
+      fs.mkdirSync(testDir);
+      const result = checkDirectoryConflict(testDir, () => {
+        // Should not be called
+      });
+      expect(result.hasConflict).toBe(false);
+      expect(result.resolution).toBeUndefined();
+    });
+
+    it('should detect conflict when directory exists and is not empty', () => {
+      const testDir = path.join(testBaseDir, 'conflict-dir');
+      fs.mkdirSync(testDir);
+      fs.writeFileSync(path.join(testDir, 'file.txt'), 'content');
+
+      let resolutionCalled = false;
+      let capturedResolution: ConflictResolution | undefined;
+
+      const result = checkDirectoryConflict(testDir, (resolution) => {
+        resolutionCalled = true;
+        capturedResolution = resolution;
+      });
+
+      expect(result.hasConflict).toBe(true);
+      expect(resolutionCalled).toBe(true);
+      expect(capturedResolution).toBeDefined();
+      expect(capturedResolution?.action).toBe('abort');
+    });
+  });
+
+  // ==================== File Operations ====================
+
+  describe('writeFile', () => {
+    it('should write file successfully', () => {
+      const testFile = path.join(testBaseDir, 'test.txt');
+      const content = 'Hello, World!';
+      const result = writeFile(testFile, content);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testFile)).toBe(true);
+      expect(fs.readFileSync(testFile, 'utf-8')).toBe(content);
+    });
+
+    it('should create parent directories if not exist', () => {
+      const testFile = path.join(testBaseDir, 'subdir', 'file.txt');
+      const content = 'Nested content';
+      const result = writeFile(testFile, content);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testFile)).toBe(true);
+    });
+
+    it('should overwrite existing file by default', () => {
+      const testFile = path.join(testBaseDir, 'file.txt');
+      fs.writeFileSync(testFile, 'Original content');
+      const result = writeFile(testFile, 'Updated content');
+      expect(result).toBe(true);
+      expect(fs.readFileSync(testFile, 'utf-8')).toBe('Updated content');
+    });
+
+    it('should not overwrite when overwrite is false', () => {
+      const testFile = path.join(testBaseDir, 'file.txt');
+      fs.writeFileSync(testFile, 'Original content');
+      const result = writeFile(testFile, 'New content', { overwrite: false });
+      expect(result).toBe(false);
+      expect(fs.readFileSync(testFile, 'utf-8')).toBe('Original content');
+    });
+  });
+
+  describe('readFile', () => {
+    it('should read file successfully', () => {
+      const testFile = path.join(testBaseDir, 'read.txt');
+      const content = 'Test content';
+      fs.writeFileSync(testFile, content);
+      const result = readFile(testFile);
+      expect(result).toBe(content);
+    });
+
+    it('should return null for non-existent file', () => {
+      const result = readFile(path.join(testBaseDir, 'nope.txt'));
+      expect(result).toBeNull();
+    });
+
+    it('should handle custom encoding', () => {
+      const testFile = path.join(testBaseDir, 'utf16.txt');
+      const content = 'Unicode test 測試';
+      fs.writeFileSync(testFile, content, { encoding: 'utf8' });
+      const result = readFile(testFile, { encoding: 'utf8' });
+      expect(result).toBe(content);
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('should delete file successfully', () => {
+      const testFile = path.join(testBaseDir, 'delete.txt');
+      fs.writeFileSync(testFile, 'content');
+      const result = deleteFile(testFile);
+      expect(result).toBe(true);
+      expect(fs.existsSync(testFile)).toBe(false);
+    });
+
+    it('should return true for non-existing file', () => {
+      const result = deleteFile(path.join(testBaseDir, 'nope.txt'));
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('copyFile', () => {
+    it('should copy file successfully', () => {
+      const source = path.join(testBaseDir, 'source.txt');
+      const dest = path.join(testBaseDir, 'dest.txt');
+      fs.writeFileSync(source, 'Source content');
+      const result = copyFile(source, dest);
+      expect(result).toBe(true);
+      expect(fs.existsSync(dest)).toBe(true);
+      expect(fs.readFileSync(dest, 'utf-8')).toBe('Source content');
+    });
+
+    it('should return false if source does not exist', () => {
+      const result = copyFile(
+        path.join(testBaseDir, 'nope.txt'),
+        path.join(testBaseDir, 'dest.txt')
+      );
+      expect(result).toBe(false);
+    });
+
+    it('should create parent directories if needed', () => {
+      const source = path.join(testBaseDir, 'source.txt');
+      const dest = path.join(testBaseDir, 'subdir', 'dest.txt');
+      fs.writeFileSync(source, 'Content');
+      const result = copyFile(source, dest);
+      expect(result).toBe(true);
+      expect(fs.existsSync(dest)).toBe(true);
+    });
+
+    it('should not overwrite when overwrite is false', () => {
+      const source = path.join(testBaseDir, 'source.txt');
+      const dest = path.join(testBaseDir, 'dest.txt');
+      fs.writeFileSync(source, 'Source');
+      fs.writeFileSync(dest, 'Existing');
+      const result = copyFile(source, dest, { overwrite: false });
+      expect(result).toBe(false);
+      expect(fs.readFileSync(dest, 'utf-8')).toBe('Existing');
+    });
+  });
+
+  // ==================== Directory Copy ====================
+
+  describe('copyDirectory', () => {
+    it('should copy directory recursively', () => {
+      const sourceDir = path.join(testBaseDir, 'src');
+      const destDir = path.join(testBaseDir, 'dest');
+      fs.mkdirSync(sourceDir);
+      fs.mkdirSync(path.join(sourceDir, 'sub'));
+      fs.writeFileSync(path.join(sourceDir, 'file1.txt'), 'Content 1');
+      fs.writeFileSync(path.join(sourceDir, 'sub', 'file2.txt'), 'Content 2');
+
+      const result = copyDirectory(sourceDir, destDir);
+      expect(result.success).toBe(true);
+      expect(result.files.length).toBe(2);
+      expect(fs.existsSync(path.join(destDir, 'file1.txt'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'sub', 'file2.txt'))).toBe(true);
+    });
+
+    it('should return failure if source does not exist', () => {
+      const result = copyDirectory(path.join(testBaseDir, 'nope'), path.join(testBaseDir, 'dest'));
+      expect(result.success).toBe(false);
+      expect(result.files).toEqual([]);
+    });
+
+    it('should preserve directory structure', () => {
+      const sourceDir = path.join(testBaseDir, 'src');
+      const destDir = path.join(testBaseDir, 'dest');
+      fs.mkdirSync(sourceDir);
+      fs.mkdirSync(path.join(sourceDir, 'level1', 'level2'), { recursive: true });
+      fs.writeFileSync(path.join(sourceDir, 'level1', 'file.txt'), 'Level 1');
+      fs.writeFileSync(path.join(sourceDir, 'level1', 'level2', 'file.txt'), 'Level 2');
+
+      const result = copyDirectory(sourceDir, destDir);
+      expect(result.success).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'level1', 'file.txt'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'level1', 'level2', 'file.txt'))).toBe(true);
+    });
+  });
+
+  // ==================== Helper Functions ====================
+
+  describe('listDirectory', () => {
+    it('should list directory contents', () => {
+      const testDir = path.join(testBaseDir, 'list-dir');
+      fs.mkdirSync(testDir);
+      fs.writeFileSync(path.join(testDir, 'file1.txt'), '1');
+      fs.writeFileSync(path.join(testDir, 'file2.txt'), '2');
+      fs.mkdirSync(path.join(testDir, 'subdir'));
+
+      const result = listDirectory(testDir);
+      expect(result).toContain('file1.txt');
+      expect(result).toContain('file2.txt');
+      expect(result).toContain('subdir');
+      expect(result.length).toBe(3);
+    });
+
+    it('should return empty array for non-existing directory', () => {
+      const result = listDirectory(path.join(testBaseDir, 'nope'));
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array for empty directory', () => {
+      const testDir = path.join(testBaseDir, 'empty');
+      fs.mkdirSync(testDir);
+      const result = listDirectory(testDir);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getFileSize', () => {
+    it('should return size of file in bytes', () => {
+      const testFile = path.join(testBaseDir, 'size.txt');
+      const content = 'Hello, World!'; // 13 bytes
+      fs.writeFileSync(testFile, content);
+      const size = getFileSize(testFile);
+      expect(size).toBe(13);
+    });
+
+    it('should return 0 for non-existing file', () => {
+      const size = getFileSize(path.join(testBaseDir, 'nope.txt'));
+      expect(size).toBe(0);
+    });
+
+    it('should handle empty file', () => {
+      const testFile = path.join(testBaseDir, 'empty.txt');
+      fs.writeFileSync(testFile, '');
+      const size = getFileSize(testFile);
+      expect(size).toBe(0);
+    });
+  });
+
+  describe('getFileModifiedDate', () => {
+    it('should return Date object for existing file', () => {
+      const testFile = path.join(testBaseDir, 'date.txt');
+      fs.writeFileSync(testFile, 'content');
+      const date = getFileModifiedDate(testFile);
+      expect(date).toBeInstanceOf(Date);
+      expect(date).not.toBeNull();
+    });
+
+    it('should return null for non-existing file', () => {
+      const date = getFileModifiedDate(path.join(testBaseDir, 'nope.txt'));
+      expect(date).toBeNull();
+    });
+  });
+
+  // ==================== Project Structure ====================
+
+  describe('createProjectStructure', () => {
+    it('should create full project structure successfully', () => {
+      const projectDir = path.join(testBaseDir, 'my-project');
+      const result = createProjectStructure(projectDir, 'MyProject');
+
+      expect(result.success).toBe(true);
+      expect(result.directories.length).toBeGreaterThan(0);
+      expect(result.files.length).toBeGreaterThan(0);
+
+      // Check directories
+      expect(fs.existsSync(projectDir)).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, 'src'))).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, 'public'))).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, 'tests'))).toBe(true);
+
+      // Check files
+      expect(fs.existsSync(path.join(projectDir, '.gitignore'))).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, 'README.md'))).toBe(true);
+
+      // Check README content
+      const readme = fs.readFileSync(path.join(projectDir, 'README.md'), 'utf-8');
+      expect(readme).toContain('MyProject');
+    });
+
+    it('should include all required files in result', () => {
+      const projectDir = path.join(testBaseDir, 'test-project');
+      const result = createProjectStructure(projectDir, 'TestProject');
+
+      expect(result.files).toContain(path.join(projectDir, '.gitignore'));
+      expect(result.files).toContain(path.join(projectDir, 'README.md'));
+      expect(result.directories).toContain(projectDir);
+      expect(result.directories).toContain(path.join(projectDir, 'src'));
+      expect(result.directories).toContain(path.join(projectDir, 'public'));
+      expect(result.directories).toContain(path.join(projectDir, 'tests'));
+    });
+  });
+});