test: cover new features + enforce coverage threshold in jest and CI

- Add tests: validate command, snapshot delete/restore-backup, generate --dry-run,
  share import --validate-only, service healthcheck + sqlite warning, validator
  password false-positive, seed path, init wizard flow (prompts.inject)
- jest.config: add global coverageThreshold (regression floor)
- CI: run tests with --coverage and upload coverage artifact
- 221 tests passing (was 201)

Author: nazarli-shabnam

.github/workflows/ci.yml

@@ -31,4 +31,12 @@ jobs:
         run: npm run build
 
       - name: Test
-        run: npm test
+        run: npm test -- --coverage
+
+      - name: Upload coverage report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-node-${{ matrix.node-version }}
+          path: coverage/
+          if-no-files-found: ignore

jest.config.js

@@ -11,6 +11,14 @@ module.exports = {
   ],
   coverageDirectory: 'coverage',
   coverageReporters: ['text', 'lcov', 'html'],
+  coverageThreshold: {
+    global: {
+      statements: 80,
+      branches: 55,
+      functions: 72,
+      lines: 80,
+    },
+  },
   verbose: true,
   clearMocks: true,
   restoreMocks: true,

tests/commands/generate.test.ts

@@ -140,6 +140,22 @@ describe('generate command', () => {
     expect(content).toContain('redis');
   });
 
+  it('dry-run prints compose to stdout without writing a file', async () => {
+    await fs.writeFile(
+      path.join(tempDir, '.dev-env.yml'),
+      'name: gen-test\ndatabases:\n  - type: redis\n    port: 6379\ndocker:\n  enabled: true'
+    );
+    process.chdir(tempDir);
+    const writeSpy = jest.spyOn(process.stdout, 'write').mockReturnValue(true);
+
+    await runGenerate({ dryRun: true });
+
+    const written = writeSpy.mock.calls.map((c) => String(c[0])).join('');
+    expect(written).toContain('redis');
+    expect(written).toContain('services:');
+    expect(await fs.pathExists(path.join(tempDir, 'docker-compose.yml'))).toBe(false);
+  });
+
   it('uses default output filename when output is empty string', async () => {
     await fs.writeFile(
       path.join(tempDir, '.dev-env.yml'),

tests/commands/init-wizard.test.ts

@@ -0,0 +1,72 @@
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import * as yaml from 'js-yaml';
+import prompts from 'prompts';
+import { runInit } from '../../src/commands/init';
+import { DevEnvConfigSchema } from '../../src/types/config';
+import { logger } from '../../src/utils/logger';
+
+describe('init wizard (runInit)', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+  const originalTTY = process.stdout.isTTY;
+
+  beforeEach(async () => {
+    jest.spyOn(logger, 'info').mockImplementation();
+    jest.spyOn(logger, 'success').mockImplementation();
+    jest.spyOn(logger, 'error').mockImplementation();
+    jest.spyOn(logger, 'debug').mockImplementation();
+    // Force interactive so runInit drives the wizard.
+    process.stdout.isTTY = true;
+    tempDir = path.join(require('os').tmpdir(), `devkit-initw-${Date.now()}-${Math.floor(performance.now())}`);
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.stdout.isTTY = originalTTY;
+    process.chdir(originalCwd);
+    await fs.remove(tempDir).catch(() => {});
+    jest.restoreAllMocks();
+  });
+
+  it('builds a valid .dev-env.yml from wizard answers (minimal flow)', async () => {
+    // Order: name, version, addDeps?, addDb?, addService?, addEnv?, dockerEnabled?
+    prompts.inject(['my-app', '2.1.0', false, false, false, true, true]);
+
+    await runInit(tempDir);
+
+    const configPath = path.join(tempDir, '.dev-env.yml');
+    expect(await fs.pathExists(configPath)).toBe(true);
+    const parsed = DevEnvConfigSchema.parse(yaml.load(await fs.readFile(configPath, 'utf-8')));
+    expect(parsed.name).toBe('my-app');
+    expect(parsed.version).toBe('2.1.0');
+    expect(parsed.env).toMatchObject({ NODE_ENV: 'development' });
+    expect(parsed.docker?.enabled).toBe(true);
+  });
+
+  it('captures a database with a health check from wizard answers', async () => {
+    // name, version, addDeps?, addDb?(yes), dbType, dbFields..., then addDb?(no) etc.
+    // db prompt sequence after type select: name, port, user, password, database, migrations?, seed?
+    // To stay robust we drive a redis DB which has the fewest follow-ups.
+    prompts.inject([
+      'db-app', '1.0.0',
+      false,                                   // addDeps?
+      true, 'redis',                           // addDb? + type
+      'cache', '7', 6379, 'localhost', '', '', // db: name, version, port, host, user, password
+      false,                                   // add migrations?
+      false,                                   // add seed?
+      false,                                   // addDb? (stop)
+      false,                                   // addService?
+      false,                                   // addEnv?
+      false,                                   // dockerEnabled?
+      true,                                    // add health check?
+    ]);
+
+    await runInit(tempDir);
+
+    const configPath = path.join(tempDir, '.dev-env.yml');
+    const parsed = DevEnvConfigSchema.parse(yaml.load(await fs.readFile(configPath, 'utf-8')));
+    expect(parsed.databases?.[0]?.type).toBe('redis');
+    expect(parsed.health_checks?.some((h) => h.type === 'redis')).toBe(true);
+  });
+});

tests/commands/setup.test.ts

@@ -149,4 +149,29 @@ describe('setup command', () => {
     const seedCall = calls.find((c) => c[0] === 'npm' && c[1].includes('seed'));
     expect(seedCall).toBeDefined();
   });
+
+  it('runs seed in the configured seed path', async () => {
+    await fs.ensureDir(path.join(tempDir, 'scripts'));
+    await fs.writeFile(
+      path.join(tempDir, '.dev-env.yml'),
+      [
+        'name: setup-test',
+        'dependencies: []',
+        'databases:',
+        '  - type: postgresql',
+        '    port: 5432',
+        '    seed:',
+        '      command: npm run seed',
+        '      path: ./scripts',
+      ].join('\n')
+    );
+    process.chdir(tempDir);
+
+    await runSetup({ skipDeps: true, skipDb: false });
+
+    const calls = (execFn as jest.Mock).mock.calls as [string, string[], Record<string, unknown>][];
+    const seedCall = calls.find((c) => c[0] === 'npm' && c[1].includes('seed'));
+    expect(seedCall).toBeDefined();
+    expect(seedCall![2].cwd).toBe(path.resolve(tempDir, './scripts'));
+  });
 });

