@kumologica/sdk 3.0.0-alpha4

package/src/api/tools/index.js

@@ -0,0 +1,13 @@
+const { TestTool } = require('./test');
+const { CoreTools } = require('./core');
+const { DebuggerTool } = require('./debugger');
+const { GitTool } = require('./git');
+const { FileManagerTool } = require('./filemanager');
+
+module.exports = {
+    CoreTools,
+    TestTool,
+    DebuggerTool,
+    GitTool,
+    FileManagerTool
+}

package/src/api/tools/test/index.js

@@ -0,0 +1,56 @@
+const { DesignerTool } = require('../base/DesignerTool');
+const { TestCaseRunner, InMemoryReporter } = require('./lib/TestCaseRunner');
+
+
+class TestTool extends DesignerTool {
+    constructor(designServer) {
+        super(designServer);
+    }
+    install() {
+        /**
+         * { type: 'test:run',
+         *   payload: { testcaseid: '123432.34343'} }
+         */
+        this.addEventHandler('test:run', this.executeTestRunAction('test:run'));
+        this.addEventHandler('test:findTestCases', this.executeTestFindTestCasesAction('test:findTestCases'));
+    }
+    executeTestRunAction(eventType) {
+        return async (ws, payload) => {
+            const { testcaseid } = payload || {};
+            const reporter = new InMemoryReporter();
+            const runner = new TestCaseRunner(this.flowServer, testcaseid, [reporter]);
+            try {
+                await runner.runAsync();
+
+                let response = {
+                    testCaseExecutionTimeInMs: reporter.executionTimeInMs,
+                    testCaseID: reporter.testCaseID,
+                    testCaseDescription: reporter.testCaseDescription,
+                    assertions: reporter.assertionResults,
+                    flowResponse: reporter.flowResponse
+                }
+                this.sendResponse(ws, eventType, response);
+
+            } catch (err) {
+                this.sendError(ws, eventType, err.message);
+            }
+
+        }
+    }
+
+    executeTestFindTestCasesAction(eventType) {
+        return async (ws, payload) => {
+            const flowApp = this.flowServer.nodes.getFlows();
+            let testNodes = []
+            if (flowApp && flowApp.flows && flowApp.flows.length > 0) {
+             testNodes = flowApp.flows.filter((node)=> node.type.toLowerCase() === 'httptestcase' || node.type.toLowerCase() ==='testcase')
+            }
+            this.sendResponse(ws, eventType, testNodes);
+        }
+    }
+}
+
+
+module.exports = {
+    TestTool
+}

