@asyncapi/generator 2.5.0 → 2.7.0

package/test/hooksRegistry.test.js

@@ -0,0 +1,173 @@
+/**
+ * @jest-environment node
+ */
+const fs = require('fs');
+const path = require('path');
+const { addHook, registerLocalHooks, registerConfigHooks, registerHooks } = require('../lib/hooksRegistry');
+
+jest.mock('fs');
+jest.mock('path');
+
+describe('hooksRegistry', () => {
+  let hooks;
+
+  beforeEach(() => {
+    hooks = {};  // reset hooks for each test
+    jest.clearAllMocks(); // Reset all mocks
+    jest.resetModules(); // Reset modules
+  });
+
+  describe('registerHooks', () => {
+    it('registers both local and config hooks', async () => {
+      const templateDir = path.join(__dirname, 'fixtures', 'template', 'hooks');      
+      const hooksDir = path.join(__dirname, 'hooks');
+      
+      fs.mkdirSync(hooksDir, { recursive: true });
+      fs.writeFileSync(path.join(hooksDir, 'preGenerate.js'), `
+        module.exports = function localPreGenerateHook() {};
+      `);
+
+      const templateConfig = {
+        hooks: {
+          '@asyncapi/hooks-module': ['configPreGenerateHook']
+        }
+      };
+
+      jest.mock('@asyncapi/hooks-module', () => ({
+        preGenerate: [function configPreGenerateHook() {}]
+      }), { virtual: true });
+
+      const result = await registerHooks(hooks, templateConfig, templateDir, 'hooks');
+      
+      expect(result.preGenerate).toHaveLength(1); 
+      expect(result.preGenerate[0].name).toBe('configPreGenerateHook');
+      
+      fs.rmSync(hooksDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('registerLocalHooks', () => {
+    const mockPreGenerateHook = function preGenerateHook() {};
+  
+    beforeAll(() => {
+      path.join.mockImplementation((...args) => args.join('/'));
+    });
+  
+    beforeEach(() => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readdirSync.mockReturnValue(['preGenerate.js']);
+      
+      jest.mock('fixtures/template/hooks/preGenerate.js', () => mockPreGenerateHook, { virtual: true });
+    });
+  
+    it('handles missing hooks directory', async () => {
+      fs.existsSync.mockReturnValueOnce(false);
+      
+      const result = await registerLocalHooks(hooks, '/non/existent/path', 'hooks');
+      expect(result).toBe(hooks);
+      expect(result.preGenerate).toBeUndefined();
+    });
+    
+    it('handles errors during hook loading', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readdirSync.mockReturnValue(['errorHook.js']);
+      
+      jest.mock('fixtures/template/hooks/errorHook.js', () => {
+        throw new Error('Mock import error');
+      }, { virtual: true });
+      
+      await expect(registerLocalHooks(hooks, 'fixtures/template', 'hooks'))
+        .resolves.not.toThrow();
+        
+      expect(hooks).toEqual({});
+    });
+  });
+
+  describe('registerConfigHooks', () => {
+    it('registers hooks from template config', async () => {
+      const templateDir = path.join(__dirname, 'fixtures', 'template');
+      const templateConfig = {
+        hooks: {
+          '@asyncapi/hooks-module': ['preGenerateHook']
+        }
+      };
+
+      // Mock the hook module
+      jest.mock('@asyncapi/hooks-module', () => ({
+        preGenerate: [function preGenerateHook() {}]
+      }), { virtual: true });
+
+      const result = await registerConfigHooks(hooks, templateDir, templateConfig);
+      
+      expect(result.preGenerate).toHaveLength(1);
+      expect(result.preGenerate[0].name).toBe('preGenerateHook');
+    });
+
+    it('handles missing hooks in config', async () => {
+      const result = await registerConfigHooks(hooks, '', {});
+      expect(result).toBeUndefined();
+      expect(hooks).toEqual({}); 
+    });
+  });
+
+  describe('addHooks', () => {
+    it('adds hooks from module to hooks object', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+
+      addHook(hooks, mod, null);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+
+    it('adds hooks from module.default if it exists', () => {
+      const mod = {
+        default: {
+          preGenerate: [function preGenerateHook() {}],
+          postGenerate: [function postGenerateHook() {}]
+        }
+      };
+
+      addHook(hooks, mod, null);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+
+    it('does not add hooks that are not in config', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+      const config = ['preGenerateHook'];
+
+      addHook(hooks, mod, config);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toBeUndefined();
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+    });
+
+    it('adds hooks that are in config', () => {
+      const mod = {
+        preGenerate: [function preGenerateHook() {}],
+        postGenerate: [function postGenerateHook() {}]
+      };
+      const config = ['preGenerateHook', 'postGenerateHook'];
+
+      addHook(hooks, mod, config);
+
+      expect(hooks.preGenerate).toHaveLength(1);
+      expect(hooks.postGenerate).toHaveLength(1);
+      expect(hooks.preGenerate[0].name).toBe('preGenerateHook');
+      expect(hooks.postGenerate[0].name).toBe('postGenerateHook');
+    });
+  });
+});

package/test/integration.test.js

@@ -10,11 +10,11 @@ const dummySpecPath = path.resolve(__dirname, './docs/dummy.yml');
 const refSpecPath = path.resolve(__dirname, './docs/apiwithref.json');
 const refSpecFolder = path.resolve(__dirname, './docs/');
 const crypto = require('crypto');
-const mainTestResultPath = 'test/temp/integrationTestResult';
-const reactTemplate = 'test/test-templates/react-template';
-const nunjucksTemplate = 'test/test-templates/nunjucks-template';
+const mainTestResultPath = path.resolve(__dirname, './temp/integrationTestResult');
+const reactTemplate = path.resolve(__dirname, './test-templates/react-template');
+const nunjucksTemplate = path.resolve(__dirname, './test-templates/nunjucks-template');
 //temp location where react template is copied for each test that does some mutation on template files
-const copyOfReactTemplate = 'test/temp/reactTemplate';
+const copyOfReactTemplate = path.resolve(__dirname, './temp/reactTemplate');
 
 describe('Integration testing generateFromFile() to make sure the result of the generation is not changend comparing to snapshot', () => {
   const generateFolderName = () => {
@@ -153,4 +153,51 @@ describe('Integration testing generateFromFile() to make sure the result of the
        Include log message test in the future to ensure that the log.debug for skipping overwrite is called
      */
   });
+
+  it('should not generate the conditionalFolder if the singleFolder parameter is set true', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFolder: 'true' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFolderPath = path.join(outputDir, 'conditionalFolder');
+    const exists = await access(conditionalFolderPath).then(() => true).catch(() => false);
+    expect(exists).toBe(false);
+  });
+  it('should not generate the conditionalFile if the singleFile parameter is set true', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'true' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFile.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(false);
+  });
+
+  it('should generate the conditionalFile if the singleFile parameter is set false', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'false' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFile.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(true);
+  });
+
+  it('should generate the conditionalFile if the singleFile parameter is set false using enum validation', async () => {
+    const outputDir = generateFolderName();
+    const generator = new Generator(reactTemplate, outputDir, {
+      forceWrite: true ,
+      templateParams: { version: 'v1', mode: 'production', singleFile: 'false' }
+    });
+    await generator.generateFromFile(dummySpecPath);
+    const conditionalFilePath = path.join(outputDir, 'conditionalFolder2/input.txt');
+    const exists = await readFile(conditionalFilePath).then(() => true).catch(() => false);
+    expect(exists).toBe(true);
+  });
 });

package/test/parser.test.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { sanitizeTemplateApiVersion, usesNewAPI, parse } = require('../lib/parser');
+const { sanitizeTemplateApiVersion, usesNewAPI, parse, convertOldOptionsToNew } = require('../lib/parser');
 const dummyV2Document = fs.readFileSync(path.resolve(__dirname, './docs/dummy.yml'), 'utf8');
 const dummyV3Document = fs.readFileSync(path.resolve(__dirname, './docs/dummyV3.yml'), 'utf8');
 
@@ -99,9 +99,107 @@ describe('Parser', () => {
     });
     it('should be able to parse AsyncAPI v3 document for parser API v3', async () => {
       const parsedDocument = await parse(dummyV3Document, {}, {templateConfig: {apiVersion: 'v3'}});
-
       expect(parsedDocument).toBeDefined();
       expect(parsedDocument.document.version()).toEqual('3.0.0');
     });
   });