tests/commands/share.test.ts

@@ -247,5 +247,26 @@ describe('share command', () => {
       const content = await fs.readFile(inCwd, 'utf-8');
       expect(content).toMatch(/imported-cwd/);
     });
+
+    it('validate-only does not write any file', async () => {
+      const sharedPath = path.join(tempDir, 'shared.yml');
+      await fs.writeFile(sharedPath, 'name: imported\nversion: "1.0.0"\ndatabases: []');
+      process.chdir(tempDir);
+
+      await runShareImport(sharedPath, { validateOnly: true });
+
+      expect(await fs.pathExists(path.join(tempDir, '.dev-env.yml'))).toBe(false);
+      expect(logger.success).toHaveBeenCalledWith(expect.stringContaining('valid'));
+    });
+
+    it('validate-only still rejects an invalid config', async () => {
+      const badPath = path.join(tempDir, 'bad.yml');
+      await fs.writeFile(badPath, 'version: "1.0.0"');
+      process.chdir(tempDir);
+
+      await expect(runShareImport(badPath, { validateOnly: true })).rejects.toThrow(
+        /Invalid dev-env config|name/
+      );
+    });
   });
 });

tests/commands/snapshot.test.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as fs from 'fs-extra';
-import { runSnapshotCreate, runSnapshotList, runSnapshotRestore } from '../../src/commands/snapshot';
+import { runSnapshotCreate, runSnapshotList, runSnapshotRestore, runSnapshotDelete } from '../../src/commands/snapshot';
 import { listSnapshots } from '../../src/core/snapshot/storage';
 import { logger } from '../../src/utils/logger';
 
