elit 3.6.4 → 3.6.6

package/dist/smtp-server.mjs

@@ -0,0 +1,87 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+
+// src/smtp-server.ts
+import { SMTPServer } from "smtp-server";
+var DEFAULT_SMTP_PORT = 2525;
+var DEFAULT_SMTP_HOST = "127.0.0.1";
+function resolveSmtpServerConfig(config = {}) {
+  const { port = DEFAULT_SMTP_PORT, host = DEFAULT_SMTP_HOST, label, ...serverOptions } = config;
+  return {
+    ...serverOptions,
+    port,
+    host,
+    label
+  };
+}
+function normalizeSmtpServerConfigs(input) {
+  const configs = Array.isArray(input) ? input : input ? [input] : [];
+  return configs.map((config) => resolveSmtpServerConfig(config));
+}
+function closeSmtpServer(server) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const handleCloseError = (error) => {
+      const errorCode = error.code;
+      if (errorCode === "ERR_SERVER_NOT_RUNNING") {
+        finish();
+        return;
+      }
+      finish(error);
+    };
+    try {
+      server.close(() => finish());
+    } catch (error) {
+      handleCloseError(error);
+    }
+  });
+}
+function createSmtpServer(config = {}) {
+  const resolvedConfig = resolveSmtpServerConfig(config);
+  const { port, host, label: _label, ...serverOptions } = resolvedConfig;
+  const server = new SMTPServer(serverOptions);
+  return {
+    server,
+    config: resolvedConfig,
+    listen(callback) {
+      return callback ? server.listen(port, host, callback) : server.listen(port, host);
+    },
+    address() {
+      return server.server.address();
+    },
+    close() {
+      return closeSmtpServer(server);
+    }
+  };
+}
+function startSmtpServer(config = {}) {
+  const handle = createSmtpServer(config);
+  handle.listen();
+  return handle;
+}
+var smtp_server_default = {
+  SMTPServer,
+  createSmtpServer,
+  startSmtpServer,
+  DEFAULT_SMTP_HOST,
+  DEFAULT_SMTP_PORT
+};
+export {
+  DEFAULT_SMTP_HOST,
+  DEFAULT_SMTP_PORT,
+  createSmtpServer,
+  smtp_server_default as default,
+  normalizeSmtpServerConfigs,
+  resolveSmtpServerConfig,
+  startSmtpServer
+};

package/dist/state.cjs

@@ -468,6 +468,7 @@ var DomNode = class {
       html += `</${tagName}>${newLine}`;
       return html;
     }
+    const isRawText = tagName === "script" || tagName === "style";
     if (children && children.length > 0) {
       const resolvedChildren = children.map((c) => {
         const resolved = this.resolveStateValue(c);
@@ -483,11 +484,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty, indent: indent + 1 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty, indent: indent + 1 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty, indent: indent + 1 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty, indent: indent + 1 });
           }
         }
         html += indentStr;
@@ -497,11 +498,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty: false, indent: 0 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty: false, indent: 0 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty: false, indent: 0 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty: false, indent: 0 });
           }
         }
       }

package/dist/state.d.ts

@@ -3,6 +3,8 @@ import 'node:events';
 import 'events';
 import 'http';
 import 'ws';
