qunitx-cli 0.1.1 → 0.5.0

package/lib/servers/http.js

@@ -3,14 +3,14 @@ import WebSocket, { WebSocketServer } from 'ws';
 import bindServerToPort from '../setup/bind-server-to-port.js';
 
 export const MIME_TYPES = {
-  html: "text/html; charset=UTF-8",
-  js: "application/javascript",
-  css: "text/css",
-  png: "image/png",
-  jpg: "image/jpg",
-  gif: "image/gif",
-  ico: "image/x-icon",
-  svg: "image/svg+xml",
+  html: 'text/html; charset=UTF-8',
+  js: 'application/javascript',
+  css: 'text/css',
+  png: 'image/png',
+  jpg: 'image/jpg',
+  gif: 'image/gif',
+  ico: 'image/x-icon',
+  svg: 'image/svg+xml',
 };
 
 export default class HTTPServer {
@@ -23,13 +23,15 @@ export default class HTTPServer {
         return handler(req, res);
       });
       server = server;
-      server.on('error', (error) => {
-        onError(error);
-        reject(error);
-      }).once('listening', () => {
-        onListen(Object.assign({ hostname: '127.0.0.1', server }, config));
-        resolve(server);
-      })
+      server
+        .on('error', (error) => {
+          onError(error);
+          reject(error);
+        })
+        .once('listening', () => {
+          onListen(Object.assign({ hostname: '127.0.0.1', server }, config));
+          resolve(server);
+        });
 
       server.wss = new WebSocketServer({ server });
       server.wss.on('error', (error) => {
@@ -37,7 +39,7 @@ export default class HTTPServer {
         console.trace(error);
       });
 
-      bindServerToPort(server, config)
+      bindServerToPort(server, config);
     });
   }
 