@@ -202,5 +202,52 @@ describe('snapshot commands', () => {
       const current = await fs.readFile(path.join(tempDir, '.dev-env.yml'), 'utf-8');
       expect(current).toBe(configYaml);
     });
+
+    it('backs up the current config to a pre-restore snapshot before overwriting', async () => {
+      await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'name: original');
+      process.chdir(tempDir);
+      await runSnapshotCreate('backup');
+      await fs.writeFile(
+        path.join(tempDir, '.devkit', 'snapshots', 'backup', 'dev-env.yml'),
+        'name: from-backup'
+      );
+
+      await runSnapshotRestore('backup', { yes: true });
+
+      const snapshots = await listSnapshots(tempDir);
+      const preRestore = snapshots.find((s) => s.name.startsWith('pre-restore-'));
+      expect(preRestore).toBeDefined();
+      const backupYaml = await fs.readFile(
+        path.join(tempDir, '.devkit', 'snapshots', preRestore!.name, 'dev-env.yml'),
+        'utf-8'
+      );
+      expect(backupYaml).toBe('name: original');
+    });
+  });
+
+  describe('runSnapshotDelete', () => {
+    it('throws when name is empty', async () => {
+      await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'name: x');
+      process.chdir(tempDir);
+      await expect(runSnapshotDelete('')).rejects.toThrow(/Snapshot name is required/);
+    });
+
+    it('throws when snapshot does not exist', async () => {
+      await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'name: x');
+      process.chdir(tempDir);
+      await expect(runSnapshotDelete('nope')).rejects.toThrow(/not found|envkit snapshot list/);
+    });
+
+    it('removes an existing snapshot', async () => {
+      await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'name: x');
+      process.chdir(tempDir);
+      await runSnapshotCreate('doomed');
+      expect(await listSnapshots(tempDir)).toHaveLength(1);
+
+      await runSnapshotDelete('doomed');
+
+      expect(await listSnapshots(tempDir)).toHaveLength(0);
+      expect(logger.success).toHaveBeenCalledWith(expect.stringContaining('doomed'));
+    });
   });
 });

tests/commands/validate.test.ts

@@ -0,0 +1,75 @@
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import { runValidate } from '../../src/commands/validate';
+import { logger } from '../../src/utils/logger';
+
+describe('validate command', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(async () => {
+    jest.spyOn(logger, 'warn').mockImplementation();
+    jest.spyOn(logger, 'info').mockImplementation();
+    jest.spyOn(logger, 'success').mockImplementation();
+    jest.spyOn(logger, 'debug').mockImplementation();
+    tempDir = path.join(require('os').tmpdir(), `devkit-validate-${Date.now()}-${Math.floor(performance.now())}`);
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.remove(tempDir).catch(() => {});
+    jest.restoreAllMocks();
+  });
+
+  it('throws when .dev-env.yml is not found', async () => {
+    process.chdir(tempDir);
+    await expect(runValidate()).rejects.toThrow(/Configuration file not found|\.dev-env\.yml/);
+  });
+
+  it('succeeds on a valid config', async () => {
+    await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'name: ok\nversion: "1.0.0"\ndatabases: []');
+    process.chdir(tempDir);
+
+    await expect(runValidate()).resolves.toBeUndefined();
+    expect(logger.success).toHaveBeenCalledWith(expect.stringContaining('is valid'));
+  });
+
+  it('throws on an invalid config (missing required name)', async () => {
+    await fs.writeFile(path.join(tempDir, '.dev-env.yml'), 'version: "1.0.0"');
+    process.chdir(tempDir);
+
+    await expect(runValidate()).rejects.toThrow(/Invalid configuration|name/);
+  });
+
+  it('warns on unresolved ${VAR} references but succeeds without --strict', async () => {
+    await fs.writeFile(
+      path.join(tempDir, '.dev-env.yml'),
+      'name: app\nenv:\n  TOKEN: ${MISSING_TOKEN}'
+    );
+    process.chdir(tempDir);
+
+    await expect(runValidate()).resolves.toBeUndefined();
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('MISSING_TOKEN'));
+  });
+
+  it('fails with --strict when there are unresolved variables', async () => {
+    await fs.writeFile(
+      path.join(tempDir, '.dev-env.yml'),
+      'name: app\nenv:\n  TOKEN: ${MISSING_TOKEN}'
+    );
+    process.chdir(tempDir);
+
+    await expect(runValidate({ strict: true })).rejects.toThrow(/--strict|unresolved/);
+  });
+
+  it('resolves a variable defined in the config env block', async () => {
+    await fs.writeFile(
+      path.join(tempDir, '.dev-env.yml'),
+      'name: app\nenv:\n  BASE: hello\n  DERIVED: ${BASE}-world'
+    );
+    process.chdir(tempDir);
+
+    await expect(runValidate({ strict: true })).resolves.toBeUndefined();
+  });
+});

