@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/principles/__tests__/baseline.test.ts

@@ -0,0 +1,328 @@
+/**
+ * @test REQ-COV-003 BaselineStorage uncovered branches
+ * @intent Cover initializeWithAnalyzer (batching, timeout, errors) and ccn statistics
+ * @covers AC-COV-003
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { BaselineStorage } from '../baseline';
+
+describe('BaselineEntry - lint tool fields (ruff, golangci, shellcheck)', () => {
+  it('accepts ruff field in BaselineEntry', () => {
+    const storage = new BaselineStorage();
+    const entry: Record<string, unknown> = {
+      'src/app.py': {
+        ruff: { warnings: 5, errors: 2 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString(),
+      },
+    };
+    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+  });
+
+  it('accepts golangci field in BaselineEntry', () => {
+    const storage = new BaselineStorage();
+    const entry: Record<string, unknown> = {
+      'src/main.go': {
+        golangci: { warnings: 3, errors: 1 },
+        totalWarnings: 3,
+        lastAnalyzed: new Date().toISOString(),
+      },
+    };
+    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+  });
+
+  it('accepts shellcheck field in BaselineEntry', () => {
+    const storage = new BaselineStorage();
+    const entry: Record<string, unknown> = {
+      'deploy.sh': {
+        shellcheck: { warnings: 2, errors: 0 },
+        totalWarnings: 2,
+        lastAnalyzed: new Date().toISOString(),
+      },
+    };
+    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).not.toThrow();
+  });
+
+  it('rejects ruff entry with non-numeric warnings', () => {
+    const storage = new BaselineStorage();
+    const entry = {
+      'src/app.py': {
+        ruff: { warnings: 'high', errors: 2 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString(),
+      },
+    };
+    expect(() => storage.validate(entry as Record<string, import('../baseline').BaselineEntry>)).toThrow(/Invalid ruff properties/);
+  });
+
+  it('combines all lint tools in getSummaryStatistics', () => {
+    const storage = new BaselineStorage();
+    const baseline: Record<string, unknown> = {
+      'src/app.py': {
+        ruff: { warnings: 5, errors: 2 },
+        totalWarnings: 5,
+        lastAnalyzed: new Date().toISOString(),
+      },
+      'src/main.go': {
+        golangci: { warnings: 3, errors: 1 },
+        totalWarnings: 3,
+        lastAnalyzed: new Date().toISOString(),
+      },
+      'deploy.sh': {
+        shellcheck: { warnings: 2, errors: 0 },
+        totalWarnings: 2,
+        lastAnalyzed: new Date().toISOString(),
+      },
+    };
+
+    const stats = storage.getSummaryStatistics(baseline as Record<string, import('../baseline').BaselineEntry>);
+
+    expect(stats.totalFiles).toBe(3);
+    expect(stats.totalWarnings).toBe(10);
+    expect(stats.ruff?.totalWarnings).toBe(5);
+    expect(stats.ruff?.totalErrors).toBe(2);
+    expect(stats.golangci?.totalWarnings).toBe(3);
+    expect(stats.golangci?.totalErrors).toBe(1);
+    expect(stats.shellcheck?.totalWarnings).toBe(2);
+    expect(stats.shellcheck?.totalErrors).toBe(0);
+  });
+});
+
+describe('BaselineStorage - extended coverage', () => {
+  let tmpDir: string;
+  let baselinePath: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'baseline-test-'));
+    baselinePath = path.join(tmpDir, '.warnings-baseline.json');
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('getSummaryStatistics - ccn aggregation', () => {
+    it('aggregates ccn warnings and max across files', () => {
+      const storage = new BaselineStorage();
+      const baseline = {
+        'src/a.ts': {
+          ccn: { warnings: 3, max: 12 },
+          totalWarnings: 3,
+          lastAnalyzed: new Date().toISOString(),
+        },
+        'src/b.ts': {
+          ccn: { warnings: 5, max: 18 },
+          totalWarnings: 5,
+          lastAnalyzed: new Date().toISOString(),
+        },
+      };
+
+      const stats = storage.getSummaryStatistics(baseline);
+
+      expect(stats.totalFiles).toBe(2);
+      expect(stats.ccn?.totalWarnings).toBe(8);
+      expect(stats.ccn?.totalMax).toBe(30);
+    });
+
+    it('returns averageWarningsPerFile of 0 for empty baseline', () => {
+      const storage = new BaselineStorage();
+      const stats = storage.getSummaryStatistics({});
+
+      expect(stats.totalFiles).toBe(0);
+      expect(stats.totalWarnings).toBe(0);
+      expect(stats.averageWarningsPerFile).toBe(0);
+      expect(stats.ccn).toBeUndefined();
+    });
+  });
+
+  describe('initializeWithAnalyzer - batching and progress', () => {
+    it('processes files in batches based on batchSize config', async () => {
+      const storage = new BaselineStorage({ batchSize: 2 });
+      const files = ['f1.ts', 'f2.ts', 'f3.ts', 'f4.ts', 'f5.ts'];
+      const callOrder: string[] = [];
+
+      const warningFn = vi.fn(async (file: string) => {
+        callOrder.push(file);
+        return { eslint: { warnings: 1, errors: 0 } };
+      });
+
+      const result = await storage.initializeWithAnalyzer(files, warningFn);
+
+      expect(warningFn).toHaveBeenCalledTimes(5);
+      expect(Object.keys(result)).toHaveLength(5);
+      expect(callOrder).toEqual(files);
+    });
+
+    it('invokes onProgress callback for each completed file', async () => {
+      const storage = new BaselineStorage({ batchSize: 2 });
+      const files = ['a.ts', 'b.ts', 'c.ts'];
+      const progressEvents: Array<{ current: number; total: number }> = [];
+
+      await storage.initializeWithAnalyzer(
+        files,
+        async () => ({ eslint: { warnings: 1, errors: 0 } }),
+        (progress) => {
+          progressEvents.push({ current: progress.current, total: progress.total });
+        },
+      );
+
+      expect(progressEvents).toHaveLength(3);
+      expect(progressEvents[progressEvents.length - 1].current).toBe(3);
+      expect(progressEvents.every((e) => e.total === 3)).toBe(true);
+    });
+  });
+
+  describe('initializeWithAnalyzer - error and limit handling', () => {
+    it('throws when files array exceeds maxSize', async () => {
+      const storage = new BaselineStorage({ maxSize: 2 });
+      const files = ['a.ts', 'b.ts', 'c.ts'];
+
+      await expect(
+        storage.initializeWithAnalyzer(files, async () => ({})),
+      ).rejects.toThrow(/exceeds the maximum of 2/);
+    });
+
+    it('logs errors via console.error when warningCountFunction rejects', async () => {
+      const storage = new BaselineStorage({ batchSize: 5 });
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { /* noop */ });
+      const files = ['ok.ts', 'fail.ts'];
+
+      const warningFn = async (file: string) => {
+        if (file === 'fail.ts') {
+          throw new Error('analyzer crashed');
+        }
+        return { eslint: { warnings: 2, errors: 0 } };
+      };
+
+      const result = await storage.initializeWithAnalyzer(files, warningFn);
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        'Some files failed to analyze:',
+        expect.any(Array),
+      );
+      expect(result['ok.ts']).toBeDefined();
+      expect(result['fail.ts']).toBeUndefined();
+    });
+
+    it('rejects with timeout when processing exceeds timeoutMs', async () => {
+      const storage = new BaselineStorage({ timeoutMs: 50, batchSize: 1 });
+      const files = ['slow.ts'];
+
+      const warningFn = () =>
+        new Promise<{ totalWarnings: number }>((resolve) => {
+          setTimeout(() => resolve({ totalWarnings: 1 }), 200);
+        });
+
+      await expect(
+        storage.initializeWithAnalyzer(files, warningFn),
+      ).rejects.toThrow(/timed out/);
+    });
+  });
+
+  describe('initializeWithAnalyzer - totalWarnings calculation', () => {
+    it('calculates totalWarnings from eslint-only entries', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['a.ts'], async () => ({
+        eslint: { warnings: 7, errors: 1 },
+      }));
+
+      expect(result['a.ts'].totalWarnings).toBe(7);
+      expect(result['a.ts'].eslint).toEqual({ warnings: 7, errors: 1 });
+    });
+
+    it('calculates totalWarnings from principles-only entries', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['b.ts'], async () => ({
+        principles: { warnings: 4, errors: 0 },
+      }));
+
+      expect(result['b.ts'].totalWarnings).toBe(4);
+      expect(result['b.ts'].principles).toEqual({ warnings: 4, errors: 0 });
+    });
+
+    it('calculates totalWarnings from ccn-only entries', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['c.ts'], async () => ({
+        ccn: { warnings: 6, max: 15 },
+      }));
+
+      expect(result['c.ts'].totalWarnings).toBe(6);
+      expect(result['c.ts'].ccn).toEqual({ warnings: 6, max: 15 });
+    });
+
+    it('uses explicit totalWarnings override when provided', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['d.ts'], async () => ({
+        eslint: { warnings: 3, errors: 0 },
+        principles: { warnings: 2, errors: 0 },
+        ccn: { warnings: 1, max: 5 },
+        totalWarnings: 99,
+      }));
+
+      expect(result['d.ts'].totalWarnings).toBe(99);
+    });
+
+    it('aggregates totalWarnings across all three sources when no override', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['e.ts'], async () => ({
+        eslint: { warnings: 2, errors: 0 },
+        principles: { warnings: 3, errors: 0 },
+        ccn: { warnings: 4, max: 10 },
+      }));
+
+      expect(result['e.ts'].totalWarnings).toBe(9);
+    });
+
+    it('sets totalWarnings to 0 when warningCountFunction returns empty object', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['empty.ts'], async () => ({}));
+
+      expect(result['empty.ts'].totalWarnings).toBe(0);
+      expect(result['empty.ts'].eslint).toBeUndefined();
+      expect(result['empty.ts'].principles).toBeUndefined();
+      expect(result['empty.ts'].ccn).toBeUndefined();
+    });
+
+    it('honors explicit totalWarnings of 0 when provided', async () => {
+      const storage = new BaselineStorage();
+      const result = await storage.initializeWithAnalyzer(['z.ts'], async () => ({
+        eslint: { warnings: 5, errors: 0 },
+        totalWarnings: 0,
+      }));
+
+      expect(result['z.ts'].totalWarnings).toBe(0);
+    });
+  });
+
+  describe('initializeWithAnalyzer - integration with save/load', () => {
+    it('saves and reloads baseline produced by initializeWithAnalyzer', async () => {
+      const storage = new BaselineStorage();
+      const built = await storage.initializeWithAnalyzer(
+        ['file1.ts', 'file2.ts'],
+        async (file) => ({
+          eslint: { warnings: file === 'file1.ts' ? 1 : 2, errors: 0 },
+        }),
+      );
+
+      await storage.save(baselinePath, built);
+      const loaded = await storage.load(baselinePath);
+
+      expect(Object.keys(loaded).sort()).toEqual(['file1.ts', 'file2.ts']);
+      expect(loaded['file2.ts'].totalWarnings).toBe(2);
+    });
+
+    it('handles empty files array without invoking analyzer', async () => {
+      const storage = new BaselineStorage();
+      const warningFn = vi.fn(async () => ({}));
+
+      const result = await storage.initializeWithAnalyzer([], warningFn);
+
+      expect(result).toEqual({});
+      expect(warningFn).not.toHaveBeenCalled();
+    });
+  });
+});

