@sk8metal/michi-cli 0.14.1 → 0.19.0

package/scripts/utils/__tests__/safe-file-reader.test.ts

@@ -0,0 +1,208 @@
+/**
+ * safeReadFile ユーティリティのテスト
+ * ファイル読み込み処理を統合し、一貫したエラーハンドリングを提供
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, chmodSync } from 'fs';
+import { join } from 'path';
+import { safeReadFile, safeReadJsonFile } from '../safe-file-reader.js';
+
+describe('safeReadFile', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(process.cwd(), 'tmp-test-safe-file-reader');
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('safeReadFile - テキストファイル読み込み', () => {
+    it('should successfully read existing file', () => {
+      // Setup
+      const filePath = join(testDir, 'test.txt');
+      writeFileSync(filePath, 'Hello World', 'utf-8');
+
+      // Execute
+      const result = safeReadFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe('Hello World');
+      }
+    });
+
+    it('should return FileNotFound error when file does not exist', () => {
+      // Setup
+      const filePath = join(testDir, 'non-existent.txt');
+
+      // Execute
+      const result = safeReadFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errors[0].type).toBe('FileNotFound');
+        expect(result.errors[0].path).toBe(filePath);
+      }
+    });
+
+    it('should return PermissionDenied error when file is not readable', () => {
+      // Setup
+      const filePath = join(testDir, 'no-permission.txt');
+      writeFileSync(filePath, 'Secret', 'utf-8');
+      chmodSync(filePath, 0o000); // 読み取り不可に設定
+
+      // Execute
+      const result = safeReadFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errors[0].type).toBe('PermissionDenied');
+        expect(result.errors[0].path).toBe(filePath);
+      }
+
+      // Cleanup: パーミッションを戻す
+      chmodSync(filePath, 0o644);
+    });
+
+    it('should handle UTF-8 encoding correctly', () => {
+      // Setup
+      const filePath = join(testDir, 'utf8.txt');
+      writeFileSync(filePath, '日本語テスト🎉', 'utf-8');
+
+      // Execute
+      const result = safeReadFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe('日本語テスト🎉');
+      }
+    });
+
+    it('should support custom encoding', () => {
+      // Setup
+      const filePath = join(testDir, 'latin1.txt');
+      const content = 'Café';
+      writeFileSync(filePath, content, 'latin1');
+
+      // Execute
+      const result = safeReadFile(filePath, 'latin1');
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(content);
+      }
+    });
+  });
+
+  describe('safeReadJsonFile - JSONファイル読み込み', () => {
+    it('should successfully read and parse valid JSON file', () => {
+      // Setup
+      const filePath = join(testDir, 'test.json');
+      const data = { name: 'test', value: 42 };
+      writeFileSync(filePath, JSON.stringify(data), 'utf-8');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toEqual(data);
+      }
+    });
+
+    it('should return InvalidJSON error when JSON is malformed', () => {
+      // Setup
+      const filePath = join(testDir, 'invalid.json');
+      writeFileSync(filePath, '{ invalid json }', 'utf-8');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errors[0].type).toBe('InvalidJSON');
+        expect(result.errors[0].path).toBe(filePath);
+        expect(result.errors[0].cause).toBeDefined();
+      }
+    });
+
+    it('should return FileNotFound error when JSON file does not exist', () => {
+      // Setup
+      const filePath = join(testDir, 'non-existent.json');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.errors[0].type).toBe('FileNotFound');
+      }
+    });
+
+    it('should handle nested JSON structures', () => {
+      // Setup
+      const filePath = join(testDir, 'nested.json');
+      const data = {
+        project: {
+          name: 'michi',
+          config: {
+            language: 'ja',
+            features: ['spec', 'jira', 'confluence']
+          }
+        }
+      };
+      writeFileSync(filePath, JSON.stringify(data), 'utf-8');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toEqual(data);
+      }
+    });
+
+    it('should handle empty JSON object', () => {
+      // Setup
+      const filePath = join(testDir, 'empty.json');
+      writeFileSync(filePath, '{}', 'utf-8');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toEqual({});
+      }
+    });
+
+    it('should handle empty JSON array', () => {
+      // Setup
+      const filePath = join(testDir, 'empty-array.json');
+      writeFileSync(filePath, '[]', 'utf-8');
+
+      // Execute
+      const result = safeReadJsonFile(filePath);
+
+      // Verify
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toEqual([]);
+      }
+    });
+  });
+});

package/scripts/utils/__tests__/security-validator.test.ts

@@ -18,19 +18,19 @@ describe('security-validator', () => {
   describe('validateAtlassianToken', () => {
     it('空のトークンはエラー', () => {
       const result = validateAtlassianToken('');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Atlassian API token is empty');
     });
 
     it('スペースを含むトークンはエラー', () => {
       const result = validateAtlassianToken('token with spaces');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Atlassian API token contains spaces');
     });
 
     it('短すぎるトークンは警告', () => {
       const result = validateAtlassianToken('short');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.warnings).toContain(
         'Atlassian API token seems too short (expected >20 characters)',
       );
@@ -38,13 +38,13 @@ describe('security-validator', () => {
 
     it('プレースホルダー値はエラー', () => {
       const result = validateAtlassianToken('your-token-here');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Atlassian API token is a placeholder value');
     });
 
     it('正しいトークンは成功', () => {
       const result = validateAtlassianToken('ATATT3xFfGF0abcdefghijklmnopqrstuvwxyz1234567890');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
       expect(result.warnings).toHaveLength(0);
     });
@@ -53,19 +53,19 @@ describe('security-validator', () => {
   describe('validateGitHubToken', () => {
     it('空のトークンはエラー', () => {
       const result = validateGitHubToken('');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('GitHub token is empty');
     });
 
     it('スペースを含むトークンはエラー', () => {
       const result = validateGitHubToken('token with spaces');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('GitHub token contains spaces');
     });
 
     it('プレフィックスなしのトークンは警告', () => {
       const result = validateGitHubToken('abcdefghijklmnopqrstuvwxyz1234567890');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.warnings).toContain(
         'GitHub token does not start with expected prefix (ghp_ or github_pat_)',
       );
@@ -73,19 +73,19 @@ describe('security-validator', () => {
 
     it('プレースホルダー値はエラー', () => {
       const result = validateGitHubToken('ghp_xxx');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('GitHub token is a placeholder value');
     });
 
     it('正しいトークン(ghp_)は成功', () => {
       const result = validateGitHubToken('ghp_abcdefghijklmnopqrstuvwxyz1234567890');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
     it('正しいトークン(github_pat_)は成功', () => {
       const result = validateGitHubToken('github_pat_abcdefghijklmnopqrstuvwxyz1234567890');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
   });
@@ -93,25 +93,25 @@ describe('security-validator', () => {
   describe('validateEmail', () => {
     it('空のメールアドレスはエラー', () => {
       const result = validateEmail('');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Email is empty');
     });
 
     it('不正な形式のメールアドレスはエラー', () => {
       const result = validateEmail('invalid-email');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Email format is invalid');
     });
 
     it('プレースホルダー値はエラー', () => {
       const result = validateEmail('user@example.com');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Email is a placeholder value');
     });
 
     it('正しいメールアドレスは成功', () => {
       const result = validateEmail('real.user@company.com');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
   });
@@ -119,19 +119,19 @@ describe('security-validator', () => {
   describe('validateUrl', () => {
     it('空のURLはエラー', () => {
       const result = validateUrl('');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('URL is empty');
     });
 
     it('不正な形式のURLはエラー', () => {
       const result = validateUrl('not-a-url');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors.length).toBeGreaterThan(0);
     });
 
     it('httpプロトコルは警告', () => {
       const result = validateUrl('http://example.com');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.warnings).toContain(
         'URL uses insecure http:// protocol (consider using https://)',
       );
@@ -139,19 +139,19 @@ describe('security-validator', () => {
 
     it('プレースホルダー値はエラー', () => {
       const result = validateUrl('https://example.com');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('URL is a placeholder value');
     });
 
     it('正しいURLは成功', () => {
       const result = validateUrl('https://real-domain.com');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
     it('expectedDomainが一致しない場合はエラー', () => {
       const result = validateUrl('https://wrong.com', 'example.com');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain(
         'URL hostname wrong.com does not contain expected domain: example.com',
       );
@@ -159,20 +159,20 @@ describe('security-validator', () => {
 
     it('expectedDomainが一致する場合は成功', () => {
       const result = validateUrl('https://sub.example.com', 'example.com');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
     });
   });
 
   describe('validateAtlassianUrl', () => {
     it('atlassian.netドメインでない場合はエラー', () => {
       const result = validateAtlassianUrl('https://wrong-domain.com');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors.some((e) => e.includes('atlassian.net'))).toBe(true);
     });
 
     it('正しいAtlassian URLは成功', () => {
       const result = validateAtlassianUrl('https://mycompany.atlassian.net');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
   });
@@ -180,43 +180,43 @@ describe('security-validator', () => {
   describe('validateGitHubRepositoryUrl', () => {
     it('空のURLはエラー', () => {
       const result = validateGitHubRepositoryUrl('');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Repository URL is empty');
     });
 
     it('不正な形式はエラー', () => {
       const result = validateGitHubRepositoryUrl('https://example.com/repo');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors.some((e) => e.includes('format'))).toBe(true);
     });
 
     it('プレースホルダー値はエラー', () => {
       const result = validateGitHubRepositoryUrl('https://github.com/your-org/your-repo.git');
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors).toContain('Repository URL contains placeholder values');
     });
 
     it('正しいHTTPS URLは成功', () => {
       const result = validateGitHubRepositoryUrl('https://github.com/owner/repo.git');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
     it('正しいHTTPS URL(.gitなし)も成功', () => {
       const result = validateGitHubRepositoryUrl('https://github.com/owner/repo');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
     it('正しいSSH URLは成功', () => {
       const result = validateGitHubRepositoryUrl('git@github.com:owner/repo.git');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
     it('正しいSSH URL(.gitなし)も成功', () => {
       const result = validateGitHubRepositoryUrl('git@github.com:owner/repo');
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
   });
@@ -232,7 +232,7 @@ describe('security-validator', () => {
         repositoryUrl: 'https://github.com/myorg/myrepo.git',
       });
 
-      expect(result.isValid).toBe(true);
+      expect(result.success).toBe(true);
       expect(result.errors).toHaveLength(0);
     });
 
@@ -246,7 +246,7 @@ describe('security-validator', () => {
         repositoryUrl: '', // 空
       });
 
-      expect(result.isValid).toBe(false);
+      expect(result.success).toBe(false);
       expect(result.errors.length).toBeGreaterThan(5);
       expect(result.errors.some((e) => e.startsWith('ATLASSIAN_URL:'))).toBe(true);
       expect(result.errors.some((e) => e.startsWith('ATLASSIAN_EMAIL:'))).toBe(true);

package/scripts/utils/__tests__/validation-result.test.ts

@@ -0,0 +1,112 @@
+/**
+ * ValidationResult 共通型のテスト
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { Result } from '../types/validation.js';
+
+describe('Result<T, E> type', () => {
+  describe('Success case', () => {
+    it('should represent successful validation', () => {
+      const result: Result<boolean, string> = {
+        success: true,
+        value: true,
+        errors: [],
+        warnings: []
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.value).toBe(true);
+      expect(result.errors).toEqual([]);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('should allow warnings in successful result', () => {
+      const result: Result<boolean, string> = {
+        success: true,
+        value: true,
+        errors: [],
+        warnings: ['This is a warning']
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.warnings.length).toBe(1);
+    });
+  });
+
+  describe('Failure case', () => {
+    it('should represent failed validation', () => {
+      const result: Result<boolean, string> = {
+        success: false,
+        value: undefined,
+        errors: ['Error message'],
+        warnings: []
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.value).toBeUndefined();
+      expect(result.errors.length).toBe(1);
+    });
+
+    it('should allow multiple errors', () => {
+      const result: Result<boolean, string> = {
+        success: false,
+        value: undefined,
+        errors: ['Error 1', 'Error 2', 'Error 3'],
+        warnings: []
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.errors.length).toBe(3);
+    });
+  });
+
+  describe('Type compatibility', () => {
+    it('should work with different value types', () => {
+      const stringResult: Result<string, string> = {
+        success: true,
+        value: 'test',
+        errors: [],
+        warnings: []
+      };
+
+      const numberResult: Result<number, string> = {
+        success: true,
+        value: 42,
+        errors: [],
+        warnings: []
+      };
+
+      const objectResult: Result<{ name: string }, string> = {
+        success: true,
+        value: { name: 'test' },
+        errors: [],
+        warnings: []
+      };
+
+      expect(stringResult.value).toBe('test');
+      expect(numberResult.value).toBe(42);
+      expect(objectResult.value).toEqual({ name: 'test' });
+    });
+
+    it('should work with different error types', () => {
+      type ValidationError = {
+        field: string;
+        message: string;
+      };
+
+      const result: Result<boolean, ValidationError> = {
+        success: false,
+        value: undefined,
+        errors: [
+          { field: 'name', message: 'Required' },
+          { field: 'email', message: 'Invalid format' }
+        ],
+        warnings: []
+      };
+
+      expect(result.errors.length).toBe(2);
+      expect(result.errors[0].field).toBe('name');
+    });
+  });
+});