repo-cloak-cli 1.2.4 → 1.3.2

package/tests/copier.test.js

@@ -1,94 +1,94 @@
-/**
- * Copier Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { copyFile, copyFileWithTransform } from '../src/core/copier.js';
-import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-
-describe('Copier Module', () => {
-    let testDir;
-    let sourceDir;
-    let destDir;
-
-    beforeEach(() => {
-        testDir = join(tmpdir(), `repo-cloak-copier-test-${Date.now()}`);
-        sourceDir = join(testDir, 'source');
-        destDir = join(testDir, 'dest');
-        mkdirSync(sourceDir, { recursive: true });
-        mkdirSync(destDir, { recursive: true });
-    });
-
-    afterEach(() => {
-        if (existsSync(testDir)) {
-            rmSync(testDir, { recursive: true, force: true });
-        }
-    });
-
-    describe('copyFile', () => {
-        it('should copy a file to destination', () => {
-            const sourceFile = join(sourceDir, 'test.txt');
-            const destFile = join(destDir, 'test.txt');
-
-            writeFileSync(sourceFile, 'Hello World');
-            copyFile(sourceFile, destFile);
-
-            expect(existsSync(destFile)).toBe(true);
-            expect(readFileSync(destFile, 'utf-8')).toBe('Hello World');
-        });
-
-        it('should create nested directories', () => {
-            const sourceFile = join(sourceDir, 'test.txt');
-            const destFile = join(destDir, 'nested', 'deep', 'test.txt');
-
-            writeFileSync(sourceFile, 'Content');
-            copyFile(sourceFile, destFile);
-
-            expect(existsSync(destFile)).toBe(true);
-        });
-    });
-
-    describe('copyFileWithTransform', () => {
-        it('should transform content during copy', () => {
-            const sourceFile = join(sourceDir, 'code.js');
-            const destFile = join(destDir, 'code.js');
-
-            writeFileSync(sourceFile, 'const company = "Cuviva";');
-
-            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
-            const result = copyFileWithTransform(sourceFile, destFile, transform);
-
-            expect(result.transformed).toBe(true);
-            expect(readFileSync(destFile, 'utf-8')).toBe('const company = "ABCCompany";');
-        });
-
-        it('should report no transformation when content unchanged', () => {
-            const sourceFile = join(sourceDir, 'code.js');
-            const destFile = join(destDir, 'code.js');
-
-            writeFileSync(sourceFile, 'const x = 1;');
-
-            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
-            const result = copyFileWithTransform(sourceFile, destFile, transform);
-
-            expect(result.transformed).toBe(false);
-        });
-
-        it('should handle binary files by copying as-is', () => {
-            const sourceFile = join(sourceDir, 'image.png');
-            const destFile = join(destDir, 'image.png');
-
-            // Create a simple binary-like file
-            const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x00]);
-            writeFileSync(sourceFile, buffer);
-
-            const transform = (content) => content.replace(/test/g, 'replaced');
-            const result = copyFileWithTransform(sourceFile, destFile, transform);
-
-            expect(result.transformed).toBe(false);
-            expect(existsSync(destFile)).toBe(true);
-        });
-    });
-});
+/**
+ * Copier Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { copyFile, copyFileWithTransform } from '../src/core/copier.js';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('Copier Module', () => {
+    let testDir;
+    let sourceDir;
+    let destDir;
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-copier-test-${Date.now()}`);
+        sourceDir = join(testDir, 'source');
+        destDir = join(testDir, 'dest');
+        mkdirSync(sourceDir, { recursive: true });
+        mkdirSync(destDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+
+    describe('copyFile', () => {
+        it('should copy a file to destination', () => {
+            const sourceFile = join(sourceDir, 'test.txt');
+            const destFile = join(destDir, 'test.txt');
+
+            writeFileSync(sourceFile, 'Hello World');
+            copyFile(sourceFile, destFile);
+
+            expect(existsSync(destFile)).toBe(true);
+            expect(readFileSync(destFile, 'utf-8')).toBe('Hello World');
+        });
+
+        it('should create nested directories', () => {
+            const sourceFile = join(sourceDir, 'test.txt');
+            const destFile = join(destDir, 'nested', 'deep', 'test.txt');
+
+            writeFileSync(sourceFile, 'Content');
+            copyFile(sourceFile, destFile);
+
+            expect(existsSync(destFile)).toBe(true);
+        });
+    });
+
+    describe('copyFileWithTransform', () => {
+        it('should transform content during copy', () => {
+            const sourceFile = join(sourceDir, 'code.js');
+            const destFile = join(destDir, 'code.js');
+
+            writeFileSync(sourceFile, 'const company = "Cuviva";');
+
+            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(true);
+            expect(readFileSync(destFile, 'utf-8')).toBe('const company = "ABCCompany";');
+        });
+
+        it('should report no transformation when content unchanged', () => {
+            const sourceFile = join(sourceDir, 'code.js');
+            const destFile = join(destDir, 'code.js');
+
+            writeFileSync(sourceFile, 'const x = 1;');
+
+            const transform = (content) => content.replace(/Cuviva/g, 'ABCCompany');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(false);
+        });
+
+        it('should handle binary files by copying as-is', () => {
+            const sourceFile = join(sourceDir, 'image.png');
+            const destFile = join(destDir, 'image.png');
+
+            // Create a simple binary-like file
+            const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x00]);
+            writeFileSync(sourceFile, buffer);
+
+            const transform = (content) => content.replace(/test/g, 'replaced');
+            const result = copyFileWithTransform(sourceFile, destFile, transform);
+
+            expect(result.transformed).toBe(false);
+            expect(existsSync(destFile)).toBe(true);
+        });
+    });
+});

package/tests/crypto.test.js

@@ -1,106 +1,106 @@
-/**
- * Crypto Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { encrypt, decrypt, encryptReplacements, decryptReplacements } from '../src/core/crypto.js';
-import { existsSync, rmSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-describe('Crypto Module', () => {
-    const testSecret = 'test-secret-key-for-unit-tests-1234567890';
-
-    describe('encrypt/decrypt', () => {
-        it('should encrypt and decrypt a string', () => {
-            const original = 'Hello World';
-            const encrypted = encrypt(original, testSecret);
-            const decrypted = decrypt(encrypted, testSecret);
-
-            expect(decrypted).toBe(original);
-        });
-
-        it('should produce different encrypted output each time (random IV)', () => {
-            const original = 'Same input';
-            const encrypted1 = encrypt(original, testSecret);
-            const encrypted2 = encrypt(original, testSecret);
-
-            expect(encrypted1).not.toBe(encrypted2);
-        });
-
-        it('should return null for wrong secret', () => {
-            const original = 'Secret message';
-            const encrypted = encrypt(original, testSecret);
-            const decrypted = decrypt(encrypted, 'wrong-secret');
-
-            expect(decrypted).toBeNull();
-        });
-
-        it('should handle special characters', () => {
-            const original = 'Special: @#$%^&*()_+ 日本語 🎭';
-            const encrypted = encrypt(original, testSecret);
-            const decrypted = decrypt(encrypted, testSecret);
-
-            expect(decrypted).toBe(original);
-        });
-
-        it('should handle empty string or return null for empty', () => {
-            const original = '';
-            const encrypted = encrypt(original, testSecret);
-            const decrypted = decrypt(encrypted, testSecret);
-
-            // Empty string may return empty or null depending on cipher
-            expect(decrypted === '' || decrypted === null).toBe(true);
-        });
-
-        it('should handle long strings', () => {
-            const original = 'A'.repeat(10000);
-            const encrypted = encrypt(original, testSecret);
-            const decrypted = decrypt(encrypted, testSecret);
-
-            expect(decrypted).toBe(original);
-        });
-    });
-
-    describe('encryptReplacements/decryptReplacements', () => {
-        it('should encrypt only the original field', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' },
-                { original: 'Secret', replacement: 'Public' }
-            ];
-
-            const encrypted = encryptReplacements(replacements, testSecret);
-
-            // Replacement should still be visible
-            expect(encrypted[0].replacement).toBe('ABCCompany');
-            expect(encrypted[1].replacement).toBe('Public');
-
-            // Original should be encrypted (contains colons from format)
-            expect(encrypted[0].original).toContain(':');
-            expect(encrypted[0].encrypted).toBe(true);
-        });
-
-        it('should decrypt back to original', () => {
-            const replacements = [
-                { original: 'Cuviva', replacement: 'ABCCompany' }
-            ];
-
-            const encrypted = encryptReplacements(replacements, testSecret);
-            const decrypted = decryptReplacements(encrypted, testSecret);
-
-            expect(decrypted[0].original).toBe('Cuviva');
-            expect(decrypted[0].replacement).toBe('ABCCompany');
-        });
-
-        it('should mark failed decryptions', () => {
-            const replacements = [
-                { original: 'Test', replacement: 'Demo' }
-            ];
-
-            const encrypted = encryptReplacements(replacements, testSecret);
-            const decrypted = decryptReplacements(encrypted, 'wrong-secret');
-
-            expect(decrypted[0].decryptFailed).toBe(true);
-        });
-    });
-});
+/**
+ * Crypto Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { encrypt, decrypt, encryptReplacements, decryptReplacements } from '../src/core/crypto.js';
+import { existsSync, rmSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+describe('Crypto Module', () => {
+    const testSecret = 'test-secret-key-for-unit-tests-1234567890';
+
+    describe('encrypt/decrypt', () => {
+        it('should encrypt and decrypt a string', () => {
+            const original = 'Hello World';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+
+        it('should produce different encrypted output each time (random IV)', () => {
+            const original = 'Same input';
+            const encrypted1 = encrypt(original, testSecret);
+            const encrypted2 = encrypt(original, testSecret);
+
+            expect(encrypted1).not.toBe(encrypted2);
+        });
+
+        it('should return null for wrong secret', () => {
+            const original = 'Secret message';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, 'wrong-secret');
+
+            expect(decrypted).toBeNull();
+        });
+
+        it('should handle special characters', () => {
+            const original = 'Special: @#$%^&*()_+ 日本語 🎭';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+
+        it('should handle empty string or return null for empty', () => {
+            const original = '';
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            // Empty string may return empty or null depending on cipher
+            expect(decrypted === '' || decrypted === null).toBe(true);
+        });
+
+        it('should handle long strings', () => {
+            const original = 'A'.repeat(10000);
+            const encrypted = encrypt(original, testSecret);
+            const decrypted = decrypt(encrypted, testSecret);
+
+            expect(decrypted).toBe(original);
+        });
+    });
+
+    describe('encryptReplacements/decryptReplacements', () => {
+        it('should encrypt only the original field', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' },
+                { original: 'Secret', replacement: 'Public' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+
+            // Replacement should still be visible
+            expect(encrypted[0].replacement).toBe('ABCCompany');
+            expect(encrypted[1].replacement).toBe('Public');
+
+            // Original should be encrypted (contains colons from format)
+            expect(encrypted[0].original).toContain(':');
+            expect(encrypted[0].encrypted).toBe(true);
+        });
+
+        it('should decrypt back to original', () => {
+            const replacements = [
+                { original: 'Cuviva', replacement: 'ABCCompany' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+            const decrypted = decryptReplacements(encrypted, testSecret);
+
+            expect(decrypted[0].original).toBe('Cuviva');
+            expect(decrypted[0].replacement).toBe('ABCCompany');
+        });
+
+        it('should mark failed decryptions', () => {
+            const replacements = [
+                { original: 'Test', replacement: 'Demo' }
+            ];
+
+            const encrypted = encryptReplacements(replacements, testSecret);
+            const decrypted = decryptReplacements(encrypted, 'wrong-secret');
+
+            expect(decrypted[0].decryptFailed).toBe(true);
+        });
+    });
+});

package/tests/git.test.js

@@ -0,0 +1,103 @@
+/**
+ * Git Module Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { isGitRepo, getChangedFiles } from '../src/core/git.js';
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { execSync } from 'child_process';
+
+describe('Git Module', () => {
+    let testDir;
+
+    function initGitRepo(dir) {
+        execSync('git init', { cwd: dir });
+        execSync('git config user.name "Test User"', { cwd: dir });
+        execSync('git config user.email "test@example.com"', { cwd: dir });
+    }
+
+    beforeEach(() => {
+        testDir = join(tmpdir(), `repo-cloak-git-test-${Date.now()}`);
+        mkdirSync(testDir, { recursive: true });
+    });
+
+    afterEach(() => {
+        if (existsSync(testDir)) {
+            try {
+                rmSync(testDir, { recursive: true, force: true });
+            } catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    });
+
+    describe('isGitRepo', () => {
+        it('should return true for git repository', () => {
+            initGitRepo(testDir);
+            expect(isGitRepo(testDir)).toBe(true);
+        });
+
+        it('should return false for non-git directory', () => {
+            expect(isGitRepo(testDir)).toBe(false);
+        });
+    });
+
+    describe('getChangedFiles', () => {
+        it('should return empty list for clean repo', async () => {
+            initGitRepo(testDir);
+            const files = await getChangedFiles(testDir);
+            expect(files).toEqual([]);
+        });
+
+        it('should detect untracked files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'newfile.txt'), 'content');
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('newfile.txt');
+        });
+
+        it('should detect modified files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'test.txt'), 'initial');
+            execSync('git add test.txt', { cwd: testDir });
+            execSync('git commit -m "initial"', { cwd: testDir });
+
+            writeFileSync(join(testDir, 'test.txt'), 'changed');
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('test.txt');
+        });
+
+        it('should expand untracked directories', async () => {
+            initGitRepo(testDir);
+            const deployDir = join(testDir, 'deploy');
+            mkdirSync(deployDir);
+            writeFileSync(join(deployDir, 'config.yml'), 'config');
+            writeFileSync(join(deployDir, 'script.sh'), 'script');
+
+            // git status --porcelain shows "?? deploy/"
+            // We want ["deploy/config.yml", "deploy/script.sh"]
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('deploy/config.yml'); // Using forward slash for cross-platform expectation in test
+            expect(files).toContain('deploy/script.sh');
+            expect(files).toHaveLength(2);
+        });
+
+        it('should handle renamed files', async () => {
+            initGitRepo(testDir);
+            writeFileSync(join(testDir, 'old.txt'), 'content');
+            execSync('git add old.txt', { cwd: testDir });
+            execSync('git commit -m "initial"', { cwd: testDir });
+
+            execSync('git mv old.txt new.txt', { cwd: testDir });
+
+            const files = await getChangedFiles(testDir);
+            expect(files).toContain('new.txt');
+            expect(files).not.toContain('old.txt');
+        });
+    });
+});