@apica-io/asm-pm-runner/dist/cli/index.js

Run a postman collection in Apica ASM.

#! /usr/bin/env node
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs_1 = __importDefault(require("fs"));
const log4js = __importStar(require("log4js"));
const helpers = __importStar(require("../lib/helpers"));
const commander_1 = require("commander");
const newmanRunner_1 = require("../processor/newmanRunner");
function run(config) {
    return __awaiter(this, void 0, void 0, function* () {
        let exitCode = 0;
        try {
            let runner = new newmanRunner_1.NewmanRunner(config);
            runner.init();
            yield runner.run();
            runner.saveResult();
        }
        catch (error) {
            logger.error(error.message || error);
            console.error(error.message || error);
            exitCode = 1;
        }
        process.exit(exitCode);
    });
}
function checkDirectory(dir, name) {
    if (dir && (!fs_1.default.existsSync(dir) || !fs_1.default.lstatSync(dir).isDirectory())) {
        console.error("The specified %s directory %s is not valid", name || "", dir);
        process.exit(9);
    }
}
const cliLogConfig = {
    appenders: {
        out: {
            type: "stdout",
        },
    },
    categories: {
        default: { appenders: ["out"], level: "INFO" },
    },
};
var pack = helpers.getPackageInfo();
let version = pack.version || "version unknown";
let program = new commander_1.Command();
program.storeOptionsAsProperties(true);
let config = {};
program
    .option("-e, --environment <path>", "Environment JSON file")
    .option("-dk, --decryptKey <decryptKey>", "Decrypt key")
    .option('-ev, --envVars [envVars...]', 'Environment variables. Format name=value format')
    .option("-v, --verbose", "Print collection information on stdout", false)
    .option('-r, --resultDir <dir>', 'The result directory')
    .option('-dd, --dataDir <dir>', 'The data directory for certificates and test data')
    .option("-l, --logLevel <logLevel>", "Log level in log4js", "info")
    .option('--sslClientCert <path>', 'Specify the path to a client certificate (PEM)')
    .option('--sslClientKey <path>', 'Specify the path to a client certificate private key')
    .option('--sslClientPassphrase <passphrase>', 'Specify the client certificate passphrase (for protected key)')
    .arguments("<collection>");
program.version(version);
program.parse(process.argv);
let log_level = program.opts().logLevel || "info";
log_level = log_level.toUpperCase();
switch (log_level) {
    case "DEBUG":
    case "TRACE":
        break;
    case "ERROR":
    case "FATAL":
        break;
    default:
        log_level = "INFO";
        break;
}
cliLogConfig.categories.default.level = log_level;
log4js.configure(cliLogConfig);
var logger = log4js.getLogger(pack.name);
config.collection = program.args[0];
config.decryptKey = program.opts().decryptKey;
config.resultDir = program.opts().resultDir;
config.dataDir = program.opts().dataDir;
config.environment = program.opts().environment;
config.envVars = program.opts().envVars;
config.verbose = program.opts().verbose;
// SSL Config
config.sslConfig = {};
config.sslConfig.cert = program.opts().sslClientCert;
config.sslConfig.key = program.opts().sslClientKey;
config.sslConfig.passPhrase = program.opts().sslClientPassphrase;
logger.info("%s (%s) started", pack.name, version);
logger.debug("collection=%s", config.collection);
checkDirectory(config.resultDir, "result");
checkDirectory(config.dataDir, "data");
if (!fs_1.default.existsSync(config.collection) || !fs_1.default.lstatSync(config.collection).isFile()) {
    console.error("The specified collection file %s does not exist", config.collection);
    process.exit(9);
}
try {
    run(config);
}
catch (e) {
    logger.error(e);
    console.error(e);
}
//# sourceMappingURL=index.js.map