+  
+  describe('getProperApiDocument', () => {
+    const parser_api_version = 'x-parser-api-version';
+    const parser_spec_parsed = 'x-parser-spec-parsed';
+    const parser_original_schema = 'x-parser-original-schema-format';
+    const parser_original_payload = 'x-parser-original-payload';
+    const parser_message = 'x-parser-message-parsed';
+    it('should convert to old API if apiVersion is undefined', async () => {
+      // parse calls the get properAPIDocument and returns it along with a diagnostic in a Object
+      // so its like called the get properAPIDocument function and then returned the result
+      const templateConfig = {};
+      const properDocument = await parse(dummyV2Document, {}, { templateConfig }); 
+
+      // Validate that properDocument convert it to expected API version from the template
+      expect(properDocument).toBeDefined();
+
+      expect(properDocument).toBeDefined();
+      expect(properDocument.document._json).toBeDefined();
+      expect(properDocument.document._json.asyncapi).toEqual('2.3.0');
+      expect(properDocument.diagnostics).toBeDefined();
+      expect(properDocument.diagnostics.length).toBeGreaterThan(0);
+
+      expect(properDocument.document._json[parser_api_version]).toBeDefined();
+      expect(properDocument.document._json[parser_api_version]).toEqual(0);
+      expect(properDocument.document._json[parser_spec_parsed]).toBeDefined(); 
+      expect(properDocument.document._json[parser_spec_parsed]).toEqual(true); 
+
+      expect(properDocument.document._meta).toBeDefined();
+      expect(properDocument.document._meta).toEqual({});
+      expect(properDocument.document._json.components.messages.dummyCreated).toBeDefined(); 
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_schema]).toBeDefined(); // Only old API includes this filed
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_payload]).toBeDefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_message]).toBeDefined();
+    });
+
+    it('should convert to specified API version', async () => {
+      const templateConfig = { apiVersion: 'v2' };
+      const properDocument = await parse(dummyV2Document, {}, { templateConfig });
+
+      // Validate that properDocument is defined
+      expect(properDocument).toBeDefined();
+
+      // Validate that the document is converted to the specified API version
+      expect(properDocument.document._json.asyncapi).toEqual('2.3.0');
+      expect(properDocument.diagnostics).toBeDefined();
+      expect(properDocument.diagnostics.length).toBeGreaterThan(0);
+      
+      expect(properDocument.document._json[parser_api_version]).toBeDefined();
+      expect(properDocument.document._json[parser_spec_parsed]).toBeDefined();
+      expect(properDocument.document._json[parser_api_version]).toEqual(2);
+      expect(properDocument.document._json[parser_spec_parsed]).toEqual(true);
+
+      expect(properDocument.document._meta).toBeDefined();
+      expect(properDocument.document._json.components.messages.dummyCreated).toBeDefined(); 
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_schema]).toBeUndefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_original_payload]).toBeUndefined();
+      expect(properDocument.document._json.components.messages.dummyCreated[parser_message]).toBeUndefined();
+    
+      // Validate that old API-specific functions and properties are not present
+      expect(properDocument.oldApiSpecificFunction).toBeUndefined();
+      expect(properDocument.oldApiSpecificProperty).toBeUndefined();
+      expect(properDocument.anotherOldApiFunction).toBeUndefined();
+    });
+  });
+
+  describe('convertOldOptionsToNew', () => {
+    it('should convert old options to new options', () => {
+      const oldOptions = {
+        path: './test/docs/',
+        applyTraits: true,
+        resolve: {
+          http: {
+            order: 1,
+            canRead: true,
+            read: jest.fn()
+          }
+        }
+      };
+      const generator = {
+        mapBaseUrlToFolder: {
+          url: 'https://schema.example.com/crm/',
+          folder: './test/docs/'
+        }
+      };
+      const newOptions = convertOldOptionsToNew(oldOptions, generator);
+
+      expect(newOptions).toBeDefined();
+      expect(newOptions.source).toEqual(oldOptions.path);
+      expect(newOptions.applyTraits).toEqual(oldOptions.applyTraits);
+      expect(newOptions.__unstable).toBeDefined();
+      expect(newOptions.__unstable.resolver.resolvers.length).toBeGreaterThan(0);
+    });
+
+    it('should return undefined if oldOptions is not provided', () => {
+      const newOptions = convertOldOptionsToNew(undefined, {});
+
+      expect(newOptions).toBeUndefined();
+    });
+  });
 });

