eleventy-test 1.1.0 → 1.2.0

package/README.md

@@ -26,7 +26,8 @@ Want to see how it is in action? For the dogfooding fans, you can see this libra
 
     const resultsAsDict = await buildScenarios({
         projectRoot: cwd(),
-        returnArray: false
+        returnArray: false,
+        enableDebug: false
     });
 
     test("Check if index.html is consistent across builds", async t => {

package/dist/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function setDebug(enabled: any): void;
+export default function debug(...message: any[]): void;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ interface IbuildScenariosArgs {
     returnArray?: boolean;
     scenariosDir?: string;
     globalInputDir?: string;
+    enableDebug?: boolean;
 }
 interface IbuildScenariosArrayArgs extends IbuildScenariosArgs {
     returnArray?: true;

package/dist/index.js

@@ -37,6 +37,17 @@ var import_promises = require("fs/promises");
 var import_path2 = require("path");
 var import_process = require("process");
 
+// src/debug.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function debug(...message) {
+  if (debugEnabled) {
+    message.forEach((msg) => console.log(msg));
+  }
+}
+
 // src/ScenarioOutput.ts
 var import_path = require("path");
 var import_fs = require("fs");
@@ -77,6 +88,9 @@ var ScenarioOutput = class {
   }
   getFileContent(filename) {
     return new Promise(async (resolve, reject) => {
+      if (!Object.keys(this._files).includes(filename)) {
+        throw new Error(`Can't find "${filename}" in files. Available files: ${Object.keys(this._files).join(", ")}`);
+      }
       if (!Object.keys(this.cache).includes(filename)) {
         this.cache[filename] = this._files[filename]();
       }
@@ -87,28 +101,38 @@ var ScenarioOutput = class {
 
 // src/eleventyUtils.ts
 async function determineInstalledEleventyVersions(projectRoot = (0, import_process.cwd)()) {
-  let eleventyPkgs = await (0, import_promises.readdir)((0, import_path2.join)(projectRoot, "node_modules/@11ty/"));
-  const eleventyRegex = new RegExp(/eleventy(\d|$)/m);
-  eleventyPkgs = eleventyPkgs.filter((name) => eleventyRegex.test(name));
+  const eleventyPkgsDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/");
   const versions2 = {};
-  for (let i = 0; i < eleventyPkgs.length; i++) {
-    const eleventyPkg = eleventyPkgs[i];
-    const eleventyPkgDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/", eleventyPkg);
-    const version = JSON.parse(
-      await (0, import_promises.readFile)(
-        (0, import_path2.join)(eleventyPkgDir, "package.json"),
-        { encoding: "utf-8" }
-      )
-    ).version;
-    versions2[version] = eleventyPkgDir;
+  debug("Determining installed Eleventy versions in " + eleventyPkgsDir);
+  if ((0, import_fs2.existsSync)(eleventyPkgsDir)) {
+    let eleventyPkgs = await (0, import_promises.readdir)(eleventyPkgsDir);
+    debug(`Found the followintg installed packages from @11ty: ${eleventyPkgs}`);
+    const eleventyRegex = new RegExp(/eleventy(\d|$)/m);
+    eleventyPkgs = eleventyPkgs.filter((name) => eleventyRegex.test(name));
+    debug(`Filtered non-main-eleventy packages. Results: ${eleventyPkgs}`);
+    for (let i = 0; i < eleventyPkgs.length; i++) {
+      const eleventyPkg = eleventyPkgs[i];
+      const eleventyPkgDir = (0, import_path2.join)(projectRoot, "node_modules/@11ty/", eleventyPkg);
+      const version = JSON.parse(
+        await (0, import_promises.readFile)(
+          (0, import_path2.join)(eleventyPkgDir, "package.json"),
+          { encoding: "utf-8" }
+        )
+      ).version;
+      versions2[version] = eleventyPkgDir;
+      debug(`Found ${version} at ${eleventyPkgDir}`);
+    }
   }
   return versions2;
 }
 async function installEleventyIfPkgManagerFound(eleventyVersion, projectRoot, filename, command) {
+  debug(`Attempting to find a package manager to install Eleventy ${eleventyVersion} with`);
   return new Promise(async (resolve, reject) => {
     if ((0, import_fs2.existsSync)((0, import_path2.join)(projectRoot, filename))) {
       try {
+        debug("Running Eleventy " + eleventyVersion);
         (0, import_child_process.execSync)(`${command} @11ty/eleventy${eleventyVersion}@npm:@11ty/eleventy@${eleventyVersion}`, { cwd: projectRoot });
+        debug("Done running Eleventy " + eleventyVersion);
         resolve(true);
       } catch (e) {
         throw e;
@@ -120,6 +144,7 @@ async function installEleventyIfPkgManagerFound(eleventyVersion, projectRoot, fi
   });
 }
 async function ensureEleventyExists(projectRoot, eleventyVersion) {
+  debug(`Ensuring Eleventy ${eleventyVersion} exists`);
   return new Promise(async (resolve, reject) => {
     const versions2 = await determineInstalledEleventyVersions(projectRoot);
     if (Object.keys(versions2).includes(eleventyVersion)) {
@@ -154,8 +179,11 @@ async function buildEleventy({
   projectRoot = (0, import_process.cwd)(),
   globalInputDir
 }) {
+  debug("Running buildEleventy", "scenarioDir: " + scenarioDir, "Eleventy version: " + eleventyVersion);
   return new Promise(async (resolve, reject) => {
+    debug("Finding package for Eleventy " + eleventyVersion);
     const eleventyDir = await ensureEleventyExists(projectRoot, eleventyVersion);
+    debug("Found pacakge for Eleventy " + eleventyVersion);
     const bin = JSON.parse(
       await (0, import_promises.readFile)(
         (0, import_path2.join)(eleventyDir, "package.json"),
@@ -163,24 +191,27 @@ async function buildEleventy({
       )
     ).bin.eleventy;
     const pathToBin = (0, import_path2.join)(eleventyDir, bin);
+    debug(`Found entrypoint for Eleventy ${eleventyVersion} at ${pathToBin}`);
     const scenarioInputDir = (0, import_path2.join)(scenarioDir, "input");
     let inputDir;
-    try {
-      await (0, import_promises.access)(scenarioInputDir);
+    debug(`Checking whether to use scenario (${scenarioInputDir}) or global input (${globalInputDir})...`);
+    if ((0, import_fs2.existsSync)(scenarioInputDir)) {
+      debug("Using scenario input");
       inputDir = scenarioInputDir;
-    } catch {
-      try {
-        await (0, import_promises.access)(globalInputDir);
-        inputDir = globalInputDir;
-      } catch {
-      }
+    } else if ((0, import_fs2.existsSync)(globalInputDir)) {
+      debug("Using global input dir");
+      inputDir = globalInputDir;
     }
+    debug("inputDir: " + inputDir);
     if (inputDir == void 0) {
-      throw Error("inputDir is undefined!");
+      throw new Error("inputDir is undefined! Either create a global input dir or one for the scenario specifically");
     }
     const outputDir = (0, import_path2.join)(scenarioDir, "eleventy-test-out");
+    debug("Cleaning old test output");
     await (0, import_promises.rm)(outputDir, { force: true, recursive: true });
+    debug("Cleaned");
     try {
+      debug("Creating Eleventy process...");
       const out = (0, import_child_process.fork)(
         pathToBin,
         ["--input", inputDir, "--output", outputDir],
@@ -190,6 +221,7 @@ async function buildEleventy({
         console.log(msg);
       });
       out.on("close", async (code) => {
+        debug(`Eleventy ${eleventyVersion}/${scenarioName} finished`);
         resolve(new ScenarioOutput(outputDir, scenarioName));
       });
     } catch (e) {
@@ -199,13 +231,16 @@ async function buildEleventy({
 }
 
 // src/index.ts
+var import_fs3 = require("fs");
 var versions;
 async function scenarioDirnameToEleventyVersion(scenarioDirname) {
   let eleventyVersion = scenarioDirname.includes("--") ? scenarioDirname.split("--")[0] : scenarioDirname;
+  debug(`eleventyVersion from dirname: ${eleventyVersion}`);
   if (eleventyVersion.length < 5) {
+    debug("eleventyVersion length is under 5, and as such not a full semantic version. Determining latest...");
     const scenarioMajorVersion = scenarioDirname[0];
     if (versions == void 0) {
-      console.log("Pulling Eleventy tags...");
+      debug("Pulling Eleventy tags...");
       versions = await new Promise((resolve, reject) => {
         (0, import_https.get)({
           hostname: "api.github.com",
@@ -218,7 +253,7 @@ async function scenarioDirnameToEleventyVersion(scenarioDirname) {
           res.on("data", (chunk) => {
             data.push(chunk);
           }).on("end", () => {
-            console.log("Parsing API response...");
+            debug("Parsing Eleventy tags API response...");
             resolve(
               JSON.parse(
                 Buffer.concat(data).toString("utf-8")
@@ -232,30 +267,36 @@ async function scenarioDirnameToEleventyVersion(scenarioDirname) {
     }
     for (let i = 0; i < versions.length; i++) {
       const version = versions[i];
+      debug("Checking " + version);
       if (!version.name.includes("-") && version.name[1] == scenarioMajorVersion) {
         eleventyVersion = version.name.substring(1);
+        debug("Determined latest of relevant major version for: " + eleventyVersion);
         break;
       }
     }
   }
   return eleventyVersion;
 }
-async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir = "tests/input" }) {
+async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), returnArray = true, scenariosDir = "tests/scenarios/", globalInputDir: passedGlobalInputDir = "tests/input", enableDebug = false }) {
+  setDebug(enableDebug);
+  debug("If you can see this, debugging has been enabled. Starting buildScenarios");
   return new Promise(async (resolve, reject) => {
     scenariosDir = (0, import_path3.isAbsolute)(scenariosDir) ? scenariosDir : (0, import_path3.join)(projectRoot, scenariosDir);
-    globalInputDir = (0, import_path3.isAbsolute)(globalInputDir) ? globalInputDir : (0, import_path3.join)(projectRoot, globalInputDir);
-    try {
-      await (0, import_promises2.access)(globalInputDir);
-    } catch {
-      globalInputDir = "undefined";
+    let globalInputDir = (0, import_path3.isAbsolute)(passedGlobalInputDir) ? passedGlobalInputDir : (0, import_path3.join)(projectRoot, passedGlobalInputDir);
+    if (globalInputDir) {
+      globalInputDir = (0, import_fs3.existsSync)(globalInputDir) ? globalInputDir : void 0;
     }
+    debug(`scenariosDir: ${scenariosDir}`, `globalInputDir: ${globalInputDir}`);
     try {
       const scenarioDirs = await (0, import_promises2.readdir)(scenariosDir, { recursive: false, encoding: "utf-8" });
       const scenarioOutputs = [];
+      debug(`Found scenario dirs: ${scenarioDirs}`);
       for (let i = 0; i < scenarioDirs.length; i++) {
         const scenarioDirname = scenarioDirs[i];
         const scenarioDir = (0, import_path3.join)(scenariosDir, scenarioDirname);
+        debug("Parsing Eleventy version of scenario " + scenarioDirname);
         let scenarioEleventyVersion = await scenarioDirnameToEleventyVersion(scenarioDirname);
+        debug("Determined Eleventy version: " + scenarioEleventyVersion);
         scenarioOutputs.push(await buildEleventy({
           eleventyVersion: scenarioEleventyVersion,
           scenarioName: scenarioDirname,
@@ -265,8 +306,10 @@ async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), return
         }));
       }
       if (returnArray) {
+        debug("Returning as array...");
         resolve(scenarioOutputs);
       } else {
+        debug("Returning as object...");
         const returnDict = {};
         scenarioOutputs.forEach((scenarioOutput) => {
           returnDict[scenarioOutput.title] = scenarioOutput;
@@ -280,7 +323,8 @@ async function buildScenarios({ projectRoot = (0, import_process2.cwd)(), return
 }
 if (require.main === module) {
   buildScenarios({
-    projectRoot: (0, import_process2.cwd)()
+    projectRoot: (0, import_process2.cwd)(),
+    enableDebug: true
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eleventy-test",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Multi-configuration testing for Eleventy plugins",
   "license": "MIT",
   "repository": "https://github.com/Denperidge/eleventy-test.git",