feat: add tests for check markdown script

scripts/markdown/check-markdown.js

@@ -1,4 +1,4 @@
-const fs = require('fs');
+const fs = require('fs').promises;
 const matter = require('gray-matter');
 const path = require('path');
 
@@ -98,49 +98,44 @@ function validateDocs(frontmatter) {
  * @param {Function} validateFunction - The function used to validate the frontmatter.
  * @param {string} [relativePath=''] - The relative path of the folder for logging purposes.
  */
-function checkMarkdownFiles(folderPath, validateFunction, relativePath = '') {
-    fs.readdir(folderPath, (err, files) => {
-        if (err) {
-            console.error('Error reading directory:', err);
-            return;
-        }
-
-        files.forEach(file => {
+async function checkMarkdownFiles(folderPath, validateFunction, relativePath = '') {
+    try {
+        const files = await fs.readdir(folderPath);
+        for (const file of files) {
             const filePath = path.join(folderPath, file);
             const relativeFilePath = path.join(relativePath, file);
 
             // Skip the folder 'docs/reference/specification'
             if (relativeFilePath.includes('reference/specification')) {
-                return;
+                continue;
             }
 
-            fs.stat(filePath, (err, stats) => {
-                if (err) {
-                    console.error('Error reading file stats:', err);
-                    return;
-                }
+            const stats = await fs.stat(filePath);
+
+            // Recurse if directory, otherwise validate markdown file
+            if (stats.isDirectory()) {
+                await checkMarkdownFiles(filePath, validateFunction, relativeFilePath);
+            } else if (path.extname(file) === '.md') {
+                const fileContent = await fs.readFile(filePath, 'utf-8');
+                const { data: frontmatter } = matter(fileContent);
 
-                // Recurse if directory, otherwise validate markdown file
-                if (stats.isDirectory()) {
-                    checkMarkdownFiles(filePath, validateFunction, relativeFilePath);
-                } else if (path.extname(file) === '.md') {
-                    const fileContent = fs.readFileSync(filePath, 'utf-8');
-                    const { data: frontmatter } = matter(fileContent);
-
-                    const errors = validateFunction(frontmatter);
-                    if (errors) {
-                        console.log(`Errors in file ${relativeFilePath}:`);
-                        errors.forEach(error => console.log(` - ${error}`));
-                        process.exitCode = 1;
-                    }
+                const errors = validateFunction(frontmatter);
+                if (errors) {
+                    console.log(`Errors in file ${relativeFilePath}:`);
+                    errors.forEach(error => console.log(` - ${error}`));
+                    process.exitCode = 1;
                 }
-            });
-        });
-    });
+            }
+        }
+    } catch (err) {
+        console.error('Error processing files:', err);
+    }
 }
 
 const docsFolderPath = path.resolve(__dirname, '../../markdown/docs');
 const blogsFolderPath = path.resolve(__dirname, '../../markdown/blog');
 
 checkMarkdownFiles(docsFolderPath, validateDocs);
 checkMarkdownFiles(blogsFolderPath, validateBlogs);
+
+module.exports = { validateBlogs, validateDocs, checkMarkdownFiles }

tests/markdown/check-markdown.test.js

@@ -0,0 +1,95 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const {
+    validateBlogs,
+    validateDocs,
+    checkMarkdownFiles
+} = require('../../scripts/markdown/check-markdown');
+
+describe('Frontmatter Validator', () => {
+    let tempDir;
+    let mockConsoleError;
+
+    beforeEach(async () => {
+        mockConsoleError = jest.spyOn(console, 'error').mockImplementation();
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'test-config'));
+    });
+
+    afterEach(async () => {
+        mockConsoleError.mockRestore();
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+
+    it('validates authors array and returns specific errors', async () => {
+        const frontmatter = {
+            title: 'Test Blog',
+            date: '2024-01-01',
+            type: 'blog',
+            tags: ['test'],
+            cover: 'cover.jpg',
+            authors: [{ name: 'John' }, { photo: 'jane.jpg' }, { name: 'Bob', photo: 'bob.jpg', link: 'not-a-url' }]
+        };
+
+        const errors = validateBlogs(frontmatter);
+        expect(errors).toEqual(expect.arrayContaining([
+            'Author at index 0 is missing a photo',
+            'Author at index 1 is missing a name',
+            'Invalid URL for author at index 2: not-a-url'
+        ]));
+    });
+
+    it('validates docs frontmatter for required fields', async () => {
+        const frontmatter = { title: 123, weight: 'not-a-number' };
+        const errors = validateDocs(frontmatter);
+        expect(errors).toEqual(expect.arrayContaining([
+            'Title is missing or not a string',
+            'Weight is missing or not a number'
+        ]));
+    });
+
+    it('checks for errors in markdown files in a directory', async () => {
+        await fs.writeFile(path.join(tempDir, 'invalid.md'), `---\ntitle: Invalid Blog\n---`);
+        const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+
+        await checkMarkdownFiles(tempDir, validateBlogs);
+
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Errors in file invalid.md:'));
+        mockConsoleLog.mockRestore();
+    });
+
+    it('returns multiple validation errors for invalid blog frontmatter', async () => {
+        const frontmatter = {
+            title: 123,
+            date: 'invalid-date',
+            type: 'blog',
+            tags: 'not-an-array',
+            cover: ['not-a-string'],
+            authors: { name: 'John Doe' }
+        };
+        const errors = validateBlogs(frontmatter);
+
+        expect(errors.length).toBeGreaterThan(3);
+    });
+
+    it('logs error to console when an error occurs in checkMarkdownFiles', async () => {
+        const invalidFolderPath = path.join(tempDir, 'non-existent-folder');
+
+        await checkMarkdownFiles(invalidFolderPath, validateBlogs);
+
+        expect(mockConsoleError.mock.calls[0][0]).toContain('Error processing files:');
+    });
+
+    it('skips the "reference/specification" folder during validation', async () => {
+        const referenceSpecDir = path.join(tempDir, 'reference', 'specification');
+        await fs.mkdir(referenceSpecDir, { recursive: true });
+        await fs.writeFile(path.join(referenceSpecDir, 'skipped.md'), `---\ntitle: Skipped File\n---`);
+
+        const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+
+        await checkMarkdownFiles(tempDir, validateDocs);
+
+        expect(mockConsoleLog).not.toHaveBeenCalledWith(expect.stringContaining('Errors in file reference/specification/skipped.md'));
+        mockConsoleLog.mockRestore();
+    });
+});