@asyncapi/generator 2.0.3 → 2.1.1

package/test/parser.test.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const path = require('path');
+const { sanitizeTemplateApiVersion, usesNewAPI, parse } = 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');
+    });
+  });
+});

package/test/renderer.test.js

@@ -0,0 +1,62 @@
+/* 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 = undefined;
+    let AsyncReactSDK = undefined;
+    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);
+    });
+  });
+});

package/test/templateConfigValidator.test.js

@@ -0,0 +1,277 @@
+/* eslint-disable sonarjs/no-identical-functions */
+/* eslint-disable sonarjs/no-duplicate-string */
+const { validateTemplateConfig } = require('../lib/templateConfigValidator');
+const fs = require('fs');
+const path = require('path');
+const { parse } = require('../lib/parser');
+const dummyYAML = fs.readFileSync(path.resolve(__dirname, './docs/dummy.yml'), 'utf8');
+
+jest.mock('../lib/utils');
+
+describe('Template Configuration Validator', () => {
+  let asyncapiDocument;
+
+  beforeAll(async () => {
+    const { document } = await parse(dummyYAML, {}, {templateConfig: {}});
+    asyncapiDocument = document;
+  });
+
+  it('Validation doesn\'t throw errors if params are not passed and template has no config', () => {
+    const templateParams = {};
+    const templateConfig  = {};
+
+    const isValid = validateTemplateConfig(templateConfig, templateParams, asyncapiDocument);
+
+    expect(isValid).toStrictEqual(true);
+  });
+
+  it('Validation doesn\'t throw errors for correct react renderer', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      renderer: 'react'
+    };
+    const isValid = validateTemplateConfig(templateConfig, templateParams, asyncapiDocument);
+    expect(isValid).toStrictEqual(true);
+  });
+  it('Validation doesn\'t throw errors for correct nunjucks renderer', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      renderer: 'nunjucks'
+    };
+    const isValid = validateTemplateConfig(templateConfig, templateParams, asyncapiDocument);
+    expect(isValid).toStrictEqual(true);
+  });
+  it('Validation throw error if renderer not supported', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      renderer: 'non_existing'
+    };
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('We do not support \'non_existing\' as a renderer for a template. Only \'react\' or \'nunjucks\' are supported.');
+  });
+
+  it('Validation throw error if template is not compatible because of generator version', () => {
+    const utils = require('../lib/utils');
+    utils.__generatorVersion = '1.0.0';
+
+    const templateParams = {};
+    const templateConfig  = {
+      generator: '>1.0.1'
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('This template is not compatible with the current version of the generator (1.0.0). This template is compatible with the following version range: >1.0.1.');
+  });
+
+  it('Validation throw error if template is not compatible because of non-supported apiVersion value', () => {
+    const utils = require('../lib/utils');
+    utils.__generatorVersion = '1.0.0';
+
+    const templateParams = {};
+    const templateConfig  = {
+      apiVersion: '999999'
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('The version specified in apiVersion is not supported by this Generator version. Supported versions are: v1, v2');
+  });
+
+  it('Validation throw error if required params not provided', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      parameters: {
+        test: {
+          description: 'test',
+          required: true
+        }
+      }
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('This template requires the following missing params: test.');
+  });
+
+  it('Validation throw error if provided param is not in the list of params supported by the template', () => {
+    const templateParams = {
+      tsets: 'myTest'
+    };
+    const templateConfig  = {
+      parameters: {
+        test: {
+          description: 'this param distance to test1 equals 3 according to levenshtein-edit-distance'
+        },
+        thisissomethingsodifferent: {
+          description: 'this param distance to test1 equals 21 according to levenshtein-edit-distance'
+        }
+      }
+    };
+    expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('This template doesn\'t have the following params: tsets.\nDid you mean "test" instead of "tsets"?');
+  });
+
+  it('Validation throw error if provided param is not supported by the template as template has no params specified', () => {
+    console.warn = jest.fn();
+    const templateParams = {
+      test1: 'myTest'
+    };
+    const templateConfig  = {};
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('This template doesn\'t have any params.');
+  });
+  it('Validation throw error if subject in condition files is not string', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      conditionalFiles: {
+        'my/path/to/file.js': {
+          subject: ['server.protocol'],
+          validation: {
+            const: 'myprotocol'
+          }
+        }
+      }
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('Invalid conditional file subject for my/path/to/file.js: server.protocol.');
+  });
+
+  it('Validation throw error if validation in condition files is not object', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      conditionalFiles: {
+        'my/path/to/file.js': {
+          subject: 'server.url',
+          validation: 'http://example.com'
+        }
+      }
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams)).toThrow('Invalid conditional file validation object for my/path/to/file.js: http://example.com.');
+  });
+
+  it('Validation enrich conditional files object with validate object', () => {
+    const templateParams = {};
+    const templateConfig  = {
+      conditionalFiles: {
+        'my/path/to/file.js': {
+          subject: 'server.protocol',
+          validation: {
+            const: 'myprotocol'
+          }
+        }
+      }
+    };
+    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'
+    };
+    const templateConfig  = {
+      parameters: {
+        server: {
+          description: ''
+        }
+      }
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Couldn\'t find server with name myserver.');
+  });
+
+  it('Validation throw error if given protocol is not supported by template', () => {
+    const templateParams = {
+      server: 'dummy-mqtt'
+    };
+    const templateConfig  = {
+      supportedProtocols: ['myprotocol'],
+      parameters: {
+        server: {
+          description: ''
+        }
+      }
+    };
+
+    expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Server "dummy-mqtt" uses the mqtt protocol but this template only supports the following ones: myprotocol.');
+  });
+
+  describe('should work with v1 apiVersion', () => {
+    let asyncapiDocument;
+    const v2TemplateConfig = {apiVersion: 'v1'};
+    beforeAll(async () => {
+      const { document } = await parse(dummyYAML, {}, {templateConfig: v2TemplateConfig});
+      asyncapiDocument = document;
+    });
+
+    it('Validation throw error if specified server is not in asyncapi document', () => {
+      const templateParams = {
+        server: 'myserver'
+      };
+      const templateConfig  = {
+        ...v2TemplateConfig,
+        parameters: {
+          server: {
+            description: ''
+          }
+        }
+      };
+
+      expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Couldn\'t find server with name myserver.');
+    });
+
+    it('Validation throw error if given protocol is not supported by template', () => {
+      const templateParams = {
+        server: 'dummy-mqtt'
+      };
+      const templateConfig  = {
+        ...v2TemplateConfig,
+        supportedProtocols: ['myprotocol'],
+        parameters: {
+          server: {
+            description: ''
+          }
+        }
+      };
+
+      expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Server "dummy-mqtt" uses the mqtt protocol but this template only supports the following ones: myprotocol.');
+    });
+  });
+
+  describe('should work with v2 apiVersion', () => {
+    let asyncapiDocument;
+    const v2TemplateConfig = {apiVersion: 'v2'};
+    beforeAll(async () => {
+      const { document } = await parse(dummyYAML, {}, {templateConfig: v2TemplateConfig});
+      asyncapiDocument = document;
+    });
+
+    it('Validation throw error if specified server is not in asyncapi document', () => {
+      const templateParams = {
+        server: 'myserver'
+      };
+      const templateConfig  = {
+        ...v2TemplateConfig,
+        parameters: {
+          server: {
+            description: ''
+          }
+        }
+      };
+
+      expect(() => validateTemplateConfig(templateConfig, templateParams, asyncapiDocument)).toThrow('Couldn\'t find server with name myserver.');
+    });
+
+    it('Validation throw error if given protocol is not supported by template', () => {
+      const templateParams = {
+        server: 'dummy-mqtt'
+      };
+      const templateConfig  = {
+        ...v2TemplateConfig,
+        supportedProtocols: ['myprotocol'],
+        parameters: {
+          server: {
+            description: ''
+          }
+        }
+      };
+
+      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/.yarncr.yml

@@ -0,0 +1,3 @@
+npmRegistries:
+  "http://localhost:4873/":
+    npmAuthToken: LwRGijjh4ZHXm+Q3FthZhA==

package/test/test-project/README.md

@@ -0,0 +1,4 @@
+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`.

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

@@ -0,0 +1,24 @@
+version: '3'
+
+services:
+  verdaccio:
+    image: verdaccio/verdaccio:5
+    ports:
+      - '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

package/test/test-project/package.json

@@ -0,0 +1,25 @@
+{
+    "description": "Test project. More info in the readme.",
+    "scripts": {
+        "test": "npm run test:cleanup && npm run test:project && npm run test:global && npm run test:registry",
+        "test:project:A": "jest --testNamePattern='Test A' --detectOpenHandles --testPathPattern=test-project/test-project --modulePathIgnorePatterns='./__mocks__'",
+        "test:project:B": "jest --testNamePattern='Test B' --detectOpenHandles --testPathPattern=test-project/test-project --modulePathIgnorePatterns='./__mocks__'",
+        "test:project:C": "jest --testNamePattern='Test C' --detectOpenHandles --testPathPattern=test-project/test-project --modulePathIgnorePatterns='./__mocks__'",
+        "test:global": "jest --detectOpenHandles --testPathPattern=test-global --modulePathIgnorePatterns='./__mocks__'",
+        "test:registry:arg": "jest --testNamePattern='argument' --detectOpenHandles --testPathPattern=test-registry --modulePathIgnorePatterns='./__mocks__'",
+        "test:registry:npm-config": "jest --testNamePattern='npm config' --detectOpenHandles --testPathPattern=test-registry --modulePathIgnorePatterns='./__mocks__'",
+        "test:cleanup": "rimraf \"../temp\""
+    },
+    "devDependencies": {
+        "fs-extra": "9.1.0",
+        "jest": "28.1.3",
+        "rimraf": "3.0.2"
+    },
+    "jest": {
+        "moduleNameMapper": {
+            "^nimma/legacy$": "<rootDir>/../../../../node_modules/nimma/dist/legacy/cjs/index.js",
+            "^nimma/(.*)": "<rootDir>/../../../../node_modules/nimma/dist/cjs/$1",
+            "^nunjucks-filters$": "<rootDir>/../../../nunjucks-filters"        
+        }
+    }
+}

package/test/test-project/test-entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Goal of this script is to copy mounted drive into a separate folder
+# It is to assure the test run is isolated from the host
+# apptemp is mounted from host and we do not want to mess in there
+
+
+# Copy the contents of /apptemp to /app
+cp -r /apptemp /app
+
+# Execute the bash script
+bash /app/apps/generator/test/test-project/test.sh test-project

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

@@ -0,0 +1,37 @@
+/**
+ * @jest-environment node
+ */
+
+const { readFile } = require('fs').promises;
+const path = require('path');
+const Generator = require('@asyncapi/generator');
+const dummySpecPath = path.resolve(__dirname, '../docs/dummy.yml');
+const templateName = 'react-template';
+const tempOutputResults = '../temp/integrationTestResult';
+const fileToCheck = 'test-file.md';
+const logMessage = require('../../lib/logMessages');
+const newContentNotExpectedInTest = 'new content';
+console.log = jest.fn();
+
+describe('Testing if markdown was generated using global template', () => {
+  jest.setTimeout(1000000);
+
+  it('generated markdown should not contain information that was added to template after it was installed globally', async () => {
+    //you always want to generate to new directory to make sure test runs in clear environment
+    const outputDir = path.resolve(tempOutputResults, Math.random().toString(36).substring(7));
+  
+    //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 in global packages location
+    const generator = new Generator(templateName, outputDir, { forceWrite: true, debug: true, templateParams: { version: 'v1', mode: 'production' } });
+    await generator.generateFromFile(dummySpecPath);
+
+    const file = await readFile(path.join(outputDir, fileToCheck), 'utf8');
+    const isNewContentThere = file.includes(newContentNotExpectedInTest);
+
+    //global template was not modified so it should not contain new content after template modification 
+    expect(isNewContentThere).toStrictEqual(false);
+    //we make sure that logs indicate that global package was used
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateNotFound(templateName));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateVersion('0.0.1'));
+  });
+});

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

@@ -0,0 +1,98 @@
+/**
+ * @jest-environment node
+ */
+
+const { readFile } = require('fs').promises;
+const path = require('path');
+const Generator = require('@asyncapi/generator');
+const dummySpecPath = path.resolve(__dirname, '../docs/dummy.yml');
+const templateLocation = path.resolve(__dirname,'../test-templates/react-template');
+const templateName = 'react-template';
+const tempOutputResults = path.resolve(__dirname, 'output');
+const fileToCheck = 'test-file.md';
+const source = path.join(__dirname, 'node_modules', templateName);
+const logMessage = require('../../lib/logMessages.js');
+const newContentNotExpectedInTest = 'new content';
+const version = '0.0.1';
+
+console.log = jest.fn();
+
+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
+    //it was installed before triggering test in test.sh
+    const generator = new Generator(templateName, tempOutputResults, { forceWrite: true, debug: true, templateParams: { version: 'v1', mode: 'production' } });
+    await generator.generateFromFile(dummySpecPath);
+
+    const file = await readFile(path.join(tempOutputResults, fileToCheck), 'utf8');
+    const isNewContentThere = file.includes(newContentNotExpectedInTest);
+
+    //we make sure that markdown file doesn't contain new content as old version of template do not have it
+    expect(isNewContentThere).toStrictEqual(false);
+    //we make sure that logs do not indicate that new installation is started
+    expect(console.log).not.toHaveBeenCalledWith(logMessage.installationDebugMessage(logMessage.TEMPLATE_INSTALL_FLAG_MSG));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateSource(source));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateVersion(version));
+  });
+
+  it('Test B - generated markdown should contain new content because of explicit fresh installation of different template version (install: true)', async () => {
+    const templateVersion = '0.0.2';
+
+    const generator = new Generator(`${templateName}@${templateVersion}`, tempOutputResults, { forceWrite: true, install: true, debug: true, templateParams: { version: 'v1', mode: 'production' } });
+    await generator.generateFromFile(dummySpecPath);
+    
+    const file = await readFile(path.join(tempOutputResults, fileToCheck), 'utf8');
+    const isNewContentThere = file.includes(newContentNotExpectedInTest);
+
+    //in 0.0.2 version of template there is a new content as in test.sh we made sure new template version has new content not present in 0.0.1
+    expect(isNewContentThere).toStrictEqual(true);
+    expect(console.log).toHaveBeenCalledWith(logMessage.installationDebugMessage(logMessage.TEMPLATE_INSTALL_FLAG_MSG));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateVersion(templateVersion));
+  });
+
+  it('Test C - generated markdown should not contain new content of template because local version of the template is old and does not have new content (with and without install:true)', async () => {
+    let file;
+    let isNewContentThere;
+
+    //we need arborist to perform installation of local template 
+    const Arborist = require('@npmcli/arborist');
+
+    //we need to install local template before we can use it
+    const arb = new Arborist({
+      path: templateLocation
+    });
+
+    await arb.reify({
+      save: false
+    });
+
+    //run generation by passing path to local template without passing install flag, sources should be taken from local path
+    const generatorWithoutInstallFlag = new Generator(templateLocation, tempOutputResults, { forceWrite: true, debug: true, templateParams: { version: 'v1', mode: 'production' } });
+    await generatorWithoutInstallFlag.generateFromFile(dummySpecPath);
+
+    file = await readFile(path.join(tempOutputResults, fileToCheck), 'utf8');
+    isNewContentThere = file.includes(newContentNotExpectedInTest);
+
+    //we make sure that markdown file doesn't contain new content as old version of template do not have it
+    expect(isNewContentThere).toStrictEqual(false);
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateSource(templateLocation));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateVersion(version));
+    expect(console.log).toHaveBeenCalledWith(logMessage.NODE_MODULES_INSTALL);
+
+    //run generation by passing path to local template and passing install flag, sources should be taken from local path and simlink created
+    const generatorWithInstallFlag = new Generator(templateLocation, tempOutputResults, { install: true, forceWrite: true, debug: true, templateParams: { version: 'v1', mode: 'production' } });
+    await generatorWithInstallFlag.generateFromFile(dummySpecPath);
+
+    file = await readFile(path.join(tempOutputResults, fileToCheck), 'utf8');
+    isNewContentThere = file.includes(newContentNotExpectedInTest);
+
+    //we make sure that markdown file doesn't contain new content as old version of template do not have it
+    expect(isNewContentThere).toStrictEqual(false);
+    expect(console.log).toHaveBeenCalledWith(logMessage.installationDebugMessage(logMessage.TEMPLATE_INSTALL_FLAG_MSG));
+    expect(console.log).toHaveBeenCalledWith(logMessage.templateVersion(version));
+    expect(console.log).toHaveBeenCalledWith(logMessage.NPM_INSTALL_TRIGGER);
+  });
+});