velocious 1.0.431 → 1.0.433

package/build/testing/request-client.js

@@ -0,0 +1,90 @@
+// @ts-check
+
+class Response {
+  /**
+   * Runs constructor.
+   * @param {globalThis.Response} fetchResponse - Fetch response.
+   */
+  constructor(fetchResponse) {
+    this.fetchResponse = fetchResponse
+  }
+
+  /**
+   * Runs parse.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async parse() {
+    this._body = await this.fetchResponse.text()
+
+    if (this.statusCode() != 200) throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`)
+  }
+
+  /**
+   * Runs body.
+   * @returns {string} - The body.
+   */
+  body() {
+    if (!this._body) throw new Error("Response body not parsed yet. Call parse() first.")
+
+    return this._body
+  }
+
+  /**
+   * Runs content type.
+   * @returns {string | null} - The content type.
+   */
+  contentType() {
+    return this.fetchResponse.headers.get("content-type")
+  }
+
+  /**
+   * Runs status code.
+   * @returns {number} - The status code.
+   */
+  statusCode() { return this.fetchResponse.status }
+}
+
+export default class RequestClient {
+  host = "localhost"
+  port = 31006
+
+  /**
+   * Runs get.
+   * @param {string} path - Path.
+   * @returns {Promise<Response>} - Resolves with the get.
+   */
+  async get(path) {
+    const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`)
+    const response = new Response(fetchResponse)
+
+    await response.parse()
+
+    return response
+  }
+
+  /**
+   * Runs post.
+   * @param {string} path - Path.
+   * @param {object} data - Data payload.
+   * @returns {Promise<Response>} - Resolves with the post.
+   */
+  async post(path, data) {
+    const fetchResponse = await fetch(
+      `http://${this.host}:${this.port}${path}`,
+      {
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST",
+        signal: AbortSignal.timeout(5000)
+      }
+    )
+
+    const response = new Response(fetchResponse)
+
+    await response.parse()
+
+    return response
+  }
+}

package/build/testing/test-files-finder.js

