doc-detective 1.2.2 → 1.2.4

package/README.md

@@ -298,6 +298,7 @@ Format:
 | `responseHeaders` | Optional. A non-exhaustive object of headers that should be included in the response. If a specified header is missing, or if a specified header value is incorrect, the action fails. If the response headers include headers that aren't specified by this option, the test can still pass. <br> Supports setting the whole headers object and individual header values from environment variables.   | <ul><li>`{ "Content-Type": "application/json" }`</li><li>`$RESPONSE_HEADERS`</li><li>`{ "Content-Type": "$CONTENT_TYPE" }`</li></ul>                                                       |
 | `responseData`    | Optional. A non-exhaustive data object that should be included in the response. If a specified data field is missing, or if a specified value is incorrect, the action fails. If the response data payload includes additional fields that aren't specified by this option, the test can still pass. <br> Supports setting the whole data object and individual data values from environment variables. | <ul><li>`{ "id": 1, "last_name": "Washington" }`</li><li>`"$REQUEST_DATA"`</li><li>`{ "id": 1, "last_name": "$LAST_NAME" }`</li></ul>                                                      |
 | `statusCodes`     | Optional. An array of accepted HTTP status response codes. Defaults to `[200]`. If the response's status code isn't included in this array, the action fails.                                                                                                                                                                                                                                           | [ 200, 204 ]                                                                                                                                                                               |
+| `envsFromResponseData` | Optional. An array of environment variables to dynamically set from response data using [`jq`](https://stedolan.github.io/jq/) filters to select and transform the JSON data.<br><br>`name` values can contain uppercase letters, lowercase letters, numbers and underscores, but **don't** include a leading "$". | <code>[ { "name": "FIRST_NAME", "jqFilter": ".first_name" } ]</code>
 
 ### Check a link
 
@@ -363,6 +364,8 @@ Format:
 
 ## Analytics
 
+**Note:** Analytics is currently turned off globally.
+
 By default, Doc Detective doesn't collect any information about tests, devices, users, or documentation and doesn't check in with any external service or server. If you want to help inform decisions about the future development of Doc Detective—such as feature development and documentation creation—you can opt into sending anonymized analytics after you run tests at one of the multiple levels of detail.
 
 There are multiple ways to turn on analytics:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doc-detective",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Unit test documentation (and record videos of those tests).",
   "main": "src/index.js",
   "scripts": {
@@ -32,6 +32,7 @@
     "git": "^0.1.5",
     "gnumake": "^0.3.5",
     "n-readlines": "^1.0.1",
+    "node-jq": "^2.3.4",
     "pixelmatch": "^5.3.0",
     "pngjs": "^6.0.0",
     "prompt-sync": "^4.2.0",
@@ -43,4 +44,4 @@
   "devDependencies": {
     "make": "^0.8.1"
   }
-}
+}

package/sample/results.json

@@ -2,8 +2,6 @@
   "tests": [
     {
       "id": "process-search-kittens",
-      "saveFailedTestRecordings": true,
-      "failedTestDirectory": "sample",
       "actions": [
         {
           "action": "goTo",
@@ -13,49 +11,6 @@
             "description": "Opened URI."
           }
         },
-        {
-          "action": "startRecording",
-          "overwrite": false,
-          "filename": "results.gif",
-          "fps": 15,
-          "result": {
-            "status": "PASS",
-            "description": "Started recording: /config/workspace/doc-detective/sample/temp_results.mp4",
-            "video": "/config/workspace/doc-detective/sample/temp_results.mp4"
-          }
-        },
-        {
-          "action": "moveMouse",
-          "css": "#gbqfbb",
-          "alignH": "center",
-          "alignV": "center",
-          "offsetX": 0,
-          "offsetY": 0,
-          "result": {
-            "status": "PASS",
-            "description": "Moved mouse to element."
-          }
-        },
-        {
-          "action": "wait",
-          "duration": "5000",
-          "result": {
-            "status": "PASS",
-            "description": "Wait complete."
-          }
-        },
-        {
-          "action": "moveMouse",
-          "css": "[title=Search]",
-          "alignV": "center",
-          "alignH": "center",
-          "offsetX": 0,
-          "offsetY": 0,
-          "result": {
-            "status": "PASS",
-            "description": "Moved mouse to element."
-          }
-        },
         {
           "action": "type",
           "css": "[title=Search]",
@@ -74,21 +29,6 @@
             "description": "Wait complete."
           }
         },
-        {
-          "action": "scroll",
-          "y": 300,
-          "result": {
-            "status": "PASS",
-            "description": "Scroll complete."
-          }
-        },
-        {
-          "action": "stopRecording",
-          "result": {
-            "status": "PASS",
-            "description": "Stopped recording: /config/workspace/doc-detective/sample/results.gif"
-          }
-        },
         {
           "action": "screenshot",
           "filename": "results.png",

package/src/config.json

@@ -35,47 +35,65 @@
       "actionStatementClose": ")",
       "markup": {
         "onscreenText": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "\\*\\*.+?\\*\\*"
           ]
         },
         "emphasis": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?<!\\*)\\*(?!\\*).+?(?<!\\*)\\*(?!\\*)"
           ]
         },
         "image": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "!\\[.+?\\]\\(.+?\\)"
           ]
         },
         "hyperlink": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?<!!)\\[.+?\\]\\(.+?\\)"
           ]
         },
         "orderedList": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?<=\n) *?[0-9][0-9]?[0-9]?.\\s*.*"
           ]
         },
         "unorderedList": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?<=\n) *?\\*.\\s*.*",
             "(?<=\n) *?-.\\s*.*"
           ]
         },
         "codeInline": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?<!`)`(?!`).+?(?<!`)`(?!`)"
           ]
         },
         "codeBlock": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(```))(\\w|\\W)*(?<=```)"
           ]
         },
         "interaction": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "[cC]lick",
             "[tT]ap",
