@kumologica/sdk 3.0.0

package/cli/commands/import-commands/mulesoft.js

@@ -0,0 +1,61 @@
+exports.command = 'mulesoft';
+exports.desc = `Imports mulesoft project as kumologica flow.`;
+
+exports.builder = {			
+	"mulesoft-project-directory": {
+        describe: "The directory where mulesoft project is located.",
+        demandOption: "The nmulesoft project directory is required.",
+		type: 'string',
+		alias: 'm',
+		nargs: 1
+	},
+	"kumologica-project-directory": {
+        describe: "The directory where kumologica project to be created",
+        demandOption: "The kumologica project directory is required.",
+		type: 'string',
+		alias: 'k',
+		nargs: 1
+	},
+	"kumologica-flow-file-name": {
+        describe: "The name of kumologica flow file to be created, must end with .json extension",
+        demandOption: "The kumologica flow file name is required.",
+		type: 'string',
+		alias: 'f',
+		nargs: 1
+	}
+}
+		
+function validate(argv) {
+	const chalk = require('chalk');
+
+	if (!argv["kumologica-flow-file-name"].endsWith('.json')) {
+		console.log(`${chalk.redBright("Validation Error: kumologica-flow-file-name must end with .json extension.")}`);
+		process.exit(1);
+	}
+}
+function display(argv) {
+	console.log('Parameters:');
+	console.log('  mulesoft-project-directory:    %s', argv["mulesoft-project-directory"]||'');
+	console.log('  kumologica-project-directory:  %s', argv["kumologica-project-directory"]||'');
+	console.log('  kumologica-flow-file-name:     %s', argv["kumologica-flow-file-name"]||'');
+}
+
+exports.handler = async function (argv) {
+	console.log('\nImporting mulesoft project\n');
+	display(argv);
+	validate(argv);
+
+	const chalk = require('chalk');
+
+	try {
+		const { importProject } = require('@kumologica/builder');
+		await importProject('mulesoft', argv);
+		console.log(chalk.greenBright('Mulesoft project imported succesfully.'));
+	
+		process.exit(0);
+	} catch (e) {
+
+		console.log(`${chalk.redBright(e.message)}`);
+		process.exit(1);
+	}
+}

package/cli/commands/import.js

@@ -0,0 +1,6 @@
+exports.command = 'import <type>'
+exports.desc = 'Imports, converts other projects into kumologica flow'
+exports.builder = function (yargs) {
+  return yargs.commandDir('import-commands')
+}
+exports.handler = function (argv) {}

package/cli/commands/open.js

@@ -0,0 +1,46 @@
+const path = require('path');
+const { logError } = require('./utils');
+
+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 });
+    
+    e.stdout.on("data", data => {
+        console.log(data.toString().trim());
+    });
+    
+    e.stderr.on("data", data => {
+        logError(data.toString().trim());
+    });
+    
+    e.on('error', (error) => {
+        console.log(`==> ${error.message}`);
+    });
+    
+    e.on("close", code => {
+        console.log(`exited with code ${code}`);
+    });
+}
+
+exports.command = "open [project_directory]"
+exports.builder = (yargs) => {
+    yargs.positional(`project_directory`, {
+        type: 'string',
+        describe: 'Path to a valid kumologica project. (Optional)'
+    })
+}
+
+exports.desc = 'Open Kumologica Designer'
+exports.handler = ({ project_directory }) => {
+    let projectDir = project_directory? path.resolve(project_directory): undefined ;
+    startElectron(projectDir);
+}

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

@@ -0,0 +1,359 @@
+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} > ${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');
+  }
+
+  async runTestSuite() {
+    const flowFileAbsPath = path.join(
+      this._appServer.settings.userDir,
+      this._appServer.settings.flowFile
+    );
+    let testCases = this.findTestCasesFromFlow(flowFileAbsPath);
+
+    // === Starting the testSuite ===
+    this._appServer.events.emit('runtime-event', {
+      id: runtimeEvents.TEST_TESTSUITE_START,
+      payload: {},
+    });
+
+    // === Iterate over all the testCases ===
+    await this.runTestCases(testCases);
+    await this.waitForResults();
+    
+    // === End the testSuite
+    this._appServer.events.emit('runtime-event', {
+      id: runtimeEvents.TEST_TESTSUITE_END,
+      payload: {},
+    });
+  }
+  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,
+};

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