tests/core/config/validator.test.ts

@@ -91,6 +91,27 @@ describe('validator', () => {
       );
     });
 
+    it('does not warn for benign keys containing the word "password" (e.g. env URLs)', () => {
+      const config = {
+        name: 'app',
+        databases: [{ type: 'redis' as const, port: 6379, host: 'localhost' }],
+        env: { PASSWORD_RESET_URL: 'https://example.com/reset' },
+      };
+      checkConfigWarnings(config as unknown as DevEnvConfig);
+      expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining('Passwords detected'));
+    });
+
+    it('returns the list of warnings it emits', () => {
+      const config = {
+        name: 'app',
+        databases: [
+          { type: 'postgresql' as const, port: 5432, host: 'localhost', user: 'u', password: 'plain', database: 'db' },
+        ],
+      };
+      const warnings = checkConfigWarnings(config as DevEnvConfig);
+      expect(warnings.some((w) => w.includes('Passwords detected'))).toBe(true);
+    });
+
     it('warns when postgresql missing user or password', () => {
       const config = {
         name: 'app',

tests/core/docker/compose-generator.test.ts

@@ -1,6 +1,7 @@
 import * as path from 'path';
 import { generateComposeContent } from '../../../src/core/docker/compose-generator';
 import type { DevEnvConfig } from '../../../src/types/config';
+import { logger } from '../../../src/utils/logger';
 
 const templatesDir = path.resolve(__dirname, '../../../templates');
 
@@ -63,6 +64,37 @@ describe('compose-generator', () => {
       expect(content).toContain('services:');
     });
 
+    it('warns when a database has no Docker image (sqlite)', () => {
+      const warnSpy = jest.spyOn(logger, 'warn').mockImplementation();
+      try {
+        const config = {
+          name: 'app',
+          databases: [{ type: 'sqlite' as const, name: 'localdb', host: 'localhost' }],
+          docker: {},
+        } as DevEnvConfig;
+        generateComposeContent(config, templatesDir);
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('localdb'));
+      } finally {
+        warnSpy.mockRestore();
+      }
+    });
+
+    it('adds a healthcheck to a generic service when a matching health_check provides a test', () => {
+      const config = {
+        name: 'app',
+        services: [{ type: 'rabbitmq', port: 5672, host: 'localhost' }],
+        health_checks: [
+          { name: 'rabbitmq_1', type: 'rabbitmq', test: 'rabbitmq-diagnostics ping', interval: '30s', retries: 3 },
+        ],
+        docker: {},
+      } as DevEnvConfig;
+      const content = generateComposeContent(config, templatesDir);
+      expect(content).toContain('healthcheck:');
+      expect(content).toContain('rabbitmq-diagnostics ping');
+      expect(content).toContain('interval: 30s');
+      expect(content).toContain('retries: 3');
+    });
+
     it('includes custom service with port and management_port', () => {
       const config = {
         name: 'app',