@grada-run/grada 0.32.0 → 0.33.0

package/tests/apply.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory, clackMocks as clack } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -17,56 +21,10 @@ vi.mock('child_process', () => ({
 }));
 
 // --- Silence interactive UI ---
-const clack = vi.hoisted(() => ({
-  mockIntro: vi.fn(),
-  mockOutro: vi.fn(),
-  mockConfirm: vi.fn(),
-  mockCancel: vi.fn(),
-  mockIsCancel: vi.fn(() => false),
-  mockSpinnerStart: vi.fn(),
-  mockSpinnerStop: vi.fn(),
-  mockSpinnerMessage: vi.fn(),
-  mockLogSuccess: vi.fn(),
-  mockLogWarn: vi.fn(),
-  mockLogError: vi.fn(),
-  mockLogMessage: vi.fn(),
-}));
-
-vi.mock('@clack/prompts', () => ({
-  intro: clack.mockIntro,
-  outro: clack.mockOutro,
-  confirm: clack.mockConfirm,
-  cancel: clack.mockCancel,
-  isCancel: clack.mockIsCancel,
-  spinner: vi.fn(() => ({
-    start: clack.mockSpinnerStart,
-    stop: clack.mockSpinnerStop,
-    message: clack.mockSpinnerMessage,
-  })),
-  log: {
-    success: clack.mockLogSuccess,
-    warn: clack.mockLogWarn,
-    error: clack.mockLogError,
-    message: clack.mockLogMessage,
-  },
-}));
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
 
 // --- Never hit network / AWS ---
-vi.mock('../src/core/telemetry.js', () => {
-  const trackEvent = vi.fn();
-  const flushTelemetry = vi.fn().mockResolvedValue();
-  // Mirrors the real trackSuccess delegation so success-path assertions
-  // keep observing trackEvent (the real helper is unit-tested separately).
-  const trackSuccess = vi.fn(async (event, properties) => {
-    trackEvent(event, { ...properties, success: true });
-    await flushTelemetry();
-  });
-  const trackFailure = vi.fn(async (event, properties) => {
-    trackEvent(event, { ...properties, success: false });
-    await flushTelemetry();
-  });
-  return { trackEvent, flushTelemetry, trackSuccess, trackFailure };
-});
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 vi.mock('../src/utils/aws.js', async (importOriginal) => {
   const actual = await importOriginal();

package/tests/capabilities.test.js

@@ -1,15 +1,14 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createTmpDirTracker } from './helpers/tmpdir.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { detectProjectCapabilities } from '../src/utils/capabilities.js';
 
-let tmpDirs = [];
+const tmp = createTmpDirTracker();
 
 function makeTmp() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'capabilities-test-'));
