@ibgib/vcs-gib 0.0.6

package/src/cli/cli-e2e.respec.node.mts

@@ -0,0 +1,318 @@
+/**
+ * @module cli-e2e.respec
+ * 
+ * End-to-End CLI Integration Spec for @ibgib/vcs-gib.
+ * Executes full lifecycle: vcs init -> vcs status -> vcs add -> vcs commit -> vcs log -> vcs branch -> vcs checkout.
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import {
+    respecfully, ifWe, iReckon
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import { main } from './vcs-cli-main.mjs';
+import { executeInitCmd } from './commands/init-cmd.mjs';
+import { executeStatusCmd } from './commands/status-cmd.mjs';
+import { executeAddCmd } from './commands/add-cmd.mjs';
+import { executeCommitCmd } from './commands/commit-cmd.mjs';
+import { executeLogCmd } from './commands/log-cmd.mjs';
+import { executeBranchCmd } from './commands/branch-cmd.mjs';
+import { executeCheckoutCmd } from './commands/checkout-cmd.mjs';
+import { bootstrapVcsMetaspace } from '../bootstrap/node-bootstrap.mjs';
+import { getB2tFSIndexIbGib } from '../engine/index/index-helper.mjs';
+
+const lc = `[apps/vcs-gib/src/cli/cli-e2e.respec.node.mts]`;
+
+await respecfully(lc, `Full E2E CLI Integration Spec`, async () => {
+
+    await ifWe(lc, `runs help and version flags without error`, async () => {
+        let helpCalled = false;
+        let versionCalled = false;
+
+        const origLog = console.log;
+        console.log = (...args: any[]) => {
+            const msg = args.join(' ');
+            if (msg.includes('Decentralized Version Control System')) {
+                helpCalled = true;
+            }
+            if (msg.includes('@ibgib/vcs-gib v0.0.4')) {
+                versionCalled = true;
+            }
+        };
+
+        try {
+            const helpExitCode = await main({ argv: ['--help'] });
+            iReckon(lc, helpExitCode).willEqual(0);
+
+            const versionExitCode = await main({ argv: ['--version'] });
+            iReckon(lc, versionExitCode).willEqual(0);
+        } finally {
+            console.log = origLog;
+        }
+
+        iReckon(lc, helpCalled).isGonnaBeTrue();
+        iReckon(lc, versionCalled).isGonnaBeTrue();
+    });
+
+    await ifWe(lc, `executes complete lifecycle: init -> status -> add -> commit -> log -> branch -> checkout`, async () => {
+        const testDir = path.join(process.cwd(), `.test_cli_e2e_${Date.now()}`);
+        const vcsFolderName = '.vcsgib_test_e2e';
+
+        try {
+            // Step 1: vcs init
+            const initRes = await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, Boolean(initRes.vcsPath)).isGonnaBeTrue();
+            iReckon(lc, initRes.branchName).willEqual('main');
+
+            // Verify .vcsgib_test_e2e directory exists
+            const vcsExists = await fs.stat(initRes.vcsPath).then(s => s.isDirectory()).catch(() => false);
+            iReckon(lc, vcsExists).isGonnaBeTrue();
+
+            // Step 2: Create files & vcs status (untracked)
+            const readmePath = path.join(testDir, 'README.md');
+            const srcDirPath = path.join(testDir, 'src');
+            const appPath = path.join(srcDirPath, 'app.ts');
+
+            await fs.mkdir(srcDirPath, { recursive: true });
+            await fs.writeFile(readmePath, '# Sample Project\nWelcome to vcs-gib.', 'utf8');
+            await fs.writeFile(appPath, 'console.log("Hello ibgib!");', 'utf8');
+
+            const status1 = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, status1.branchName).willEqual('main');
+            iReckon(lc, status1.staged.length).willEqual(0);
+            iReckon(lc, status1.untracked.length >= 2).isGonnaBeTrue();
+
+            const untrackedPaths = status1.untracked.map(u => u.path);
+            iReckon(lc, untrackedPaths).includes('README.md');
+            iReckon(lc, untrackedPaths).includes('src/app.ts');
+
+            // Step 3: vcs add <all>
+            const addRes = await executeAddCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                all: true,
+                quiet: true,
+            });
+
+            iReckon(lc, addRes.stagedCount >= 2).isGonnaBeTrue();
+
+            const { localSpace: e2eSpaceAdd, vcsPath: e2eVcsPathAdd } = await bootstrapVcsMetaspace({
+                repoPath: testDir,
+                vcsFolderName,
+            });
+            const e2eIndexAdd = await getB2tFSIndexIbGib({ space: e2eSpaceAdd, vcsPath: e2eVcsPathAdd });
+            iReckon(lc, Boolean(e2eIndexAdd?.data?.staged_item && e2eIndexAdd.data.staged_item.length >= 2)).isGonnaBeTrue();
+            iReckon(lc, e2eIndexAdd?.rel8ns?.staged_item).isGonnaBeFalsy();
+
+            const status2 = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, status2.staged.length >= 2).isGonnaBeTrue();
+
+            // Step 4: vcs commit -m "Initial commit"
+            const commitRes = await executeCommitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                message: 'Initial commit',
+                quiet: true,
+            });
+
+            const { localSpace: e2eSpaceCommit, vcsPath: e2eVcsPathCommit } = await bootstrapVcsMetaspace({
+                repoPath: testDir,
+                vcsFolderName,
+            });
+            const e2eIndexCommit = await getB2tFSIndexIbGib({ space: e2eSpaceCommit, vcsPath: e2eVcsPathCommit });
+            iReckon(lc, e2eIndexCommit?.data?.staged_item).willEqual([]);
+            iReckon(lc, e2eIndexCommit?.rel8ns?.staged_item).isGonnaBeFalsy();
+
+            iReckon(lc, Boolean(commitRes.commitAddr)).isGonnaBeTrue();
+            iReckon(lc, Boolean(commitRes.commentAddr)).isGonnaBeTrue();
+            iReckon(lc, commitRes.branchName).willEqual('main');
+
+            const status3 = await executeStatusCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, status3.staged.length).willEqual(0);
+            iReckon(lc, status3.modified.length).willEqual(0);
+            iReckon(lc, status3.untracked.length).willEqual(0);
+
+            // Step 5: vcs log
+            const logRes = await executeLogCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, logRes.branchName).willEqual('main');
+            iReckon(lc, logRes.commits.length).willEqual(1);
+            iReckon(lc, logRes.commits[0].message).willEqual('Initial commit');
+
+            // Step 6: vcs branch feature-ui
+            const branchRes = await executeBranchCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                branchName: 'feature-ui',
+                quiet: true,
+            });
+
+            iReckon(lc, branchRes.createdBranchName).willEqual('feature-ui');
+
+            const listBranches = await executeBranchCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, listBranches.branches.length).willEqual(2);
+            const mainBranch = listBranches.branches.find(b => b.name === 'main');
+            const featureBranch = listBranches.branches.find(b => b.name === 'feature-ui');
+
+            iReckon(lc, mainBranch?.isActive).isGonnaBeTrue();
+            iReckon(lc, featureBranch?.isActive).isGonnaBeFalse();
+
+            // Step 7: vcs checkout feature-ui
+            const checkoutRes = await executeCheckoutCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                branchName: 'feature-ui',
+                quiet: true,
+            });
+
+            iReckon(lc, checkoutRes.previousBranch).willEqual('main');
+            iReckon(lc, checkoutRes.currentBranch).willEqual('feature-ui');
+            iReckon(lc, Boolean(checkoutRes.worktreePath)).isGonnaBeTrue();
+
+            // Verify feature-ui is active now and both branches are listed
+            const listBranches2 = await executeBranchCmd({
+                targetDir: checkoutRes.worktreePath,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            iReckon(lc, listBranches2.branches.length).willEqual(2);
+            const featureBranchActive = listBranches2.branches.find(b => b.name === 'feature-ui');
+            iReckon(lc, featureBranchActive?.isActive).isGonnaBeTrue();
+
+            // Checkout back to main and verify all branches listed
+            const checkoutMainRes = await executeCheckoutCmd({
+                targetDir: checkoutRes.worktreePath,
+                vcsFolderName,
+                branchName: 'main',
+                quiet: true,
+            });
+            iReckon(lc, checkoutMainRes.currentBranch).willEqual('main');
+
+            const listBranches3 = await executeBranchCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, listBranches3.branches.length).willEqual(2);
+
+            // Checkout back to feature-ui
+            await executeCheckoutCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                branchName: 'feature-ui',
+                quiet: true,
+            });
+
+            // Verify worktree folder was created and contains project files
+            const worktreeReadme = path.join(checkoutRes.worktreePath, 'README.md');
+            const worktreeReadmeContent = await fs.readFile(worktreeReadme, 'utf8');
+            iReckon(lc, worktreeReadmeContent).includes('Sample Project');
+
+            // Verify dedicated branch space subfolders in .vcsgib_test_e2e
+            const e2eMainSpace = path.join(initRes.vcsPath, 'ibgib', 'b2s_main');
+            const e2eFeatureSpace = path.join(initRes.vcsPath, 'ibgib', 'b2s_feature-ui');
+            const e2eMainExists = await fs.stat(e2eMainSpace).then(s => s.isDirectory()).catch(() =>
+                fs.stat(path.join(initRes.vcsPath, 'b2s_main')).then(s => s.isDirectory()).catch(() => false)
+            );
+            const e2eFeatureExists = await fs.stat(e2eFeatureSpace).then(s => s.isDirectory()).catch(() =>
+                fs.stat(path.join(initRes.vcsPath, 'b2s_feature-ui')).then(s => s.isDirectory()).catch(() => false)
+            );
+            iReckon(lc, e2eMainExists).isGonnaBeTrue();
+            iReckon(lc, e2eFeatureExists).isGonnaBeTrue();
+
+            // Strict Workspace Isolation Assertion:
+            // ONLY vcsFolderName, 'b', 'README.md', and 'src' are allowed in testDir root.
+            // 'ibgib' must NOT spill into root!
+            const rootEntries = await fs.readdir(testDir);
+            const unexpectedRootEntries = rootEntries.filter(e =>
+                e !== vcsFolderName && e !== 'b' && e !== 'README.md' && e !== 'src'
+            );
+            iReckon(lc, unexpectedRootEntries).willEqual([]);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+    await ifWe(lc, `executes upward discovery and unmodified add check via CLI helpers`, async () => {
+        const testDir = path.join(process.cwd(), `.test_cli_e2e_fixes_${Date.now()}`);
+        const vcsFolderName = '.vcsgib_test_e2e_fixes';
+
+        try {
+            await executeInitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                quiet: true,
+            });
+
+            const srcDir = path.join(testDir, 'src');
+            await fs.mkdir(srcDir, { recursive: true });
+            await fs.writeFile(path.join(srcDir, 'index.ts'), 'console.log("e2e");', 'utf8');
+
+            // 1. Run add and commit
+            await executeAddCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                all: true,
+                quiet: true,
+            });
+
+            await executeCommitCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                message: 'Add index.ts',
+                quiet: true,
+            });
+
+            // 2. Upward discovery test: execute status from srcDir
+            const statusSub = await executeStatusCmd({
+                targetDir: srcDir,
+                vcsFolderName,
+                quiet: true,
+            });
+            iReckon(lc, statusSub.branchName).willEqual('main');
+            iReckon(lc, statusSub.untracked.length).willEqual(0);
+            iReckon(lc, statusSub.staged.length).willEqual(0);
+
+            // 3. Unmodified re-staging test: execute add -a on unchanged repo
+            const addAgain = await executeAddCmd({
+                targetDir: testDir,
+                vcsFolderName,
+                all: true,
+                quiet: true,
+            });
+            iReckon(lc, addAgain.stagedCount).willEqual(0);
+        } finally {
+            await fs.rm(testDir, { recursive: true, force: true });
+        }
+    });
+
+});