deploy-stack 0.17.7 → 0.17.9

package/tests/ai.test.js

@@ -0,0 +1,60 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import { syncAi } from '../src/commands/sync-ai.js';
+
+// 1. Mock the interactive prompts to simulate user input
+vi.mock('@clack/prompts', () => ({
+    intro: vi.fn(),
+    outro: vi.fn(),
+    // Simulate the user selecting 'claude' from the list and hitting Enter
+    multiselect: vi.fn().mockResolvedValue(['claude']),
+    spinner: () => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() }),
+    log: { success: vi.fn(), warn: vi.fn(), error: vi.fn(), message: vi.fn() }
+}));
+
+// 2. Mock telemetry to prevent real network calls
+vi.mock('../src/core/telemetry.js', () => ({
+    trackEvent: vi.fn(),
+    flushTelemetry: vi.fn().mockResolvedValue(),
+}));
+
+describe('AI Context Synchronization', () => {
+    const originalCwd = process.cwd();
+    const testDir = path.join(originalCwd, 'tests', '.tmp-ai-env');
+
+    beforeEach(async () => {
+        // Create a fake project directory and step into it
+        await fs.mkdir(testDir, { recursive: true });
+        process.chdir(testDir);
+    });
+
+    afterEach(async () => {
+        // Step back out and clean up
+        process.chdir(originalCwd);
+        await fs.rm(testDir, { recursive: true, force: true });
+        vi.clearAllMocks();
+    });
+
+    it('safely injects managed blocks without overwriting existing user instructions', async () => {
+        // Setup 1: Create a CLAUDE.md with pre-existing user instructions
+        const existingUserText = 'Always use async/await. Never use promises directly.\n';
+        await fs.writeFile('CLAUDE.md', existingUserText);
+
+        // Setup 2: Create a dummy terraform state so syncAi can extract the region/port
+        await fs.mkdir('terraform', { recursive: true });
+        await fs.writeFile(path.join('terraform', 'main.tf'), 'region = "us-east-2"\nport = "8000"');
+
+        // Execute the CLI command
+        await syncAi();
+
+        // Assert: Read the file back and verify both contents exist
+        const finalContent = await fs.readFile('CLAUDE.md', 'utf-8');
+
+        // 1. The user's original rules MUST remain intact
+        expect(finalContent).toContain(existingUserText);
+
+        // 2. The deploy-stack managed block MUST be injected
+        expect(finalContent).toContain('deploy-stack');
+    });
+});

package/tests/cli.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+describe('CLI Executable', () => {
+    it('must have the Node.js shebang at the top to prevent bash execution errors', () => {
+        const cliPath = path.resolve(__dirname, '../bin/cli.js');
+        const content = fs.readFileSync(cliPath, 'utf8');
+
+        expect(content.startsWith('#!/usr/bin/env node')).toBe(true);
+    });
+
+    it('must have executable permissions', () => {
+        const cliPath = path.resolve(__dirname, '../bin/cli.js');
+        const stats = fs.statSync(cliPath);
+
+        // Checks if the file is executable by the owner (Unix permission check)
+        const isExecutable = (stats.mode & fs.constants.S_IXUSR) !== 0;
+        expect(isExecutable).toBe(true);
+    });
+});