@@ -0,0 +1,364 @@
+// @ts-check
+
+import fs from "fs/promises"
+import path from "path"
+
+import fileExists from "../utils/file-exists.js"
+import Logger from "../logger.js"
+import restArgsError from "../utils/rest-args-error.js"
+
+// Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
+export default class TestFilesFinder {
+  static IGNORED_NAMES = [".git", "node_modules"]
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {string} args.directory - Directory path.
+   * @param {string[]} [args.directories] - Directories.
+   * @param {string[]} args.processArgs - Process args.
+   */
+  constructor({directory, directories, processArgs, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.directory = path.resolve(directory)
+    this.logger = new Logger(this)
+
+    if (directories) {
+      this.directories = directories.map((entry) => path.resolve(entry))
+    } else {
+      this.directories = [
+        `${this.directory}/__tests__`,
+        `${this.directory}/tests`,
+        `${this.directory}/spec`
+      ]
+    }
+
+    this.findingCount = 0
+    this.processArgs = processArgs
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.foundFiles = []
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Record<number, Promise<void>>} */
+    this.findingPromises = {}
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.directoryArgs = []
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.directoryFullPaths = []
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.fileArgs = []
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {string[]} */
+    this.explicitFiles = []
+
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Record<string, number[]>} */
+    this.lineFiltersByFile = {}
+
+    this._argsPrepared = false
+  }
+
+  /**
+   * Runs find test files.
+   * @returns {Promise<string[]>} - Resolves with the test files.
+   */
+  async findTestFiles() {
+    await this.prepareArgs()
+
+    if (this.explicitFiles.length > 0 && this.directoryArgs.length === 0) {
+      return Array.from(new Set(this.explicitFiles))
+    }
+
+    await this.withFindingCount(async () => {
+      const hasExplicitArgs = this.directoryFullPaths.length > 0 || this.fileArgs.length > 0
+      const directoriesToScan = hasExplicitArgs ? this.directoryFullPaths : this.directories
+
+      for (const directory of directoriesToScan) {
+        if (await fileExists(directory)) {
+          await this.findTestFilesInDir(directory)
+        }
+      }
+    })
+
+    await this.waitForFindingPromises()
+
+    if (this.explicitFiles.length > 0) {
+      this.foundFiles.push(...this.explicitFiles)
+    }
+
+    return Array.from(new Set(this.foundFiles))
+  }
+
+  /**
+   * Runs get line filters by file.
+   * @returns {Record<string, number[]>} - Line filters by file.
+   */
+  getLineFiltersByFile() { return this.lineFiltersByFile }
+
+  /**
+   * Runs finding promises length.
+   * @returns {number} - The ing promises length.
+   */
+  findingPromisesLength() { return Object.keys(this.findingPromises).length }
+
+  async waitForFindingPromises() {
+    while (this.findingPromisesLength() > 0) {
+      await this.waitForFindingPromisesIteration()
+    }
+  }
+
+  /**
+   * Runs wait for finding promises iteration.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async waitForFindingPromisesIteration() {
+    const unfinishedPromises = []
+
+    for (const findingPromiseId in this.findingPromises) {
+      const findingPromise = this.findingPromises[findingPromiseId]
+
+      unfinishedPromises.push(findingPromise)
+    }
+
+    await Promise.all(unfinishedPromises)
+  }
+
+  /**
+   * Runs with finding count.
+   * @param {function() : Promise<void>} callback - Callback function.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  withFindingCount(callback) {
+    return new Promise((resolve) => {
+      const findingPromise = callback()
+      const findingCount = this.findingCount
+
+      this.findingCount += 1
+      this.findingPromises[findingCount] = findingPromise
+
+      findingPromise.finally(() => {
+        delete this.findingPromises[findingCount]
+
+        resolve(undefined)
+      })
+    })
+  }
+
+  /**
+   * Runs find test files in dir.
+   * @param {string} dir - Dir.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async findTestFilesInDir(dir) {
+    await this.withFindingCount(async () => {
+      const files = await fs.readdir(dir)
+
+      for (const file of files) {
+        if (TestFilesFinder.IGNORED_NAMES.includes(file)) {
+          continue
+        }
+
+        const fullPath = `${dir}/${file}`
+        const localPath = fullPath.replace(`${this.directory}/`, "")
+        const isDir = (await fs.stat(fullPath)).isDirectory()
+
+        if (isDir) {
+          this.findTestFilesInDir(fullPath)
+        } else {
+          if (this.isFileMatchingRequirements(file, localPath)) {
+            this.foundFiles.push(fullPath)
+          }
+        }
+      }
+    })
+  }
+
+  /**
+   * Runs is file matching requirements.
+   * @param {string} file - File.
+   * @param {string} localPath - Local path.
+   * @returns {boolean} - Whether file matching requirements.
+   */
+  isFileMatchingRequirements(file, localPath) {
+    if (this.directoryArgs.length > 0) {
+      for (const directoryArg of this.directoryArgs) {
+        if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
+          this.logger.debug("Found test file because matching dir and looks like this file:", file)
+          return true
+        }
+      }
+    }
+
+    if (this.fileArgs.length > 0) {
+      for (const fileArg of this.fileArgs) {
+        if (fileArg == localPath) {
+          this.logger.debug("Found test file because matching file arg:", file)
+          return true
+        }
+      }
+    }
+
+    if (this.fileArgs.length == 0 && this.directoryArgs.length == 0 && this.looksLikeTestFile(file)) {
+      this.logger.debug("Found test file because looks like this file:", file)
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Runs looks like test file.
+   * @param {string} file - File.
+   * @returns {boolean} - Whether looks like test file.
+   */
+  looksLikeTestFile(file) {
+    return Boolean(file.match(/-(spec|test)\.(m|)js$/))
+  }
+
+  /**
+   * Runs prepare args.
+   * @returns {Promise<void>} - Resolves when test args are prepared.
+   */
+  async prepareArgs() {
+    if (this._argsPrepared) return
+
+    for (const testArg of this.testArgs) {
+      if (testArg === "--") continue
+
+      const {cleanArg, line} = this.splitLineArg(testArg)
+      const forceDirectory = testArg.endsWith("/") || testArg.endsWith(path.sep)
+      const fullPath = path.isAbsolute(cleanArg) ? cleanArg : path.resolve(this.directory, cleanArg)
+      const baseName = path.basename(this.directory)
+      const hasBasePrefix = cleanArg === baseName || cleanArg.startsWith(`${baseName}/`) || cleanArg.startsWith(`${baseName}${path.sep}`)
+      const basePrefixedFullPath = (!path.isAbsolute(cleanArg) && hasBasePrefix) ? path.resolve(path.dirname(this.directory), cleanArg) : null
+      const fullPathCandidates = basePrefixedFullPath ? [basePrefixedFullPath] : [fullPath]
+
+      if (forceDirectory) {
+        const preferredLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
+        this.directoryArgs.push(this.ensureTrailingSlash(preferredLocalPath))
+        this.directoryFullPaths.push(path.resolve(basePrefixedFullPath || fullPath))
+        continue
+      }
+
+      try {
+        let stats
+        let resolvedFullPath
+
+        for (const candidatePath of fullPathCandidates) {
+          try {
+            stats = await fs.stat(candidatePath)
+            resolvedFullPath = candidatePath
+            break
+          } catch {
+            // Keep searching
+          }
+        }
+
+        if (!stats || !resolvedFullPath) throw new Error("Path not found")
+        const localPath = this.toLocalPath(resolvedFullPath)
+
+        if (stats.isDirectory()) {
+          this.directoryArgs.push(this.ensureTrailingSlash(localPath))
+          this.directoryFullPaths.push(resolvedFullPath)
+        } else if (stats.isFile()) {
+          this.fileArgs.push(localPath)
+          this.explicitFiles.push(resolvedFullPath)
+
+          if (line) {
+            this.addLineFilter(resolvedFullPath, line)
+          }
+        }
+      } catch {
+        const fallbackLocalPath = this.toLocalPath(basePrefixedFullPath || fullPath)
+        this.fileArgs.push(fallbackLocalPath)
+
+        if (line) {
+          this.addLineFilter(basePrefixedFullPath || fullPath, line)
+        }
+      }
+    }
+
+    this._argsPrepared = true
+  }
+
+  /**
+   * Runs add line filter.
+   * @param {string} filePath - File path.
+   * @param {number} line - Line number.
+   * @returns {void} - No return value.
+   */
+  addLineFilter(filePath, line) {
+    const fullPath = path.resolve(filePath)
+
+    if (!this.lineFiltersByFile[fullPath]) {
+      this.lineFiltersByFile[fullPath] = []
+    }
+
+    if (!this.lineFiltersByFile[fullPath].includes(line)) {
+      this.lineFiltersByFile[fullPath].push(line)
+    }
+  }
+
+  /**
+   * Runs split line arg.
+   * @param {string} testArg - Test arg.
+   * @returns {{cleanArg: string, line?: number}} - Cleaned arg and line.
+   */
+  splitLineArg(testArg) {
+    const match = testArg.match(/^(.*):(\d+)$/)
+
+    if (!match) {
+      return {cleanArg: testArg}
+    }
+
+    const line = Number(match[2])
+
+    if (!Number.isFinite(line)) {
+      return {cleanArg: testArg}
+    }
+
+    return {cleanArg: match[1], line}
+  }
+
+  /**
+   * Runs ensure trailing slash.
+   * @param {string} localPath - Local path.
+   * @returns {string} - Normalized local path with trailing slash.
+   */
+  ensureTrailingSlash(localPath) {
+    if (localPath === "") return localPath
+    return localPath.endsWith("/") ? localPath : `${localPath}/`
+  }
+
+  /**
+   * Runs to local path.
+   * @param {string} fullPath - Full path.
+   * @returns {string} - Local path relative to the base directory.
+   */
+  toLocalPath(fullPath) {
+    const relativePath = path.relative(this.directory, fullPath)
+    return relativePath.split(path.sep).join("/")
+  }
+}

