Merge pull request #41 from electricimp/develop

Tests development

Author: Pavel Petroshenko

Diff for: README.md

@@ -1,4 +1,4 @@
-# impt #
+# impt #
 
 *impt* is a command line tool which allows you to interact with the Electric Imp impCloud™ via the [impCentral™ API](https://apidoc.electricimp.com) for the development, testing and deployment of application and factory code, and for device and product management.
 
@@ -753,7 +753,7 @@ Many *impt* commands combine several impCentral API requests which change impCen
 
 ## Testing ##
 
-There are [Jasmine](https://www.npmjs.com/package/jasmine) tests available to verify *impt* implementation itself. The [Testing read me](./spec/TestingReadme.md) describes how to run the tests and extend them, if necessary.
+There are [Jasmine](https://www.npmjs.com/package/jasmine) tests available to verify *impt* implementation itself. The [Readme](./spec/README.md) describes how to run the tests and extend them, if necessary.
 
 ## License ##
 

Diff for: TestingGuide.md

@@ -0,0 +1,317 @@
+// MIT License
+//
+// Copyright 2018 Electric Imp
+//
+// SPDX-License-Identifier: MIT
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+// EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+require('jasmine-expect');
+
+const Shell = require('shelljs');
+const FS = require('fs');
+const config = require('./config');
+const Utils = require('../lib/util/Utils');
+const UserInteractor = require('../lib/util/UserInteractor');
+const child_process = require('child_process');
+
+const TIMEOUT_MS = 300000;
+const TESTS_EXECUTION_FOLDER = `${__dirname}/../__test${process.env.IMPT_FOLDER_SUFFIX ? process.env.IMPT_FOLDER_SUFFIX : ''}`;
+const KEY_ANSWER = {
+    CTRL_C: '\x03',
+    ENTER: '\n',
+    YES: 'y',
+    NO: 'n'
+};
+const ENV_VARS = [
+    'IMPT_USER',
+    'IMPT_PASSWORD',
+    'IMPT_LOGINKEY',
+    'IMPT_ENDPOINT',
+    'IMPT_AUTH_FILE_PATH'
+]
+
+// Helper class for testing impt tool.
+// Contains common methods for testing environment initialization and cleanup,
+// running impt commands, check commands output, ...
+class ImptTestHelper {
+    static get TIMEOUT() {
+        return TIMEOUT_MS;
+    }
+
+    static get TESTS_EXECUTION_FOLDER() {
+        return TESTS_EXECUTION_FOLDER;
+    }
+
+    static get ATTR_NAME() {
+        return 'name';
+    }
+
+    static get ATTR_DESCRIPTION() {
+        return 'description';
+    }
+
+    static get ATTR_ID() {
+        return 'id';
+    }
+
+    static get ATTR_TYPE() {
+        return 'type';
+    }
+
+    static get OUTPUT_MODES() {
+        const VALID_MODES = ['minimal', 'json', 'debug'];
+        // default output mode present always
+        let modes = [''];
+        config.outputModes.forEach((item) => { if (VALID_MODES.includes(item)) modes.push(`-z ${item}`) });
+        return modes;
+    }
+
+    static get KEY_ANSWER() {
+        return KEY_ANSWER;
+    }
+
+    // Initializes testing environment: creates test execution folder, sets default jasmine test timeout.
+    // Optionally executes 'impt auth login --local' command in the test execution folder.
+    // Should be called from any test suite beforeAll method.
+    static init(login = true) {
+        jasmine.DEFAULT_TIMEOUT_INTERVAL = TIMEOUT_MS;
+        Utils.removeDirSync(TESTS_EXECUTION_FOLDER);
+        FS.mkdirSync(TESTS_EXECUTION_FOLDER);
+        if (!config.username || !config.password) {
+            console.log("Error! Environment variable IMPT_USER_NAME and/or IMPT_USER_PASSWORD not set");
+            return;
+        }
+        if (login) {
+            const endpoint = config.apiEndpoint ? `--endpoint ${config.apiEndpoint}` : '';
+            return ImptTestHelper.runCommand(
+                `impt auth login --local --user ${config.username} --pwd ${config.password} ${endpoint}`,
+                ImptTestHelper.checkSuccessStatus);
+        }
+        return Promise.resolve();
+    }
+
+    // Cleans up testing environment.
+    // Should be called from any test suite afterAll method.
+    static cleanUp() {
+        Shell.cd(__dirname);
+        Utils.removeDirSync(TESTS_EXECUTION_FOLDER);
+        return Promise.resolve();
+    }
+
+    // Executes impt command and calls outputChecker function to check the command output
+    static runCommand(command, outputChecker, env = {}) {
+        return new Promise((resolve, reject) => {
+            if (config.debug) {
+                console.log('Running command: ' + command);
+            }
+            Shell.cd(TESTS_EXECUTION_FOLDER);
+            ENV_VARS.forEach(function (val) {
+                if (env[val] === undefined) delete Shell.env[val];
+                else Shell.env[val] = env[val];
+            });
+            Shell.exec(`node ${__dirname}/../bin/${command}`,
+                { silent: !config.debug },
+                (code, stdout, stderr) => {
+                    resolve({ code: code, output: stdout.replace(/((\u001b\[2K.*\u001b\[1G)|(\u001b\[[0-9]{2}m))/g, '') });
+                }
+            );
+        }).then(outputChecker);
+    }
+
+    static runCommandInteractive(command, outputChecker, env = {}) {
+        return new Promise((resolve, reject) => {
+            if (config.debug) {
+                console.log('Running command: ' + command);
+            }
+            ENV_VARS.forEach(function (val) {
+                if (env[val] === undefined) delete Shell.env[val];
+                else Shell.env[val] = env[val];
+            });
+            let child = Shell.exec(`node ${__dirname}/../bin/${command}`,
+                { silent: !config.debug },
+                (code, stdout, stderr) => {
+                    resolve({ code: code, output: stdout.replace(/((\u001b\[2K.*\u001b\[1G)|(\u001b\[[0-9]{2}m))/g, '') });
+                });
+            child.stdin.end();
+        }).then(outputChecker);
+    }
+
+    static runCommandWithTerminate(command, outputChecker) {
+        var child;
+        return Promise.all([
+            new Promise((resolve, reject) => {
+                if (config.debug) {
+                    console.log('Running command: ' + command);
+                }
+                child = Shell.exec(`node ${__dirname}/../bin/${command}`,
+                    { silent: !config.debug },
+                    (code, stdout, stderr) => {
+                        resolve({ code: code, output: stdout.replace(/((\u001b\[2K.*\u001b\[1G)|(\u001b\[[0-9]{2}m))/g, '') });
+                    });
+
+            }).then(outputChecker),
+            this.delayMs(20000).
+                then(() => child.kill('SIGINT')).
+                then(() => child.kill())
+        ]);
+    }
+
+    static delayMs(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+
+    static getDeviceAttrs(product, dg, output) {
+        let jsonInfo = null;
+        return ImptTestHelper.runCommand(`impt product create -n ${product}`, ImptTestHelper.emptyCheckEx).
+            then(() => ImptTestHelper.runCommand(`impt dg create -n ${dg} -p ${product}`, ImptTestHelper.emptyCheck)).
+            then(() => ImptTestHelper.runCommand(`impt device assign -d ${config.devices[config.deviceidx]} -g ${dg} -q`, ImptTestHelper.emptyCheckEx)).
+            then(() => ImptTestHelper.runCommand(`impt build deploy -g ${dg}`, ImptTestHelper.emptyCheckEx)).
+            then(() => ImptTestHelper.runCommand(`impt device info -d ${config.devices[config.deviceidx]} -z json`, (commandOut) => {
+                jsonInfo = commandOut.output;
+                ImptTestHelper.emptyCheck(commandOut);
+            })).
+            then(() => ImptTestHelper.runCommand(`impt product delete -p ${product} -f -b -q`, ImptTestHelper.emptyCheckEx)).
+            then(() => {
+                return new Promise((resolve) => {
+                    let json = JSON.parse(jsonInfo);
+                    if (json.Device) {
+                        let device_mac = json.Device.mac_address;
+                        let device_name = json.Device.name;
+                        let agent_id = json.Device.agent_id;
+                        resolve({ mac: device_mac, name: device_name, agentid: agent_id });
+                    }
+                    else
+                        resolve(null);
+                })
+            }).
+            then(output);
+    }
+
+    static getAuthAttrs(output) {
+        let jsonInfo = null;
+        return ImptTestHelper.runCommand(`impt auth info -z json`, (commandOut) => {
+            jsonInfo = commandOut.output;
+            ImptTestHelper.emptyCheck(commandOut);
+        }).
+            then(() => {
+                return new Promise((resolve) => {
+                    let json = JSON.parse(jsonInfo);
+                    if (json.Auth) {
+                        let auth_email = json.Auth.Email;
+                        let user_id = json.Auth['Account id'];
+                        resolve({ email: auth_email, id: user_id });
+                    }
+                    else
+                        resolve(null);
+                })
+            }).
+            then(output);
+    }
+
+    // Checks if file exist in the TESTS_EXECUTION_FOLDER
+    static checkFileExist(fileName) {
+        expect(Shell.test('-e', `${TESTS_EXECUTION_FOLDER}/${fileName}`)).toBe(true);
+    }
+
+    // Checks if file not exist in the TESTS_EXECUTION_FOLDER
+    static checkFileNotExist(fileName) {
+        expect(Shell.test('-e', `${TESTS_EXECUTION_FOLDER}/${fileName}`)).not.toBe(true);
+    }
+
+    static checkFileEqual(fileName, fileName2) {
+        expect(Shell.test('-e', `${TESTS_EXECUTION_FOLDER}/${fileName}`)).toBe(true);
+        expect(Shell.test('-e', `${TESTS_EXECUTION_FOLDER}/${fileName2}`)).toBe(true);
+        let file = Shell.cat(`${TESTS_EXECUTION_FOLDER}/${fileName}`);
+        let file2 = Shell.cat(`${TESTS_EXECUTION_FOLDER}/${fileName2}`);
+        expect(file).toEqual(file2);
+    }
+
+    static projectCreate(dg, dfile = 'device.nut', afile = 'agent.nut') {
+        return ImptTestHelper.runCommand(`impt project link -g ${dg} -x ${dfile}  -y ${afile} -q`, ImptTestHelper.emptyCheckEx);
+    }
+
+    static projectDelete() {
+        return ImptTestHelper.runCommand(`impt project delete -f -q`, ImptTestHelper.emptyCheckEx);
+    }
+
+    static deviceAssign(dg) {
+        return ImptTestHelper.runCommand(`impt device assign -d ${config.devices[config.deviceidx]} -g ${dg} -q`, ImptTestHelper.emptyCheckEx);
+    }
+
+    static deviceRestart() {
+        return ImptTestHelper.runCommand(`impt device restart -d ${config.devices[config.deviceidx]}`, ImptTestHelper.emptyCheckEx);
+    }
+
+    static deviceUnassign(dg) {
+        return ImptTestHelper.runCommand(`impt dg unassign -g ${dg}`, ImptTestHelper.emptyCheckEx);
+    }
+
+    // Checks success return code of the command
+    static checkSuccessStatus(commandOut) {
+        expect(commandOut.code).toEqual(0);
+    }
+
+    // Checks fail return code of the command
+    static checkFailStatus(commandOut) {
+        expect(commandOut.output).not.toMatch(UserInteractor.ERRORS.ACCESS_FAILED);
+        expect(commandOut.code).not.toEqual(0);
+    }
+
+    // Does not check command status, just check 'Access to impCentral failed or timed out' error doesn't occur.
+    static emptyCheck(commandOut) {
+        expect(commandOut.output).not.toMatch(UserInteractor.ERRORS.ACCESS_FAILED);
+    }
+
+    // Checks if the command output contains the specified attribute name and value
+    static checkAttribute(commandOut, attrName, attrValue) {
+        expect(commandOut.output).toMatch(new RegExp(`${attrName}"?:\\s+"?${attrValue.replace(new RegExp(/"/g), '\\\\?"')}"?`));
+    }
+
+    // Checks if the command output contains the specified message for default or debug output mode
+    static checkOutputMessage(outputMode, commandOut, message) {
+        const matcher = outputMode.match('-(z|-output)\\s+(json|minimal)');
+        if (matcher && matcher.length) expect(true).toBeTrue;
+        else expect(commandOut.output).toMatch(new RegExp(message.replace(new RegExp(/[()\\]/g), `\\$&`).replace(new RegExp(/"/g), '\\\\?"')));
+    }
+
+    // parse ID from command output and return id value if success, otherwise return null
+    static parseId(commandOut) {
+        const idMatcher = commandOut.output.match(new RegExp(`${ImptTestHelper.ATTR_ID}"?:\\s+"?([A-Za-z0-9-]+)`));
+        if (idMatcher && idMatcher.length > 1) {
+            return idMatcher[1];
+        }
+        else return null;
+    }
+
+    // parse sha from command output and return sha value if success, otherwise return null
+    static parseSha(commandOut) {
+        const idMatcher = commandOut.output.match(new RegExp(`sha"?:\\s+"?([A-Za-z0-9]{64})`));
+        if (idMatcher && idMatcher.length > 1) {
+            return idMatcher[1];
+        }
+        else return null;
+    }
+}
+
+module.exports = ImptTestHelper;