package/principles/__tests__/boy-scout-integration.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+
+const execAsync = promisify(exec);
+
+vi.mock('fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs/promises')>();
+  return {
+    ...actual,
+    readFile: vi.fn(),
+    access: vi.fn(),
+    writeFile: vi.fn(),
+  };
+});
+
+vi.mock('../analyzer', () => ({
+  analyze: vi.fn(),
+  getAdapterForFile: vi.fn(),
+}));
+
+vi.mock('../index', () => ({
+  getAllRules: vi.fn(() => []),
+}));
+
+import { readFile, access, writeFile } from 'fs/promises';
+import {
+  classifyFiles,
+  calculateDelta,
+  runEnforcement,
+} from '../boy-scout';
+import { analyze } from '../analyzer';
+
+const mockAnalyze = vi.mocked(analyze);
+const mockReadFile = vi.mocked(readFile);
+const mockAccess = vi.mocked(access);
+const mockWriteFile = vi.mocked(writeFile);
+
+interface BaselineEntry {
+  totalWarnings: number;
+  lastAnalyzed: string;
+}
+
+type AnalysisResult = Awaited<ReturnType<typeof analyze>>;
+
+const emptyAnalysis = (): AnalysisResult => ({ violations: [] } as unknown as AnalysisResult);
+
+function fakeAnalysis(violations: Partial<AnalysisResult['violations']>[number][]): AnalysisResult {
+  return { violations: violations as unknown as AnalysisResult['violations'] } as unknown as AnalysisResult;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+/**
+ * @test REQ-59 Boy Scout Rule integration tests
+ * @intent Verify runEnforcement, CLI integration, and edge cases for Boy Scout Rule
+ * @covers AC-59-01
+ */
+describe('Boy Scout Rule - runEnforcement', () => {
+  it('passes when new files have zero warnings and modified files are clean', async () => {
+    mockAnalyze.mockResolvedValue(emptyAnalysis());
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ 'src/modified.ts': { totalWarnings: 3, lastAnalyzed: '2024-01-01' } })
+    );
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement(['src/new.ts'], ['src/modified.ts'], '/tmp/test-baseline.json');
+
+    expect(result.overallStatus).toBe('PASS');
+    expect(result.summary.totalFiles).toBe(2);
+  });
+
+  it('blocks when new files have warnings', async () => {
+    mockAnalyze.mockResolvedValue(
+      fakeAnalysis([{ file: 'src/new.ts', line: 1, ruleId: 'test', severity: 'warning' as const, message: 'm' }])
+    );
+    mockAccess.mockRejectedValue(new Error('ENOENT'));
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement(['src/new.ts'], [], '/tmp/test-baseline.json');
+
+    expect(result.overallStatus).toBe('BLOCK');
+    expect(result.summary.blockedFiles).toBe(1);
+  });
+
+  it('blocks when modified files increase warnings', async () => {
+    mockAnalyze.mockResolvedValue(
+      fakeAnalysis([
+        { file: 'src/modified.ts', line: 1, ruleId: 'test', severity: 'warning' as const, message: 'm' },
+        { file: 'src/modified.ts', line: 2, ruleId: 'test', severity: 'warning' as const, message: 'm' },
+        { file: 'src/modified.ts', line: 3, ruleId: 'test', severity: 'warning' as const, message: 'm' },
+      ])
+    );
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ 'src/modified.ts': { totalWarnings: 1, lastAnalyzed: '2024-01-01' } })
+    );
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement([], ['src/modified.ts'], '/tmp/test-baseline.json');
+    expect(result.overallStatus).toBe('BLOCK');
+    expect(result.violations[0].reason).toContain('cannot increase warnings');
+  });
+
+  it('auto-initializes missing baseline entries for modified files', async () => {
+    mockAnalyze.mockResolvedValue(emptyAnalysis());
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue('{}');
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement([], ['src/modified.ts'], '/tmp/test-baseline.json');
+    expect(mockWriteFile).toHaveBeenCalled();
+    expect(result.overallStatus).toBe('PASS');
+  });
+
+  it('handles empty newFiles and modifiedFiles arrays', async () => {
+    mockAnalyze.mockResolvedValue(emptyAnalysis());
+    mockAccess.mockRejectedValue(new Error('ENOENT'));
+
+    const result = await runEnforcement([], [], '/tmp/test-baseline.json');
+    expect(result.overallStatus).toBe('PASS');
+    expect(result.summary.totalFiles).toBe(0);
+  });
+
+  it('filters out empty strings from file arrays', async () => {
+    mockAnalyze.mockResolvedValue(emptyAnalysis());
+    mockAccess.mockRejectedValue(new Error('ENOENT'));
+
+    const result = await runEnforcement(['', '  ', ''], ['', '  '], '/tmp/test.json');
+    expect(result.overallStatus).toBe('PASS');
+  });
+
+  it('auto-init saves updated baseline when missing entries exist', async () => {
+    mockAnalyze.mockResolvedValue(
+      fakeAnalysis([{ file: 'src/a.ts', line: 1, ruleId: 'test', severity: 'warning' as const, message: 'm' }])
+    );
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(JSON.stringify({}));
+    mockWriteFile.mockResolvedValue(undefined);
+
+    await runEnforcement([], ['src/a.ts'], '/tmp/test-baseline.json');
+    expect(mockWriteFile).toHaveBeenCalled();
+    expect(vi.mocked(mockWriteFile).mock.calls[0][0]).toBe('/tmp/test-baseline.json');
+  });
+
+  it('blocks modified file with <=5 baseline warnings that are not cleared', async () => {
+    mockAnalyze.mockResolvedValue(
+      fakeAnalysis([{ file: 'src/mod.ts', line: 1, ruleId: 'test', severity: 'warning' as const, message: 'm' }])
+    );
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ 'src/mod.ts': { totalWarnings: 3, lastAnalyzed: '2024-01-01' } })
+    );
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement([], ['src/mod.ts'], '/tmp/test-baseline.json');
+    expect(result.overallStatus).toBe('BLOCK');
+    expect(result.violations[0].reason).toContain('must clear to zero');
+  });
+
+  it('enforcement passes when modified file clears all warnings', async () => {
+    mockAnalyze.mockResolvedValue(emptyAnalysis());
+    mockAccess.mockResolvedValue(undefined);
+    mockReadFile.mockResolvedValue(
+      JSON.stringify({ 'src/mod.ts': { totalWarnings: 3, lastAnalyzed: '2024-01-01' } })
+    );
+    mockWriteFile.mockResolvedValue(undefined);
+
+    const result = await runEnforcement([], ['src/mod.ts'], '/tmp/test-baseline.json');
+    expect(result.overallStatus).toBe('PASS');
+  });
+});
+
+describe('calculateDelta reason messages', () => {
+  it('returns "Warnings decreased" reason on decrease', () => {
+    const result = calculateDelta({ totalWarnings: 10 } as BaselineEntry, 7, 'MODIFIED');
+    expect(result.delta).toBe(-3);
+    expect(result.enforcement).toBe('PASS');
+    expect(result.reason).toContain('Warnings decreased by 3');
+  });
+
+  it('returns "All warnings cleared" reason when current is zero', () => {
+    const result = calculateDelta({ totalWarnings: 0 } as BaselineEntry, 0, 'MODIFIED');
+    expect(result.delta).toBe(0);
+    expect(result.enforcement).toBe('PASS');
+    expect(result.reason).toContain('All warnings cleared');
+  });
+
+  it('returns "No new warnings introduced" when same count and >5', () => {
+    const result = calculateDelta({ totalWarnings: 8, lastAnalyzed: new Date().toISOString() } as BaselineEntry, 8, 'MODIFIED');
+    expect(result.delta).toBe(0);
+    expect(result.enforcement).toBe('PASS');
+    expect(result.reason).toContain('No new warnings introduced');
+  });
+
+  it('sets correct file field in delta result', () => {
+    const result = calculateDelta(null, 5, 'MODIFIED');
+    result.file = 'src/test.ts';
+    expect(result.file).toBe('src/test.ts');
+    expect(result.status).toBe('MODIFIED');
+  });
+});
+
+describe('classifyFiles edge cases', () => {
+  it('ignores rename lines with insufficient parts', () => {
+    const classified = classifyFiles(['R095']);
+    expect(classified.renamed).toEqual([]);
+  });
+
+  it('ignores lines with less than 2 parts', () => {
+    const classified = classifyFiles(['A']);
+    expect(classified.new).toEqual([]);
+  });
+
+  it('handles unknown status codes gracefully', () => {
+    const classified = classifyFiles(['X    src/unknown.ts']);
+    expect(classified.new).toEqual([]);
+    expect(classified.renamed).toEqual([]);
+  });
+
+  it('handles files with spaces in paths for new files', () => {
+    const classified = classifyFiles(['A    src/my file.ts']);
+    expect(classified.new).toEqual(['src/my file.ts']);
+  });
+});
+
+describe('CLI integration', () => {
+  const BOY_SCOUT_PATH = path.resolve(__dirname, '../boy-scout.ts');
+  const CLI_TEST_TIMEOUT = 60000;
+
+  it('shows help and exits with --help flag', async () => {
+    const { stdout } = await execAsync(`npx tsx ${BOY_SCOUT_PATH} --help`, { timeout: 30000 });
+    expect(stdout).toContain('Usage: boy-scout');
+    expect(stdout).toContain('--new-files');
+  }, CLI_TEST_TIMEOUT);
+
+  it('shows help and exits with -h flag', async () => {
+    const { stdout } = await execAsync(`npx tsx ${BOY_SCOUT_PATH} -h`, { timeout: 30000 });
+    expect(stdout).toContain('Usage: boy-scout');
+  }, CLI_TEST_TIMEOUT);
+
+  it('shows help and exits with help command', async () => {
+    const { stdout } = await execAsync(`npx tsx ${BOY_SCOUT_PATH} help`, { timeout: 30000 });
+    expect(stdout).toContain('Usage: boy-scout');
+  }, CLI_TEST_TIMEOUT);
+
+  it('runs init-baseline via CLI', async () => {
+    const { stdout } = await execAsync(
+      `npx tsx ${BOY_SCOUT_PATH} --init-baseline src/principles/boy-scout.ts`,
+      { timeout: 30000 }
+    );
+    expect(stdout).toContain('Baseline initialized successfully');
+  }, CLI_TEST_TIMEOUT);
+
+  it('runs enforcement via CLI with empty files', async () => {
+    await expect(
+      execAsync(`npx tsx ${BOY_SCOUT_PATH} --new-files "" --modified-files ""`, { timeout: 30000 })
+    ).resolves.toMatchObject({ stdout: expect.stringContaining('"overallStatus"') });
+  }, CLI_TEST_TIMEOUT);
+});