@@ -46,7 +48,7 @@ export default class HTTPServer {
       GET: {},
       POST: {},
       DELETE: {},
-      PUT: {}
+      PUT: {},
     };
     this.middleware = [];
     this._server = http.createServer((req, res) => {
@@ -78,13 +80,17 @@ export default class HTTPServer {
 
   listen(port = 0, callback = () => {}) {
     return new Promise((resolve, reject) => {
-      this._server.listen(port, (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(callback());
-        }
-      });
+      const onError = (err) => {
+        this._server.off('listening', onListening);
+        reject(err);
+      };
+      const onListening = () => {
+        this._server.off('error', onError);
+        resolve(callback());
+      };
+      this._server.once('error', onError);
+      this._server.once('listening', onListening);
+      this._server.listen(port);
     });
   }
 
@@ -121,7 +127,7 @@ export default class HTTPServer {
       path,
       handler,
       paramNames: this.extractParamNames(path),
-      isWildcard: path === '/*'
+      isWildcard: path === '/*',
     };
   }
 
@@ -159,27 +165,32 @@ export default class HTTPServer {
       return null;
     }
 
-    return routes[url] || Object.values(routes).find(route => {
-      const { path, isWildcard } = route;
+    return (
+      routes[url] ||
+      Object.values(routes).find((route) => {
+        const { path, isWildcard } = route;
 
-      if (!isWildcard && !path.includes(':')) {
-        return false;
-      }
+        if (!isWildcard && !path.includes(':')) {
+          return false;
+        }
 
-      if (isWildcard || this.matchPathSegments(path, url)) {
-        if (route.paramNames.length > 0) {
-          const regexPattern = this.buildRegexPattern(path, route.paramNames);
-          const regex = new RegExp(`^${regexPattern}$`);
-          const regexMatches = regex.exec(url);
-          if (regexMatches) {
-            route.paramValues = regexMatches.slice(1);
+        if (isWildcard || this.matchPathSegments(path, url)) {
+          if (route.paramNames.length > 0) {
+            const regexPattern = this.buildRegexPattern(path, route.paramNames);
+            const regex = new RegExp(`^${regexPattern}$`);
+            const regexMatches = regex.exec(url);
+            if (regexMatches) {
+              route.paramValues = regexMatches.slice(1);
+            }
           }
+          return true;
         }
-        return true;
-      }
 
-      return false;
-    }) || routes['/*'] || null;
+        return false;
+      }) ||
+      routes['/*'] ||
+      null
+    );
   }
 
   matchPathSegments(path, url) {
@@ -217,7 +228,7 @@ export default class HTTPServer {
     const paramRegex = /:(\w+)/g;
     const paramMatches = path.match(paramRegex);
 
-    return paramMatches ? paramMatches.map(match => match.slice(1)) : [];
+    return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
   }
 
   extractParams(route, url) {

package/lib/setup/bind-server-to-port.js

@@ -1,14 +1,5 @@
-import resolvePortNumberFor from '../utils/resolve-port-number-for.js';
-
-// NOTE: there was a race condition between socket.connection and server.listen, check if nanoexpress fixes it
 export default async function bindServerToPort(server, config) {
-  try {
-    let port = await resolvePortNumberFor(config.port);
-
-    await server.listen(port);
-
-    return server;
-  } catch(e) {
-    return await bindServerToPort(server, Object.assign(config, { port: config.port + 1 }));
-  }
+  await server.listen(0);
+  config.port = server._server.address().port;
+  return server;
 }

package/lib/setup/browser.js

@@ -1,23 +1,35 @@
 import Puppeteer from 'puppeteer';
 import setupWebServer from './web-server.js';
 import bindServerToPort from './bind-server-to-port.js';
+import findChrome from '../utils/find-chrome.js';
 
-export default async function setupBrowser(config = {
-  port: 1234, debug: false, watch: false, timeout: 10000
-}, cachedContent) {
+export default async function setupBrowser(
+  config = {
+    port: 1234,
+    debug: false,
+    watch: false,
+    timeout: 10000,
+  },
+  cachedContent,
+  existingBrowser = null,
+) {
   let [server, browser] = await Promise.all([
     setupWebServer(config, cachedContent),
-    Puppeteer.launch({
-      debugger: config.debug || false,
-      args: ['--no-sandbox', '--disable-gpu', '--remote-debugging-port=0', '--window-size=1440,900'],
-      executablePath: process.env.CHROME_BIN || null,
-      headless: 'new',
-    }),
-  ]);
-  let [page, _] = await Promise.all([
-    browser.newPage(),
-    bindServerToPort(server, config)
+    existingBrowser
+      ? Promise.resolve(existingBrowser)
+      : Puppeteer.launch({
+          debugger: config.debug || false,
+          args: [
+            '--no-sandbox',
+            '--disable-gpu',
+            '--remote-debugging-port=0',
+            '--window-size=1440,900',
+          ],
+          executablePath: await findChrome(),
+          headless: true,
+        }),
   ]);
+  let [page, _] = await Promise.all([browser.newPage(), bindServerToPort(server, config)]);
 
   page.on('console', async (msg) => {
     if (config.debug) {
@@ -28,7 +40,7 @@ export default async function setupBrowser(config = {
   });
   page.on('error', (msg) => {
     try {
-      throw error;
+      throw msg;
     } catch (e) {
       console.error(e, e.stack);
       console.log(e, e.stack);
@@ -49,7 +61,3 @@ export default async function setupBrowser(config = {
 function turnToObjects(jsHandle) {
   return jsHandle.jsonValue();
 }
-
-// function turnMStoSecond(timeInMS) {
-//   return (timeInMS / 1000).toFixed(2);
-// }

package/lib/setup/config.js

@@ -7,23 +7,21 @@ import parseCliFlags from '../utils/parse-cli-flags.js';
 
 export default async function setupConfig() {
   let projectRoot = await findProjectRoot();
-  let [projectPackageJSON, cliConfigFlags] = await Promise.all([
-    readConfigFromPackageJSON(projectRoot),
-    parseCliFlags(projectRoot)
-  ]);
+  let cliConfigFlags = parseCliFlags(projectRoot);
+  let projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
   let inputs = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
   let config = {
-    projectRoot,
-    htmlPaths: [],
-    lastFailedTestFiles: null,
-    lastRanTestFiles: null,
     ...defaultProjectConfigValues,
+    htmlPaths: [],
     ...projectPackageJSON.qunitx,
     ...cliConfigFlags,
-    inputs
+    projectRoot,
+    inputs,
+    testFileLookupPaths: setupTestFilePaths(projectRoot, inputs),
+    lastFailedTestFiles: null,
+    lastRanTestFiles: null,
   };
   config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
-  config.testFileLookupPaths = setupTestFilePaths(config.projectRoot, config.inputs);
   config.fsTree = await setupFSTree(config.testFileLookupPaths, config);
 
   return config;

package/lib/setup/file-watcher.js

@@ -1,7 +1,12 @@
 import chokidar from 'chokidar';
 import kleur from 'kleur';
 
-export default async function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
+export default async function setupFileWatchers(
+  testFileLookupPaths,
+  config,
+  onEventFunc,
+  onFinishFunc,
+) {
   let extensions = ['js', 'ts'];
   let fileWatchers = testFileLookupPaths.reduce((watcher, watchPath) => {
     return Object.assign(watcher, {
@@ -9,14 +14,26 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
         if (extensions.some((extension) => path.endsWith(extension))) {
           mutateFSTree(config.fsTree, event, path);
 
-          console.log('#', kleur.magenta().bold('=================================================================='));
+          console.log(
+            '#',
+            kleur
+              .magenta()
+              .bold('=================================================================='),
+          );
           console.log('#', getEventColor(event), path.split(config.projectRoot)[1]);
-          console.log('#', kleur.magenta().bold('=================================================================='));
+          console.log(
+            '#',
+            kleur
+              .magenta()
+              .bold('=================================================================='),
+          );
 
           if (!global.chokidarBuild) {
             global.chokidarBuild = true;
 
-            let result = extensions.some((extension) => path.endsWith(extension)) ? onEventFunc(event, path) : null;
+            let result = extensions.some((extension) => path.endsWith(extension))
+              ? onEventFunc(event, path)
+              : null;
 
             if (!(result instanceof Promise)) {
               global.chokidarBuild = false;
@@ -35,7 +52,7 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
               .finally(() => (global.chokidarBuild = false));
           }
         }
-      })
+      }),
     });
   }, {});
 
@@ -45,7 +62,7 @@ export default async function setupFileWatchers(testFileLookupPaths, config, onE
       Object.keys(fileWatchers).forEach((watcherKey) => fileWatchers[watcherKey].close());
 
       return fileWatchers;
-    }
+    },
   };
 }
 

package/lib/setup/fs-tree.js

@@ -6,43 +6,45 @@ export default async function buildFSTree(fileAbsolutePaths, config = {}) {
   let targetExtensions = ['js', 'ts'];
   let fsTree = {};
 
-  await Promise.all(fileAbsolutePaths.map(async (fileAbsolutePath) => {
-    let glob = picomatch.scan(fileAbsolutePath);
+  await Promise.all(
+    fileAbsolutePaths.map(async (fileAbsolutePath) => {
+      let glob = picomatch.scan(fileAbsolutePath);
 
-    // TODO: maybe allow absolute path references
+      // TODO: maybe allow absolute path references
 
-    try {
-      if (glob.isGlob) {
-        let fileNames = await recursiveLookup(glob.base, (path) => {
-          return targetExtensions.some((extension) => path.endsWith(extension));
-        });
-
-        fileNames.forEach((fileName) => {
-          if (picomatch.isMatch(fileName, fileAbsolutePath, { bash: true })) {
-            fsTree[fileName] = null;
-          }
-        });
-      } else {
-        let entry = await fs.stat(fileAbsolutePath);
-
-        if (entry.isFile()) {
-          fsTree[fileAbsolutePath] = null;
-        } else if (entry.isDirectory()) {
+      try {
+        if (glob.isGlob) {
           let fileNames = await recursiveLookup(glob.base, (path) => {
             return targetExtensions.some((extension) => path.endsWith(extension));
           });
 
           fileNames.forEach((fileName) => {
-            fsTree[fileName] = null;
+            if (picomatch.isMatch(fileName, fileAbsolutePath, { bash: true })) {
+              fsTree[fileName] = null;
+            }
           });
+        } else {
+          let entry = await fs.stat(fileAbsolutePath);
+
+          if (entry.isFile()) {
+            fsTree[fileAbsolutePath] = null;
+          } else if (entry.isDirectory()) {
+            let fileNames = await recursiveLookup(glob.base, (path) => {
+              return targetExtensions.some((extension) => path.endsWith(extension));
+            });
+
+            fileNames.forEach((fileName) => {
+              fsTree[fileName] = null;
+            });
+          }
         }
-      }
-    } catch (error) {
-      console.error(error);
+      } catch (error) {
+        console.error(error);
 
-      return process.exit(1);
-    }
-  }));
+        return process.exit(1);
+      }
+    }),
+  );
 
   return fsTree;
 }

package/lib/setup/keyboard-events.js

@@ -6,21 +6,24 @@ export default function setupKeyboardEvents(config, cachedContent, connections)
   listenToKeyboardKey('qq', () => abortBrowserQUnit(config, connections));
   listenToKeyboardKey('qa', () => {
     abortBrowserQUnit(config, connections);
-    runTestsInBrowser(config, cachedContent, connections)
+    runTestsInBrowser(config, cachedContent, connections);
   });
   listenToKeyboardKey('qf', () => {
     abortBrowserQUnit(config, connections);
 
     if (!config.lastFailedTestFiles) {
-      console.log('#', kleur.blue(`QUnitX: No tests failed so far, so repeating the last test run`));
+      console.log(
+        '#',
+        kleur.blue(`QUnitX: No tests failed so far, so repeating the last test run`),
+      );
       return runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
     }
 
-    runTestsInBrowser(config, cachedContent, connections, config.lastFailedTestFiles)
+    runTestsInBrowser(config, cachedContent, connections, config.lastFailedTestFiles);
   });
   listenToKeyboardKey('ql', () => {
     abortBrowserQUnit(config, connections);
-    runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles)
+    runTestsInBrowser(config, cachedContent, connections, config.lastRanTestFiles);
   });
 }
 

package/lib/setup/test-file-paths.js

@@ -1,25 +1,29 @@
 import picomatch from 'picomatch';
 
-export default function setupTestFilePaths(projectRoot, inputs) { // NOTE: very complex algorithm, order is very important
-  let [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce((result, input) => {
-    let isGlob = picomatch.scan(input).isGlob;
+export default function setupTestFilePaths(projectRoot, inputs) {
+  // NOTE: very complex algorithm, order is very important
+  let [folders, filesWithGlob, filesWithoutGlob] = inputs.reduce(
+    (result, input) => {
+      let isGlob = picomatch.scan(input).isGlob;
 
-    if (!pathIsFile(input)) {
-      result[0].push({
-        input,
-        isFile: false,
-        isGlob
-      });
-    } else {
-      result[isGlob ? 1 : 2].push({
-        input,
-        isFile: true,
-        isGlob
-      });
-    }
+      if (!pathIsFile(input)) {
+        result[0].push({
+          input,
+          isFile: false,
+          isGlob,
+        });
+      } else {
+        result[isGlob ? 1 : 2].push({
+          input,
+          isFile: true,
+          isGlob,
+        });
+      }
 
-    return result;
-  }, [[], [], []]);
+      return result;
+    },
+    [[], [], []],
+  );
 
   let result = folders.reduce((folderResult, folder) => {
     if (!pathIsIncludedInPaths(folders, folder)) {
@@ -30,10 +34,7 @@ export default function setupTestFilePaths(projectRoot, inputs) { // NOTE: very
   }, []);
 
   filesWithGlob.forEach((file) => {
-    if (
-      !pathIsIncludedInPaths(result, file) &&
-      !pathIsIncludedInPaths(filesWithGlob, file)
-    ) {
+    if (!pathIsIncludedInPaths(result, file) && !pathIsIncludedInPaths(filesWithGlob, file)) {
       result.push(file);
     }
   });
@@ -68,7 +69,8 @@ function buildGlobFormat(path) {
   if (!path.isFile) {
     if (!path.isGlob) {
       return `${path.input}/*`;
-    } else if (path.input.endsWith('*')) { // NOTE: could be problematic in future, investigate if I should check endsWith /*
+    } else if (path.input.endsWith('*')) {
+      // NOTE: could be problematic in future, investigate if I should check endsWith /*
       return path.input;
     }