Merge pull request #5 from hadiindrawan/dev

add config for multiple env

Author: hadiindrawan

index.js

@@ -59,9 +59,8 @@ if (argRunner != 'undefined' && argRunner == 'generate') {
         // Set packagesExist variable to list of object keys if packageList is not undefined, otherwise set packagesExist to an empty array
         const packagesExist = packageList !== undefined ? Object.keys(packageList) : [];
 
-        let beInstall = ['chai', 'mocha', 'chai-http', 'chai-json-schema', 'dotenv', 'to-json-schema']
-        // let beInstall = ['chai']
-        let matchedPack = beInstall.filter(key => !packagesExist.includes(key))
+        let needPackage = ['chai', 'mocha', 'chai-http', 'chai-json-schema', 'dotenv', 'to-json-schema', 'cross-env']
+        let matchedPack = needPackage.filter(key => !packagesExist.includes(key))
         let strPack = matchedPack.join(' ')
 
         let mochaExist = packagesExist.includes('mocha') ? false : true
@@ -167,8 +166,8 @@ function validateInput(input) {
 }
 
 function addScriptRunner() {
-    const scriptName = 'test:regression-dev'; // Name of your new script
-    const scriptCommand = 'mocha runner/regression.js --timeout 15000'; // Command to execute your script
+    const scriptName = 'test:dev'; // Name of your new script
+    const scriptCommand = 'cross-env NODE_ENV=dev mocha runner/regression.js --timeout 15000'; // Command to execute your script
 
     // Read the package.json answers.jsonFileQ
     const packageJson = JSON.parse(fs.readFileSync('./package.json'));

lib/component/helper.js

@@ -10,7 +10,7 @@ async function writeHelper() {
 
 	// Check if a file named 'request.helper.js' exists in the tests/helper dir
 	// If it does not exist then create a new file based on the template file 'requestHelper.dot'
-	isFileExisted("tests/helper", "request.helper.js")
+	isFileExisted(helperDir, "request.helper.js")
 		.then((data) => {
 			if (!data[0]) {
 				fs.writeFile(
@@ -26,7 +26,7 @@ async function writeHelper() {
 
 	// Check if a file named 'general.helper.js' exists in the tests/helper dir
 	// If it does not exist then create a new file based on the template file 'generalHelper.dot'
-	isFileExisted("tests/helper", "general.helper.js")
+	isFileExisted(helperDir, "general.helper.js")
 		.then((data) => {
 			if (!data[0]) {
 				fs.writeFile(

lib/component/utils.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import isFileExisted from "../utils/check_dir.js";
+import basePath from "../utils/base_path.js";
+
+// Asynchronous function to write data into directory
+async function writeUtils() {
+    // create helper directory if it doesn't exists
+    const utilsDir = "tests/utils";
+    fs.mkdirSync(utilsDir, { recursive: true });
+
+    // Check if a file named 'request.helper.js' exists in the tests/helper dir
+    // If it does not exist then create a new file based on the template file 'requestHelper.dot'
+    isFileExisted(utilsDir, "config.js")
+        .then((data) => {
+            if (!data[0]) {
+                fs.writeFile(
+                    "tests/utils/config.js",
+                    fs.readFileSync(basePath() + "lib/template/config.dot", "utf8"),
+                    function (err) {
+                        if (err) throw err;
+                    }
+                )
+            }
+        })
+        .catch((err) => console.log(err));
+}
+
+export default writeUtils;

lib/generate.js

@@ -7,6 +7,7 @@ import writeData from './component/data.js'
 import writeRunner from './component/runner.js'
 import writeHelper from './component/helper.js'
 import writeJsonSchema from './component/json_schema.js'
+import writeUtils from './component/utils.js';
 
 // main generator
 async function generate(file) {
@@ -18,6 +19,8 @@ async function generate(file) {
         writeData()
         // write helper dir
         writeHelper()
+        // write utils dir
+        writeUtils()
 
         // write .example.env file
         fs.writeFile('.example.env','DEV_MAIN=your_api_url', function (err) { if (err) throw err ; });

lib/template/config.dot

@@ -0,0 +1,21 @@
+const dotenv = require('dotenv')
+
+class config {
+    constructor() {
+        // Write your constructor here, if you need 
+    }
+
+    env() {
+        // change according to your need
+        dotenv.config({ path: __dirname + `/../../.env.${process.env.NODE_ENV}` });
+
+        // Defining an object named 'env', contained your variables needed
+        const env = {
+            host: process.env.MAIN
+        }
+    
+        return env
+    }
+
+}
+module.exports = config

lib/template/generalHelper.dot

@@ -1,7 +1,6 @@
 class general {
     constructor() {
         // Write your constructor here, if you need 
-
     }
 
     // Write your method here

lib/template/mainPages.dot

@@ -1,37 +1,15 @@
 const chai = require('chai')
 chai.use(require('chai-http'))
-require('dotenv').config()
+const config = require('../utils/config')
 
 class main {
     constructor() {
 		// Write your constructor here, if you need
-        this.env = process.env.npm_lifecycle_event
     }
 
-    // This function is named `mainService` which contains switch statements that return different Chai request urls based on the environment specified
+    // This function is named `mainService` that return different Chai request urls based on the environment specified
     mainService() {
-        // A Switch statement which will perform action based on the matches of cases 
-        switch (true) {
-
-            // The following case checks whether the given environment includes dev in it or not 
-            case this.env.includes('dev'):
-                // If 'dev' environment, then will return dev url
-                return chai.request(process.env.DEV_MAIN);
-
-            // The following case checks whether the given environment includes staging in it or not 
-            case this.env.includes('staging'):
-                // If 'staging' environment, then will return staging url
-                return chai.request(process.env.STAGING_MAIN);
-
-            // The following case checks whether the given environment includes prod in it or not 
-            case this.env.includes('prod'):
-                // If 'prod' environment, then will return prod url
-                return chai.request(process.env.PROD_MAIN);
-
-            // The default case throws an error when none of the above cases are matched, specifying an invalid environemnt 
-            default:
-                throw new Error(`Invalid environment specified: ${this.env}`);
-        }
+        return chai.request(new config().env().host)
     }
 
     // write other services here

test.js

@@ -0,0 +1,60 @@
+async function processItem(item, basePath) {
+    const helperPath = '../../helper/request.helper';
+    const mainpagesPath = './main.pages'
+
+    if (item.hasOwnProperty('item')) {
+        const testPath = 'tests/scenarios/' + item.name
+        const testRelativePath = '../tests/scenarios/' + item.name
+        const pagesPath = 'tests/pages/' + item.name
+        const pagesPathRelativePath = '../../pages/' + item.name
+        const jsonSchemaPath = 'tests/schema/' + item.name
+        const jsonSchemaRelativePath = '../../schema/' + item.name
+        let runPath = item.hasOwnProperty('item') ? 'runner/' + item.name : 'runner'
+
+        fs.mkdirSync(testPath, { recursive: true })
+        fs.mkdirSync(pagesPath, { recursive: true })
+        fs.mkdirSync(jsonSchemaPath, { recursive: true })
+        fs.mkdirSync(runPath, { recursive: true })
+        writeRunner(item, testRelativePath, runPath)
+
+        asyncForEach(item.item, async (data) => {
+            if (data.hasOwnProperty('item')) {
+                for (const innerItem of data.item) {
+                    console.log(innerItem);
+                    await processItem(innerItem, 'tests/' + innerItem.name);
+                }
+            } else {
+                writeTest(data, testPath, pagesPathRelativePath)
+                writePages(data, pagesPath, jsonSchemaRelativePath, helperPath, mainpagesPath)
+                writeJsonSchema(data, jsonSchemaPath)
+                await waitFor(10)
+            }
+        })
+    } else {
+        const testPath = 'tests/scenarios/'
+        const testRelativePath = '../tests/scenarios'
+        const pagesPath = 'tests/pages'
+        const pagesPathRelativePath = '../pages'
+        const jsonSchemaPath = 'tests/schema'
+        const jsonSchemaRelativePath = '../schema'
+        const runPath = 'runner'
+
+        fs.mkdirSync(testPath, { recursive: true })
+        fs.mkdirSync(pagesPath, { recursive: true })
+        fs.mkdirSync(jsonSchemaPath, { recursive: true })
+        fs.mkdirSync(runPath, { recursive: true })
+
+        writeRunner(item, testRelativePath, runPath)
+        writeTest(item, testPath, pagesPathRelativePath)
+        writePages(item, pagesPath, jsonSchemaRelativePath, helperPath, mainpagesPath)
+        writeJsonSchema(item, jsonSchemaPath)
+        await waitFor(10)
+    }
+}
+
+asyncForEach(items, async (element) => {
+    // Recursively process inner items
+    const basePath = 'tests';
+    await processItem(element, basePath);
+    // }
+})