fix: new tests

Author: killerapp

.github/workflows/release.yml

@@ -15,14 +15,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Setup Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
-          node-version: "lts/*"
+          node-version: "18.x"
 
       - name: Install dependencies
         run: npm ci

test/.context/diagrams/test.mmd

@@ -0,0 +1,172 @@
+import { jest } from '@jest/globals';
+import { ContextGenerator } from '../../src/lib/ContextGenerator.js';
+import * as path from 'node:path';
+
+// Mock fs/promises module
+jest.mock('node:fs/promises', () => ({
+  access: jest.fn(),
+  mkdir: jest.fn(),
+  writeFile: jest.fn()
+}));
+
+import * as fs from 'node:fs/promises';
+
+describe('ContextGenerator', () => {
+  let generator: ContextGenerator;
+  const mockFs = fs as jest.Mocked<typeof fs>;
+
+  beforeEach(() => {
+    generator = new ContextGenerator();
+    jest.clearAllMocks();
+    // Default mocks for non-existing files
+    mockFs.access.mockRejectedValue(new Error('ENOENT'));
+    mockFs.mkdir.mockResolvedValue(undefined);
+    mockFs.writeFile.mockResolvedValue(undefined);
+  });
+
+  describe('generateContextDir', () => {
+    it('should create directory when it does not exist', async () => {
+      const result = await generator.generateContextDir();
+      expect(result).toBe(true);
+      expect(mockFs.mkdir).toHaveBeenCalledWith('.context', { recursive: true });
+    });
+
+    it('should not create directory when it already exists', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const result = await generator.generateContextDir();
+      expect(result).toBe(false);
+      expect(mockFs.mkdir).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when directory creation fails', async () => {
+      mockFs.mkdir.mockRejectedValue(new Error('Permission denied'));
+      await expect(generator.generateContextDir()).rejects.toThrow('Failed to generate context directory');
+    });
+  });
+
+  describe('generateIndexFile', () => {
+    it('should create index.md when it does not exist', async () => {
+      const result = await generator.generateIndexFile();
+      expect(result).toBe(true);
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining('index.md'),
+        expect.stringContaining('module-name:')
+      );
+    });
+
+    it('should not create index.md when it already exists', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const result = await generator.generateIndexFile();
+      expect(result).toBe(false);
+      expect(mockFs.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when file creation fails', async () => {
+      mockFs.writeFile.mockRejectedValue(new Error('Permission denied'));
+      await expect(generator.generateIndexFile()).rejects.toThrow('Failed to generate index file');
+    });
+
+    it('should include all required sections in index.md content', async () => {
+      await generator.generateIndexFile();
+      const writeFileCall = mockFs.writeFile.mock.calls[0];
+      const content = writeFileCall[1] as string;
+      
+      expect(content).toContain('module-name:');
+      expect(content).toContain('version:');
+      expect(content).toContain('description:');
+      expect(content).toContain('technologies:');
+      expect(content).toContain('architecture:');
+      expect(content).toContain('development:');
+      expect(content).toContain('business-requirements:');
+      expect(content).toContain('quality-assurance:');
+      expect(content).toContain('deployment:');
+      expect(content).toContain('permissions:');
+    });
+  });
+
+  describe('generateIgnoreFile', () => {
+    it('should create .contextignore when it does not exist', async () => {
+      const result = await generator.generateIgnoreFile();
+      expect(result).toBe(true);
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        '.contextignore',
+        expect.stringContaining('node_modules/')
+      );
+    });
+
+    it('should not create .contextignore when it already exists', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const result = await generator.generateIgnoreFile();
+      expect(result).toBe(false);
+      expect(mockFs.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when file creation fails', async () => {
+      mockFs.writeFile.mockRejectedValue(new Error('Permission denied'));
+      await expect(generator.generateIgnoreFile()).rejects.toThrow('Failed to generate ignore file');
+    });
+
+    it('should include common ignore patterns', async () => {
+      await generator.generateIgnoreFile();
+      const writeFileCall = mockFs.writeFile.mock.calls[0];
+      const content = writeFileCall[1] as string;
+      
+      expect(content).toContain('node_modules/');
+      expect(content).toContain('dist/');
+      expect(content).toContain('.env');
+      expect(content).toContain('*.log');
+    });
+  });
+
+  describe('generate', () => {
+    it('should generate all files when none exist', async () => {
+      const result = await generator.generate();
+      expect(result).toEqual({
+        dirCreated: true,
+        indexCreated: true,
+        ignoreCreated: true
+      });
+    });
+
+    it('should not regenerate existing files', async () => {
+      mockFs.access.mockResolvedValue(undefined);
+      const result = await generator.generate();
+      expect(result).toEqual({
+        dirCreated: false,
+        indexCreated: false,
+        ignoreCreated: false
+      });
+    });
+
+    it('should handle mixed existing and non-existing files', async () => {
+      // Mock only directory exists
+      mockFs.access.mockImplementation((path) => {
+        if (path === '.context') {
+          return Promise.resolve(undefined);
+        }
+        return Promise.reject(new Error('ENOENT'));
+      });
+
+      const result = await generator.generate();
+      expect(result).toEqual({
+        dirCreated: false,
+        indexCreated: true,
+        ignoreCreated: true
+      });
+    });
+  });
+
+  describe('custom context directory', () => {
+    it('should use custom directory path when provided', async () => {
+      const customPath = path.join('custom', '.context');
+      const customGenerator = new ContextGenerator(customPath);
+      await customGenerator.generate();
+    
+      expect(mockFs.mkdir).toHaveBeenCalledWith(customPath, { recursive: true });
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
+        path.join(customPath, 'index.md'),
+        expect.any(String)
+      );
+    });
+  });
+});

