@kumologica/sdk 3.3.0-beta9 → 3.4.0-beta2

package/cli/commands/open.js

@@ -1,18 +1,17 @@
 const path = require('path');
-const { logError } = require('../utils/logger');
+const { spawn } = require("child_process");
 
+const { logError } = require('../utils/logger');
 const rootPath = path.join(__dirname, '..', '..',);
 
 function startElectron(projectDir) {
     console.debug(`Project directory: ${projectDir}`);
     console.debug(`Root directory: ${rootPath}`);
     
-    const { spawn } = require("child_process");
-    // TODO remove  '..', '..' if not working from npm
-//    const e = spawn(path.join(rootPath,  '..', '..', "node_modules", ".bin", "electron"), 
-    const e = spawn(path.join(rootPath, "node_modules", ".bin", "electron"), 
-                    ['.', projectDir],
-                    { cwd: rootPath, shell: true });
+    let electronPath = process.env["KUMOLOGICA_ELECTRON_PATH"] || path.join(rootPath, "node_modules", ".bin", "electron");
+    console.debug(`Electron path: ${electronPath}`);
+
+    const e = spawn( electronPath, ['.', projectDir], { cwd: rootPath, shell: true } );
     
     e.stdout.on("data", data => {
         console.log(data.toString().trim());

package/cli/commands/test-commands/TestSuiteRunner.js

@@ -0,0 +1,75 @@
+const { performance } = require('perf_hooks');
+const { TestCaseRunner, InMemoryReporter, TerminalReporter } = require('./lib');
+const { logError, logNotice, logInfo, logFatal } = require('../../utils/logger');
+
+
+class TestSuiteRunner {
+    constructor(designerServer) {
+        this.designerServer = designerServer;
+        this.flowServer = this.designerServer.getFlowServer();
+    }
+    /**
+     * 
+     * @param {*} testcases 
+     * return an array containing found errors during execution, or undefined if successful
+     */
+    async runAll(testcases) {
+        logInfo(`TestCases - Executing\n`);
+        let testSuiteTimeStart = performance.now();
+
+        let totalPassedTestCases = 0;
+        let totalFailedCases = 0;
+        const totalTestCases = testcases.length;
+        for (let i = 0; i <= totalTestCases - 1; i++) {
+            let success = await this.runTestCase(testcases[i]);
+            if (success) {
+                totalPassedTestCases = totalPassedTestCases + 1;
+            } else {
+                totalFailedCases = totalFailedCases + 1;
+            }
+        }
+        let testSuiteTimeEnd = performance.now();
+        let testSuiteExecutionTimeInMs = testSuiteTimeEnd - testSuiteTimeStart;
+        this.printSummary(testSuiteExecutionTimeInMs, totalTestCases, totalFailedCases, totalPassedTestCases);
+        return 0;
+    }
+
+    /**
+     * 
+     * @param {*} testcase 
+     * @returns true if success, otherwise false
+     */
+    async runTestCase(testcase) {
+        let testcaseid = testcase.id;
+
+        const inMemReporter = new InMemoryReporter;
+        const terminalReporter = new TerminalReporter;
+
+        const testcaseRunner = new TestCaseRunner(this.flowServer, testcaseid, [inMemReporter, terminalReporter]);
+        try {
+            await testcaseRunner.runAsync();
+            return !inMemReporter.isFailedStatus()
+        } catch (err) {
+            console.log(err);
+            logFatal(`Unexpected error occurred while running testcase: "${testcase.name}" due to: ${err.message}.`)
+        }
+    }
+
+    printSummary(totalExecutionTimeInMs, totalTestCases, totalFailedCases, totalPassedTestCases) {
+        logInfo(`TestCases - Completed
+    
+Final Execution Statistics
+-------------------------------
+ Execution Time: ${Math.floor(totalExecutionTimeInMs)} ms
+ Total Test Cases: ${totalTestCases}
+ Failed: ${totalFailedCases}
+ Passed: ${totalPassedTestCases}
+-------------------------------
+        `);
+    }
+
+}
+
+module.exports = {
+    TestSuiteRunner
+}

package/cli/commands/test-commands/lib/TestCaseRunner.js

@@ -0,0 +1,105 @@
+const got = require('got');
+const { performance } = require('perf_hooks');
+const { EventEmitter } = require('events').EventEmitter;
+
+const { TerminalReporter, InMemoryReporter } = require('./reporters');
+
+const TESTCASE_SIGNALS = {
+    TESTCASE_STOP: '__testrunner-stop__',
+};
+
+class TestCaseRunner {
+    constructor(flowServer, testCaseId, testReporters) {
+        this.flowServer = flowServer;
+        this.testCaseId = testCaseId;
+        this.testReporters = testReporters;
+
+        // Measuring the execution time
+        this.timeTestCaseStart = null;
+        this.timeTestCaseEnd = null;
+
+        // Managing runtime events
+        this.runtimeEventEmitter = this.flowServer.events;
+
+        // Signal the start/end of testcase execution
+        this.testCaseRunnerEmitter = new EventEmitter();
+
+    }
+
+    subscribeRuntimeEvents() {
+        let runtimeEventTypes = this.flowServer.eventTypes;
+
+        this.runtimeEventEmitter.on('runtime-event', async (data) => {
+            let p = data.payload;
+
+            // Attributes from p.testCaseResults
+            let testCaseID;
+            let testCaseDescription;
+            let target; // flow:*
+            let targetOutput; // { response: {}, error: {}},
+            let assertionResults; // [...]
+            let error;
+
+            switch (data.id) {
+                case runtimeEventTypes.TEST_TESTCASE_START:
+                    this.timeTestCaseStart = performance.now();
+                    ({ testCaseID, testCaseDescription } = p.testCaseResults);
+                    this.testReporters.map(reporter => reporter.handleStart(testCaseID, testCaseDescription));
+                    break;
+                case runtimeEventTypes.TEST_TESTCASE_END:
+                case runtimeEventTypes.TEST_TESTCASE_END_WITH_ERROR:
+                    this.timeTestCaseEnd = performance.now();
+                    ({ testCaseID, testCaseDescription, target, assertionResults, error, targetOutput } = p.testCaseResults); // targetOutput.response: { statusCode, headers, body } }
+                    this.testReporters.map(reporter => reporter.handleResult(testCaseID, testCaseDescription, target, assertionResults, error, this.timeTestCaseStart, this.timeTestCaseEnd, targetOutput));
+                    this.testCaseRunnerEmitter.emit(TESTCASE_SIGNALS.TESTCASE_STOP);
+                    break;
+                default:
+                // do nothing
+            }
+
+        });
+
+    }
+
+    async runAsync() {
+        return new Promise(async (resolve, reject) => {
+            // Subscribe to the runtime events
+            this.subscribeRuntimeEvents();
+            // Wait for the end of the testcase execution
+            this.testCaseRunnerEmitter.on(TESTCASE_SIGNALS.TESTCASE_STOP, () => {
+                resolve();
+            });
+            try {
+                // Trigger the execution of the testcase
+                await this.invokeTest(this.testCaseId);
+            } catch (err) {
+                if (err && err.response && err.response.statusCode === 404 && err.response.body === '{"errorMessage":"Targeted node not found"}') {
+                    reject(new Error('TestCaseID not found'));
+                } else {
+                    console.log(`Error found in TestRunner due to`, err.toString());
+                    resolve();
+                }
+            }
+
+        })
+
+    }
+
+    async invokeTest(testCaseId) {
+        let resp = await got({
+            url: `http://127.0.0.1:${this.flowServer.settings.port}`,
+            method: 'POST',
+            headers: { 'x-kumologica-testcasenode': `${testCaseId}` },
+        });
+        return resp;
+    }
+}
+
+
+
+module.exports = {
+    TestCaseRunner,
+    // Reporters
+    TerminalReporter,
+    InMemoryReporter
+}

package/cli/commands/test-commands/lib/index.js

@@ -0,0 +1,12 @@
+const {    
+    TestCaseRunner,
+    // Reporters
+    TerminalReporter,
+    InMemoryReporter
+} = require('./TestCaseRunner');
+
+module.exports = {
+    TestCaseRunner,
+    TerminalReporter,
+    InMemoryReporter
+}

package/cli/commands/test-commands/lib/reporters/index.js

@@ -0,0 +1,120 @@
+const chalk = require('chalk');
+const log = console.log;
+
+const STATUS_PASSED = 'passed';
+const STATUS_FAILED = 'failed';
+
+class TestReporter {
+    handleStart(testCaseID, testCaseDescription) { /* TO BE IMPLEMENTED */ }
+    handleResult(testCaseID, testCaseDescription, target, assertionResults, error, timeStart, timeEnd, targetOutput) { /* TO BE IMPLEMENTED */ }
+}
+
+class InMemoryReporter extends TestReporter {
+    handleStart(testCaseID, testCaseDescription) {
+        this.testCaseID = testCaseID;
+        this.testCaseDescription = testCaseDescription;
+    }
+    handleResult(testCaseID, testCaseDescription, target, assertionResults, error, timeStart, timeEnd, targetOutput) {
+        this.assertionResults = assertionResults.map(({ status, description, diffReported }) => ({
+            status,
+            description,
+            diffReported
+        }));
+        this.executionTimeInMs = timeEnd - timeStart;
+        this.flowResponse = targetOutput.response;
+    }
+    isFailedStatus() {
+        let failedAssertions = this.assertionResults.filter(ar => ar.status === STATUS_FAILED);
+        return failedAssertions.length >= 1;
+    }
+}
+
+class TerminalReporter extends TestReporter {
+    handleStart(testCaseID, testCaseDescription) {
+        //console.log(`TestCase started: ${testCaseID} - ${testCaseDescription}`);
+    }
+    handleResult(testCaseID, testCaseDescription, target, assertionResults, error, timeStart, timeEnd, targetOutput) {
+        // Print header
+        this.printTestCaseHeader(testCaseDescription, target);
+
+        // Print assertions
+        this.printTestAssertionResult(assertionResults || []);
+
+        // Print status
+        if (!error) {
+            this.printTestCaseStatus(assertionResults);
+        } else {
+            this.printTestCaseWithError(testCaseDescription, target, error);
+        }
+
+    }
+    printTestCaseHeader(description, target) {
+        let prettyName = `${description}`; // mvp: only full flow being targeted > ${target} 
+        const sep = '=';
+        let underline = sep.repeat(prettyName.length);
+        let headerLine = `- ${prettyName}\n  ${underline}`;
+        log(chalk.cyan(headerLine));
+        log(`  Results:`);
+    }
+    printTestAssertionResult(assertionResults) {
+        // Print Assertions
+        if (assertionResults.length === 0) {
+            log(chalk.dim(`     (No assertions found)`));
+        } else {
+            assertionResults.map((ar, index) => {
+                this.printTestAssertion(ar, index);
+            });
+        }
+    }
+    printTestAssertion(ar, index) {
+        // console.log('Assertion:', ar)
+        let { description, selector, property, comparison, valueExpected, diffReported } = ar;
+        let status = diffReported ? STATUS_FAILED : STATUS_PASSED;
+        let icon;
+        if (status === STATUS_FAILED) {
+            icon = chalk.red('\u2716'); // cross mark
+        } else {
+            icon = chalk.green(`\u2713`); // tick
+        }
+        // Description
+        let descriptionName;
+        if (description && description.length > 0) {
+            descriptionName = description;
+        } else {
+            descriptionName = `${selector} - ${property} - ${comparison} - ${valueExpected}`;
+        }
+        let prettyName = `    ${index}. ${icon} ${descriptionName}`;
+        if (diffReported) {
+            prettyName = `${prettyName}
+        Diff report:\n${chalk.red(JSON.stringify(diffReported, null, 2))}`;
+        }
+        log(prettyName);
+    }
+
+    printTestCaseStatus(assertionResults) {
+        // See if any assertion has failed
+        let failedAssertions = assertionResults.filter(ar => ar.status === STATUS_FAILED);
+        let failedTestCase = failedAssertions.length >= 1 ? true : false;
+        // Print it nicely
+        let coloredStatus;
+        if (failedTestCase) {
+            coloredStatus = chalk.bgRed.white(` Failed `);
+        } else {
+            coloredStatus = chalk.bgGreen.white(` Passed `);
+        }
+        log(`  Status: ${coloredStatus}\n`);
+    }
+
+    printTestCaseWithError(testCaseDescription, target, error) {
+        // Print header
+        this.printTestCaseHeader(testCaseDescription, target);
+        log(`  ERROR: ${error}`);
+        log(`  Status: ${chalk.bgRed.white(` Failed `)}\n`);
+    }
+
+}
+
+module.exports = {
+    TerminalReporter,
+    InMemoryReporter
+}

package/cli/commands/test.js

@@ -1,151 +1,123 @@
-const chalk = require('chalk');
-const { Select } = require('enquirer');
-const fs = require('fs');
 const path = require('path');
+const { Select } = require('enquirer');
 const wcmatch = require('wildcard-match');
-
-const { AppServer } = require('@kumologica/runtime');
+const { util } = require('@kumologica/runtime');
 const { codegen } = require('@kumologica/builder');
 
-const { TestSuiteController } = require('./test-utils/TestSuiteController');
-const { logError } = require('../utils/logger');
-
-const log = console.log;
-const APP_SERVER_PORT = 1990;
-		
-async function runTest(flowFilePath, testcaseSelected, iterative) {
-    log(`\n> Starting runtime on port ${APP_SERVER_PORT}...`);
-  
-    let appServer = new AppServer({
-      projectDir: path.dirname(flowFilePath),
-      flowFilePath: flowFilePath,
-      port: APP_SERVER_PORT,
-      serverMode: AppServer.mode.HEADLESS_KUMOLOGICA,
-      logLevel: AppServer.logLevel.ERROR,
-      editorApi: undefined,
-      startupEmitter: undefined
-    });
-
-    try {
-      await appServer.start();
-      log(`> FlowFile to be tested: ${chalk.bold(path.resolve(flowFilePath))} \n`);
-      let testSuiteController = new TestSuiteController(appServer);
-      
-      // If testcase is null, default to universal wildcard
-      testcaseSelected  = testcaseSelected || "**";
-
-      // Find out all testcases available on the flow
-      let testcasesAvailable = testSuiteController.findTestCasesFromFlow(flowFilePath);
-      if (!testcasesAvailable || (testcasesAvailable && testcasesAvailable.length === 0)) {
-        logError(`No testcases found on flow file: ${flowFileAbsPath}`);
-        process.exit(1);
-      };
-      let testcaseAvailableNames = testcasesAvailable.map(tc=>tc.name);
-
-      // Capture the testcase from user on iterative mode
-      if (iterative) {
-        const prompt = new Select({
-          name: 'testcase',
-          message: 'What testcase do you want to run?',
-          choices: [...testcaseAvailableNames, 'Run all TestCases...']
-        });
-        await prompt.run()
-          .then(tc => {
-            if (tc === 'Run all TestCases...'){
-              testcaseSelected = "**";
-            }else {
-              testcaseSelected = tc;
-            }
-          })
-          .catch(err => {
-            logError(`Error found while running tests on iterative mode due to: `, err.message);
-            process.exit(1);
-          });
-      }
+const { TestSuiteRunner } = require('./test-commands/TestSuiteRunner');
+const { DesignerServer } = require('../../src/server/DesignerServer');
+const { logError, logNotice, logInfo, logFatal } = require('../utils/logger');
 
-      // Filter all testcases to be part of the test suite
-      const isMatch = wcmatch(testcaseSelected);
-      let testCasesSelected = [];
-      testcasesAvailable.forEach(async tc => {
-        if (isMatch(tc.name)){
-          testCasesSelected.push({ name: tc.name, id: tc.id });
-        }
-      });
+const isDirectory = util.isDirectorySync;
 
-      // Execute the testcasesIds if any, otherwise throw an error
-      if (testCasesSelected.length === 0){
-        logError(`No matched testcases found`);
-        process.exit(1);
-      } else {
-        const errors = await testSuiteController.runTestSuite(testCasesSelected); 
-        process.exit(errors > 0);
-      }
-      
-    } catch (err) {
-      log(
-        chalk.red(
-          `Unexpected error occurred while starting server due to <${err.message}>`
-        )
-      );
-      console.log(err);
-      process.exit(1);
-    }
-  }
-  
-function isDirectory(dir) {
-  try{
-    let stats = fs.statSync(dir);
-    return stats.isDirectory();
-  } catch (err) {
-    return undefined;
-  }
- 
- 
-}
 
 exports.command = 'test [project_directory]';
 exports.desc = `Run test suite`;
 exports.builder = (yargs) => {
   yargs.positional(`project_directory`, {
-      type: 'string',
-      describe: 'Path to a valid kumologica project directory or flow file. (Optional)'
+    type: 'string',
+    describe: 'Path to a valid kumologica project directory or flow file. (Optional)'
   })
   yargs.option(`testcase`, {
     describe: "Testcase name to run",
     type: 'string',
     alias: 't',
     nargs: 1
-    });
-    yargs.option(`iterative`, {
-      describe: "Manually select the testcase to run from all available testcases",
-      type: 'boolean',
-      alias: 'i'
-      });
+  });
+  yargs.option(`iterative`, {
+    describe: "Manually select the testcase to run from all available testcases",
+    type: 'boolean',
+    alias: 'i'
+  });
 }
 exports.handler = ({ project_directory, testcase, iterative }) => {
   let projectDirOrFile = project_directory || process.cwd();
   let projectFlowPath = projectDirOrFile;
 
   let isDir = isDirectory(projectDirOrFile);
-  if (isDir){
+  if (isDir) {
     let flowFileName = codegen.findFlowFile(projectDirOrFile); // returns only the flowname
-    if (!flowFileName){
-      logError(`No flow found in directory: ${projectDirOrFile}`);
-      process.exit(1);
-    }else {
+    if (!flowFileName) {
+      logFatal(`No flow found in directory: ${projectDirOrFile}`);
+    } else {
       projectFlowPath = path.join(projectDirOrFile, flowFileName);
     }
-  } else if (isDir === false){
+  } else if (isDir === false) {
     // do nothing as it was assumed to be a file
   } else {
-    logError(`Directory does not exist: ${project_directory}`);
-    process.exit(1);
+    logFatal(`Directory does not exist: ${project_directory}`);
   }
 
-	try {
-		runTest(projectFlowPath, testcase, iterative);
-	} catch (e) {
-		logError(e.message);
-		process.exit(1);
-	}
+  try {
+    runTestOnNewServer(projectFlowPath, testcase, iterative);
+  } catch (e) {
+    logFatal(e.message);
+  }
+}
+
+async function runTestOnNewServer(flowFilePath, testcaseSelected, iterative) {
+  let designerServer = new DesignerServer(
+    flowFilePath,
+    false,
+    {
+      loglevel: "error",
+      noadmin: true
+    });
+
+  try {
+    await designerServer.listen();
+    logInfo(`> Flow file: ${path.resolve(flowFilePath)} \n`);
+    let testSuiteRunner = new TestSuiteRunner(designerServer);
+
+    // If testcase is null, default to universal wildcard
+    testcaseSelected = testcaseSelected || "**";
+
+    // Find out all testcases available on the flow
+    let testcasesAvailable = codegen.findTestCasesFromFlow(flowFilePath);
+    if (!testcasesAvailable || (testcasesAvailable && testcasesAvailable.length === 0)) {
+      logFatal(`No testcases found on flow file: ${flowFileAbsPath}`);
+    };
+    let testcaseAvailableNames = testcasesAvailable.map(tc => tc.name);
+
+    // Capture the testcase from user on iterative mode
+    if (iterative) {
+      const prompt = new Select({
+        name: 'testcase',
+        message: 'What testcase do you want to run?',
+        choices: [...testcaseAvailableNames, 'Run all TestCases...']
+      });
+      await prompt.run()
+        .then(tc => {
+          if (tc === 'Run all TestCases...') {
+            testcaseSelected = "**";
+          } else {
+            testcaseSelected = tc;
+          }
+        })
+        .catch(err => {
+          logFatal(`Error found while running tests on iterative mode due to: `, err.message);
+        });
+    }
+
+    // Filter all testcases to be part of the test suite
+    const isMatch = wcmatch(testcaseSelected);
+    let testCasesSelected = [];
+    testcasesAvailable.forEach(async tc => {
+      if (isMatch(tc.name)) {
+        testCasesSelected.push({ name: tc.name, id: tc.id });
+      }
+    });
+
+    // Execute the testcasesIds if any, otherwise throw an error
+    if (testCasesSelected.length === 0) {
+      logFatal(`No matched testcases found`);
+    } else {
+      const errors = await testSuiteRunner.runAll(testCasesSelected);
+      process.exit(errors > 0);
+    }
+
+  } catch (err) {
+    console.log(err);
+    logFatal(`Unexpected error occurred while starting server due to <${err.message}>`);
+  }
 }

package/package.json

@@ -3,7 +3,7 @@
   "productName": "Kumologica Designer",
   "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
   "author": "Kumologica Pty Ltd <contact@kumologica.com>",
-  "version": "3.3.0-beta9",
+  "version": "3.4.0-beta2",
   "description": "Kumologica Designer, harnessing Serverless for your cloud integration needs",
   "main": "src/app/main.js",
   "files": [
@@ -64,9 +64,9 @@
   "license": "Proprietary",
   "dependencies": {
     "@electron/remote": "^2.0.8",
-    "@kumologica/builder": "3.3.0-beta9",
-    "@kumologica/devkit": "3.3.0-beta9",
-    "@kumologica/runtime": "3.3.0-beta9",
+    "@kumologica/builder": "3.4.0-beta2",
+    "@kumologica/devkit": "3.4.0-beta2",
+    "@kumologica/runtime": "3.4.0-beta2",
     "adm-zip": "0.4.13",
     "ajv": "8.10.0",
     "archive-type": "^4.0.0",
@@ -124,7 +124,6 @@
     "simplemde": "1.11.2",
     "smoketail": "0.2.2",
     "static-eval": "2.0.2",
-    "tcp-port-used": "1.0.2",
     "url": "^0.11.0",
     "util": "0.12.1",
     "whatwg-url": "^11.0.0",

package/src/app/lib/stores/store.js

@@ -44,11 +44,13 @@ class Store {
   // ...and this will set it
   set(key, val) {
     this.data[key] = val;
+    let value = JSON.stringify(this.data);
+
     // Wait, I thought using the node.js' synchronous APIs was bad form?
     // We're not writing a server so there's not nearly the same IO demand on the process
     // Also if we used an async API and our app was quit before the asynchronous write had a chance to complete,
     // we might lose that data. Note that in a real app, we would try/catch this.
-    fs.outputFileSync(this.path, JSON.stringify(this.data, null, 2));
+    fs.outputFileSync(this.path, value);
   }
 
   trim(key, size) {}
@@ -78,6 +80,18 @@ class Store {
       this.set(key, values);
     }
   }
+  remove(key, val) {
+    let values = this.get(key) || [];
+    if (!Array.isArray(values)) {
+      throw new Error(
+        `Key: ${key} be an array. File: ${this.configName} may be corrupted`
+      );
+    }
+    if (values.indexOf(val) >= 0) {
+      values.splice(values.indexOf(val), 1);
+    }
+    this.set(key, values);
+  }
 }
 
 function parseDataFile(filePath, defaults) {

package/src/app/lib/stores/user-preference-store.js

@@ -4,6 +4,7 @@ const defaultKeys = {
   recentProjects: 'recentProjects',
   untitledProject: 'untitledProject'
 };
+
 const MAX_NUM_RECENT_PROJECTS = 10;
 
 const Store = require('./store');
@@ -25,6 +26,7 @@ class UserPreferenceStore extends Store {
       MAX_NUM_RECENT_PROJECTS
     );
   }
+
   getRecentProjects() {
     return super.get(defaultKeys.recentProjects);
   }