refactor: add reader adapter with complete fs abstraction

Author: Copilot

packages/cicd/github-actions/src/github-actions-generator.adapter.e2e.spec.ts

@@ -9,10 +9,10 @@ import {
 } from '@ci-dokumentor/core';
 import { initTestContainer } from './container.js';
 import mockFs from 'mock-fs';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { GitRepositoryProvider } from '@ci-dokumentor/repository-git';
 import { sanitizeSnapshotContent } from '@ci-dokumentor/core/tests';
-import { join } from 'path';
+import { join } from 'node:path';
 
 const rootPath = join(__dirname, '../../../..');
 
@@ -406,7 +406,7 @@ runs:
           rendererAdapter,
           repositoryProvider,
         })
-      ).rejects.toThrow('ENOENT, no such file or directory \'/test/action.yml\'');
+      ).rejects.toThrow('Source file does not exist: "/test/action.yml"');
 
       await rendererAdapter.finalize();
     });

packages/cicd/github-actions/src/github-actions-generator.adapter.ts

@@ -103,7 +103,7 @@ export class GitHubActionsGeneratorAdapter implements GeneratorAdapter {
     rendererAdapter: RendererAdapter;
     repositoryProvider: RepositoryProvider;
   }): Promise<void> {
-    const gitHubActionOrWorkflow = this.gitHubActionsParser.parseFile(
+    const gitHubActionOrWorkflow = await this.gitHubActionsParser.parseFile(
       source,
       await repositoryProvider.getRepositoryInfo()
     );

packages/cicd/github-actions/src/github-actions-parser.spec.ts

@@ -1,36 +1,38 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import mockFs from 'mock-fs';
+import { describe, it, expect, beforeEach, afterEach, Mocked, vi } from 'vitest';
 import {
   GitHubActionsParser,
   GitHubAction,
   GitHubWorkflow,
   GitHubActionInput,
   GitHubActionOutput,
 } from './github-actions-parser.js';
-import { RepositoryInfo } from '@ci-dokumentor/core';
-import { RepositoryInfoMockFactory } from '@ci-dokumentor/core/tests';
+import { ReaderAdapter, RepositoryInfo } from '@ci-dokumentor/core';
+import { ReaderAdapterMockFactory, RepositoryInfoMockFactory } from '@ci-dokumentor/core/tests';
 
 describe('GitHubActionsParser', () => {
-  let repositoryInfo: RepositoryInfo;
+  let mockReaderAdapter: Mocked<ReaderAdapter>;
+  let mockRepositoryInfo: Mocked<RepositoryInfo>;
   let parser: GitHubActionsParser;
 
   beforeEach(() => {
-    repositoryInfo = RepositoryInfoMockFactory.create();
+    vi.resetAllMocks();
 
-    parser = new GitHubActionsParser();
+    mockReaderAdapter = ReaderAdapterMockFactory.create();
+    mockRepositoryInfo = RepositoryInfoMockFactory.create();
+
+    parser = new GitHubActionsParser(mockReaderAdapter);
   });
 
   afterEach(() => {
-    mockFs.restore();
+    vi.resetAllMocks();
   });
 
   describe('parseFile', () => {
     describe('GitHub Actions', () => {
       it('should parse an action file', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            'action.yml': `name: Test Action
+        const filePath = '/test/action.yml';
+        const fileContent = `name: Test Action
 description: A test GitHub Action
 author: Test Author
 branding:
@@ -62,15 +64,13 @@ outputs:
         value: \${{ steps.step-id.outputs.value }}
 runs:
   using: composite
-`,
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act
-        const result = parser.parseFile(
-          '/test/action.yml',
-          repositoryInfo
-        ) as GitHubAction;
+        const result = await parser.parseFile(filePath, mockRepositoryInfo) as GitHubAction;
 
         // Assert
         expect(result).toBeDefined();
@@ -117,29 +117,22 @@ runs:
     describe('GitHub Workflows', () => {
       it('should parse a complete workflow file', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'workflow.yml': `name: Test Workflow
+        const filePath = '/test/.github/workflows/workflow.yml';
+        const fileContent = `name: Test Workflow
 on: push
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
-`,
-              },
-            },
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act
-        const result = parser.parseFile(
-          '/test/.github/workflows/workflow.yml',
-          repositoryInfo
-        ) as GitHubWorkflow;
+        const result = await parser.parseFile(filePath, mockRepositoryInfo) as GitHubWorkflow;
 
         // Assert
         expect(result).toBeDefined();
@@ -151,28 +144,21 @@ jobs:
 
       it('should parse a workflow without defined name', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'workflow-test.yml': `on: push
+        const filePath = '/test/.github/workflows/workflow-test.yml';
+        const fileContent = `on: push
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
-`,
-              },
-            },
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act
-        const result = parser.parseFile(
-          '/test/.github/workflows/workflow-test.yml',
-          repositoryInfo
-        ) as GitHubWorkflow;
+        const result = await parser.parseFile(filePath, mockRepositoryInfo) as GitHubWorkflow;
 
         // Assert
         expect(result).toBeDefined();
@@ -183,101 +169,69 @@ jobs:
     describe('Error handling', () => {
       it('should throw error for invalid YAML', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'invalid.yml': `invalid: yaml: content`,
-              },
-            },
-          },
-        });
+        const filePath = '/test/.github/workflows/invalid.yml';
+        const fileContent = `invalid: yaml: content`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act & Assert
-        expect(() =>
-          parser.parseFile('/test/.github/workflows/invalid.yml', repositoryInfo)
-        ).toThrow('Nested mappings are not allowed in compact mappings at line 1, column 10');
+        await expect(parser.parseFile(filePath, mockRepositoryInfo)).rejects.toThrow();
       });
 
       it('should throw error for empty file', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'empty.yml': '',
-              },
-            },
-          },
-        });
+        const filePath = '/test/.github/workflows/empty.yml';
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(''));
 
         // Act & Assert
-        expect(() =>
-          parser.parseFile('/test/.github/workflows/empty.yml', repositoryInfo)
-        ).toThrow('Unsupported source file');
+        await expect(parser.parseFile(filePath, mockRepositoryInfo)).rejects.toThrow();
       });
 
       it('should throw error for plain text when parseable as YAML', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'plain-text.yml': `This is not a YAML file`,
-              },
-            },
-          },
-        });
+        const filePath = '/test/.github/workflows/plain-text.yml';
+        const fileContent = `This is not a YAML file`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act & Assert
-        expect(() =>
-          parser.parseFile('/test/.github/workflows/plain-text.yml', repositoryInfo)
-        ).toThrow(
-          'Unsupported GitHub Actions file format: /test/.github/workflows/plain-text.yml'
-        );
+        await expect(parser.parseFile(filePath, mockRepositoryInfo)).rejects.toThrow();
       });
 
       it('should throw error for valid YAML but unsupported structure', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'object-without-required-fields.yml': `someField: value
+        const filePath = '/test/.github/workflows/object-without-required-fields.yml';
+        const fileContent = `someField: value
 anotherField: 123
-`,
-              },
-            },
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act & Assert
-        expect(() =>
-          parser.parseFile(
-            '/test/.github/workflows/object-without-required-fields.yml',
-            repositoryInfo
-          )
-        ).toThrow(
-          'Unsupported GitHub Actions file format: /test/.github/workflows/object-without-required-fields.yml'
-        );
+        await expect(parser.parseFile(filePath, mockRepositoryInfo)).rejects.toThrow();
       });
     });
 
     describe('Type detection', () => {
       it('should detect GitHub Action when it has name but no on/jobs properties', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            'action.yml': `name: Simple Action
+        const filePath = '/test/action.yml';
+        const fileContent = `name: Simple Action
 description: A simple GitHub Action
 runs:
   using: node20
-`,
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act
-        const result = parser.parseFile('/test/action.yml', repositoryInfo);
+        const result = await parser.parseFile(filePath, mockRepositoryInfo);
 
         // Assert
         expect(result).toBeDefined();
@@ -288,29 +242,22 @@ runs:
 
       it('should detect GitHub Workflow when it has on property', async () => {
         // Arrange
-        mockFs({
-          '/test': {
-            '.github': {
-              workflows: {
-                'workflow.yml': `name: Test Workflow
+        const filePath = '/test/.github/workflows/workflow.yml';
+        const fileContent = `name: Test Workflow
 on: push
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
-`,
-              },
-            },
-          },
-        });
+`;
+
+        mockReaderAdapter.resourceExists.mockReturnValue(true);
+        mockReaderAdapter.readResource.mockResolvedValue(Buffer.from(fileContent));
 
         // Act
-        const result = parser.parseFile(
-          '/test/.github/workflows/workflow.yml',
-          repositoryInfo
-        );
+        const result = await parser.parseFile(filePath, mockRepositoryInfo);
 
         // Assert
         expect(result).toBeDefined();

packages/cicd/github-actions/src/github-actions-parser.ts

@@ -1,7 +1,8 @@
-import { readFileSync } from 'node:fs';
+import { FileReaderAdapter, RepositoryInfo } from '@ci-dokumentor/core';
+import type { ReaderAdapter } from '@ci-dokumentor/core';
+import { inject, injectable } from 'inversify';
 import { basename, dirname, extname, join, relative } from 'node:path';
 import { parse } from 'yaml';
-import { RepositoryInfo } from '@ci-dokumentor/core';
 
 // See https://github.com/SchemaStore/schemastore/blob/master/src/schemas/json/github-action.json
 
@@ -101,7 +102,10 @@ export type GitHubWorkflowOutput = {
 
 export type GitHubActionsManifest = GitHubAction | GitHubWorkflow;
 
+@injectable()
 export class GitHubActionsParser {
+  constructor(@inject(FileReaderAdapter) private readonly readerAdapter: ReaderAdapter) { }
+
   isGitHubActionFile(source: string): boolean {
     // Check if the source is a GitHub Action by looking for action.yml or action.yaml
     return /action\.ya?ml$/i.test(source);
@@ -112,11 +116,16 @@ export class GitHubActionsParser {
     return source.includes('.github/workflows/');
   }
 
-  parseFile(
+  async parseFile(
     source: string,
     repositoryInfo: RepositoryInfo
-  ): GitHubActionsManifest {
-    const parsed = parse(readFileSync(source, 'utf8'));
+  ): Promise<GitHubActionsManifest> {
+    if (!this.readerAdapter.resourceExists(source)) {
+      throw new Error(`Source file does not exist: "${source}"`);
+    }
+
+    const content = await this.readerAdapter.readResource(source);
+    const parsed = parse(content.toString('utf8'));
     if (!parsed) {
       throw new Error(`Unsupported source file: ${source}`);
     }