@@ -106,46 +124,64 @@
       "actionStatementClose": "-->",
       "markup": {
         "onscreenText": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<b))(\\w|\\W)*(?<=<\/b>)"
           ]
         },
         "emphasis": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<i))(\\w|\\W)*(?<=<\/i>)"
           ]
         },
         "image": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<img))(\\w|\\W)*(?<=<\/img>|>)"
           ]
         },
         "hyperlink": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<a))(\\w|\\W)*(?<=<\/a>)"
           ]
         },
         "orderedList": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<ol))(\\w|\\W)*(?<=<\/ol>)"
           ]
         },
         "unorderedList": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<ul))(\\w|\\W)*(?<=<\/ul>)"
           ]
         },
         "codeInline": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<code))(\\w|\\W)*(?<=<\/code>)"
           ]
         },
         "codeBlock": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "(?=(<pre))(\\w|\\W)*(?<=<\/pre>)"
           ]
         },
         "interaction": {
+          "includeInCoverage": true,
+          "includeInSuggestions": true,
           "regex": [
             "[cC]lick",
             "[tT]ap",

package/src/index.js

@@ -13,11 +13,12 @@ const { reportCoverage } = require("./lib/coverage");
 const { suggestTests, runSuggestions } = require("./lib/suggest");
 const { exit } = require("process");
 
-exports.run = main;
+exports.run = test;
+exports.test = test;
 exports.coverage = coverage;
 exports.suggest = suggest;
 
-async function main(config, argv) {
+async function test(config, argv) {
   // Set args
   argv = setArgs(argv);
   log(config, "debug", `ARGV:`);
@@ -50,6 +51,8 @@ async function main(config, argv) {
   if (config.analytics.send) {
     // sendAnalytics(config, results);
   }
+
+  return results;
 }
 
 async function coverage(config, argv) {
@@ -82,6 +85,8 @@ async function coverage(config, argv) {
 
   // Output
   outputResults(config.coverageOutput, coverageReport, config);
+
+  return coverageReport;
 }
 
 async function suggest(config, argv) {
@@ -120,4 +125,6 @@ async function suggest(config, argv) {
     suggestionReport,
     config
   );
+
+  return suggestionReport;
 }

package/src/lib/analysis.js

@@ -204,6 +204,8 @@ function checkMarkupCoverage(config, testCoverage) {
     // Only keep marks that have a truthy (>0) length
     Object.keys(markup).forEach((mark) => {
       markCoverage = {
+        includeInCoverage: markup[mark].includeInCoverage,
+        includeInSuggestions: markup[mark].includeInSuggestions,
         coveredLines: [],
         coveredMatches: [],
         uncoveredLines: [],

package/src/lib/coverage.js

@@ -21,30 +21,32 @@ function reportCoverage(config, markupCoverage) {
       uncovered: 0,
     };
     Object.keys(file.markup).forEach((mark) => {
-      if (typeof report.summary[mark] === "undefined") {
-        report.summary[mark] = {
-          covered: 0,
-          uncovered: 0,
+      if (file.markup[mark].includeInCoverage) {
+        if (typeof report.summary[mark] === "undefined") {
+          report.summary[mark] = {
+            covered: 0,
+            uncovered: 0,
+          };
+        }
+        report.summary.covered =
+          report.summary.covered + file.markup[mark].coveredLines.length;
+        report.summary.uncovered =
+          report.summary.uncovered + file.markup[mark].uncoveredLines.length;
+        report.summary[mark].covered =
+          report.summary[mark].covered + file.markup[mark].coveredLines.length;
+        report.summary[mark].uncovered =
+          report.summary[mark].uncovered +
+          file.markup[mark].uncoveredLines.length;
+        fileJson.covered =
+          fileJson.covered + file.markup[mark].coveredLines.length;
+        fileJson.uncovered =
+          fileJson.uncovered + file.markup[mark].uncoveredLines.length;
+        fileJson[mark] = {
+          covered: file.markup[mark].coveredLines.length,
+          uncovered: file.markup[mark].uncoveredLines.length,
+          uncoveredMatches: file.markup[mark].uncoveredMatches,
         };
       }
-      report.summary.covered =
-        report.summary.covered + file.markup[mark].coveredLines.length;
-      report.summary.uncovered =
-        report.summary.uncovered + file.markup[mark].uncoveredLines.length;
-      report.summary[mark].covered =
-        report.summary[mark].covered + file.markup[mark].coveredLines.length;
-      report.summary[mark].uncovered =
-        report.summary[mark].uncovered +
-        file.markup[mark].uncoveredLines.length;
-      fileJson.covered =
-        fileJson.covered + file.markup[mark].coveredLines.length;
-      fileJson.uncovered =
-        fileJson.uncovered + file.markup[mark].uncoveredLines.length;
-      fileJson[mark] = {
-        covered: file.markup[mark].coveredLines.length,
-        uncovered: file.markup[mark].uncoveredLines.length,
-        uncoveredMatches: file.markup[mark].uncoveredMatches,
-      };
     });
     report.files.push(fileJson);
   });

package/src/lib/suggest.js

@@ -599,10 +599,12 @@ function transformMatches(fileMarkupObject) {
   matches = [];
   // Load array with uncovered matches
   Object.keys(fileMarkupObject).forEach((mark) => {
-    fileMarkupObject[mark].uncoveredMatches.forEach((match) => {
-      match.type = mark;
-      matches.push(match);
-    });
+    if (fileMarkupObject[mark].includeInSuggestions) {
+      fileMarkupObject[mark].uncoveredMatches.forEach((match) => {
+        match.type = mark;
+        matches.push(match);
+      });
+    }
   });
   // Sort matches by line, then index
   matches.sort((a, b) => a.line - b.line || a.indexInFile - b.indexInFile);

package/src/lib/tests/goTo.js

@@ -1,4 +1,4 @@
-const { setEnvs } = require("../utils");
+const { setEnvs, loadEnvs } = require("../utils");
 
 exports.goTo = goTo;
 
@@ -17,14 +17,8 @@ async function goTo(action, page) {
     let result = await setEnvs(action.env);
     if (result.status === "FAIL") return { result };
   }
-  if (
-    action.uri[0] === "$" &&
-    process.env[action.uri.substring(1)] != undefined
-  ) {
-    uri = process.env[action.uri.substring(1)];
-  } else {
-    uri = action.uri;
-  }
+  uri = loadEnvs(action.uri);
+
   // Catch common formatting errors
   if (!uri.includes("://")) uri = "https://" + uri;
   // Run action

package/src/lib/tests/httpRequest.js

@@ -1,9 +1,11 @@
 const axios = require("axios");
-const { setEnvs, loadEnvsForObject } = require("../utils");
+const jq = require("node-jq");
+const { exit } = require("process");
+const { setEnvs, loadEnvs, log } = require("../utils");
 
 exports.httpRequest = httpRequest;
 
-async function httpRequest(action) {
+async function httpRequest(action, config) {
   const methods = ["get", "post", "put", "patch", "delete"];
 
   let status;
@@ -17,12 +19,13 @@ async function httpRequest(action) {
   let defaultPayload = {
     uri: "",
     method: "get",
-    headers: {},
-    params: {},
+    requestHeaders: {},
+    requestParams: {},
     requestData: {},
     responseHeaders: {},
     responseData: {},
     statusCodes: ["200"],
+    envsFromResponseData: [],
   };
 
   // Load environment variables
@@ -33,11 +36,8 @@ async function httpRequest(action) {
 
   // URI
   //// Define
-  if (action.uri[0] === "$") {
-    uri = process.env[action.uri.substring(1)];
-  } else {
-    uri = action.uri || defaultPayload.uri;
-  }
+  uri = loadEnvs(action.uri) || defaultPayload.uri;
+
   //// Validate
   if (!uri || typeof uri != "string") {
     //Fail
@@ -50,11 +50,8 @@ async function httpRequest(action) {
 
   // Method
   //// Define
-  if (action.method && action.method[0] === "$") {
-    method = process.env[action.method.substring(1)];
-  } else {
-    method = action.method || defaultPayload.method;
-  }
+  method = loadEnvs(action.method) || defaultPayload.method;
+
   //// Sanitize
   method = method.toLowerCase();
   //// Validate
@@ -69,54 +66,40 @@ async function httpRequest(action) {
   request.method = method;
 
   // Headers
-  if (action.headers && JSON.stringify(action.headers) != "{}") {
+  if (
+    (action.requestHeaders && JSON.stringify(action.requestHeaders) != "{}") ||
+    (action.headers && JSON.stringify(action.headers) != "{}")
+  ) {
     //// Define
-    if (action.headers[0] === "$") {
-      headers = process.env[action.headers.substring(1)];
-      try {
-        headers = JSON.parse(headers);
-      } catch {}
-    } else {
-      headers = action.headers || defaultPayload.headers;
-    }
-    //// Load environment variables
-    headers = loadEnvsForObject(headers);
+    requestHeaders =
+      loadEnvs(action.requestHeaders) ||
+      loadEnvs(action.headers) ||
+      defaultPayload.requestHeaders;
+
     //// Validate
     //// Set request
-    if (JSON.stringify(headers) != "{}") request.headers = headers;
+    if (JSON.stringify(requestHeaders) != "{}")
+      request.headers = requestHeaders;
   }
 
   // Params
-  if (action.params && JSON.stringify(action.params) != "{}") {
+  if ((action.requestParams && JSON.stringify(action.requestParams) != "{}") || (action.params && JSON.stringify(action.params) != "{}")) {
     //// Define
-    if (action.params[0] === "$") {
-      params = process.env[action.params.substring(1)];
-      try {
-        params = JSON.parse(params);
-      } catch {}
-    } else {
-      params = action.params || defaultPayload.params;
-    }
-    //// Load environment variables
-    params = loadEnvsForObject(params);
+    requestParams =
+      loadEnvs(action.requestParams) ||
+      loadEnvs(action.params) ||
+      defaultPayload.requestParams;
+
     //// Validate
     //// Set request
-    if (params != {}) request.params = params;
+    if (JSON.stringify(requestParams) != "{}") request.params = requestParams;
   }
 
   // requestData
   if (action.requestData) {
     //// Define
-    if (action.requestData[0] === "$") {
-      requestData = process.env[action.requestData.substring(1)];
-      try {
-        requestData = JSON.parse(requestData);
-      } catch {}
-    } else {
-      requestData = action.requestData || defaultPayload.requestData;
-    }
-    //// Load environment variables
-    requestData = loadEnvsForObject(requestData);
+    requestData = loadEnvs(action.requestData) || defaultPayload.requestData;
+
     //// Validate
     //// Set request
     if (requestData != {}) request.data = requestData;
@@ -124,30 +107,15 @@ async function httpRequest(action) {
 
   // responseData
   //// Define
-  if (action.responseData && action.responseData[0] === "$") {
-    responseData = process.env[action.responseData.substring(1)];
-    try {
-      responseData = JSON.parse(responseData);
-    } catch {}
-  } else {
-    responseData = action.responseData || defaultPayload.responseData;
-  }
-  //// Load environment variables
-  responseData = loadEnvsForObject(responseData);
+  responseData = loadEnvs(action.responseData) || defaultPayload.responseData;
+
   //// Validate
 
   // responseHeaders
   //// Define
-  if (action.responseHeaders && action.responseHeaders[0] === "$") {
-    responseHeaders = process.env[action.responseHeaders.substring(1)];
-    try {
-      responseHeaders = JSON.parse(responseHeaders);
-    } catch {}
-  } else {
-    responseHeaders = action.responseHeaders || defaultPayload.responseHeaders;
-  }
-  //// Load environment variables
-  responseHeaders = loadEnvsForObject(responseHeaders);
+  responseHeaders =
+    loadEnvs(action.responseHeaders) || defaultPayload.responseHeaders;
+
   //// Validate
 
   // Status codes
@@ -161,6 +129,34 @@ async function httpRequest(action) {
   //// Validate
   if (statusCodes === []) statusCodes = defaultPayload.statusCodes;
 
+  // Envs from response data
+  //// Define
+  envsFromResponseData =
+    action.envsFromResponseData || defaultPayload.envsFromResponseData;
+  //// Sanitize
+  for (i = 0; i < envsFromResponseData.length; i++) {
+    if (typeof statusCodes[i] === "string")
+      statusCodes[i] = Number(statusCodes[i]);
+  }
+  //// Validate
+  let validEnvs = envsFromResponseData.every(
+    (env) =>
+      typeof env === "object" &&
+      env.name.match(/^[a-zA-Z0-9_]+$/gm) &&
+      typeof env.jqFilter === "string" &&
+      env.jqFilter.length > 1
+  );
+  if (!validEnvs) {
+    envsFromResponseData = [];
+    log(
+      config,
+      "warning",
+      "Not setting environment variables. One or more invalid variable definitions."
+    );
+  }
+  if (envsFromResponseData === [])
+    envsFromResponseData = defaultPayload.envsFromResponseData;
+
   // Send request
   response = await axios(request)
     .then((response) => {
@@ -173,7 +169,7 @@ async function httpRequest(action) {
   // If request returned an error
   if (response.error) {
     status = "FAIL";
-    description = `Error: ${JSON.stringify(response.error.response)}`;
+    description = `Error: ${JSON.stringify(response.error.message)}`;
     result = { status, description };
     return { result };
   }
@@ -211,12 +207,30 @@ async function httpRequest(action) {
       description =
         description +
         ` Expected response headers were present in actual response headers.`;
-    } else {
       status = "FAIL";
+    } else {
       description = description + " " + dataComparison.result.description;
     }
   }
 
+  // Set environment variables from response data
+  for (const variable of envsFromResponseData) {
+    let value = await jq.run(variable.jqFilter, response.data, {
+      input: "json",
+      output: "compact",
+    });
+    if (value) {
+      process.env[variable.name] = value;
+      description =
+        description + ` Set '$${variable.name}' environment variable.`;
+    } else {
+      if (status != "FAIL") status = "WARNING";
+      description =
+        description +
+        ` Couldn't set '${variable.name}' environment variable. The jq filter (${variable.jqFilter}) returned a null result.`;
+    }
+  }
+
   description = description.trim();
   result = { status, description };
   return { result };

package/src/lib/tests.js

@@ -2,7 +2,7 @@ const puppeteer = require("puppeteer");
 const fs = require("fs");
 const { exit, stdout, exitCode } = require("process");
 const { installMouseHelper } = require("./install-mouse-helper");
-const { setEnvs, log, timestamp } = require("./utils");
+const { setEnvs, log, timestamp, loadEnvs } = require("./utils");
 const util = require("util");
 const exec = util.promisify(require("child_process").exec);
 const axios = require("axios");
@@ -320,7 +320,7 @@ async function runAction(config, action, page, videoDetails) {
       result = await checkLink(action);
       break;
     case "httpRequest":
-      result = await httpRequest(action);
+      result = await httpRequest(action, config);
       break;
   }
   return result;
@@ -337,14 +337,7 @@ async function checkLink(action) {
     let result = await setEnvs(action.env);
     if (result.status === "FAIL") return { result };
   }
-  if (
-    action.uri[0] === "$" &&
-    process.env[action.uri.substring(1)] != undefined
-  ) {
-    uri = process.env[action.uri.substring(1)];
-  } else {
-    uri = action.uri;
-  }
+  uri = loadEnvs(action.uri);
 
   // Validate protocol
   if (uri.indexOf("://") < 0) {
@@ -393,15 +386,20 @@ async function runShell(action) {
   let description;
   let result;
   let exitCode;
+  let command;
 
-  // Load environment variables
+  // Set environment variables
   if (action.env) {
     let result = await setEnvs(action.env);
     if (result.status === "FAIL") return { result };
   }
 
+  // Command
+  //// Load envs
+  command = loadEnvs(action.command);
+
   // Promisify and execute command
-  const promise = exec(action.command);
+  const promise = exec(command);
   const child = promise.child;
   child.on("close", function (code) {
     exitCode = code;
@@ -474,15 +472,9 @@ async function typeElement(action, elementHandle) {
   }
   // Type keys
   if (action.keys) {
-    // Detect if using an environment variable and sub in value
-    if (
-      action.keys[0] === "$" &&
-      process.env[action.keys.substring(1)] != undefined
-    ) {
-      keys = process.env[action.keys.substring(1)];
-    } else {
-      keys = action.keys;
-    }
+    // Resolve environment variables in keys
+    keys = loadEnvs(action.keys);
+
     try {
       await elementHandle.type(keys);
     } catch {
@@ -547,14 +539,8 @@ async function matchText(action, page) {
     if (result.status === "FAIL") return { result };
   }
   // Set text
-  if (
-    action.text[0] === "$" &&
-    process.env[action.text.substring(1)] != undefined
-  ) {
-    text = process.env[action.text.substring(1)];
-  } else {
-    text = action.text;
-  }
+  text = loadEnvs(action.text);
+
   let elementTag = await page.$eval(action.css, (element) =>
     element.tagName.toLowerCase()
   );

package/src/lib/utils.js

@@ -17,6 +17,7 @@ exports.setEnvs = setEnvs;
 exports.loadEnvsForObject = loadEnvsForObject;
 exports.log = log;
 exports.timestamp = timestamp;
+exports.loadEnvs = loadEnvs;
 
 const analyticsRequest =
   "Thanks for using Doc Detective! If you want to contribute to the project, consider sending analytics to help us understand usage patterns and functional gaps. To turn on analytics, set 'analytics.send = true' in your config, or use the '-a true' argument. See https://github.com/hawkeyexl/doc-detective#analytics";
@@ -775,7 +776,7 @@ function setFiles(config) {
             // Is a file
             isFile &&
             // Isn't present in files array already
-            files.indexOf(s) < 0 &&
+            files.indexOf(content) < 0 &&
             // No extension filter or extension included in filter
             (config.testExtensions === "" ||
               config.testExtensions.includes(path.extname(content)))
@@ -1014,23 +1015,60 @@ async function log(config, level, message) {
   }
 }
 
-function loadEnvsForObject(object) {
-  Object.keys(object).forEach((key) => {
+function loadEnvs(stringOrObject) {
+  if (!stringOrObject) return stringOrObject;
+  // Try to convert string to object
+  try {
     if (
-      object[key][0] === "$" &&
-      process.env[object[key].substring(1)] != undefined
+      typeof stringOrObject === "string" &&
+      typeof JSON.parse(stringOrObject) === "object"
     ) {
-      object[key] = process.env[object[key].substring(1)];
+      stringOrObject = JSON.parse(stringOrObject);
     }
-    try {
-      if (typeof JSON.parse(object[key]) === "object") {
-        object[key] = JSON.parse(object[key]);
-      }
-    } catch {}
-    if (typeof object[key] === "object") {
-      object[key] = loadEnvsForObject(object[key]);
+  } catch {}
+  if (typeof stringOrObject === "object") {
+    // Load for object
+    stringOrObject = loadEnvsForObject(stringOrObject);
+  } else {
+    // Load for string
+    stringOrObject = loadEnvsForString(stringOrObject);
+  }
+  // Try to convert resolved string to object
+  try {
+    if (typeof JSON.parse(stringOrObject) === "object") {
+      stringOrObject = JSON.parse(stringOrObject);
+    }
+  } catch {}
+  return stringOrObject;
+}
+
+function loadEnvsForString(string) {
+  // Find all variables
+  variableRegex = new RegExp(/\$[a-zA-Z0-9_]+/, "g");
+  matches = string.match(variableRegex);
+  // If no matches, return
+  if (!matches) return string;
+  // Iterate matches
+  matches.forEach((match) => {
+    // Check if is declared variable
+    value = process.env[match.substring(1)];
+    if (value) {
+      // If variable value might have a nested variable, recurse to try to resolve
+      if (value.includes("$")) value = loadEnvs(value);
+      // Convert to string in case value was a substring of the greater string
+      if (typeof value === "object") value = JSON.stringify(value);
+      // Replace match with variable value
+      string = string.replace(match, value);
     }
   });
+  return string;
+}
+
+function loadEnvsForObject(object) {
+  Object.keys(object).forEach((key) => {
+    // Resolve all variables in key value
+    object[key] = loadEnvs(object[key]);
+  });
   return object;
 }