more tests

Author: JohannesHoppe

src/parameter-tests/gh-pages-shell.spec.ts

@@ -0,0 +1,218 @@
+/**
+ * SHELL-LEVEL GH-PAGES TESTING
+ *
+ * This test suite mocks child_process.spawn to capture the exact git commands
+ * executed by gh-pages.publish(). This allows us to:
+ *
+ * 1. Document the exact git command sequence with gh-pages v3.1.0
+ * 2. Upgrade to gh-pages v6.1.1
+ * 3. Verify that the git command sequence remains identical
+ * 4. Detect any behavioral changes at the shell level
+ *
+ * Strategy:
+ * - Mock cp.spawn to intercept all git commands
+ * - Capture: executable, arguments, working directory
+ * - Compare command sequences before/after upgrade
+ *
+ * CURRENT STATUS:
+ * This is infrastructure-only for now. The actual integration with gh-pages
+ * requires mocking the file system (fs-extra) as well. This will be implemented
+ * in the next iteration.
+ */
+
+interface SpawnCall {
+  exe: string;
+  args: string[];
+  cwd: string;
+}
+
+const spawnCalls: SpawnCall[] = [];
+
+// Mock child_process.spawn at module level (must be before imports)
+jest.mock('child_process', () => ({
+  ...jest.requireActual('child_process'),
+  spawn: jest.fn((command: string, args?: readonly string[], options?: {cwd?: string}) => {
+    const cwd = options?.cwd || process.cwd();
+
+    spawnCalls.push({
+      exe: command,
+      args: args ? [...args] : [],
+      cwd
+    });
+
+    // Create mock child process that succeeds immediately
+    const mockChild = {
+      stdout: {
+        on: jest.fn((event: string, callback?: (data: Buffer) => void) => {
+          if (event === 'data' && callback) {
+            // Simulate git output for commands that return data
+            if (args && args.includes('config') && args.includes('--get')) {
+              callback(Buffer.from('https://github.com/test/repo.git\n'));
+            }
+          }
+          return mockChild.stdout;
+        })
+      },
+      stderr: {
+        on: jest.fn(() => mockChild.stderr)
+      },
+      on: jest.fn((event: string, callback?: (code: number) => void) => {
+        if (event === 'close' && callback) {
+          // Simulate successful command (exit code 0)
+          setTimeout(() => callback(0), 0);
+        }
+        return mockChild;
+      })
+    };
+
+    return mockChild;
+  })
+}));
+
+import { logging } from '@angular-devkit/core';
+
+describe('Shell-Level gh-pages Testing', () => {
+  let logger: logging.LoggerApi;
+
+  beforeEach(() => {
+    logger = new logging.NullLogger();
+    spawnCalls.length = 0; // Clear array
+    process.env = {};
+  });
+
+  describe('Helper functions', () => {
+    it('should format git commands as readable strings', () => {
+      const calls: SpawnCall[] = [
+        {
+          exe: 'git',
+          args: ['clone', 'https://github.com/test/repo.git', '/cache/dir', '--branch', 'gh-pages'],
+          cwd: '/test'
+        },
+        {
+          exe: 'git',
+          args: ['config', 'user.email', 'test@example.com'],
+          cwd: '/cache/dir'
+        },
+        {
+          exe: 'git',
+          args: ['commit', '-m', 'Deploy'],
+          cwd: '/cache/dir'
+        }
+      ];
+
+      const formatted = calls.map(call => formatGitCommand(call));
+
+      expect(formatted[0]).toBe('git clone https://github.com/test/repo.git /cache/dir --branch gh-pages');
+      expect(formatted[1]).toBe('git config user.email test@example.com');
+      expect(formatted[2]).toBe('git commit -m Deploy');
+    });
+
+    it('should filter only git commands from spawn calls', () => {
+      const calls: SpawnCall[] = [
+        { exe: 'git', args: ['status'], cwd: '/test' },
+        { exe: 'node', args: ['script.js'], cwd: '/test' },
+        { exe: 'git', args: ['commit', '-m', 'test'], cwd: '/test' },
+        { exe: 'npm', args: ['install'], cwd: '/test' }
+      ];
+
+      const gitCommands = filterGitCommands(calls);
+
+      expect(gitCommands).toHaveLength(2);
+      expect(gitCommands[0].args[0]).toBe('status');
+      expect(gitCommands[1].args[0]).toBe('commit');
+    });
+
+    it('should group git commands by operation type', () => {
+      const calls: SpawnCall[] = [
+        { exe: 'git', args: ['clone', 'repo', 'dir'], cwd: '/test' },
+        { exe: 'git', args: ['fetch', 'origin'], cwd: '/test' },
+        { exe: 'git', args: ['add', '.'], cwd: '/test' },
+        { exe: 'git', args: ['commit', '-m', 'msg'], cwd: '/test' },
+        { exe: 'git', args: ['push', 'origin', 'main'], cwd: '/test' }
+      ];
+
+      const groups = groupGitCommandsByType(calls);
+
+      expect(groups.clone).toHaveLength(1);
+      expect(groups.fetch).toHaveLength(1);
+      expect(groups.add).toHaveLength(1);
+      expect(groups.commit).toHaveLength(1);
+      expect(groups.push).toHaveLength(1);
+    });
+  });
+
+  describe('Documentation: Expected git command sequence', () => {
+    it('should document the expected git commands for standard deployment', () => {
+      // This test documents what we EXPECT to see when gh-pages.publish() runs
+      // Once we implement full mocking, we'll verify these commands are executed
+
+      const expectedCommands = [
+        'git clone <repo> <cache-dir> --branch <branch> --single-branch --origin <remote> --depth 1',
+        'git config --get remote.<remote>.url',
+        'git clean -f -d',
+        'git fetch <remote>',
+        'git ls-remote --exit-code . <remote>/<branch>',
+        'git checkout <branch>',
+        'git reset --hard <remote>/<branch>',
+        'git rm --ignore-unmatch -r -f . (unless --add flag)',
+        'git add .',
+        'git config user.email <email> (if user set)',
+        'git config user.name <name> (if user set)',
+        'git diff-index --quiet HEAD',
+        'git commit -m <message>',
+        'git push --tags <remote> <branch>'
+      ];
+
+      // Document for future reference
+      expect(expectedCommands).toHaveLength(14);
+    });
+
+    it('should document variations with --add flag', () => {
+      const withoutAdd = 'Files are removed before new ones are added';
+      const withAdd = 'Files are NOT removed, just added on top';
+
+      expect(withoutAdd).toBeDefined();
+      expect(withAdd).toBeDefined();
+    });
+
+    it('should document user credentials handling', () => {
+      const withUser = 'git config user.email and user.name are executed';
+      const withoutUser = 'git uses local/global git config for commit author';
+
+      expect(withUser).toBeDefined();
+      expect(withoutUser).toBeDefined();
+    });
+  });
+});
+
+/**
+ * Format a spawn call as a readable git command string
+ */
+function formatGitCommand(call: SpawnCall): string {
+  return `${call.exe} ${call.args.join(' ')}`;
+}
+
+/**
+ * Filter only git commands from spawn calls
+ */
+function filterGitCommands(calls: SpawnCall[]): SpawnCall[] {
+  return calls.filter(call => call.exe === 'git' || call.exe.endsWith('/git'));
+}
+
+/**
+ * Group git commands by operation type (clone, fetch, add, commit, push, etc.)
+ */
+function groupGitCommandsByType(calls: SpawnCall[]): Record<string, SpawnCall[]> {
+  const gitCalls = filterGitCommands(calls);
+  const groups: Record<string, SpawnCall[]> = {};
+
+  for (const call of gitCalls) {
+    const operation = call.args[0] || 'unknown';
+    if (!groups[operation]) {
+      groups[operation] = [];
+    }
+    groups[operation].push(call);
+  }
+
+  return groups;
+}