@kumologica/sdk 3.3.0-beta9 → 3.4.0-beta2

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,
-};

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

@@ -1,171 +0,0 @@
-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_KUMOLOGICA,
-    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);
-  }
-});

package/cli/commands/test-utils/util/output.js

@@ -1,14 +0,0 @@
-const chalk = require('chalk');
-
-function error(message) {
-  return chalk.red(message);
-}
-
-function bold(message) {
-  return chalk.bold(message);
-}
-
-module.exports = {
-  error,
-  bold
-};

package/cli/commands/test-utils/util/updates/index.js

@@ -1,17 +0,0 @@
-const updateNotifier = require('update-notifier');
-const chalk = require('chalk');
-const pkg = require('./pkg');
-
-module.exports = () => {
-  const { update } = updateNotifier({ pkg });
-
-  if (!update) {
-    return;
-  }
-
-  console.log(
-    `${chalk.white.bold.bgRed(
-      'UPDATE AVAILABLE'
-    )} The latest version of Kumologica CLI is ${chalk.bold(update.latest)}`
-  );
-};

package/cli/commands/test-utils/util/updates/pkg.js

@@ -1,13 +0,0 @@
-/* eslint-disable import/no-unresolved */
-
-const path = require('path');
-const pkg = require('../../../package.json');
-
-try {
-  const distDir = path.dirname(process.execPath);
-  pkg._npmPkg = require(path.join(distDir, '../../package.json'));
-} catch (err) {
-  pkg._npmPkg = null;
-}
-
-module.exports = pkg;