@kumologica/sdk 3.2.0-beta9 → 4.0.0-alpha2

package/src/api/tools/test/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/src/server/DesignerServer.js

@@ -0,0 +1,141 @@
+const {
+    AbstractServerfulServer,
+    ConfigBuilder,
+    PLATFORMS
+} = require('@kumologica/runtime');
+
+const { WebSocket } = require('ws');
+const url = require('url');
+const dotenv = require('dotenv');
+const AdminServerApi = require('../api/core/rest');
+const Tools = require('../api/tools');
+
+/**
+ * This class will encapsulate the adminApp and FlowApp into two servers.
+ * It will be the one running on the development box of the user (either local or remote),
+ * and it will serve all the functioanlity to the Kumologica Cloud Editor.
+ */
+
+class DesignerServer {
+    /**
+     *
+     * @param {string} flow - path of the flowFile. It supports relative and absolute paths. If flow does not exist, the process will be exited.
+     * @param {boolean} safe - create an empty shell of a project in the event that the flow file is not created.
+     * @param {object} cliParams - 
+     */
+    constructor(flowPath, safe, cliParams) {
+        // WebSocket based admin server
+        this.wss = null;
+        this.subscribers = {}; // collection of all eventTypes, actions attached to the ws admin api
+
+        if (!flowPath) {
+            console.log(
+                '[ERROR] Flow is not defined. Make sure you pass the flow file to the constructor of FlowBuilder'
+            );
+            os.exit(1);
+        }
+
+        this.config = ConfigBuilder.getInstance().buildConfig(
+            flowPath,
+            PLATFORMS.LOCAL,
+            cliParams
+        );
+
+        this.flowServer = new AbstractServerfulServer(this.config);
+
+        if (this.config.adminEnabled) {
+            //this.adminServer = AdminServerApi.init(this.flowServer.runtime._);
+            this.installTools();
+        }
+
+
+    }
+
+    installTools() {
+        new Tools.CoreTools(this).install();
+        new Tools.TestTool(this).install();
+        new Tools.DebuggerTool(this).install();
+        new Tools.GitTool(this).install();
+        new Tools.FileManagerTool(this).install();
+        // new AWSTool(this).install();
+    }
+
+    async listen() {
+        await this.flowServer.start();
+        this.flowServer.log.debug(`Runtime Configuration:${JSON.stringify(this.config, null, 2)}`);
+    }
+
+    async listenAdminServer() {
+        if (this.config.adminEnabled) {
+            // this.adminServer.listen(this.config.adminPort);
+            this.wss = new WebSocket.Server({ port: this.config.adminPort });
+            this.wss.on('connection', (ws, req) => {
+                // ws://localhost:1990?token=xxxxxxxx
+                let token = url.parse(req.url, true).query.token;
+                if (token !== 'supersecret') {
+                    ws.terminate();
+                }
+                // TODO: Check the security to set up the connection
+                // otherwise ws.terminate()
+                this.flowServer.log.info(`Client connected to the Admin WebSocket API successfully`);
+                ws.on('message', (message) => {
+                    this.handleMessage(ws, message);
+                });
+
+                ws.on('close', () => {
+                    console.log('WebSocket client disconnected');
+                });
+            });
+        }
+    }
+
+
+    handleMessage(ws, message) {
+        try {
+            const data = JSON.parse(message.toString('utf8'));
+
+            if (data.type && this.subscribers[data.type]) {
+                this.subscribers[data.type].forEach((subscriber) => {
+                    subscriber.action(ws, data.payload);
+                });
+            } else {
+                throw new Error('Invalid event format received');
+            }
+
+        } catch (err) {
+
+            let response = {
+                type: 'error',
+                payload: {
+                    reason: err.message
+                }
+            };
+            ws.send(JSON.stringify(response))
+        }
+    }
+
+    /**
+     * Used by the designer tools to register their ws api actions
+     * @param {*} eventType
+     * @param {*} action
+     */
+    registerEvent(eventType, action) {
+        if (!this.subscribers[eventType]) {
+            this.subscribers[eventType] = [];
+        }
+        this.subscribers[eventType].push({ action });
+    }
+
+
+    getFlowServer() {
+        return this.flowServer;
+    }
+
+    getAdminServer() {
+        return this.adminServer;
+    }
+}
+
+module.exports = {
+    DesignerServer,
+};

package/cli/commands/test-utils/TestSuiteController.js