test/cli.test.ts

@@ -0,0 +1,134 @@
+import { jest } from '@jest/globals';
+import { ContextLinter } from '../../src/lib/ContextLinter.js';
+
+// Mock fs/promises module
+jest.mock('fs/promises', () => ({
+  access: jest.fn(),
+  readFile: jest.fn(),
+  writeFile: jest.fn()
+}));
+
+import * as fs from 'fs/promises';
+
+describe('ContextLinter', () => {
+  let linter: ContextLinter;
+  const mockFs = fs as jest.Mocked<typeof fs>;
+
+  beforeEach(() => {
+    linter = new ContextLinter();
+    jest.clearAllMocks();
+    // Default successful mocks
+    mockFs.access.mockResolvedValue(undefined);
+    mockFs.writeFile.mockResolvedValue(undefined);
+  });
+
+  describe('lint', () => {
+    it('should return no issues for valid content', async () => {
+      const validContent = `---
+module-name: test-module
+version: 1.0.0
+description: Test description
+technologies: [TypeScript, Node.js]
+architecture: MVC
+`;
+      mockFs.readFile.mockResolvedValue(validContent);
+
+      const result = await linter.lint();
+      expect(result.issues).toHaveLength(0);
+      expect(result.fixedCount).toBe(0);
+    });
+
+    it('should detect missing frontmatter delimiter', async () => {
+      const invalidContent = `
+module-name: test-module
+version: 1.0.0
+description: Test description
+technologies: [TypeScript, Node.js]
+architecture: MVC
+`;
+      mockFs.readFile.mockResolvedValue(invalidContent);
+
+      const result = await linter.lint();
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].message).toContain('Missing frontmatter delimiter');
+    });
+
+    it('should detect missing required fields', async () => {
+      const incompleteContent = `---
+module-name: test-module
+version: 1.0.0
+`;
+      mockFs.readFile.mockResolvedValue(incompleteContent);
+
+      const result = await linter.lint();
+      expect(result.issues.length).toBeGreaterThan(0);
+      expect(result.issues.some(i => i.message.includes('Missing required field: description'))).toBe(true);
+      expect(result.issues.some(i => i.message.includes('Missing required field: technologies'))).toBe(true);
+      expect(result.issues.some(i => i.message.includes('Missing required field: architecture'))).toBe(true);
+    });
+
+    it('should detect invalid version format', async () => {
+      const invalidVersionContent = `---
+module-name: test-module
+version: 1.0
+description: Test description
+technologies: [TypeScript, Node.js]
+architecture: MVC
+`;
+      mockFs.readFile.mockResolvedValue(invalidVersionContent);
+
+      const result = await linter.lint();
+      expect(result.issues).toHaveLength(1);
+      expect(result.issues[0].message).toBe('Invalid version format');
+    });
+
+    describe('auto-fix mode', () => {
+      it('should fix missing frontmatter delimiter', async () => {
+        const invalidContent = `
+module-name: test-module
+version: 1.0.0
+description: Test description
+technologies: [TypeScript, Node.js]
+architecture: MVC
+`;
+        mockFs.readFile.mockResolvedValue(invalidContent);
+
+        const result = await linter.lint(true);
+        expect(result.fixedCount).toBe(1);
+        expect(mockFs.writeFile).toHaveBeenCalled();
+        const writtenContent = mockFs.writeFile.mock.calls[0][1] as string;
+        expect(writtenContent.startsWith('---')).toBe(true);
+      });
+
+      it('should fix missing required fields', async () => {
+        const incompleteContent = `---
+module-name: test-module
+version: 1.0.0
+`;
+        mockFs.readFile.mockResolvedValue(incompleteContent);
+
+        const result = await linter.lint(true);
+        expect(result.fixedCount).toBe(3); // description, technologies, architecture
+        expect(mockFs.writeFile).toHaveBeenCalled();
+        const writtenContent = mockFs.writeFile.mock.calls[0][1] as string;
+        expect(writtenContent).toContain('description:');
+        expect(writtenContent).toContain('technologies:');
+        expect(writtenContent).toContain('architecture:');
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error when context directory does not exist', async () => {
+        mockFs.access.mockRejectedValue(new Error('Directory not found'));
+
+        await expect(linter.lint()).rejects.toThrow('Linting failed');
+      });
+
+      it('should throw error when index.md cannot be read', async () => {
+        mockFs.readFile.mockRejectedValue(new Error('File read error'));
+
+        await expect(linter.lint()).rejects.toThrow('Linting failed');
+      });
+    });
+  });
+});