-    tmpDirs.push(dir);
-    return dir;
+    return tmp.makeTmp('capabilities-test-');
 }
 
 function writeFile(dir, relPath, content) {
@@ -24,13 +23,11 @@ function writeJson(dir, relPath, value) {
 }
 
 beforeEach(() => {
-    tmpDirs = [];
+    tmp.reset();
 });
 
 afterEach(() => {
-    for (const dir of tmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
+    tmp.cleanup();
 });
 
 describe('detectProjectCapabilities: empty and malformed projects', () => {

package/tests/command.test.js

@@ -1,28 +1,27 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { telemetryMockFactory } from './helpers/telemetry.js';
+import { mockConsoleTrio } from './helpers/console.js';
 import { failCommand, failProjectNotInitialized } from '../src/utils/command.js';
 import { trackEvent, flushTelemetry } from '../src/core/telemetry.js';
 
-vi.mock('../src/core/telemetry.js', () => ({
-    trackEvent: vi.fn(),
-    flushTelemetry: vi.fn().mockResolvedValue(),
-}));
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 describe('failCommand', () => {
     let exitSpy;
     let logSpy;
     let errorSpy;
+    let spies;
 
     beforeEach(() => {
         vi.clearAllMocks();
-        exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
-        logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-        errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        spies = mockConsoleTrio();
+        ({ exitSpy, logSpy, errorSpy } = spies);
     });
 
     afterEach(() => {
-        exitSpy.mockRestore();
-        logSpy.mockRestore();
-        errorSpy.mockRestore();
+        spies.restore();
     });
 
     it('prints, tracks, flushes, exits, and returns the standard result', async () => {

package/tests/db.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory, mockText, mockSelect, mockConfirm, mockPassword, mockSpinner } from './helpers/clack.js';
+import { telemetryMockFactory, mockTrackEvent } from './helpers/telemetry.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -47,44 +51,9 @@ import {
 import { injectMigrationGate, quoteShellArg, buildMigrationCommand, findGateBlock } from '../src/commands/db/migrate.js';
 import { resolveWorkspaceSuffix } from '../src/utils/resolvers.js';
 
-const { mockText, mockSelect, mockConfirm, mockPassword, mockSpinner } = vi.hoisted(() => ({
-    mockText: vi.fn(),
-    mockSelect: vi.fn(),
-    mockConfirm: vi.fn(),
-    mockPassword: vi.fn(),
-    mockSpinner: vi.fn(() => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() })),
-}));
-
-vi.mock('@clack/prompts', () => ({
-    intro: vi.fn(),
-    outro: vi.fn(),
-    spinner: (...args) => mockSpinner(...args),
-    text: (...args) => mockText(...args),
-    select: (...args) => mockSelect(...args),
-    confirm: (...args) => mockConfirm(...args),
-    password: (...args) => mockPassword(...args),
-    cancel: vi.fn(),
-    isCancel: (value) => typeof value === 'symbol',
-}));
-
-const { mockTrackEvent } = vi.hoisted(() => ({
-    mockTrackEvent: vi.fn(),
-}));
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
 
-vi.mock('../src/core/telemetry.js', () => {
-    const flushTelemetry = vi.fn(() => Promise.resolve());
-    // Mirrors the real trackSuccess delegation so success-path assertions
-    // keep observing trackEvent (the real helper is unit-tested separately).
-    const trackSuccess = vi.fn(async (event, properties) => {
-        mockTrackEvent(event, { ...properties, success: true });
-        await flushTelemetry();
-    });
-    const trackFailure = vi.fn(async (event, properties) => {
-        mockTrackEvent(event, { ...properties, success: false });
-        await flushTelemetry();
-    });
-    return { trackEvent: mockTrackEvent, flushTelemetry, trackSuccess, trackFailure };
-});
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 const {
     MockDescribeDBInstancesCommand,

package/tests/destroy.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory, clackMocks as clack } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -20,27 +24,7 @@ vi.mock('child_process', async (importOriginal) => {
 });
 
 // --- Silence interactive UI; confirm is controllable per test ---
-const clack = vi.hoisted(() => ({
-  mockIntro: vi.fn(),
-  mockOutro: vi.fn(),
-  mockConfirm: vi.fn(),
-  mockCancel: vi.fn(),
-  mockSpinnerStart: vi.fn(),
-  mockSpinnerStop: vi.fn(),
-  mockSpinnerMessage: vi.fn(),
-}));
-
-vi.mock('@clack/prompts', () => ({
-  intro: clack.mockIntro,
-  outro: clack.mockOutro,
-  confirm: clack.mockConfirm,
-  cancel: clack.mockCancel,
-  spinner: vi.fn(() => ({
-    start: clack.mockSpinnerStart,
-    stop: clack.mockSpinnerStop,
-    message: clack.mockSpinnerMessage,
-  })),
-}));
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
 
 // --- Never touch AWS or the network ---
 vi.mock('../src/utils/aws.js', () => ({
@@ -78,17 +62,7 @@ vi.mock('../src/utils/system.js', async (importOriginal) => {
   };
 });
 
-vi.mock('../src/core/telemetry.js', () => {
-  const trackEvent = vi.fn();
-  const flushTelemetry = vi.fn().mockResolvedValue();
-  // Mirrors the real trackSuccess delegation so success-path assertions
-  // keep observing trackEvent (the real helper is unit-tested separately).
-  const trackSuccess = vi.fn(async (event, properties) => {
-    trackEvent(event, { ...properties, success: true });
-    await flushTelemetry();
-  });
-  return { trackEvent, flushTelemetry, trackSuccess };
-});
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 import { destroyStack } from '../src/commands/destroy.js';
 import { teardownStateBucket } from '../src/utils/aws.js';

package/tests/diagnose.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
 import { stripVTControlCharacters } from 'node:util';
 import fs from 'fs';
 import os from 'os';
@@ -56,27 +60,9 @@ vi.mock('@aws-sdk/client-cloudwatch-logs', () => {
 });
 
 // Silence interactive prompts and telemetry during tests
-vi.mock('@clack/prompts', () => ({
-    intro: vi.fn(),
-    outro: vi.fn(),
-    spinner: () => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() })
-}));
-
-vi.mock('../src/core/telemetry.js', () => {
-    const trackEvent = vi.fn();
-    const flushTelemetry = vi.fn().mockResolvedValue();
-    // Mirrors the real trackSuccess delegation so success-path assertions
-    // keep observing trackEvent (the real helper is unit-tested separately).
-    const trackSuccess = vi.fn(async (event, properties) => {
-        trackEvent(event, { ...properties, success: true });
-        await flushTelemetry();
-    });
-    const trackFailure = vi.fn(async (event, properties) => {
-        trackEvent(event, { ...properties, success: false });
-        await flushTelemetry();
-    });
-    return { trackEvent, flushTelemetry, trackSuccess, trackFailure };
-});
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
+
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 describe('Command: diagnose', () => {
     beforeEach(() => {

package/tests/doctor.test.js

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
 import { runDoctor, installHint, DOCTOR_CHECKS } from '../src/commands/doctor.js';
 import { checkDependency } from '../src/utils/system.js';
 import { trackEvent, flushTelemetry } from '../src/core/telemetry.js';
@@ -7,20 +11,9 @@ vi.mock('../src/utils/system.js', () => ({
     checkDependency: vi.fn(),
 }));
 
-vi.mock('@clack/prompts', () => ({
-    intro: vi.fn(),
-    outro: vi.fn(),
-    spinner: () => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() }),
-}));
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
 
-vi.mock('../src/core/telemetry.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        trackEvent: vi.fn(),
-        flushTelemetry: vi.fn().mockResolvedValue(),
-        detectCiProvider: actual.detectCiProvider,
-    };
-});
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
 const realPlatform = process.platform;
 

package/tests/domain.test.js

@@ -1,4 +1,9 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
+import { createTmpDirTracker } from './helpers/tmpdir.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -34,36 +39,16 @@ import {
 import { trackEvent, flushTelemetry } from '../src/core/telemetry.js';
 import { confirm, outro } from '@clack/prompts';
 
-vi.mock('@clack/prompts', () => ({
-    intro: vi.fn(),
-    outro: vi.fn(),
-    confirm: vi.fn(),
-    text: vi.fn(),
-    spinner: () => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() }),
-    log: { info: vi.fn(), warn: vi.fn(), message: vi.fn(), success: vi.fn(), error: vi.fn() },
-    cancel: vi.fn(),
-    isCancel: (value) => typeof value === 'symbol',
-}));
-
-vi.mock('../src/core/telemetry.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    const trackEvent = vi.fn();
-    const flushTelemetry = vi.fn().mockResolvedValue();
-    const trackSuccess = vi.fn(async (event, properties) => {
-        trackEvent(event, { ...properties, success: true });
-        await flushTelemetry();
-    });
-    return { trackEvent, flushTelemetry, trackSuccess, isActiveEnvValue: actual.isActiveEnvValue, detectCiProvider: actual.detectCiProvider };
-});
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
+
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
 
-let tmpDirs = [];
+const tmp = createTmpDirTracker();
 let exitSpy;
 let logSpy;
 
 function makeTmp() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'domain-test-'));