package/test/templateConfigValidator.test.js

@@ -160,6 +160,23 @@ describe('Template Configuration Validator', () => {
     expect(templateConfig.conditionalFiles['my/path/to/file.js']).toBeDefined();
   });
 
+  it('Validation enrich conditional files object with validate object if the subject is info', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      conditionalFiles: {
+        'my/path/to/file.js': {
+          subject: 'info.title',
+          validation: {
+            const: 'asyncapi'
+          }
+        }
+      }
+    };
+    validateTemplateConfig(templateConfig, templateParams);
+
+    expect(templateConfig.conditionalFiles['my/path/to/file.js']).toBeDefined();
+  });
+
   it('Validation throw error if specified server is not in asyncapi document', () => {
     const templateParams = {
       server: 'myserver'
@@ -274,4 +291,4 @@ describe('Template Configuration Validator', () => {
       expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Server "dummy-mqtt" uses the mqtt protocol but this template only supports the following ones: myprotocol.');
     });
   });
-});
+});

package/test/test-project/README.md

@@ -1,4 +1,8 @@
 It is a test project where AsyncAPI Generator and test template are used as Node.js dependencies.
 The purpose of this project is to test AsyncAPI Generator library use case outside the Generator code base.
 
-Instead of running tests with `npm test`, make sure you have Docker Compose and run `docker-compose rm -f -s test-project verdaccio && NODE_IMAGE_TAG=18 docker-compose up --abort-on-container-exit --remove-orphans`.
+Instead of running tests with `npm test`, make sure you have Docker Compose and run the following command:
+
+Linux/MacOS: `NODE_VERSION=18 docker-compose up --abort-on-container-exit --force-recreate`.
+
+Windows: `set NODE_VERSION=18&& docker-compose up --abort-on-container-exit --force-recreate`.