@@ -0,0 +1,171 @@
+const expect = require('chai').expect;
+const { TestSuiteController } = require('./TestSuiteController');
+const { resolve } = require('path');
+const { AppServer } = require('@kumologica/runtime');
+
+function emulateRuntimeEvents(events) {
+  //  Start testSuite
+  events.emit('runtime-event', {
+    id: 'test:testsuite-start',
+    payload: {}
+  });
+  // Start testcase
+  events.emit('runtime-event', {
+    id: 'test:testcase-start',
+    payload: {
+      testCaseId: 'case1',
+      testCaseDescription: 'Ensure status code is ok',
+      target: 'flow:*'
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'HTTP Response is 200',
+      selector: 'StatusCode',
+      property: '',
+      comparison: 'equalsTo',
+      valueExpected: 200
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'At least one account returned',
+      selector: 'JsonBody',
+      property: '$.[*]',
+      comparison: 'greaterOrEqualsTo',
+      valueExpected: 1
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'Meet response SLA ',
+      selector: 'responseTime',
+      property: '',
+      comparison: 'lessOrEqualsTo',
+      valueExpected: 2000
+    }
+  });
+
+  // Finish testCase
+
+  events.emit('runtime-event', {
+    id: 'test:testcase-end',
+    payload: {
+      testCaseId: 'case1'
+    }
+  });
+
+  // Start testcase
+  events.emit('runtime-event', {
+    id: 'test:testcase-start',
+    payload: {
+      testCaseId: 'case2',
+      testCaseDescription: 'Handle business exceptions',
+      target: 'flow:*'
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'HTTP Response is 500',
+      selector: 'StatusCode',
+      property: '',
+      comparison: 'equalsTo',
+      valueExpected: 500
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'body is empty',
+      selector: 'JsonBody',
+      property: '',
+      comparison: 'isEmpty()',
+      valueExpected: 1
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'Doesnt meet response SLA ',
+      selector: 'responseTime',
+      property: '',
+      comparison: 'greaterOrEqualsTo',
+      valueExpected: 2000,
+      diffReported: {
+        expected: 'Response time > 2000 ms',
+        actual: 'Response time equals to 500 ms'
+      }
+    }
+  });
+
+  // Emit passed assertion
+  events.emit('runtime-event', {
+    id: 'test:assertion-report',
+    payload: {
+      description: 'Response header is type JSON',
+      selector: 'headers',
+      property: 'content/type',
+      comparison: 'equalsTo',
+      valueExpected: 'json'
+    }
+  });
+
+  // Finish testCase
+
+  events.emit('runtime-event', {
+    id: 'test:testcase-end',
+    payload: {
+      testCaseId: 'case1'
+    }
+  });
+
+  // Finish testSuite
+  events.emit('runtime-event', {
+    id: 'test:testsuite-end',
+    payload: {}
+  });
+}
+
+it('Simulate happy path runtime events', async () => {
+  expect('hola').to.equal('hola');
+  //console.log(resolve('lib/cmds/test/fixtures/example3-flow.json'));
+  let appServer = new AppServer(
+    resolve('lib/cmds/test/fixtures/example3-flow.json'),
+    resolve('lib/cmds/test/fixtures/example3-flow.json'),
+    1990,
+    AppServer.mode.HEADLESS_DEFAULT_EXPRESS,
+    AppServer.logLevel.ERROR,
+    undefined
+  );
+  try {
+    await appServer.start();
+    let testSuiteController = new TestSuiteController(appServer);
+    let promiseFinished = testSuiteController.waitForResults();
+    emulateRuntimeEvents(appServer.events);
+    await promiseFinished;
+
+    await appServer.stop();
+    process.exit();
+  } catch (err) {
+    console.log(
+      `Unexpected error occurred while starting server due to <${err.message}>`
+    );
+    console.log(err);
+  }
+});