package/build/testing/test-filter-parser.js

@@ -0,0 +1,198 @@
+// @ts-check
+
+const INCLUDE_TAG_FLAGS = new Set(["--tag", "--include-tag", "-t"])
+const EXCLUDE_TAG_FLAGS = new Set(["--exclude-tag", "--skip-tag", "-x"])
+const EXAMPLE_FLAGS = new Set(["--example", "--name", "-e"])
+const GROUPS_FLAGS = new Set(["--groups"])
+const GROUP_NUMBER_FLAGS = new Set(["--group-number"])
+
+/**
+ * Runs split tags.
+ * @param {string | undefined} value - Tag argument value.
+ * @returns {string[]} - Tags list.
+ */
+function splitTags(value) {
+  if (!value) return []
+
+  return value
+    .split(",")
+    .map((tag) => tag.trim())
+    .filter(Boolean)
+}
+
+/**
+ * Runs escape reg exp.
+ * @param {string} value - Value.
+ * @returns {string} - Escaped value for regex.
+ */
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+/**
+ * Runs the normalizeExamplePatterns helper.
+ * @param {string[]} patterns - Patterns.
+ * @returns {RegExp[]} - Normalized patterns.
+ */
+export function normalizeExamplePatterns(patterns) {
+  const normalized = []
+
+  for (const pattern of patterns) {
+    const regexMatch = pattern.match(/^\/(.+)\/([gimsuy]*)$/)
+
+    if (regexMatch) {
+      normalized.push(new RegExp(regexMatch[1], regexMatch[2]))
+    } else {
+      normalized.push(new RegExp(escapeRegExp(pattern)))
+    }
+  }
+
+  return normalized
+}
+
+/**
+ * ParseFiltersResult type.
+ * @typedef {object} ParseFiltersResult
+ * @property {string[]} includeTags - Tags to include.
+ * @property {string[]} excludeTags - Tags to exclude.
+ * @property {string[]} examplePatterns - Example name patterns.
+ * @property {string[]} filteredProcessArgs - Remaining process args with filter flags removed.
+ * @property {number | undefined} groups - Total number of groups for test splitting.
+ * @property {number | undefined} groupNumber - Which group to run (1-indexed).
+ */
+
+/**
+ * Runs the parseFilters helper.
+ * @param {string[]} processArgs - Process args.
+ * @returns {ParseFiltersResult} - Parsed tags, group options, and process args.
+ */
+export function parseFilters(processArgs) {
+  const includeTags = []
+  const excludeTags = []
+  const filteredProcessArgs = processArgs.length > 0 ? [processArgs[0]] : []
+  const examplePatterns = []
+
+  /**
+   * Defines groups.
+    @type {number | undefined} */
+  let groups
+  /**
+   * Defines groupNumber.
+    @type {number | undefined} */
+  let groupNumber
+
+  let inRestArgs = false
+
+  for (let i = 1; i < processArgs.length; i++) {
+    const arg = processArgs[i]
+
+    if (arg === "--") {
+      inRestArgs = true
+      filteredProcessArgs.push(arg)
+      continue
+    }
+
+    if (!inRestArgs) {
+      if (INCLUDE_TAG_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          includeTags.push(...splitTags(nextValue))
+          i++
+        }
+        continue
+      }
+
+      if (EXCLUDE_TAG_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          excludeTags.push(...splitTags(nextValue))
+          i++
+        }
+        continue
+      }
+
+      if (arg.startsWith("--tag=")) {
+        includeTags.push(...splitTags(arg.slice("--tag=".length)))
+        continue
+      }
+
+      if (arg.startsWith("--include-tag=")) {
+        includeTags.push(...splitTags(arg.slice("--include-tag=".length)))
+        continue
+      }
+
+      if (arg.startsWith("--exclude-tag=")) {
+        excludeTags.push(...splitTags(arg.slice("--exclude-tag=".length)))
+        continue
+      }
+
+      if (arg.startsWith("--skip-tag=")) {
+        excludeTags.push(...splitTags(arg.slice("--skip-tag=".length)))
+        continue
+      }
+
+      if (EXAMPLE_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          examplePatterns.push(nextValue)
+          i++
+        }
+        continue
+      }
+
+      if (arg.startsWith("--example=")) {
+        examplePatterns.push(arg.slice("--example=".length))
+        continue
+      }
+
+      if (arg.startsWith("--name=")) {
+        examplePatterns.push(arg.slice("--name=".length))
+        continue
+      }
+
+      if (GROUPS_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          groups = parseInt(nextValue, 10)
+          i++
+        }
+        continue
+      }
+
+      if (arg.startsWith("--groups=")) {
+        groups = parseInt(arg.slice("--groups=".length), 10)
+        continue
+      }
+
+      if (GROUP_NUMBER_FLAGS.has(arg)) {
+        const nextValue = processArgs[i + 1]
+
+        if (nextValue && !nextValue.startsWith("-")) {
+          groupNumber = parseInt(nextValue, 10)
+          i++
+        }
+        continue
+      }
+
+      if (arg.startsWith("--group-number=")) {
+        groupNumber = parseInt(arg.slice("--group-number=".length), 10)
+        continue
+      }
+    }
+
+    filteredProcessArgs.push(arg)
+  }
+
+  return {
+    includeTags: Array.from(new Set(includeTags)),
+    excludeTags: Array.from(new Set(excludeTags)),
+    examplePatterns,
+    filteredProcessArgs,
+    groups,
+    groupNumber
+  }
+}