@@ -1,363 +0,0 @@
-const EventEmitter = require('events').EventEmitter;
-const { performance } = require('perf_hooks');
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
-const { error } = require('./util/output');
-const got = require('got');
-const log = console.log;
-
-
-const runtimeEvents = {
-  TEST_TESTSUITE_START: 'test:testsuite-start',
-  TEST_TESTSUITE_END: 'test:testsuite-end',
-  TEST_TESTCASE_START: 'test:testcase-start',
-  TEST_TESTCASE_END: 'test:testcase-end',
-  TEST_TESTCASE_END_WITH_ERROR: 'test:testcase-end-with-error',
-};
-
-const internalEvents = {
-  TEST_RUNNER_STOP: '__testrunner-stop__',
-};
-
-// Keep the counter of testcases to wait before sending signal to stop the testsuite
-let remainingTestCases = 0;
-
-const STATUS_PASSED = 'passed';
-const STATUS_FAILED = 'failed';
-
-class TestCase {
-  constructor(testCaseId, testCaseDescription, testCaseTarget) {
-    this._testCaseId = testCaseId;
-    this._testCaseDescription = testCaseDescription;
-    this._testCaseTarget = testCaseTarget;
-    this._assertionResults = [];
-    this._status = STATUS_PASSED;
-  }
-  attachAssertions(assertions) {
-    this._assertionResults = assertions;
-    if (this._assertionResults){
-      let failedAssertions = this._assertionResults.filter(ar => ar.status === STATUS_FAILED);
-      if (failedAssertions.length >= 1){
-        this._status = STATUS_FAILED;
-      } else {
-        this._status = STATUS_PASSED;
-      }
-     
-    } else {
-      this._status = STATUS_PASSED;
-    }
-  }
-  
-}
-
-class TestReporter {
-  constructor(runtimeEventEmitter) {
-    this._testReporterEmitter = new EventEmitter();
-    this._runtimeEventEmitter = runtimeEventEmitter;
-    this._testCases = [];
-    this._runningTestCase = null;
-    // Measuring the execution time
-    this._timeStartTestSuite = null;
-    this._timeEndTestSuite = null;
-    this.subscribeRuntimeEvents();
-  }
-
-  get emitter() {
-    return this._testReporterEmitter;
-  }
-
-  subscribeRuntimeEvents() {
-    this._runtimeEventEmitter.on('runtime-event', async (data) => {
-      //console.log('TestReporter has received a runtime-event', data);
-      let p = data.payload;
-
-      switch (data.id) {
-        case runtimeEvents.TEST_TESTSUITE_START:
-          this._timeStartTestSuite = performance.now();
-          break;
-        case runtimeEvents.TEST_TESTSUITE_END:
-          this._timeEndTestSuite = performance.now();
-          this.printSummary();
-          break;
-
-        case runtimeEvents.TEST_TESTCASE_START:
-          let tcr = p.testCaseResults;
-          let testCase = new TestCase(
-            tcr.testCaseID,
-            tcr.testCaseDescription,
-            tcr.target
-          );
-          this.addTestCase(testCase);
-          // this.printTestCaseHeader();
-          break;
-        case runtimeEvents.TEST_TESTCASE_END:
-          this.printTestCaseResult(p.testCaseResults);
-          let tc = this.findTestCase(p.testCaseResults.testCaseID);
-          if (tc){
-            tc.attachAssertions(p.testCaseResults.assertionResults);
-          }
-         
-          remainingTestCases = remainingTestCases - 1;
-          if (remainingTestCases === 0) {
-            // Inform the TestController to stop the command
-            this._testReporterEmitter.emit(internalEvents.TEST_RUNNER_STOP);
-          }
-          break;
-        case runtimeEvents.TEST_TESTCASE_END_WITH_ERROR:
-          this.printTestCaseWithError(p.testCaseResults, p.error);
-          remainingTestCases = remainingTestCases - 1;
-          if (remainingTestCases === 0) {
-            // Inform the TestController to stop the command
-            this._testReporterEmitter.emit(internalEvents.TEST_RUNNER_STOP);
-          }
-          break;
-        default:
-        // do not do anything
-      }
-
-      // For future ideas of how to implement debugger on terminal
-      // if (data.id === 'node-debug') {
-      //   console.log(JSON.stringify(data.payload, null, 2));
-      // }
-    });
-  }
-
-  addTestCase(testCase) {
-    this._runningTestCase = testCase;
-    this._testCases.push(testCase);
-  }
-
-  
-  findTestCase(testCaseId){
-    let tcfound = this._testCases.filter(tc => tc._testCaseId === testCaseId);
-    if (tcfound.length === 0) {
-      return undefined;
-    } else {
-      return tcfound[0];
-    }
-
-  }
-
-  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:`);
-  }
-
-  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);
-  }
-
-  printTestAssertionResult(assertionResults) {
-    // Print Assertions
-    if (assertionResults.length === 0){
-      log(chalk.dim(`     (No assertions found)`));
-    } else {
-      assertionResults.map( (ar, index) => {
-        this.printTestAssertion(ar, index);
-      });
-    }
-  }
-
-  printTestCaseStatus(testCaseResult){
-      // See if any assertion has failed
-      let failedAssertions = testCaseResult.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(testCaseResult, error){
-    let {
-      testCaseDescription, 
-      target 
-    } = testCaseResult;
-
-    // Print header
-    this.printTestCaseHeader(testCaseDescription, target);
-    log(`  ERROR: ${error}`);
-    log(`  Status: ${chalk.bgRed.white(` Failed `)}\n`);
-  }
-
-  printTestCaseResult(testCaseResult) {
-    let {
-      testCaseID,
-      testCaseDescription, 
-      target, 
-      assertionResults } = testCaseResult;
-
-    // Print header
-    this.printTestCaseHeader(testCaseDescription, target);
-    
-    // Print assertions
-    this.printTestAssertionResult(assertionResults || []);
-
-    // Print status
-    this.printTestCaseStatus(testCaseResult);
-  }
-
-  printSummary() {
-    log(`TestCases - Completed
-
-Final Execution Statistics
--------------------------------
-Execution Time: ${this.getExecutionTime()} ms
-Total Test Cases: ${this.getTestCases().length}
-Failed: ${this.getFailedTestCases().length}
-Passed: ${this.getPassedTestCases().length}
--------------------------------
-    `);
-  }
-
-  getTestCases() {
-    return this._testCases;
-  }
-
-  getFailedTestCases() {
-    let failedTestCases = this.getTestCases().filter(
-      (tc) => tc._status === STATUS_FAILED
-    );
-    return failedTestCases || [];
-  }
-
-  getPassedTestCases() {
-    let passedTestCases = this.getTestCases().filter(
-      (tc) => tc._status === STATUS_PASSED
-    );
-    return passedTestCases || [];
-  }
-  getExecutionTime() {
-    if (this._timeStartTestSuite && this._timeEndTestSuite) {
-      return this.toFixed(this._timeEndTestSuite - this._timeStartTestSuite, 2);
-    } else {
-      return 0;
-    }
-  }
-
-  /**
-   *
-   * @param {*} num - number to get truncated its decimal digits
-   * @param {*} fixed - number of digits to be truncated
-   */
-  toFixed(num, fixed) {
-    fixed = fixed || 0;
-    fixed = Math.pow(10, fixed);
-    return Math.floor(num * fixed) / fixed;
-  }
-}
-
-class TestSuiteController {
-  constructor(appServer) {
-    this._appServer = appServer;
-    this._testReporter = new TestReporter(this._appServer.events);
-  }
-
-  async waitForResults() {
-    log(`TestCases - Executing\n`);
-    try {
-      const testReporterEmitter = this._testReporter.emitter;
-      return new Promise((resolve, reject) => {
-        testReporterEmitter.on(internalEvents.TEST_RUNNER_STOP, () => {
-          resolve();
-        });
-      });
-    } catch (err) {
-      log(
-        error(
-          `Unexpected error occurred while starting server due to <${err.message}>`
-        )
-      );
-      process.exit(1);
-    }
-  }
-
-  findTestCasesFromFlow(flowFilePath) {
-    const flowFileData = fs.readFileSync(flowFilePath, 'utf-8');
-    const flowFileJson = JSON.parse(flowFileData);
-    return flowFileJson.filter((node) => node.type === 'TestCase' || node.type === 'HTTPTestCase');
-  }
-
-  /**
-   * 
-   * @param {*} testcasesSelected - array of {id: nodeId, name: nodeName}
-   * @returns 
-   */
-  async runTestSuite(testcasesSelected) {
-    // === Starting the testSuite ===
-    this._appServer.events.emit('runtime-event', {
-      id: runtimeEvents.TEST_TESTSUITE_START,
-      payload: {},
-    });
-
-    // === Iterate over all the testCases ===
-    await this.runTestCases(testcasesSelected);
-    await this.waitForResults();
-    const errorsNum = this._testReporter.getFailedTestCases().length;
-
-    // === End the testSuite
-    this._appServer.events.emit('runtime-event', {
-      id: runtimeEvents.TEST_TESTSUITE_END,
-      payload: {},
-    });
-
-    return errorsNum;
-  }
-
-  async runTestCases(testCases) {
-    remainingTestCases = testCases.length;
-    const port = this._appServer._server.address().port;
-
-      testCases.map(async(testCase) => {
-        try{
-          await got({
-            url: `http://127.0.0.1:${port}`,
-            method: 'POST',
-            headers: { 'x-kumologica-testcasenode': `${testCase.id}` },
-          });
-        } catch (err) {
-          log(`Error found while running TestCase Id=${testCase.id} due to... ${err}`);
-          process.exit(1);
-        }
-       
-    })
-  }
-
-  _debugResponse(resp) {
-    log(JSON.stringify(resp));
-  }
-}
-
-module.exports = {
-  TestSuiteController,
-};