codegraph/__tests__/installer.test.ts

/**
 * Installer Tests
 *
 * Tests for installer config-writer fixes:
 * - readJsonFile error handling
 * - writeClaudeMd section replacement
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';

// We test the exported functions from config-writer
import {
  writeMcpConfig,
  writePermissions,
  writeClaudeMd,
  hasMcpConfig,
  hasPermissions,
  hasClaudeMdSection,
} from '../src/installer/config-writer';

function createTempDir(): string {
  return fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-installer-test-'));
}

function cleanupTempDir(dir: string): void {
  if (fs.existsSync(dir)) {
    fs.rmSync(dir, { recursive: true, force: true });
  }
}

describe('Installer Config Writer', () => {
  let origCwd: string;
  let tempDir: string;

  beforeEach(() => {
    tempDir = createTempDir();
    origCwd = process.cwd();
    process.chdir(tempDir);
  });

  afterEach(() => {
    process.chdir(origCwd);
    cleanupTempDir(tempDir);
  });

  describe('readJsonFile error handling', () => {
    it('should return empty object for non-existent file', () => {
      // writeMcpConfig reads .mcp.json - if it doesn't exist, it should create it
      writeMcpConfig('local');

      const mcpJson = path.join(tempDir, '.mcp.json');
      expect(fs.existsSync(mcpJson)).toBe(true);

      const content = JSON.parse(fs.readFileSync(mcpJson, 'utf-8'));
      expect(content.mcpServers).toBeDefined();
      expect(content.mcpServers.codegraph).toBeDefined();
    });

    it('should handle corrupted JSON by creating backup', () => {
      // Create a corrupted .mcp.json
      const mcpJson = path.join(tempDir, '.mcp.json');
      fs.writeFileSync(mcpJson, '{ this is not valid json !!!');

      // Suppress console.warn during test
      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});

      // Should not throw - gracefully handles corruption
      writeMcpConfig('local');

      // Should have warned
      expect(warnSpy).toHaveBeenCalled();
      const warnMsg = warnSpy.mock.calls[0][0];
      expect(warnMsg).toContain('Warning');

      // Backup should exist
      expect(fs.existsSync(mcpJson + '.backup')).toBe(true);
      // Original backup content should be the corrupted content
      const backup = fs.readFileSync(mcpJson + '.backup', 'utf-8');
      expect(backup).toContain('this is not valid json');

      // New file should be valid JSON with codegraph config
      const content = JSON.parse(fs.readFileSync(mcpJson, 'utf-8'));
      expect(content.mcpServers.codegraph).toBeDefined();

      warnSpy.mockRestore();
    });

    it('should preserve existing valid config when adding codegraph', () => {
      const mcpJson = path.join(tempDir, '.mcp.json');
      fs.writeFileSync(mcpJson, JSON.stringify({
        mcpServers: { other: { command: 'other-tool' } },
        customField: 'preserved',
      }, null, 2));

      writeMcpConfig('local');

      const content = JSON.parse(fs.readFileSync(mcpJson, 'utf-8'));
      expect(content.mcpServers.codegraph).toBeDefined();
      expect(content.mcpServers.other).toBeDefined();
      expect(content.customField).toBe('preserved');
    });
  });

  describe('writeClaudeMd section replacement', () => {
    it('should create new CLAUDE.md with markers', () => {
      const result = writeClaudeMd('local');

      expect(result.created).toBe(true);
      const content = fs.readFileSync(path.join(tempDir, '.claude', 'CLAUDE.md'), 'utf-8');
      expect(content).toContain('<!-- CODEGRAPH_START -->');
      expect(content).toContain('<!-- CODEGRAPH_END -->');
      expect(content).toContain('## CodeGraph');
    });

    it('should replace marked section on update', () => {
      // First write
      writeClaudeMd('local');

      // Modify file to add custom content before and after
      const claudeMdPath = path.join(tempDir, '.claude', 'CLAUDE.md');
      const original = fs.readFileSync(claudeMdPath, 'utf-8');
      const modified = '## My Custom Section\n\nCustom content\n\n' + original + '\n\n## Another Section\n\nMore content\n';
      fs.writeFileSync(claudeMdPath, modified);

      // Second write should leave the marked block as-is (byte-identical
      // body, so result is `created:false, updated:false` — both flags
      // are off but the surrounding custom content must survive).
      writeClaudeMd('local');

      const final = fs.readFileSync(claudeMdPath, 'utf-8');
      expect(final).toContain('## My Custom Section');
      expect(final).toContain('Custom content');
      expect(final).toContain('## Another Section');
      expect(final).toContain('More content');
      expect(final).toContain('## CodeGraph');
    });

    it('should use atomic writes (no temp files left behind)', () => {
      writeClaudeMd('local');

      const claudeDir = path.join(tempDir, '.claude');
      const files = fs.readdirSync(claudeDir);
      const tmpFiles = files.filter(f => f.includes('.tmp.'));
      expect(tmpFiles).toHaveLength(0);
    });

    it('should not overwrite content after unmarked section with ### subsections', () => {
      // Create a CLAUDE.md with an unmarked CodeGraph section that has ### subsections
      // followed by another ## section
      const claudeDir = path.join(tempDir, '.claude');
      fs.mkdirSync(claudeDir, { recursive: true });
      const claudeMdPath = path.join(claudeDir, 'CLAUDE.md');
      fs.writeFileSync(claudeMdPath, [
        '## Pre-existing Section',
        '',
        'Some content',
        '',
        '## CodeGraph',
        '',
        '### Subsection A',
        '',
        'Old codegraph content',
        '',
        '### Subsection B',
        '',
        'More old content',
        '',
        '## Important Section After',
        '',
        'This content must not be overwritten!',
        '',
      ].join('\n'));

      const result = writeClaudeMd('local');
      expect(result.updated).toBe(true);

      const final = fs.readFileSync(claudeMdPath, 'utf-8');
      // The section after CodeGraph must be preserved
      expect(final).toContain('## Important Section After');
      expect(final).toContain('This content must not be overwritten!');
      // Pre-existing section should also be preserved
      expect(final).toContain('## Pre-existing Section');
      // New CodeGraph content should be present with markers
      expect(final).toContain('<!-- CODEGRAPH_START -->');
      expect(final).toContain('<!-- CODEGRAPH_END -->');
    });

    it('should replace unmarked section without subsections', () => {
      const claudeDir = path.join(tempDir, '.claude');
      fs.mkdirSync(claudeDir, { recursive: true });
      const claudeMdPath = path.join(claudeDir, 'CLAUDE.md');
      // Note: regex needs \n before ## CodeGraph, so prefix with another section
      fs.writeFileSync(claudeMdPath, [
        '## Intro',
        '',
        'Preamble',
        '',
        '## CodeGraph',
        '',
        'Old simple content',
        '',
        '## Next Section',
        '',
        'Must be preserved',
        '',
      ].join('\n'));

      writeClaudeMd('local');

      const final = fs.readFileSync(claudeMdPath, 'utf-8');
      expect(final).toContain('<!-- CODEGRAPH_START -->');
      expect(final).toContain('## Next Section');
      expect(final).toContain('Must be preserved');
      expect(final).not.toContain('Old simple content');
    });
  });
});