feat: add tests for build tools script

scripts/build-tools.js

@@ -1,24 +1,33 @@
 const { getData } = require('./tools/extract-tools-github');
 const { convertTools } = require('./tools/tools-object');
 const { combineTools } = require('./tools/combine-tools');
-const manualTools = require('../config/tools-manual.json')
-
 const fs = require('fs');
 const { resolve } = require('path');
 
-const buildTools = async () => {
+const buildTools = async (automatedToolsPath, manualToolsPath, toolsPath, tagsPath) => {
   try {
     let githubExtractData = await getData();
     let automatedTools = await convertTools(githubExtractData);
+
     fs.writeFileSync(
-      resolve(__dirname, '../config', 'tools-automated.json'),
+      automatedToolsPath,
       JSON.stringify(automatedTools, null, '  ')
     );
-    await combineTools(automatedTools, manualTools);
+
+    await combineTools(automatedTools, require(manualToolsPath), toolsPath, tagsPath);
   } catch (err) {
-    console.log(err);
-    throw err
+    throw new Error(`An error occurred while building tools: ${err.message}`);
   }
 };
 
-buildTools();
+/* istanbul ignore next */
+if (require.main === module) {
+  const automatedToolsPath = resolve(__dirname, '../config', 'tools-automated.json');
+  const manualToolsPath = resolve(__dirname, '../config', 'tools-manual.json');
+  const toolsPath = resolve(__dirname, '../config', 'tools.json');
+  const tagsPath = resolve(__dirname, '../config', 'all-tags.json');
+
+  buildTools(automatedToolsPath, manualToolsPath, toolsPath, tagsPath);
+}
+
+module.exports = { buildTools };

scripts/tools/combine-tools.js

@@ -5,7 +5,6 @@ const fs = require('fs')
 const schema = require("./tools-schema.json");
 const Ajv = require("ajv")
 const addFormats = require("ajv-formats")
-const { resolve } = require('path');
 const Fuse = require("fuse.js");
 const ajv = new Ajv()
 addFormats(ajv, ["uri"])
@@ -106,7 +105,7 @@ const getFinalTool = async (toolObject) => {
 
 // Combine the automated tools and manual tools list into single JSON object file, and 
 // lists down all the language and technology tags in one JSON file.
-const combineTools = async (automatedTools, manualTools) => {
+const combineTools = async (automatedTools, manualTools, toolsPath, tagsPath) => {
     for (const key in automatedTools) {
         let finalToolsList = [];
         if (automatedTools[key].toolsList.length) {
@@ -136,14 +135,8 @@ const combineTools = async (automatedTools, manualTools) => {
         finalToolsList.sort((tool, anotherTool) => tool.title.localeCompare(anotherTool.title));
         finalTools[key].toolsList = finalToolsList
     }
-    fs.writeFileSync(
-        resolve(__dirname, '../../config', 'tools.json'),
-        JSON.stringify(finalTools)
-    );
-    fs.writeFileSync(
-        resolve(__dirname, '../../config', 'all-tags.json'),
-        JSON.stringify({ languages: languageList, technologies: technologyList }),
-    )
+    fs.writeFileSync(toolsPath,JSON.stringify(finalTools));
+    fs.writeFileSync(tagsPath,JSON.stringify({ languages: languageList, technologies: technologyList }),)
 }
 
 module.exports = { combineTools }

tests/build-tools.test.js

@@ -0,0 +1,112 @@
+const { readFileSync, rmSync, mkdirSync, writeFileSync } = require('fs');
+const { resolve } = require('path');
+const { getData } = require('../scripts/tools/extract-tools-github');
+const { convertTools } = require('../scripts/tools/tools-object');
+const { combineTools } = require('../scripts/tools/combine-tools');
+const { buildTools } = require('../scripts/build-tools');
+const { tagsData, manualTools, mockConvertedData, initialToolsData, mockExtractData } = require('../tests/fixtures/buildToolsData');
+
+jest.mock('../scripts/tools/extract-tools-github');
+jest.mock('../scripts/tools/tools-object');
+jest.mock('../scripts/tools/combine-tools');
+
+describe('buildTools', () => {
+    const testDir = resolve(__dirname, 'test_config');
+    const toolsPath = resolve(testDir, 'tools.json');
+    const tagsPath = resolve(testDir, 'all-tags.json');
+    const automatedToolsPath = resolve(testDir, 'tools-automated.json');
+    const manualToolsPath = resolve(testDir, 'tools-manual.json');
+
+    beforeAll(() => {
+        mkdirSync(testDir, { recursive: true });
+
+        writeFileSync(manualToolsPath, JSON.stringify(manualTools));
+    });
+
+    afterAll(() => {
+        rmSync(testDir, { recursive: true, force: true });
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should extract, convert, combine tools, and write to file', async () => {
+        getData.mockImplementation(async () => {
+            writeFileSync(automatedToolsPath, JSON.stringify(mockExtractData));
+            return mockExtractData;
+        });
+
+        convertTools.mockImplementation(async () => {
+            writeFileSync(automatedToolsPath, JSON.stringify(mockConvertedData));
+            return mockConvertedData;
+        });
+
+        combineTools.mockImplementation(async () => {
+            writeFileSync(toolsPath, JSON.stringify(initialToolsData));
+            writeFileSync(tagsPath, JSON.stringify(tagsData));
+            return true;
+        });
+
+        await buildTools(automatedToolsPath, manualToolsPath, toolsPath, tagsPath);
+
+        const automatedToolsContent = readFileSync(automatedToolsPath, 'utf8');
+        expect(JSON.parse(automatedToolsContent)).toEqual(mockConvertedData);
+
+        const manualToolsData = JSON.parse(readFileSync(manualToolsPath, 'utf8'));
+        const tagsFileData = JSON.parse(readFileSync(tagsPath, 'utf8'));
+        const toolsFileData = JSON.parse(readFileSync(toolsPath, 'utf8'));
+
+        expect(combineTools).toHaveBeenCalledWith(mockConvertedData, manualToolsData, toolsPath, tagsPath);
+
+        expect(toolsFileData).toEqual(initialToolsData);
+        expect(tagsFileData).toEqual(tagsData);
+    });
+
+    it('should handle getData error', async () => {
+        getData.mockRejectedValue(new Error('Extract error'));
+
+        try {
+            await buildTools(automatedToolsPath, manualToolsPath, toolsPath, tagsPath);
+        } catch (err) {
+            expect(err.message).toContain('Extract error');
+        }
+    });
+
+    it('should handle convertTools error', async () => {
+        getData.mockResolvedValue(mockExtractData);
+        convertTools.mockRejectedValue(new Error('Convert error'));
+
+        try {
+            await buildTools(automatedToolsPath, manualToolsPath, toolsPath, tagsPath);
+        } catch (err) {
+            expect(err.message).toContain('Convert error');
+        }
+    });
+
+    it('should handle combineTools error', async () => {
+        getData.mockResolvedValue(mockExtractData);
+        convertTools.mockResolvedValue(mockConvertedData);
+        combineTools.mockRejectedValue(new Error('Combine Tools error'));
+
+        try {
+            await buildTools(automatedToolsPath, manualToolsPath, toolsPath, tagsPath);
+        } catch (err) {
+            expect(err.message).toContain('Combine Tools error');
+        }
+    });
+
+    it('should handle file write errors', async () => {
+        getData.mockResolvedValue(mockExtractData);
+        convertTools.mockResolvedValue(mockConvertedData);
+        combineTools.mockResolvedValue(true);
+
+        const invalidPath = '/invalid_dir/tools.json';
+
+        try {
+            await buildTools(invalidPath, manualToolsPath, toolsPath, tagsPath);
+        } catch (err) {
+            expect(err.message).toMatch(/ENOENT|EACCES/);
+        }
+    });
+});

tests/fixtures/buildToolsData.js

@@ -0,0 +1,39 @@
+const tagsData = [
+    { id: 1, name: 'tag1' },
+    { id: 2, name: 'tag2' },
+];
+
+const manualTools = [
+    { id: 1, tool: 'manualTool1' },
+    { id: 2, tool: 'manualTool2' },
+];
+
+const mockConvertedData = [
+    { id: 1, tool: 'tool1' },
+    { id: 2, tool: 'tool2' },
+];
+
+const initialToolsData = [
+    {
+        title: "API Tracker",
+        description: "Explore public AsyncAPI specifications.",
+    },
+    {
+        title: "AsyncAPI Server API",
+        description: "Official tools for AsyncAPI.",
+    },
+    {
+        title: "AsyncAPI Generator",
+        description: "Generate AsyncAPI documents effortlessly.",
+    },
+];
+
+const mockExtractData = [{ name: 'tool1' }, { name: 'tool2' }];
+
+module.exports = {
+    tagsData,
+    manualTools,
+    mockConvertedData,
+    initialToolsData,
+    mockExtractData,
+};