-    tmpDirs.push(dir);
-    return dir;
+    return tmp.makeTmp('domain-test-');
 }
 
 const CLOUDFRONT_TF = [
@@ -129,7 +114,7 @@ function capturedOutput() {
 }
 
 beforeEach(() => {
-    tmpDirs = [];
+    tmp.reset();
     vi.clearAllMocks();
     exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
     logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -138,9 +123,7 @@ beforeEach(() => {
 afterEach(() => {
     exitSpy.mockRestore();
     logSpy.mockRestore();
-    for (const dir of tmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
+    tmp.cleanup();
 });
 
 describe('hcl: findResourceBlock', () => {

package/tests/drift.test.js

@@ -1,4 +1,9 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// NOTE: helper imports must stay above src imports: vi.mock factories run
+// during module evaluation and need the factories initialized.
+import { clackPromptsMockFactory } from './helpers/clack.js';
+import { telemetryMockFactory } from './helpers/telemetry.js';
+import { createTmpDirTracker } from './helpers/tmpdir.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -12,34 +17,16 @@ import {
 } from '../src/commands/drift.js';
 import { trackEvent, flushTelemetry } from '../src/core/telemetry.js';
 
-vi.mock('@clack/prompts', () => ({
-    intro: vi.fn(),
-    outro: vi.fn(),
-    spinner: () => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() }),
-}));
-
-vi.mock('../src/core/telemetry.js', () => {
-    const trackEvent = vi.fn();
-    const flushTelemetry = vi.fn().mockResolvedValue();
-    const trackSuccess = vi.fn(async (event, properties) => {
-        trackEvent(event, { ...properties, success: true });
-        await flushTelemetry();
-    });
-    const trackFailure = vi.fn(async (event, properties) => {
-        trackEvent(event, { ...properties, success: false });
-        await flushTelemetry();
-    });
-    return { trackEvent, flushTelemetry, trackSuccess, trackFailure };
-});
+vi.mock('@clack/prompts', () => clackPromptsMockFactory());
 
-let tmpDirs = [];
+vi.mock('../src/core/telemetry.js', (importOriginal) => telemetryMockFactory(importOriginal));
+
+const tmp = createTmpDirTracker();
 let exitSpy;
 let logSpy;
 
 function makeTmp() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'drift-test-'));
-    tmpDirs.push(dir);
-    return dir;
+    return tmp.makeTmp('drift-test-');
 }
 
 function writeDeployYml(dir, roleArn = 'arn:aws:iam::123456789012:role/myapp-github-actions-role') {
@@ -60,7 +47,7 @@ function writeMainTf(dir, region = 'us-east-2') {
 }
 
 beforeEach(() => {
-    tmpDirs = [];
+    tmp.reset();
     vi.clearAllMocks();
     exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
     logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -69,9 +56,7 @@ beforeEach(() => {
 afterEach(() => {
     exitSpy.mockRestore();
     logSpy.mockRestore();
-    for (const dir of tmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
+    tmp.cleanup();
 });
 
 describe('parseDriftArgs', () => {

package/tests/e2e/helpers.js

@@ -0,0 +1,122 @@
+// Shared helpers for the E2E suites (Tier 0 + Tier 1). Kept separate from
+// tests/helpers/ on purpose: unit mocks must never leak into black-box runs.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const ROOT = path.resolve(HERE, '..', '..');
+export const CLI = path.join(ROOT, 'bin', 'cli.js');
+
+// Repo-local workspace root so CI can upload it as an artifact on failure.
+// Overridable via E2E_TMP_ROOT for local debugging.
+export const E2E_TMP_ROOT = process.env.E2E_TMP_ROOT || path.join(HERE, '.tmp');
+
+// Shared provider cache across runs (mirrors scripts/test-iac.js).
+const pluginCacheDir = path.join(os.tmpdir(), 'grada-e2e-plugin-cache');
+
+export function e2eEnv({ mockAws }) {
+    fs.mkdirSync(pluginCacheDir, { recursive: true });
+    const env = {
+        ...process.env,
+        DO_NOT_TRACK: '1',
+        TF_PLUGIN_CACHE_DIR: pluginCacheDir,
+    };
+    if (mockAws) {
+        env.CI_MOCK_AWS = 'true';
+    } else {
+        delete env.CI_MOCK_AWS;
+    }
+    return env;
+}
+
+export function commandExists(cmd) {
+    try {
+        const result = spawnSync(cmd, ['--version'], { stdio: 'pipe' });
+        return result.status === 0;
+    } catch {
+        return false;
+    }
+}
+
+// Fail fast with a helpful error when local prerequisites are missing.
+export function assertPrerequisites() {
+    if (!commandExists('terraform')) {
+        throw new Error(
+            'E2E requires the Terraform CLI on PATH (https://developer.hashicorp.com/terraform/install).'
+        );
+    }
+}
+
+export function makeTmpDir(prefix) {
+    fs.mkdirSync(E2E_TMP_ROOT, { recursive: true });
+    return fs.mkdtempSync(path.join(E2E_TMP_ROOT, `${prefix}-`));
+}
+
+export function removeDir(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+
+// Run the real CLI with stdin always closed (headless purity: a prompt
+// crashes loudly instead of hanging). Output is inherited for visibility
+// unless capture is requested for assertions.
+export function runCli(args, { cwd, env, capture = false } = {}) {
+    const result = spawnSync('node', [CLI, ...args], {
+        cwd,
+        env,
+        stdio: capture ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'inherit', 'inherit'],
+        encoding: 'utf-8',
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        output: `${result.stdout ?? ''}\n${result.stderr ?? ''}`,
+    };
+}
+
+export function runTerraform(args, { cwd, env }) {
+    const result = spawnSync('terraform', args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'inherit', 'inherit'],
+        encoding: 'utf-8',
+    });
+    if (result.status !== 0) {
+        throw new Error(`terraform ${args.join(' ')} failed with exit ${result.status}`);
+    }
+}
+
+// Isolated workspace that is removed on success and preserved (with its
+// path printed) on failure for debugging and CI artifact upload.
+export async function withTmpDir(prefix, fn) {
+    const dir = makeTmpDir(prefix);
+    try {
+        await fn(dir);
+    } catch (error) {
+        console.log(`E2E workspace preserved for debugging: ${dir}`);
+        throw error;
+    }
+    removeDir(dir);
+}
+
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readBackendValue(projectDir, key) {
+    const backend = fs.readFileSync(path.join(projectDir, 'terraform', 'backend.tf'), 'utf-8');
+    const match = backend.match(new RegExp(`${key}\\s*=\\s*"([^"]+)"`));
+    if (!match) throw new Error(`could not parse ${key} from terraform/backend.tf`);
+    return match[1];
+}
+
+export function readBackendBucket(projectDir) {
+    return readBackendValue(projectDir, 'bucket');
+}
+
+export function readBackendRegion(projectDir) {
+    return readBackendValue(projectDir, 'region');
+}