dotenv-diff 2.7.9 → 2.7.10

package/dist/test/unit/commands/compare.test.js

@@ -0,0 +1,664 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { compareMany } from '../../../src/commands/compare.js';
+// ---- mocks ----
+vi.mock('../../../src/services/parseEnvFile.js', () => ({
+    parseEnvFile: vi.fn(),
+}));
+vi.mock('../../../src/core/diffEnv.js', () => ({
+    diffEnv: vi.fn(),
+}));
+vi.mock('../../../src/services/git.js', () => ({
+    checkGitignoreStatus: vi.fn(),
+}));
+vi.mock('../../../src/core/duplicates.js', () => ({
+    findDuplicateKeys: vi.fn(),
+}));
+vi.mock('../../../src/core/filterIgnoredKeys.js', () => ({
+    filterIgnoredKeys: vi.fn((keys) => keys),
+}));
+vi.mock('../../../src/core/compare/updateTotals.js', () => ({
+    updateTotals: vi.fn(() => false),
+}));
+vi.mock('../../../src/core/fixEnv.js', () => ({
+    applyFixes: vi.fn(),
+}));
+vi.mock('../../../src/ui/shared/printFixTips.js', () => ({
+    printFixTips: vi.fn(),
+}));
+vi.mock('../../../src/ui/compare/printStats.js', () => ({
+    printStats: vi.fn(),
+}));
+vi.mock('../../../src/ui/shared/printDuplicates.js', () => ({
+    printDuplicates: vi.fn(),
+}));
+vi.mock('../../../src/ui/compare/printHeader.js', () => ({
+    printHeader: vi.fn(),
+}));
+vi.mock('../../../src/ui/shared/printAutoFix.js', () => ({
+    printAutoFix: vi.fn(),
+}));
+vi.mock('../../../src/ui/compare/printIssues.js', () => ({
+    printIssues: vi.fn(),
+}));
+vi.mock('../../../src/ui/shared/printSuccess.js', () => ({
+    printSuccess: vi.fn(),
+}));
+vi.mock('../../../src/ui/shared/printGitignore.js', () => ({
+    printGitignoreWarning: vi.fn(),
+}));
+vi.mock('../../../src/ui/compare/compareJsonOutput.js', () => ({
+    compareJsonOutput: vi.fn((params) => params),
+}));
+vi.mock('../../../src/ui/compare/printErrorNotFound.js', () => ({
+    printErrorNotFound: vi.fn(),
+}));
+import { parseEnvFile } from '../../../src/services/parseEnvFile.js';
+import { diffEnv } from '../../../src/core/diffEnv.js';
+import { checkGitignoreStatus } from '../../../src/services/git.js';
+import { findDuplicateKeys } from '../../../src/core/duplicates.js';
+import { filterIgnoredKeys } from '../../../src/core/filterIgnoredKeys.js';
+import { updateTotals } from '../../../src/core/compare/updateTotals.js';
+import { applyFixes } from '../../../src/core/fixEnv.js';
+import { printFixTips } from '../../../src/ui/shared/printFixTips.js';
+import { printStats } from '../../../src/ui/compare/printStats.js';
+import { printDuplicates } from '../../../src/ui/shared/printDuplicates.js';
+import { printHeader } from '../../../src/ui/compare/printHeader.js';
+import { printAutoFix } from '../../../src/ui/shared/printAutoFix.js';
+import { printIssues } from '../../../src/ui/compare/printIssues.js';
+import { printGitignoreWarning } from '../../../src/ui/shared/printGitignore.js';
+import { compareJsonOutput } from '../../../src/ui/compare/compareJsonOutput.js';
+import { printErrorNotFound } from '../../../src/ui/compare/printErrorNotFound.js';
+describe('compareMany', () => {
+    let cwd;
+    let envPath;
+    let examplePath;
+    const mockParseEnvFile = parseEnvFile;
+    const mockDiffEnv = diffEnv;
+    const mockCheckGitignoreStatus = checkGitignoreStatus;
+    const mockFindDuplicateKeys = findDuplicateKeys;
+    const mockFilterIgnoredKeys = filterIgnoredKeys;
+    const mockUpdateTotals = updateTotals;
+    const mockApplyFixes = applyFixes;
+    const mockPrintFixTips = printFixTips;
+    const mockPrintStats = printStats;
+    const mockPrintDuplicates = printDuplicates;
+    const mockPrintHeader = printHeader;
+    const mockPrintAutoFix = printAutoFix;
+    const mockPrintIssues = printIssues;
+    const mockPrintGitignoreWarning = printGitignoreWarning;
+    const mockCompareJsonOutput = compareJsonOutput;
+    const mockPrintErrorNotFound = printErrorNotFound;
+    beforeEach(() => {
+        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'dotenv-diff-compare-'));
+        envPath = path.join(cwd, '.env');
+        examplePath = path.join(cwd, '.env.example');
+        // Create files
+        fs.writeFileSync(envPath, 'KEY1=value1\nKEY2=value2\n');
+        fs.writeFileSync(examplePath, 'KEY1=\nKEY2=\n');
+        // Setup default mock implementations
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: 'value1', KEY2: 'value2' };
+            }
+            return { KEY1: '', KEY2: '' };
+        });
+        mockDiffEnv.mockReturnValue({
+            missing: [],
+            extra: [],
+            valueMismatches: [],
+        });
+        mockFindDuplicateKeys.mockReturnValue([]);
+        mockCheckGitignoreStatus.mockReturnValue(null);
+        mockFilterIgnoredKeys.mockImplementation((keys) => keys);
+        mockUpdateTotals.mockReturnValue(false);
+        mockCompareJsonOutput.mockImplementation((params) => params);
+    });
+    afterEach(() => {
+        fs.rmSync(cwd, { recursive: true, force: true });
+        vi.clearAllMocks();
+    });
+    const createOptions = (overrides = {}) => ({
+        checkValues: false,
+        cwd,
+        allowDuplicates: false,
+        fix: false,
+        json: false,
+        ignore: [],
+        ignoreRegex: [],
+        showStats: false,
+        strict: false,
+        ...overrides,
+    });
+    it('compares successfully when files exist and have no issues', async () => {
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(false);
+        expect(mockPrintHeader).toHaveBeenCalledWith('.env', '.env.example', false);
+    });
+    it('returns exitWithError true when both files do not exist', async () => {
+        const nonExistentEnv = path.join(cwd, 'missing.env');
+        const nonExistentExample = path.join(cwd, 'missing.example');
+        const pairs = [
+            {
+                envName: 'missing.env',
+                envPath: nonExistentEnv,
+                examplePath: nonExistentExample,
+            },
+        ];
+        const opts = createOptions();
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+        expect(mockPrintErrorNotFound).toHaveBeenCalled();
+    });
+    it('detects missing keys and reports them', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['KEY3'],
+            extra: [],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            missing: ['KEY3'],
+        }), false, false);
+    });
+    it('detects extra keys and reports them', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: [],
+            extra: ['EXTRA_KEY'],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            extra: ['EXTRA_KEY'],
+        }), false, false);
+    });
+    it('detects empty keys and reports them', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: '', KEY2: 'value2' };
+            }
+            return { KEY1: '', KEY2: '' };
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            empty: ['KEY1'],
+        }), false, false);
+    });
+    it('detects duplicates in env and example files', async () => {
+        mockFindDuplicateKeys.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return [{ key: 'DUP_KEY', count: 2 }];
+            }
+            if (filePath === examplePath) {
+                return [{ key: 'DUP_EX', count: 3 }];
+            }
+            return [];
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintDuplicates).toHaveBeenCalledWith('.env', '.env.example', [{ key: 'DUP_KEY', count: 2 }], [{ key: 'DUP_EX', count: 3 }], false, false);
+    });
+    it('skips duplicates check when allowDuplicates is true', async () => {
+        mockFindDuplicateKeys.mockReturnValue([{ key: 'DUP', count: 2 }]);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ allowDuplicates: true });
+        await compareMany(pairs, opts);
+        expect(mockPrintDuplicates).toHaveBeenCalledWith('.env', '.env.example', [], [], false, false);
+    });
+    it('checks gitignore status and reports issues', async () => {
+        mockCheckGitignoreStatus.mockReturnValue({
+            reason: 'not-ignored',
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintGitignoreWarning).toHaveBeenCalledWith({
+            envFile: '.env',
+            reason: 'not-ignored',
+        });
+    });
+    it('checks values when checkValues is true', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: [],
+            extra: [],
+            valueMismatches: [
+                { key: 'KEY1', expected: 'expected', actual: 'actual' },
+            ],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ checkValues: true });
+        await compareMany(pairs, opts);
+        expect(mockDiffEnv).toHaveBeenCalledWith(expect.any(Object), expect.any(Object), true);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            mismatches: [{ key: 'KEY1', expected: 'expected', actual: 'actual' }],
+        }), false, false);
+    });
+    it('applies fixes when fix flag is enabled', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING_KEY'],
+            extra: [],
+            valueMismatches: [],
+        });
+        mockApplyFixes.mockReturnValue({
+            changed: true,
+            result: {
+                removedDuplicates: [],
+                addedEnv: ['MISSING_KEY'],
+                gitignoreUpdated: false,
+            },
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ fix: true });
+        await compareMany(pairs, opts);
+        expect(mockApplyFixes).toHaveBeenCalledWith({
+            envPath,
+            missingKeys: ['MISSING_KEY'],
+            duplicateKeys: [],
+            ensureGitignore: false,
+        });
+        expect(mockPrintAutoFix).toHaveBeenCalledWith({
+            fixApplied: true,
+            removedDuplicates: [],
+            addedEnv: ['MISSING_KEY'],
+            gitignoreUpdated: false,
+        }, '.env', false);
+    });
+    it('applies fixes with duplicate keys when duplicates exist', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: [],
+            extra: [],
+            valueMismatches: [],
+        });
+        mockFindDuplicateKeys.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return [
+                    { key: 'DUPLICATE_KEY', count: 2 },
+                    { key: 'ANOTHER_DUP', count: 3 },
+                ];
+            }
+            return [];
+        });
+        mockApplyFixes.mockReturnValue({
+            changed: true,
+            result: {
+                removedDuplicates: ['DUPLICATE_KEY', 'ANOTHER_DUP'],
+                addedEnv: [],
+                gitignoreUpdated: false,
+            },
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ fix: true });
+        await compareMany(pairs, opts);
+        expect(mockApplyFixes).toHaveBeenCalledWith({
+            envPath,
+            missingKeys: [],
+            duplicateKeys: ['DUPLICATE_KEY', 'ANOTHER_DUP'],
+            ensureGitignore: false,
+        });
+    });
+    it('shows stats when showStats is enabled', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: 'value1', KEY2: 'value2', KEY3: 'value3' };
+            }
+            return { KEY1: '', KEY2: '' };
+        });
+        mockFilterIgnoredKeys.mockImplementation((keys) => keys);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ showStats: true });
+        await compareMany(pairs, opts);
+        expect(mockPrintStats).toHaveBeenCalledWith('.env', '.env.example', expect.objectContaining({
+            envCount: 3,
+            exampleCount: 2,
+            sharedCount: 2,
+        }), expect.any(Object), false, true, false);
+    });
+    it('calculates duplicateCount correctly in stats (count - 1)', async () => {
+        mockFindDuplicateKeys.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return [{ key: 'DUP_ENV', count: 3 }]; // contributes 2
+            }
+            if (filePath === examplePath) {
+                return [{ key: 'DUP_EX', count: 2 }]; // contributes 1
+            }
+            return [];
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ showStats: true });
+        await compareMany(pairs, opts);
+        expect(mockPrintStats).toHaveBeenCalledWith('.env', '.env.example', expect.objectContaining({
+            duplicateCount: 3, // (3-1) + (2-1) = 2 + 1
+        }), expect.any(Object), false, true, false);
+    });
+    it('returns exitWithError true in strict mode when issues exist', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING_KEY'],
+            extra: [],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ strict: true });
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+    });
+    it('returns exitWithError false in strict mode when no issues exist', async () => {
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ strict: true });
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(false);
+    });
+    it('filters categories based on --only flag', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING'],
+            extra: ['EXTRA'],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ only: ['missing'] });
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            missing: ['MISSING'],
+            extra: [],
+        }), false, false);
+    });
+    it('skips gitignore check when not in only filter', async () => {
+        mockCheckGitignoreStatus.mockReturnValue({
+            reason: 'not-ignored',
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ only: ['missing'] });
+        await compareMany(pairs, opts);
+        expect(mockPrintGitignoreWarning).not.toHaveBeenCalled();
+    });
+    it('collects entries when collect callback is provided', async () => {
+        const collected = [];
+        const collect = (entry) => {
+            collected.push(entry);
+        };
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ collect });
+        await compareMany(pairs, opts);
+        expect(collected).toHaveLength(1);
+        expect(collected[0]).toMatchObject({
+            envName: '.env',
+            exampleName: '.env.example',
+        });
+    });
+    it('processes multiple pairs sequentially', async () => {
+        const env2Path = path.join(cwd, '.env.production');
+        fs.writeFileSync(env2Path, 'PROD_KEY=prod\n');
+        const pairs = [
+            { envName: '.env', envPath, examplePath },
+            { envName: '.env.production', envPath: env2Path, examplePath },
+        ];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintHeader).toHaveBeenCalledTimes(2);
+        expect(mockPrintHeader).toHaveBeenNthCalledWith(1, '.env', '.env.example', false);
+        expect(mockPrintHeader).toHaveBeenNthCalledWith(2, '.env.production', '.env.example', false);
+    });
+    it('returns exitWithError true when updateTotals indicates error', async () => {
+        mockUpdateTotals.mockReturnValue(true);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+    });
+    it('filters ignored keys correctly', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: 'value1', IGNORED: 'ignored', KEY2: 'value2' };
+            }
+            return { KEY1: '', KEY2: '' };
+        });
+        mockFilterIgnoredKeys.mockImplementation((keys, ignore) => {
+            return keys.filter((k) => !ignore.includes(k));
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ ignore: ['IGNORED'] });
+        await compareMany(pairs, opts);
+        expect(mockFilterIgnoredKeys).toHaveBeenCalledWith(expect.arrayContaining(['KEY1', 'IGNORED', 'KEY2']), ['IGNORED'], []);
+    });
+    it('filters keys with regex patterns', async () => {
+        mockFilterIgnoredKeys.mockImplementation((keys, _ignore, regexList) => {
+            return keys.filter((k) => !regexList.some((rx) => rx.test(k)));
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ ignoreRegex: [/^TEST_/] });
+        await compareMany(pairs, opts);
+        expect(mockFilterIgnoredKeys).toHaveBeenCalledWith(expect.any(Array), [], [/^TEST_/]);
+    });
+    it('prints fix tips when issues exist and fix is not enabled', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING'],
+            extra: [],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ fix: false });
+        await compareMany(pairs, opts);
+        expect(mockPrintFixTips).toHaveBeenCalledWith(expect.objectContaining({
+            missing: ['MISSING'],
+        }), false, false, false);
+    });
+    it('outputs JSON format when json flag is enabled', async () => {
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ json: true });
+        await compareMany(pairs, opts);
+        expect(mockPrintHeader).toHaveBeenCalledWith('.env', '.env.example', true);
+        expect(mockPrintStats).not.toHaveBeenCalled(); // No stats in JSON mode
+    });
+    it('handles empty values correctly', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: '', KEY2: '  ', KEY3: 'value' };
+            }
+            return { KEY1: '', KEY2: '', KEY3: '' };
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            empty: expect.arrayContaining(['KEY1', 'KEY2']),
+        }), false, false);
+    });
+    it('includes stats in JSON output', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: 'value1', KEY2: 'value2', KEY3: 'value3' };
+            }
+            return { KEY1: '', KEY2: '' };
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        await compareMany(pairs, opts);
+        expect(mockCompareJsonOutput).toHaveBeenCalledWith(expect.objectContaining({
+            stats: expect.objectContaining({
+                envCount: 3,
+                exampleCount: 2,
+                sharedCount: 2,
+                duplicateCount: 0,
+                valueMismatchCount: 0,
+            }),
+        }));
+    });
+    it('handles missing example file gracefully', async () => {
+        fs.unlinkSync(examplePath);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+        expect(mockPrintErrorNotFound).toHaveBeenCalled();
+    });
+    it('handles missing env file gracefully', async () => {
+        fs.unlinkSync(envPath);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions();
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+        expect(mockPrintErrorNotFound).toHaveBeenCalled();
+    });
+    it('filters duplicate keys by ignore list', async () => {
+        mockFindDuplicateKeys.mockReturnValue([
+            { key: 'DUP1', count: 2 },
+            { key: 'IGNORED_DUP', count: 2 },
+        ]);
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ ignore: ['IGNORED_DUP'] });
+        await compareMany(pairs, opts);
+        // The filtering happens inside findDuplicates helper
+        expect(mockFindDuplicateKeys).toHaveBeenCalled();
+    });
+    it('applies gitignore fix when ensureGitignore is true', async () => {
+        mockCheckGitignoreStatus.mockReturnValue({
+            reason: 'not-ignored',
+        });
+        mockApplyFixes.mockReturnValue({
+            changed: true,
+            result: {
+                removedDuplicates: [],
+                addedEnv: [],
+                gitignoreUpdated: true,
+            },
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ fix: true });
+        await compareMany(pairs, opts);
+        expect(mockApplyFixes).toHaveBeenCalledWith(expect.objectContaining({
+            ensureGitignore: true,
+        }));
+    });
+    it('handles multiple issues simultaneously', async () => {
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING1', 'MISSING2'],
+            extra: ['EXTRA1'],
+            valueMismatches: [{ key: 'KEY1', expected: 'exp', actual: 'act' }],
+        });
+        mockFindDuplicateKeys.mockReturnValue([{ key: 'DUP', count: 2 }]);
+        mockCheckGitignoreStatus.mockReturnValue({
+            reason: 'no-gitignore',
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ checkValues: true, strict: true });
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(true);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({
+            missing: ['MISSING1', 'MISSING2'],
+            extra: ['EXTRA1'],
+            mismatches: [{ key: 'KEY1', expected: 'exp', actual: 'act' }],
+        }), false, false);
+        expect(mockPrintGitignoreWarning).toHaveBeenCalled();
+    });
+    it('correctly calculates shared keys count', async () => {
+        mockParseEnvFile.mockImplementation((filePath) => {
+            if (filePath === envPath) {
+                return { KEY1: 'v1', KEY2: 'v2', KEY3: 'v3' };
+            }
+            return { KEY1: '', KEY2: '', KEY4: '' };
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ showStats: true });
+        await compareMany(pairs, opts);
+        expect(mockPrintStats).toHaveBeenCalledWith(expect.any(String), expect.any(String), expect.objectContaining({
+            envCount: 3,
+            exampleCount: 3,
+            sharedCount: 2, // KEY1 and KEY2
+        }), expect.any(Object), false, true, false);
+    });
+    it('falls back ?? false when json and fix are undefined (lines 103, 123-124, 266, 280-281)', async () => {
+        // opts.json and opts.fix are undefined → opts.json ?? false and opts.fix ?? false
+        // take the right-hand fallback branch for each ?? operator.
+        const opts = {
+            ...createOptions(),
+            json: undefined,
+            fix: undefined,
+        };
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const result = await compareMany(pairs, opts);
+        expect(result.exitWithError).toBe(false);
+        // printHeader receives false from opts.json ?? false (line 103)
+        expect(mockPrintHeader).toHaveBeenCalledWith('.env', '.env.example', false);
+        // printDuplicates receives false for both ?? args (lines 123-124)
+        expect(mockPrintDuplicates).toHaveBeenCalledWith('.env', '.env.example', [], [], false, false);
+        // printIssues receives false for both ?? args (line 266)
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.any(Object), false, false);
+        // printFixTips receives false for both ?? args (lines 280-281)
+        expect(mockPrintFixTips).toHaveBeenCalledWith(expect.any(Object), false, false, false);
+    });
+    it('falls back ?? false/false in printStats when showStats=true and json/checkValues are undefined (lines 244, 246)', async () => {
+        // opts.json=undefined → opts.json ?? false = false (line 244 right branch)
+        // opts.checkValues=undefined → opts.checkValues ?? false = false (line 246 right branch)
+        // opts.showStats=true (defined) → opts.showStats ?? true takes left branch (right is dead code)
+        const opts = {
+            ...createOptions({ showStats: true }),
+            json: undefined,
+            checkValues: undefined,
+        };
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        await compareMany(pairs, opts);
+        expect(mockPrintStats).toHaveBeenCalledWith('.env', '.env.example', expect.any(Object), expect.any(Object), false, // opts.json ?? false → false (right branch)
+        true, // opts.showStats → true (left branch, defined)
+        false);
+    });
+    it('falls back json ?? false in printAutoFix when fix=true and json is undefined (line 298)', async () => {
+        // opts.fix=true → reaches applyFixes + printAutoFix
+        // opts.json=undefined → opts.json ?? false takes the right branch (line 298)
+        mockApplyFixes.mockReturnValue({
+            changed: true,
+            result: {
+                removedDuplicates: [],
+                addedEnv: ['NEW_KEY'],
+                gitignoreUpdated: false,
+            },
+        });
+        mockDiffEnv.mockReturnValue({
+            missing: ['NEW_KEY'],
+            extra: [],
+            valueMismatches: [],
+        });
+        const opts = {
+            ...createOptions({ fix: true }),
+            json: undefined,
+        };
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        await compareMany(pairs, opts);
+        // printAutoFix called with false from opts.json ?? false
+        expect(mockPrintAutoFix).toHaveBeenCalledWith(expect.any(Object), '.env', false);
+    });
+    it('treats undefined env values as empty via v ?? "" fallback (line 191)', async () => {
+        // parseEnvFile returns KEY1: undefined → (v ?? "").trim() === "" takes ?? right branch
+        mockParseEnvFile.mockImplementationOnce(() => ({
+            KEY1: undefined,
+            KEY2: 'value2',
+        }));
+        // second parseEnvFile call (example file) falls through to the beforeEach default
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        await compareMany(pairs, createOptions());
+        // KEY1 has undefined value → treated as empty
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({ empty: ['KEY1'] }), false, false);
+    });
+    it('excludes missing from filtered when only filter does not include missing (line 201 false branch)', async () => {
+        // only: ['extra'] → run('missing') returns false → line 201 takes the [] branch
+        mockDiffEnv.mockReturnValue({
+            missing: ['MISSING_KEY'],
+            extra: ['EXTRA_KEY'],
+            valueMismatches: [],
+        });
+        const pairs = [{ envName: '.env', envPath, examplePath }];
+        const opts = createOptions({ only: ['extra'] });
+        await compareMany(pairs, opts);
+        expect(mockPrintIssues).toHaveBeenCalledWith(expect.objectContaining({ missing: [], extra: ['EXTRA_KEY'] }), false, false);
+    });
+});
+//# sourceMappingURL=compare.test.js.map