@vitronai/themis 0.1.0-beta.0 → 0.1.0-beta.2

package/src/config.js

@@ -9,13 +9,18 @@ const DEFAULT_CONFIG = {
   reporter: 'next',
   environment: 'node',
   setupFiles: [],
-  tsconfigPath: 'tsconfig.json'
+  tsconfigPath: 'tsconfig.json',
+  testIgnore: []
 };
 
 function loadConfig(cwd) {
   const configPath = path.join(cwd, 'themis.config.json');
   if (!fs.existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG, setupFiles: [] };
+    return {
+      ...DEFAULT_CONFIG,
+      setupFiles: [],
+      testIgnore: []
+    };
   }
 
   const raw = fs.readFileSync(configPath, 'utf8');
@@ -39,9 +44,22 @@ function normalizeConfig(config) {
     throw new Error('Invalid config tsconfigPath value: expected a string path or null.');
   }
 
+  if (!Array.isArray(config.testIgnore) || !config.testIgnore.every((entry) => typeof entry === 'string')) {
+    throw new Error('Invalid config testIgnore value: expected an array of regex strings.');
+  }
+
+  for (const pattern of config.testIgnore) {
+    try {
+      new RegExp(pattern);
+    } catch (error) {
+      throw new Error(`Invalid config testIgnore pattern "${pattern}": ${error.message}`);
+    }
+  }
+
   return {
     ...config,
-    setupFiles: [...config.setupFiles]
+    setupFiles: [...config.setupFiles],
+    testIgnore: [...config.testIgnore]
   };
 }
 

package/src/discovery.js

@@ -4,25 +4,30 @@ const path = require('path');
 function discoverTests(cwd, config) {
   const start = path.resolve(cwd, config.testDir);
   const regex = new RegExp(config.testRegex);
+  const ignored = compileIgnorePatterns(config.testIgnore);
   const files = [];
 
   if (!fs.existsSync(start)) {
     return files;
   }
 
-  walk(start, regex, files);
+  walk(start, regex, ignored, files, cwd);
   return files.sort();
 }
 
-function walk(dir, regex, files) {
+function walk(dir, regex, ignored, files, cwd) {
   const entries = fs.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
       continue;
     }
     const fullPath = path.join(dir, entry.name);
+    const relativePath = normalizeRelativePath(cwd, fullPath);
+    if (shouldIgnore(relativePath, entry.isDirectory(), ignored)) {
+      continue;
+    }
     if (entry.isDirectory()) {
-      walk(fullPath, regex, files);
+      walk(fullPath, regex, ignored, files, cwd);
       continue;
     }
     if (entry.isFile() && regex.test(entry.name)) {
@@ -31,4 +36,28 @@ function walk(dir, regex, files) {
   }
 }
 
+function compileIgnorePatterns(patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0) {
+    return [];
+  }
+
+  return patterns.map((pattern) => new RegExp(pattern));
+}
+
+function normalizeRelativePath(cwd, fullPath) {
+  return path.relative(cwd, fullPath).split(path.sep).join('/');
+}
+
+function shouldIgnore(relativePath, isDirectory, ignored) {
+  if (!Array.isArray(ignored) || ignored.length === 0) {
+    return false;
+  }
+
+  const candidates = isDirectory
+    ? [relativePath, `${relativePath}/`]
+    : [relativePath];
+
+  return candidates.some((candidate) => ignored.some((pattern) => pattern.test(candidate)));
+}
+
 module.exports = { discoverTests };

package/src/expect.js

@@ -117,11 +117,29 @@ function createExpect(context = {}) {
           );
         }
       },
-      toMatchSnapshot(snapshotName) {
-        if (!context.snapshotState) {
-          throw new Error('toMatchSnapshot() is only available inside the Themis runtime');
+      toHaveTextContent(expected) {
+        const node = assertDomNode(received, 'toHaveTextContent');
+        const actual = normalizeText(node.textContent);
+        const target = normalizeText(expected);
+        if (!actual.includes(target)) {
+          throw new Error(`Expected element text ${format(actual)} to contain ${format(target)}`);
+        }
+      },
+      toHaveAttribute(name, expectedValue) {
+        const node = assertDomNode(received, 'toHaveAttribute');
+        const actual = node.getAttribute(name);
+        if (actual === null) {
+          throw new Error(`Expected element to have attribute ${String(name)}`);
+        }
+        if (expectedValue !== undefined && actual !== String(expectedValue)) {
+          throw new Error(`Expected attribute ${String(name)} to be ${format(expectedValue)}, received ${format(actual)}`);
+        }
+      },
+      toBeInTheDocument() {
+        const node = assertDomNode(received, 'toBeInTheDocument');
+        if (!node.ownerDocument || !node.ownerDocument.documentElement.contains(node)) {
+          throw new Error('Expected element to be attached to the current document');
         }
-        context.snapshotState.matchSnapshot(received, snapshotName);
       }
     };
   };
@@ -167,6 +185,17 @@ function format(value) {
   return util.inspect(value, { depth: 5, colors: false, maxArrayLength: 20 });
 }
 
+function assertDomNode(received, matcherName) {
+  if (typeof Node === 'undefined' || !(received instanceof Node)) {
+    throw new Error(`${matcherName} expects a DOM node`);
+  }
+  return received;
+}
+
+function normalizeText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
 const expect = createExpect();
 
 module.exports = {