+import 'net';
+import 'smtp-server';
 
 /**
  * Elit - State Management

package/dist/state.js

@@ -426,6 +426,7 @@
         html += `</${tagName}>${newLine}`;
         return html;
       }
+      const isRawText = tagName === "script" || tagName === "style";
       if (children && children.length > 0) {
         const resolvedChildren = children.map((c) => {
           const resolved = this.resolveStateValue(c);
@@ -441,11 +442,11 @@
             if (Array.isArray(child)) {
               for (const c of child) {
                 if (!shouldSkipChild(c)) {
-                  html += this.renderToString(c, { pretty, indent: indent + 1 });
+                  html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty, indent: indent + 1 });
                 }
               }
             } else {
-              html += this.renderToString(child, { pretty, indent: indent + 1 });
+              html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty, indent: indent + 1 });
             }
           }
           html += indentStr;
@@ -455,11 +456,11 @@
             if (Array.isArray(child)) {
               for (const c of child) {
                 if (!shouldSkipChild(c)) {
-                  html += this.renderToString(c, { pretty: false, indent: 0 });
+                  html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty: false, indent: 0 });
                 }
               }
             } else {
-              html += this.renderToString(child, { pretty: false, indent: 0 });
+              html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty: false, indent: 0 });
             }
           }
         }

package/dist/state.mjs

@@ -424,6 +424,7 @@ var DomNode = class {
       html += `</${tagName}>${newLine}`;
       return html;
     }
+    const isRawText = tagName === "script" || tagName === "style";
     if (children && children.length > 0) {
       const resolvedChildren = children.map((c) => {
         const resolved = this.resolveStateValue(c);
@@ -439,11 +440,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty, indent: indent + 1 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty, indent: indent + 1 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty, indent: indent + 1 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty, indent: indent + 1 });
           }
         }
         html += indentStr;
@@ -453,11 +454,11 @@ var DomNode = class {
           if (Array.isArray(child)) {
             for (const c of child) {
               if (!shouldSkipChild(c)) {
-                html += this.renderToString(c, { pretty: false, indent: 0 });
+                html += isRawText && typeof c === "string" ? c : this.renderToString(c, { pretty: false, indent: 0 });
               }
             }
           } else {
-            html += this.renderToString(child, { pretty: false, indent: 0 });
+            html += isRawText && typeof child === "string" ? child : this.renderToString(child, { pretty: false, indent: 0 });
           }
         }
       }

package/dist/test-runtime.cjs

@@ -77,6 +77,52 @@ function readFileSync(path, options) {
   }
   throw new Error("Unsupported runtime");
 }
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statSync(path) {
+  if (isNode || isBun) {
+    return fs.statSync(path);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
 
 // src/path.ts
 function getSeparator(isWin) {
@@ -324,12 +370,16 @@ var testPattern = void 0;
 var currentTestFile = void 0;
 var currentSourceMapConsumer = void 0;
 var wrapperLineOffset = 0;
-async function transpileFile(filePath) {
-  const source = await readFile(filePath, "utf-8");
-  const result = (0, import_esbuild.transformSync)(source, {
-    loader: filePath.endsWith(".ts") || filePath.endsWith(".tsx") ? "ts" : "js",
-    format: "esm",
-    sourcemap: "inline",
+var TEST_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+function resolveTestLoader(filePath) {
+  return /\.(?:ts|tsx|mts|cts)$/i.test(filePath) ? "ts" : "js";
+}
+function createTestTransformOptions(filePath, format, sourcemap) {
+  return {
+    loader: resolveTestLoader(filePath),
+    format,
+    sourcemap,
+    sourcefile: filePath,
     target: "es2020",
     tsconfigRaw: {
       compilerOptions: {
@@ -338,7 +388,106 @@ async function transpileFile(filePath) {
         jsxFragmentFactory: "Fragment"
       }
     }
-  });
+  };
+}
+function resolveExistingTestModulePath(basePath) {
+  const nodePath = require("path");
+  if (existsSync(basePath) && statSync(basePath).isFile()) {
+    return basePath;
+  }
+  for (const extension of TEST_MODULE_EXTENSIONS) {
+    const candidatePath = `${basePath}${extension}`;
+    if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+      return candidatePath;
+    }
+  }
+  if (existsSync(basePath) && statSync(basePath).isDirectory()) {
+    const packageJsonPath = nodePath.join(basePath, "package.json");
+    if (existsSync(packageJsonPath) && statSync(packageJsonPath).isFile()) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        for (const candidateEntry of [packageJson.main, packageJson.module]) {
+          if (typeof candidateEntry !== "string" || candidateEntry.trim().length === 0) {
+            continue;
+          }
+          try {
+            return resolveExistingTestModulePath(nodePath.resolve(basePath, candidateEntry));
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+      }
+    }
+    for (const extension of TEST_MODULE_EXTENSIONS) {
+      const candidatePath = nodePath.join(basePath, `index${extension}`);
+      if (existsSync(candidatePath) && statSync(candidatePath).isFile()) {
+        return candidatePath;
+      }
+    }
+  }
+  return basePath;
+}
+function resolveTestModulePath(fromFilePath, specifier) {
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    return specifier;
+  }
+  const nodePath = require("path");
+  const basePath = specifier.startsWith(".") ? nodePath.resolve(dirname(fromFilePath), specifier) : specifier;
+  return resolveExistingTestModulePath(basePath);
+}
+function shouldTranspileTestModule(filePath) {
+  return /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filePath);
+}
+function createTestModuleRequire(fromFilePath, moduleCache) {
+  return (specifier) => {
+    if (specifier.startsWith("elit/") || specifier === "elit") {
+      return require(specifier);
+    }
+    const resolvedPath = resolveTestModulePath(fromFilePath, specifier);
+    if (resolvedPath === specifier) {
+      return require(specifier);
+    }
+    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isFile()) {
+      return require(resolvedPath);
+    }
+    if (!shouldTranspileTestModule(resolvedPath)) {
+      return require(resolvedPath);
+    }
+    return loadTranspiledTestModule(resolvedPath, moduleCache);
+  };
+}
+function loadTranspiledTestModule(modulePath, moduleCache) {
+  const cached = moduleCache.get(modulePath);
+  if (cached) {
+    return cached.exports;
+  }
+  const source = readFileSync(modulePath, "utf-8");
+  let transpiled;
+  try {
+    transpiled = (0, import_esbuild.transformSync)(source, createTestTransformOptions(modulePath, "cjs", false));
+  } catch (error) {
+    throw new Error(`Failed to transpile test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const moduleRecord = { exports: {} };
+  const moduleObj = { exports: moduleRecord.exports };
+  moduleCache.set(modulePath, moduleRecord);
+  try {
+    const fn = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
+    const requireFn = createTestModuleRequire(modulePath, moduleCache);
+    fn(moduleObj, moduleObj.exports, requireFn, modulePath, dirname(modulePath));
+  } catch (error) {
+    throw new Error(`Failed to execute test dependency ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  moduleRecord.exports = moduleObj.exports;
+  if (!modulePath.includes(".test.") && !modulePath.includes(".spec.")) {
+    coveredFiles.add(modulePath);
+  }
+  return moduleRecord.exports;
+}
+async function transpileFile(filePath) {
+  const source = await readFile(filePath, "utf-8");
+  const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(filePath, "esm", "inline"));
   let sourceMap;
   const sourceMapMatch = result.code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
   if (sourceMapMatch) {
@@ -350,7 +499,7 @@ async function transpileFile(filePath) {
 }
 function createTestFunction(defaultTimeout = 5e3) {
   const testFn = function(name, fn, timeout) {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: currentSuite.skip,
@@ -359,10 +508,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.skip = (name, fn, timeout) => {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: true,
@@ -371,11 +520,11 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.only = (name, fn, timeout) => {
     hasOnly = true;
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: false,
@@ -384,10 +533,10 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   testFn.todo = (name, fn, timeout) => {
-    const test2 = {
+    const test = {
       name,
       fn,
       skip: false,
@@ -396,7 +545,7 @@ function createTestFunction(defaultTimeout = 5e3) {
       timeout: timeout ?? defaultTimeout,
       suite: currentSuite
     };
-    currentSuite.tests.push(test2);
+    currentSuite.tests.push(test);
   };
   return testFn;
 }
@@ -962,29 +1111,7 @@ async function runTests(options) {
     try {
       const source = await readFile(file, "utf-8");
       const testFileDir = dirname(file);
-      const importRegex = /import\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"]/g;
-      const imports = {};
-      let importIndex = 0;
-      let codeWithoutImports = source.replace(importRegex, (_, named, path) => {
-        const varName = `__import_${importIndex++}`;
-        const trimmedNamed = named.trim();
-        imports[varName] = { path, named: trimmedNamed };
-        return `// ${trimmedNamed} import injected later
-`;
-      });
-      const result = (0, import_esbuild.transformSync)(codeWithoutImports, {
-        loader: file.endsWith(".ts") || file.endsWith(".tsx") ? "ts" : "js",
-        format: "iife",
-        sourcemap: "inline",
-        target: "es2020",
-        tsconfigRaw: {
-          compilerOptions: {
-            jsx: "react",
-            jsxFactory: "h",
-            jsxFragmentFactory: "Fragment"
-          }
-        }
-      });
+      const result = (0, import_esbuild.transformSync)(source, createTestTransformOptions(file, "cjs", "inline"));
       let code = result.code;
       const sourceMapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;base64,(.+)/);
       if (sourceMapMatch) {
@@ -995,99 +1122,15 @@ async function runTests(options) {
       } else {
         currentSourceMapConsumer = void 0;
       }
-      const importedValues = {};
-      const importParamNames = [];
-      const importAssignments = [];
-      if (Object.keys(imports).length > 0) {
-        for (const [, { path, named }] of Object.entries(imports)) {
-          let resolvedPath = path;
-          if (path.startsWith(".")) {
-            const nodePath = require("path");
-            resolvedPath = nodePath.resolve(testFileDir, path);
-          }
-          if (!resolvedPath.endsWith(".ts") && !resolvedPath.endsWith(".js") && !resolvedPath.endsWith(".mjs") && !resolvedPath.endsWith(".cjs")) {
-            resolvedPath += ".ts";
-          }
-          if (resolvedPath.endsWith(".ts")) {
-            try {
-              const importSource = await readFile(resolvedPath, "utf-8");
-              const transpiled = (0, import_esbuild.transformSync)(importSource, {
-                loader: "ts",
-                format: "cjs",
-                target: "es2020",
-                tsconfigRaw: {
-                  compilerOptions: {
-                    jsx: "react",
-                    jsxFactory: "h",
-                    jsxFragmentFactory: "Fragment"
-                  }
-                }
-              });
-              const moduleExports = {};
-              const moduleObj = { exports: moduleExports };
-              const fn2 = new Function("module", "exports", "require", "__filename", "__dirname", transpiled.code);
-              const requireFn = (id) => {
-                if (id.startsWith("elit/") || id === "elit") {
-                  return require(id);
-                }
-                if (id.startsWith(".")) {
-                  const nodePath = require("path");
-                  const absPath = nodePath.resolve(dirname(resolvedPath), id);
-                  return require(absPath);
-                }
-                return require(id);
-              };
-              fn2(moduleObj, moduleExports, requireFn, resolvedPath, dirname(resolvedPath));
-              if (!resolvedPath.includes(".test.") && !resolvedPath.includes(".spec.")) {
-                coveredFiles.add(resolvedPath);
-              }
-              let exportedValue = moduleObj.exports[named];
-              if (exportedValue === void 0 && moduleObj.exports.default) {
-                exportedValue = moduleObj.exports.default[named];
-              }
-              if (exportedValue === void 0 && typeof moduleObj.exports === "object") {
-                exportedValue = moduleObj.exports[named];
-              }
-              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-              importedValues[paramKey] = exportedValue;
-              importParamNames.push(paramKey);
-              importAssignments.push(`const ${named} = ${paramKey};`);
-            } catch (err) {
-              const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-              importedValues[paramKey] = null;
-              importParamNames.push(paramKey);
-              importAssignments.push(`const ${named} = ${paramKey}; /* Error importing ${resolvedPath}: ${err} */`);
-            }
-          } else {
-            const requiredModule = require(resolvedPath);
-            const exportedValue = requiredModule[named];
-            const paramKey = `__import_${Math.random().toString(36).substring(2, 11)}`;
-            importedValues[paramKey] = exportedValue;
-            importParamNames.push(paramKey);
-            importAssignments.push(`const ${named} = ${paramKey};`);
-          }
-        }
-      }
-      let preamble = "";
-      if (Object.keys(imports).length > 0) {
-        const iifeStartMatch = code.match(/^(\s*(?:var\s+\w+\s*=\s*)?\(\(\)\s*=>\s*\{\n)/);
-        if (iifeStartMatch) {
-          const iifePrefix = iifeStartMatch[1];
-          const assignments = `${importAssignments.join("\n")}
-`;
-          preamble = iifePrefix;
-          code = iifePrefix + assignments + code.slice(iifeStartMatch[1].length);
-        } else {
-          preamble = importAssignments.join("\n") + "\n";
-          code = preamble + code;
-        }
-      }
-      wrapperLineOffset = preamble.split("\n").length;
+      wrapperLineOffset = 0;
       setupGlobals();
-      const allParams = ["describe", "it", "test", "expect", "beforeAll", "afterAll", "beforeEach", "afterEach", "vi", "require", "module", "__filename", "__dirname", ...importParamNames];
-      const allArgs = [describe, it, test, expect, beforeAll, afterAll, beforeEach, afterEach, vi, require, module, file, testFileDir, ...importParamNames.map((p) => importedValues[p])];
-      const fn = new Function(...allParams, code);
-      await fn(...allArgs);
+      const moduleCache = /* @__PURE__ */ new Map();
+      const moduleRecord = { exports: {} };
+      const moduleObj = { exports: moduleRecord.exports };
+      moduleCache.set(file, moduleRecord);
+      const fn = new Function("module", "exports", "require", "__filename", "__dirname", code);
+      const requireFn = createTestModuleRequire(file, moduleCache);
+      await fn(moduleObj, moduleObj.exports, requireFn, file, testFileDir);
       await executeSuite(currentSuite, timeout, bail);
       if (currentSourceMapConsumer) {
         currentSourceMapConsumer.destroy();
@@ -1152,22 +1195,22 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
   for (const hook of beforeAllHooks) {
     await hook();
   }
-  for (const test2 of suite.tests) {
-    if (hasOnly && !test2.only && !suite.only) {
+  for (const test of suite.tests) {
+    if (hasOnly && !test.only && !suite.only) {
       continue;
     }
     let testMatches = true;
     if (testPattern) {
       const escapedPattern = escapeRegex(testPattern);
       const regex = new RegExp(escapedPattern, "i");
-      testMatches = regex.test(test2.name);
+      testMatches = regex.test(test.name);
     }
     if (!testMatches) {
       continue;
     }
-    if (test2.skip || suite.skip) {
+    if (test.skip || suite.skip) {
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "skip",
         duration: 0,
         suite: suite.name,
@@ -1175,9 +1218,9 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
       });
       continue;
     }
-    if (test2.todo) {
+    if (test.todo) {
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "todo",
         duration: 0,
         suite: suite.name,
@@ -1191,13 +1234,13 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
     const startTime = Date.now();
     try {
       await Promise.race([
-        test2.fn(),
+        test.fn(),
         new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test2.timeout}ms`)), test2.timeout)
+          (_, reject) => setTimeout(() => reject(new Error(`Test timed out after ${test.timeout}ms`)), test.timeout)
         )
       ]);
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "pass",
         duration: Date.now() - startTime,
         suite: suite.name,
@@ -1211,7 +1254,7 @@ async function executeSuite(suite, timeout, bail, parentMatched = false) {
         codeSnippet = error.codeSnippet;
       }
       testResults.push({
-        name: test2.name,
+        name: test.name,
         status: "fail",
         duration: Date.now() - startTime,
         error,