package/src/api/tools/test/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.response.statusCode === 404 &&
+                    err.response.body === '{"errorMessage":"Targeted node not found"}') {
+                    reject(new Error('TestCaseID not found'));
+                } else {
+                    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/src/api/tools/test/lib/fixtures/example3-flow.json

@@ -0,0 +1,148 @@
+[
+    {
+        "id": "main.flow",
+        "type": "tab",
+        "label": "main",
+        "disabled": false,
+        "info": ""
+    },
+    {
+        "id": "test.flow",
+        "type": "tab",
+        "label": "test",
+        "disabled": false,
+        "info": ""
+    },
+    {
+        "id": "eacbb9ef.69d5c8",
+        "type": "EventListener",
+        "z": "main.flow",
+        "name": "GET /hello",
+        "provider": "aws",
+        "eventSource": "api",
+        "dynamodbOperation": "",
+        "apiMethod": "get",
+        "apiUrl": "/",
+        "albMethod": "any",
+        "albUrl": "",
+        "bucketName": "",
+        "event": "s3:ObjectCreated:*",
+        "kapiUrl": "",
+        "kcronexpression": "",
+        "x": 120,
+        "y": 160,
+        "wires": [
+            [
+                "5eb3cd61.894f04"
+            ]
+        ],
+        "caname": "event-handler",
+        "category": "general"
+    },
+    {
+        "id": "5eb3cd61.894f04",
+        "type": "Logger",
+        "z": "main.flow",
+        "name": "Log",
+        "level": "INFO",
+        "message": "Request received",
+        "x": 262.5,
+        "y": 160,
+        "wires": [
+            [
+                "b5fc6ccd.17dd7"
+            ]
+        ],
+        "caname": "logger",
+        "category": "logging"
+    },
+    {
+        "id": "b5fc6ccd.17dd7",
+        "type": "EventListener-End",
+        "z": "main.flow",
+        "name": "Success",
+        "statusCode": "500",
+        "headers": {
+            "Content-Type": "application/json"
+        },
+        "payload": "{\"hello\": \"world\"}",
+        "x": 522.5,
+        "y": 160,
+        "wires": [],
+        "caname": "eventlistenerend",
+        "category": "general"
+    },
+    {
+        "id": "b970b7d2.5454c8",
+        "type": "Assertion",
+        "z": "test.flow",
+        "name": "check response",
+        "selector": "jsonBody",
+        "property": "hello",
+        "comparison": "equals",
+        "value": "world",
+        "x": 265,
+        "y": 160,
+        "wires": [
+            [
+                "e0721cc7.653eb"
+            ]
+        ],
+        "caname": "test-assertion",
+        "category": "testing"
+    },
+    {
+        "id": "e0721cc7.653eb",
+        "type": "TestCaseEnd",
+        "z": "test.flow",
+        "name": "TestCaseEnd",
+        "x": 425,
+        "y": 160,
+        "wires": [],
+        "caname": "test-case-end",
+        "category": "testing"
+    },
+    {
+        "id": "e8fb91dc.46c24",
+        "type": "HTTPTestCase",
+        "z": "test.flow",
+        "name": "HTTPTestCase",
+        "method": "GET",
+        "path": "/",
+        "headers": {
+            "Accept": "application/json"
+        },
+        "authtype": "none",
+        "secUser": "",
+        "secPassword": "",
+        "secToken": "",
+        "payload": "",
+        "x": 122.5,
+        "y": 160,
+        "wires": [
+            [
+                "b970b7d2.5454c8"
+            ]
+        ],
+        "caname": "http-test-case",
+        "category": "testing"
+    },
+    {
+        "id": "d974781.eca0588",
+        "type": "TestCase",
+        "z": "test.flow",
+        "name": "TestCase",
+        "selectedTargetNode": "eacbb9ef.69d5c8",
+        "payload": "{\n  \"path\": \"/settings\",\n  \"headers\": {\n    \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\",\n    \"Accept-Encoding\": \"gzip, deflate, lzma, sdch, br\",\n    \"Accept-Language\": \"en-US,en;q=0.8\",\n    \"CloudFront-Forwarded-Proto\": \"https\",\n    \"CloudFront-Is-Desktop-Viewer\": \"true\",\n    \"CloudFront-Is-Mobile-Viewer\": \"false\",\n    \"CloudFront-Is-SmartTV-Viewer\": \"false\",\n    \"CloudFront-Is-Tablet-Viewer\": \"false\",\n    \"CloudFront-Viewer-Country\": \"US\",\n    \"Host\": \"wt6mne2s9k.execute-api.us-west-2.amazonaws.com\",\n    \"Upgrade-Insecure-Requests\": \"1\",\n    \"User-Agent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48\",\n    \"Via\": \"1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)\",\n    \"X-Amz-Cf-Id\": \"nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==\",\n    \"X-Forwarded-For\": \"192.168.100.1, 192.168.1.1\",\n    \"X-Forwarded-Port\": \"443\",\n    \"X-Forwarded-Proto\": \"https\"\n  },\n  \"pathParameters\": {\n    \"proxy\": \"hello\"\n  },\n  \"requestContext\": {\n    \"accountId\": \"123456789012\",\n    \"resourceId\": \"us4z18\",\n    \"stage\": \"test\",\n    \"requestId\": \"41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9\",\n    \"identity\": {\n      \"cognitoIdentityPoolId\": \"\",\n      \"accountId\": \"\",\n      \"cognitoIdentityId\": \"\",\n      \"caller\": \"\",\n      \"apiKey\": \"\",\n      \"sourceIp\": \"192.168.100.1\",\n      \"cognitoAuthenticationType\": \"\",\n      \"cognitoAuthenticationProvider\": \"\",\n      \"userArn\": \"\",\n      \"userAgent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48\",\n      \"user\": \"\"\n    },\n    \"resourcePath\": \"/{proxy+}\",\n    \"httpMethod\": \"GET\",\n    \"apiId\": \"wt6mne2s9k\"\n  },\n  \"resource\": \"/{proxy+}\",\n  \"httpMethod\": \"GET\",\n  \"queryStringParameters\": {\n    \"name\": \"me\"\n  },\n  \"stageVariables\": {\n    \"stageVarName\": \"stageVarValue\"\n  }\n}",
+        "initialLoad": "false",
+        "x": 122.5,
+        "y": 60,
+        "wires": [
+            [
+                "b970b7d2.5454c8"
+            ]
+        ],
+        "caname": "test-case",
+        "category": "testing"
+    }
+]

package/src/api/tools/test/lib/fixtures/package.json

@@ -0,0 +1,6 @@
+{
+    "name": "cloudaction-project",
+    "description": "A CloudAction Project",
+    "version": "0.0.1",
+    "private": true
+}

package/src/api/tools/test/lib/fixtures/s3-event.js

@@ -0,0 +1,43 @@
+const MOCK_S3_EVENT = {
+  Records: [
+    {
+      eventVersion: '2.1',
+      eventSource: 'aws:s3',
+      awsRegion: 'us-east-2',
+      eventTime: '2019-09-03T19:37:27.192Z',
+      eventName: 'ObjectCreated:Put',
+      userIdentity: {
+        principalId: 'AWS:AIDAINPONIXQXHT3IKHL2'
+      },
+      requestParameters: {
+        sourceIPAddress: '205.255.255.255'
+      },
+      responseElements: {
+        'x-amz-request-id': 'D82B88E5F771F645',
+        'x-amz-id-2':
+          'vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo='
+      },
+      s3: {
+        s3SchemaVersion: '1.0',
+        configurationId: '828aa6fc-f7b5-4305-8584-487c791949c1',
+        bucket: {
+          name: 'lambda-artifacts-deafc19498e3f2df',
+          ownerIdentity: {
+            principalId: 'A3I5XTEXAMAI3E'
+          },
+          arn: 'arn:aws:s3:::lambda-artifacts-deafc19498e3f2df'
+        },
+        object: {
+          key: 'b21b84d653bb07b05b1e6b33684dc11b',
+          size: 1305107,
+          eTag: 'b21b84d653bb07b05b1e6b33684dc11b',
+          sequencer: '0C0F6F405D6ED209E1'
+        }
+      }
+    }
+  ]
+};
+
+module.exports = {
+  MOCK_S3_EVENT
+};

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