@asyncapi/generator 2.7.1 → 2.8.2

package/test/hooksRegistry.test.js

@@ -1,173 +0,0 @@
-/**
- * @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

@@ -1,203 +0,0 @@
-/**
- * @jest-environment node
- */
-
-const path = require('path');
-const { readFile, writeFile, access, mkdir } = require('fs').promises;
-const { copy } = require('fs-extra');
-const Generator = require('../lib/generator');
-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 = 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 = 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 = () => {
-    //you always want to generate to new directory to make sure test runs in clear environment
-    return path.resolve(mainTestResultPath, crypto.randomBytes(4).toString('hex'));
-  };
-
-  const getCleanReactTemplate = async () => {
-    //for each test new react template is needed in unique location
-    const newReactTemplateLocation = path.resolve(copyOfReactTemplate, crypto.randomBytes(4).toString('hex'));
-    await copy(reactTemplate, newReactTemplateLocation);
-    return newReactTemplateLocation;
-  };
-
-  jest.setTimeout(100000);
-  const testOutputFile = 'test-file.md';
-
-  const tempJsContent = `
-  import { File, Text } from '@asyncapi/generator-react-sdk';
-  
-  export default function() {
-    return (
-      <File name="temp.md">
-        <Text>Test</Text>
-      </File>
-    );
-  }
-  `;
-
-  it('generated using Nunjucks template', async () => {
-    const outputDir = generateFolderName();
-    const generator = new Generator(nunjucksTemplate, outputDir, {
-      forceWrite: true,
-      templateParams: { version: 'v1', mode: 'production' }
-    });
-    await generator.generateFromFile(dummySpecPath);
-    const file = await readFile(path.join(outputDir, testOutputFile), 'utf8');
-    expect(file).toMatchSnapshot();
-  });
-
-  it('generate using React template', async () => {
-    const outputDir = generateFolderName();
-    const generator = new Generator(reactTemplate, outputDir, {
-      forceWrite: true ,
-      templateParams: { version: 'v1', mode: 'production' }
-    });
-    await generator.generateFromFile(dummySpecPath);
-    const mdFile = await readFile(path.join(outputDir, testOutputFile), 'utf8');
-    //react template has hooks lib enabled and generation of asyncapi document that was passed as input should work out of the box without adding @asyncapi/generator-hooks to dependencies
-    const asyncAPIFile = await readFile(path.join(outputDir, 'asyncapi.yaml'), 'utf8');
-    expect(mdFile).toMatchSnapshot();
-    expect(asyncAPIFile).toMatchSnapshot();
-  });
-
-  it('generate json based api with referenced JSON Schema', async () => {
-    const outputDir = generateFolderName();
-    const generator = new Generator(reactTemplate, outputDir, {
-      mapBaseUrlToFolder: { url: 'https://schema.example.com/crm/', folder: `${refSpecFolder}/`},
-      forceWrite: true,
-      templateParams: { version: 'v1', mode: 'production' }
-    });
-    await generator.generateFromFile(refSpecPath);
-    const file = await readFile(path.join(outputDir, testOutputFile), 'utf8');
-    expect(file).toMatchSnapshot();
-  });
-
-  it('check if the temp.md file is created with compile option true', async () => {
-    const outputDir = generateFolderName();
-    const cleanReactTemplate = await getCleanReactTemplate();
-    // Create temp.md.js file dynamically
-
-    const tempJsPath = path.join(cleanReactTemplate, 'template/temp.md.js');
-    // Create temp.md.js file dynamically
-    await writeFile(tempJsPath, tempJsContent);
-
-    const generator = new Generator(cleanReactTemplate, outputDir, {
-      forceWrite: true,
-      compile: true,
-      debug: true,
-    });
-    await generator.generateFromFile(dummySpecPath);
-
-    const tempMdPath = path.join(outputDir, 'temp.md');
-
-    // Check the content of temp.md
-    const tempMdContent = await readFile(tempMdPath, 'utf8');
-    expect(tempMdContent.trim()).toBe('Test');
-  });
-
-  it('check if the temp.md file is not created when compile option is false', async () => {
-    const outputDir = generateFolderName();
-    const cleanReactTemplate = await getCleanReactTemplate();
-    // Create temp.md.js file dynamically
-    const tempJsPath = path.join(cleanReactTemplate, 'template/temp.md.js');
-    await writeFile(tempJsPath, tempJsContent);
-  
-    const generator = new Generator(cleanReactTemplate, outputDir, {
-      forceWrite: true,
-      compile: false, 
-      debug: true
-    });
-    await generator.generateFromFile(dummySpecPath);
-  
-    // Check if temp.md is not created in the output directory
-    const tempMdPath = path.join(outputDir, 'temp.md');
-    const tempMdExists = await access(tempMdPath).then(() => true).catch(() => false);
-    expect(tempMdExists).toBe(false);
-  });
-
-  it('should ignore specified files with noOverwriteGlobs', async () => {
-    const outputDir = generateFolderName();
-    const cleanReactTemplate = await getCleanReactTemplate();
-    // Manually create a file to test if it's not overwritten
-    await mkdir(outputDir, { recursive: true });
-    // Create a variable to store the file content
-    const testContent = '<script>const initialContent = "This should not change";</script>';
-    // eslint-disable-next-line sonarjs/no-duplicate-string
-    const testFilePath = path.normalize(path.resolve(outputDir, testOutputFile));
-    await writeFile(testFilePath, testContent);
-
-    // Manually create an output first, before generation, with additional custom file to validate if later it is still there, not overwritten
-    const generator = new Generator(cleanReactTemplate, outputDir, {
-      forceWrite: true,
-      noOverwriteGlobs: [`**/${testOutputFile}`],
-      debug: true,
-    });
-
-    await generator.generateFromFile(dummySpecPath);
-
-    // Read the file to confirm it was not overwritten
-    const fileContent = await readFile(testFilePath, 'utf8');
-    // Check if the files have been overwritten
-    expect(fileContent).toBe(testContent);
-    // Check if the log debug message was printed
-    /*TODO:
-       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,205 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-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');
-
-describe('Parser', () => {
-  describe('sanitizeTemplateApiVersion', () => {
-    it('should return version number when given `v99` syntax', () => {
-      const rawVersion = 'v99';
-      const expectedVersion = 99;
-      const sanitizedVersion = sanitizeTemplateApiVersion(rawVersion);
-
-      expect(sanitizedVersion).toStrictEqual(expectedVersion);
-    });
-    it('should return version number when given `v1` syntax', () => {
-      const rawVersion = 'v1';
-      const expectedVersion = 1;
-      const sanitizedVersion = sanitizeTemplateApiVersion(rawVersion);
-
-      expect(sanitizedVersion).toStrictEqual(expectedVersion);
-    });
-    it('should return version number when given `1` syntax', () => {
-      const rawVersion = '1';
-      const expectedVersion = 1;
-      const sanitizedVersion = sanitizeTemplateApiVersion(rawVersion);
-
-      expect(sanitizedVersion).toStrictEqual(expectedVersion);
-    });
-  });
-  describe('usesNewAPI', () => {
-    it('should use new parser api if v1', () => {
-      const templateConfig = {
-        apiVersion: 'v1'
-      };
-      const isUsingNewAPI = usesNewAPI(templateConfig);
-
-      expect(isUsingNewAPI).toStrictEqual(true);
-    });
-    it('should use new parser api if v2', () => {
-      const templateConfig = {
-        apiVersion: 'v2'
-      };
-      const isUsingNewAPI = usesNewAPI(templateConfig);
-
-      expect(isUsingNewAPI).toStrictEqual(true);
-    });
-    it('should use new parser api if v3', () => {
-      const templateConfig = {
-        apiVersion: 'v3'
-      };
-      const isUsingNewAPI = usesNewAPI(templateConfig);
-
-      expect(isUsingNewAPI).toStrictEqual(true);
-    });
-    it('should not use new API if no apiVersion', () => {
-      const templateConfig = { };
-      const isUsingNewAPI = usesNewAPI(templateConfig);
-
-      expect(isUsingNewAPI).toStrictEqual(false);
-    });
-  });
-  describe('parse', () => {
-    it('should be able to parse AsyncAPI v2 document for parser API v1', async () => {
-      const parsedDocument = await parse(dummyV2Document, {}, {templateConfig: {apiVersion: 'v1'}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document.version()).toEqual('2.3.0');
-    });
-    it('should be able to parse AsyncAPI v2 document for parser API v2', async () => {
-      const parsedDocument = await parse(dummyV2Document, {}, {templateConfig: {apiVersion: 'v2'}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document.version()).toEqual('2.3.0');
-    });
-    it('should be able to parse AsyncAPI v2 document for parser API v3', async () => {
-      const parsedDocument = await parse(dummyV2Document, {}, {templateConfig: {apiVersion: 'v3'}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document.version()).toEqual('2.3.0');
-    });
-    it('should not be able to parse AsyncAPI v3 document for parser API v1', async () => {
-      const parsedDocument = await parse(dummyV3Document, {}, {templateConfig: {apiVersion: 'v1'}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document).not.toBeDefined();
-    });
-    it('should not be able to parse AsyncAPI v3 document for old parser', async () => {
-      const parsedDocument = await parse(dummyV3Document, {}, {templateConfig: {}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document).not.toBeDefined();
-    });
-    it('should be able to parse AsyncAPI v3 document for parser API v2', async () => {
-      const parsedDocument = await parse(dummyV3Document, {}, {templateConfig: {apiVersion: 'v2'}});
-
-      expect(parsedDocument).toBeDefined();
-      expect(parsedDocument.document.version()).toEqual('3.0.0');
-    });
-    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/renderer.test.js

@@ -1,62 +0,0 @@
-/* eslint-disable sonarjs/no-duplicate-string */
-const { 
-  configureReact,
-  renderReact,
-  saveRenderedReactContent,
-} = require('../lib/renderer/react');
-
-jest.mock('../lib/utils');
-jest.mock('@asyncapi/generator-react-sdk');
-
-describe('React renderer', () => {
-  describe('saveRenderedReactContent', () => {
-    let util;
-    let AsyncReactSDK;
-    beforeAll(() => {
-      util = require('../lib/utils');
-      AsyncReactSDK = require('@asyncapi/generator-react-sdk');
-    });
-
-    it('works transpilation', async () => {
-      await configureReact('../file', '../dir', '../file');
-      expect(AsyncReactSDK.transpileFiles).toHaveBeenCalledTimes(1);
-    });
-
-    it('works rendering', async () => {
-      await renderReact({}, '../file', {}, '../file', '../dir', '../location', {}, false, '');
-      expect(AsyncReactSDK.renderTemplate).toHaveBeenCalledTimes(1);
-    });
-    
-    it('works saving single rendered content', async () => {
-      const content = {
-        content: 'Content',
-        metadata: {
-          fileName: 'file.html',
-        }
-      };
-
-      await saveRenderedReactContent(content, '../some/path');
-      expect(util.writeFile).toHaveBeenCalledTimes(1);
-    });
-
-    it('works saving multiple rendered contents', async () => {
-      const content = [
-        {
-          content: 'Content1',
-          metadata: {
-            fileName: 'file1.html',
-          }
-        },
-        {
-          content: 'Content2',
-          metadata: {
-            fileName: 'file2.html',
-          }
-        },
-      ];
-
-      await saveRenderedReactContent(content, '../some/path');
-      expect(util.writeFile).toHaveBeenCalledTimes(2);
-    });
-  });
-});