package/test/test-project/docker-compose.yml

@@ -1,5 +1,3 @@
-version: '3'
-
 services:
   verdaccio:
     image: verdaccio/verdaccio:5
@@ -7,18 +5,12 @@ services:
       - '4873:4873'
     volumes:
       - './verdaccio:/verdaccio/conf'
-    networks:
-      - mynetwork
 
   test-project:
-    privileged: true
-    image: "node:${NODE_IMAGE_TAG}"
-    volumes:
-      - ../../../../:/apptemp
-    command: bash /apptemp/apps/generator/test/test-project/test-entrypoint.sh
-    networks:
-      - mynetwork
-  
-networks:
-  mynetwork:
-    driver: bridge
+    pull_policy: build
+    build:
+      context: ../../../../  # Root of the project
+      args:
+        NODE_VERSION: ${NODE_VERSION}
+    user: root # Use root user to avoid permission issues when creating directories
+    command: ["sh", "/app/apps/generator/test/test-project/test.sh", "test-project"]

package/test/test-project/package.json

@@ -11,7 +11,6 @@
         "test:cleanup": "rimraf \"../temp\""
     },
     "devDependencies": {
-        "fs-extra": "9.1.0",
         "jest": "28.1.3",
         "rimraf": "3.0.2"
     },

package/test/test-project/test-project.test.js

@@ -15,11 +15,15 @@ const logMessage = require('../../lib/logMessages.js');
 const newContentNotExpectedInTest = 'new content';
 const version = '0.0.1';
 
-console.log = jest.fn();
+const originalConsoleLog = console.log;
 
+// Replace console.log with a custom mock function
+console.log = jest.fn((...args) => {
+  // Call the original function to actually log to the console
+  originalConsoleLog(...args);
+});
 describe('Testing if markdown was generated with proper version of the template', () => {
   jest.setTimeout(1000000);
-
   it('Test A - generated markdown should not contain new content in modified template', async () => {
     //we setup generator using template name, not path, without explicitly running installation
     //generator picks up template that is already in node_modules as it was installed before as node dependency

package/test/test-project/test-registry.test.js

@@ -8,8 +8,14 @@ const Generator = require('@asyncapi/generator');
 const dummySpecPath = path.resolve(__dirname, '../docs/dummy.yml');
 const tempOutputResults = path.resolve(__dirname, 'output');
 
-console.log = jest.fn();
+// Save the original console.log
+const originalConsoleLog = console.log;
 
+// Replace console.log with a custom mock function
+console.log = jest.fn((...args) => {
+  // Call the original function to actually log to the console
+  originalConsoleLog(...args);
+});
 describe('Integration testing generateFromFile() to make sure the template can be download from the private repository from argument', () => {
   jest.setTimeout(1000000);
 
@@ -38,7 +44,6 @@ describe('Integration testing generateFromFile() to make sure the template can b
 
 describe('Integration testing generateFromFile() to make sure the template can be download from the private repository from npm config', () => {
   jest.setTimeout(1000000);
-
   it('generated using private registory from npm config', async () => {
     const generator = new Generator('react-template', tempOutputResults,
       {

package/test/test-project/test.sh

@@ -51,7 +51,7 @@ Starting registry test
 sudo chown -R 1001:121 "/root/.npm"
 
 # Always run these steps
-cd app
+cd /app
 
 echo "##########
 Running installation in root
@@ -71,6 +71,11 @@ Publish test template to local npm-verdaccio
 npm config set -- //verdaccio:4873/:_auth=YWRtaW46bmltZGE=
 npm config set registry http://verdaccio:4873
 
+echo "##########
+Publish @asyncapi/generator-components to local npm-verdaccio
+##########"
+npm publish ../../../../packages/components
+
 echo "##########
 Publishing the correct template as 0.0.1
 ##########"

package/test/test-project/verdaccio/config.yaml

@@ -10,7 +10,13 @@ packages:
   "react-template":
     access: admin
     publish: admin
+  "@asyncapi/generator-components":
+    access: admin
+    publish: admin
   "!react-template":
     access: admin
     proxy: npmjs
+  "!@asyncapi/generator-components":
+    access: admin
+    proxy: npmjs
 log: { type: stdout, format: pretty, level: error }