package/tests/generator.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import { generateTemplates } from '../src/utils/generator.js';
+
+describe('Infrastructure Generator', () => {
+    const testTargetDir = path.join(process.cwd(), 'tests', '.tmp-test-env');
+
+    beforeAll(async () => {
+        await fs.mkdir(testTargetDir, { recursive: true });
+    });
+
+    afterAll(async () => {
+        await fs.rm(testTargetDir, { recursive: true, force: true });
+    });
+
+    const matrix = [
+        // 1. Backend APIs & Monoliths
+        { name: 'Django_Postgres', framework: 'django', needsDb: true, buildDir: '' },
+        { name: 'Rails_Postgres', framework: 'rails', needsDb: true, buildDir: '' },
+        { name: 'Go_Distroless', framework: 'go', needsDb: false, buildDir: '' },
+        { name: 'FastAPI_Python', framework: 'python', needsDb: false, buildDir: '' },
+
+        // 2. Frontend & Meta-Frameworks
+        { name: 'NextJS_Standalone', framework: 'nextjs', needsDb: false, buildDir: '.next/standalone' },
+        { name: 'Nuxt_SSR', framework: 'nuxt', needsDb: false, buildDir: '.output/server' },
+        { name: 'Vite_Static_SPA', framework: 'static', needsDb: false, buildDir: 'dist' },
+        { name: 'SvelteKit_Node', framework: 'svelte', needsDb: false, buildDir: 'build' },
+
+        // 3. Migration Engines
+        {
+            name: 'Heroku_Procfile_Migration',
+            framework: 'django',
+            needsDb: true,
+            buildDir: '',
+            procfile: { web: ['gunicorn config.wsgi'], worker: ['celery -A config worker'] }
+        },
+        {
+            name: 'Vercel_Edge_Migration',
+            framework: 'nextjs',
+            needsDb: false,
+            buildDir: '.next/standalone',
+            vercelRouting: '{"routes": [{"src": "/api/(.*)", "dest": "https://api.example.com/$1"}]}'
+        },
+        {
+            name: 'Docker_Compose_Sidecars',
+            framework: 'node',
+            needsDb: false,
+            buildDir: '',
+            dockerCompose: [{ name: 'web', port: 3000 }, { name: 'redis', image: 'redis:alpine' }]
+        }
+    ];
+
+    for (const tc of matrix) {
+        it(`generates correct infrastructure, CI/CD, and Dockerfile for ${tc.name}`, async () => {
+            await fs.rm(testTargetDir, { recursive: true, force: true }).catch(() => { });
+            await fs.mkdir(path.join(testTargetDir, '.github', 'workflows'), { recursive: true });
+
+            const dummyConfig = {
+                PROJECT_NAME: `test-${tc.name.toLowerCase()}`,
+                REGION: 'us-east-2',
+                PORT: '8000',
+                CPU: '256',
+                MEMORY: '512',
+                COMPUTE_TIER: 'Micro',
+                ESTIMATED_COST: '~$30',
+                STATE_BUCKET: 'test-bucket-123',
+                AWS_ACCOUNT_ID: '123456789012',
+                HEALTH_CHECK_PATH: '/health',
+                DESIRED_COUNT: '1',
+                DEPLOY_BRANCH: 'main',
+                BUILD_DIR: tc.buildDir,
+                finalFramework: tc.framework,
+                NEEDS_DATABASE: tc.needsDb,
+                DJANGO_WSGI: tc.framework === 'django' ? 'gunicorn config.wsgi' : '',
+                DISABLE_DEFAULT_CI: false,
+                PROCFILE: tc.procfile || null,
+                VERCEL_RULES: tc.vercelRouting ? { routes: [] } : null,
+                VERCEL_EDGE_ROUTING: tc.vercelRouting || '',
+                DOCKER_COMPOSE: tc.dockerCompose || null,
+                ENABLE_PR_PREVIEWS: true,
+                TASK_COMMAND: '',
+                WORKER_COMMAND: '',
+                DB_ENV_VARS: '',
+                COMPOSE_WEB_ENV_VARS: '',
+                EXTRA_CONTAINERS: '',
+                TASK_SECRETS: '',
+                INITIAL_SECRET_MAP: '{\n  }',
+                SAFE_ALB_NAME: `test-alb`,
+            };
+
+            await generateTemplates(testTargetDir, dummyConfig);
+
+            const mainTfPath = path.join(testTargetDir, 'terraform', 'main.tf');
+            const networkTfPath = path.join(testTargetDir, 'terraform', 'network.tf');
+            const databaseTfPath = path.join(testTargetDir, 'terraform', 'database.tf');
+            const workerTfPath = path.join(testTargetDir, 'terraform', 'worker.tf');
+
+            const deployYmlPath = path.join(testTargetDir, '.github', 'workflows', 'deploy.yml');
+            const previewYmlPath = path.join(testTargetDir, '.github', 'workflows', 'preview.yml');
+            const teardownYmlPath = path.join(testTargetDir, '.github', 'workflows', 'teardown.yml');
+
+            const dockerfilePath = path.join(testTargetDir, 'Dockerfile');
+
+            // Read contents (falling back to a string if they correctly don't exist)
+            const mainTfContent = await fs.readFile(mainTfPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+            const networkTfContent = await fs.readFile(networkTfPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+            const databaseTfContent = await fs.readFile(databaseTfPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+            const workerTfContent = await fs.readFile(workerTfPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+
+            const deployYmlContent = await fs.readFile(deployYmlPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+            const previewYmlContent = await fs.readFile(previewYmlPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+            const teardownYmlContent = await fs.readFile(teardownYmlPath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+
+            const dockerfileContent = await fs.readFile(dockerfilePath, 'utf-8').catch(() => 'FILE_NOT_FOUND');
+
+            // Snapshot everything
+            expect(mainTfContent).toMatchSnapshot(`${tc.name} - main.tf`);
+            expect(networkTfContent).toMatchSnapshot(`${tc.name} - network.tf`);
+            expect(databaseTfContent).toMatchSnapshot(`${tc.name} - database.tf`);
+            expect(workerTfContent).toMatchSnapshot(`${tc.name} - worker.tf`);
+
+            expect(deployYmlContent).toMatchSnapshot(`${tc.name} - deploy.yml`);
+            expect(previewYmlContent).toMatchSnapshot(`${tc.name} - preview.yml`);
+            expect(teardownYmlContent).toMatchSnapshot(`${tc.name} - teardown.yml`);
+
+            expect(dockerfileContent).toMatchSnapshot(`${tc.name} - Dockerfile`);
+        });
+    }
+});

package/tests/parser.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { parseCliArgs } from '../src/core/parser.js';
+
+describe('CLI Argument Parser', () => {
+    it('safely extracts telemetry variations and prevents positional hijacking', () => {
+        // Simulating: npx deploy-stack secrets push .env --no-telemetry=true
+        const args = ['secrets', 'push', '.env', '--no-telemetry=true'];
+        const result = parseCliArgs(args);
+
+        expect(result.hasNoTelemetry).toBe(true);
+        expect(result.positionalArgs).toEqual(['secrets', 'push', '.env']);
+        expect(result.baseCommand).toBe('secrets push');
+    });
+
+    it('correctly parses headless boolean flags without assignments', () => {
+        // Simulating: npx deploy-stack --headless --needsDatabase
+        const args = ['--headless', '--needsDatabase'];
+        const result = parseCliArgs(args);
+
+        expect(result.isHeadless).toBe(true);
+        expect(result.headlessOptions.needsDatabase).toBe(true);
+    });
+
+    it('correctly maps headless assignment flags', () => {
+        // Simulating: npx deploy-stack --headless --framework=django --region=us-east-2
+        const args = ['--headless', '--framework=django', '--region=us-east-2'];
+        const result = parseCliArgs(args);
+
+        expect(result.headlessOptions.framework).toBe('django');
+        expect(result.headlessOptions.region).toBe('us-east-2');
+    });
+});

package/tests/secrets.test.js

@@ -0,0 +1,93 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import { pushSecrets } from '../src/commands/secrets.js';
+
+// 1. Use vi.hoisted() so these variables are available when vi.mock() runs at the top of the file
+const { mockSend, MockSecretsManagerClient, MockUpdateSecretCommand } = vi.hoisted(() => {
+    const sendFn = vi.fn().mockResolvedValue({});
+    return {
+        mockSend: sendFn,
+        MockSecretsManagerClient: vi.fn(function (config) {
+            this.config = config;
+            this.send = sendFn;
+        }),
+        MockUpdateSecretCommand: vi.fn(function (input) {
+            Object.assign(this, input);
+        })
+    };
+});
+
+// 2. Inject the hoisted mocks into the AWS SDK
+vi.mock('@aws-sdk/client-secrets-manager', () => ({
+    SecretsManagerClient: MockSecretsManagerClient,
+    UpdateSecretCommand: MockUpdateSecretCommand
+}));
+
+// 3. Mock telemetry to prevent real network calls during testing
+vi.mock('../src/core/telemetry.js', () => ({
+    trackEvent: vi.fn(),
+    flushTelemetry: vi.fn().mockResolvedValue(),
+}));
+
+describe('Secrets Push Command', () => {
+    const originalCwd = process.cwd();
+    const testDir = path.join(originalCwd, 'tests', '.tmp-secrets-env');
+
+    beforeEach(async () => {
+        // Create a fake project directory and step into it
+        await fs.mkdir(path.join(testDir, 'terraform'), { recursive: true });
+        process.chdir(testDir);
+    });
+
+    afterEach(async () => {
+        // Step back out, clean up the files, and reset mocks
+        process.chdir(originalCwd);
+        await fs.rm(testDir, { recursive: true, force: true });
+        vi.clearAllMocks();
+        mockSend.mockReset();
+        mockSend.mockResolvedValue({}); // Reset to default success state
+    });
+
+    it('reads .env, pushes to AWS, and writes secret_keys.json', async () => {
+        // Setup: Create a fake .env and a fake main.tf (to test region extraction)
+        await fs.writeFile('.env', 'GITHUB_TOKEN=ghp_12345\nDB_PASS=supersecret');
+        await fs.writeFile(path.join('terraform', 'main.tf'), 'region = "us-east-2"');
+
+        // Execute the CLI command
+        await pushSecrets('.env', 'my-project');
+
+        // Assert 1: Did we initialize the AWS client with the correct region from main.tf?
+        expect(MockSecretsManagerClient).toHaveBeenCalledWith({ region: 'us-east-2' });
+
+        // Assert 2: Did we package the exact right payload for AWS?
+        expect(MockUpdateSecretCommand).toHaveBeenCalledWith({
+            SecretId: 'my-project-secrets',
+            SecretString: JSON.stringify({ GITHUB_TOKEN: 'ghp_12345', DB_PASS: 'supersecret' })
+        });
+
+        // Assert 3: Did we write the keys to the local JSON file for Terraform to use?
+        const keysPath = path.join('terraform', 'secret_keys.json');
+        const keysContent = await fs.readFile(keysPath, 'utf-8');
+        expect(JSON.parse(keysContent)).toEqual(['GITHUB_TOKEN', 'DB_PASS']);
+    });
+
+    it('handles a missing AWS vault (ResourceNotFoundException) gracefully', async () => {
+        // Setup: Force the mocked send method to reject
+        mockSend.mockRejectedValueOnce({ name: 'ResourceNotFoundException', message: 'Vault missing' });
+        await fs.writeFile('.env', 'API_KEY=123');
+
+        // We must mock process.exit so the test runner doesn't crash when the CLI tries to exit
+        const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { });
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+
+        // Execute
+        await pushSecrets('.env', 'my-project');
+
+        // Assert: Ensure the CLI caught the error and attempted a clean exit
+        expect(exitSpy).toHaveBeenCalledWith(1);
+
+        exitSpy.mockRestore();
+        consoleSpy.mockRestore();
+    });
+});