Merge pull request #33 from JaredCE/add-verbose-logging

Add verbose logging

Author: JaredCE

README.md

@@ -34,6 +34,9 @@ arazzo-runner -a arazzo.json -i input.json
 # With URL
 arazzo-runner -a https://example.com/arazzo.json -i ./input.json
 
+# With Verbose Logging
+arazzo-runner -a https://example.com/arazzo.json -i ./input.json --verbose
+
 # Show help
 arazzo-runner --help
 

cli.js

@@ -17,6 +17,9 @@ const options = {
     type: "string",
     short: "i",
   },
+  verbose: {
+    type: "boolean",
+  },
   help: {
     type: "boolean",
     short: "h",
@@ -40,6 +43,7 @@ OPTIONS:
   -i, --input <file>        Path to input JSON file (required)
   -h, --help                Show this help message
   -v, --version             Show version number
+  -vv, --verbose            Verbose Logging
 
 EXAMPLES:
   # Run with local files
@@ -139,7 +143,7 @@ async function main() {
   console.log("");
 
   try {
-    const runner = new Runner();
+    const runner = new Runner({ verbose: values?.verbose || false });
     await runner.runArazzo(arazzoPath, inputPath);
 
     console.log("");

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "arazzo-runner",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "A runner to run through Arazzo Document workflows",
   "main": "index.js",
   "scripts": {

package.json

@@ -343,8 +343,20 @@ class Arazzo extends Document {
 
     let response;
     if (this.operation?.mutualTLS) {
+      this.logger.verbose("Using mutualTLS call");
       response = await this.mutualTLS();
     } else {
+      this.logger.verbose("Using fetch call");
+
+      this.logger.verbose(`url: ${url}`);
+      this.logger.verbose(`method: ${options.method}`);
+      this.logger.verbose("headers:");
+      for (const [key, value] of options.headers.entries()) {
+        this.logger.verbose(`${key}: ${value}`);
+      }
+
+      this.logger.verbose(`body: ${options.body}`);
+
       response = await fetch(url, options);
     }
 
@@ -367,6 +379,7 @@ class Arazzo extends Document {
     let clientKeyPath;
     try {
       clientKeyPath = path.resolve(this.inputs.key);
+      this.logger.verbose(`clientKey Path: ${clientKeyPath}`);
     } catch (err) {
       this.logger.error(`could not resolve clientKey`);
       throw err;
@@ -375,6 +388,7 @@ class Arazzo extends Document {
     let clientCertPath;
     try {
       clientCertPath = path.resolve(this.inputs.cert);
+      this.logger.verbose(`clientCert Path: ${clientCertPath}`);
     } catch (err) {
       this.logger.error(`could not resolve clientCert`);
       throw err;
@@ -388,11 +402,17 @@ class Arazzo extends Document {
 
     const opUrl = new URL(url);
 
+    this.logger.verbose(`url: ${opUrl.pathname + opUrl.search}`);
+    this.logger.verbose(`method: ${this.operation.method}`);
+    this.logger.verbose("headers:");
     const headersObj = {};
     for (const [key, value] of this.operation.headers.entries()) {
+      this.logger.verbose(`${key}: ${value}`);
       Object.assign(headersObj, { [key]: value });
     }
 
+    this.logger.verbose(`body: ${this.operation.data}`);
+
     return new Promise((resolve, reject) => {
       const options = {
         key: fs.readFileSync(clientKeyPath),

src/Arazzo.js

@@ -6,6 +6,21 @@ const OpenAPI = require("./OpenAPI");
 class DocumentFactory {
   constructor() {}
 
+  /**
+   * Tests whether a string is a URL or not
+   * @private
+   * @param {string} str
+   * @returns
+   */
+  isUrl(str) {
+    try {
+      new URL(str);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Document Factory to create Arazzo or OpenAPI documents
    * @function buildDocument
@@ -23,7 +38,9 @@ class DocumentFactory {
       document = new Arazzo(path, name, options, this);
     }
 
-    await document.loadDocument();
+    if (this.isUrl(path)) {
+      await document.loadDocument();
+    } else document.setMainArazzo();
 
     return document;
   }

src/DocFactory.js

@@ -1,7 +1,8 @@
 "use strict";
 
 class Logger {
-  constructor() {
+  constructor(verboseLogging) {
+    this.verboseLogging = verboseLogging || false;
     this.logOutput = {
       debug: (message) => console.debug(message),
       error: (message) => console.error(`❌ ${message}`),
@@ -50,7 +51,7 @@ class Logger {
   }
 
   verbose(str) {
-    this.log(str, this.logTypes.VERBOSE);
+    if (this.verboseLogging) this.log(str, this.logTypes.VERBOSE);
   }
 
   warning(str) {

src/Logger.js

@@ -6,8 +6,9 @@ const Input = require("./Input");
 const Logger = require("./Logger");
 
 class Runner {
-  constructor(logger) {
-    this.logger = logger || new Logger();
+  constructor(options, logger) {
+    const verboseLogging = options?.verbose || false;
+    this.logger = logger || new Logger(verboseLogging);
   }
 
   /**

src/Runner.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const expect = require("chai").expect;
+const sinon = require("sinon");
 
 const Logger = require("../../src/Logger");
 
@@ -46,10 +47,40 @@ describe(`Logger`, function () {
   });
 
   describe(`verbose`, function () {
-    it(`should output the expected string`, function () {
+    it(`should output the expected string when verboseLogging is true`, function () {
+      const logger = new Logger(true);
+
+      const spy = sinon.spy(logger, "log");
+
+      logger.verbose("The expected string");
+
+      expect(spy.callCount).to.be.equal(1);
+
+      spy.restore();
+    });
+
+    it(`should output the expected string when verboseLogging is false`, function () {
+      const logger = new Logger(false);
+
+      const spy = sinon.spy(logger, "log");
+
+      logger.verbose("The expected string");
+
+      expect(spy.callCount).to.be.equal(0);
+
+      spy.restore();
+    });
+
+    it(`should output the expected string when verboseLogging is undefined`, function () {
       const logger = new Logger();
 
+      const spy = sinon.spy(logger, "log");
+
       logger.verbose("The expected string");
+
+      expect(spy.callCount).to.be.equal(0);
+
+      spy.restore();
     });
   });