Bug - Pattern Liquid tests

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.52.1] (21/01/2026)
+In this update we solved a bug related to the `silverfin run-test -p "string pattern" -h template_handle` command. Previously, when we run tests and define a pattern, those tests can include an alias, but the anchor was defined in a different section that gets filtered out when running the tests. This has now been resolved.
+
 ## [1.52.0] (12/01/2026)
 This update improves test execution performance when running tests with status checks across multiple template handles. 
 Tests are now run in parallel for multiple handles when using the `--status` flag, significantly reducing the overall execution time. Previously, tests with status checks for multiple handles would run sequentially, but now they leverage parallel processing for better efficiency. This change only affects the `silverfin run-test` command when both multiple handles and the status flag are used together.

lib/liquidTestRunner.js

@@ -26,6 +26,103 @@ function findTestRows(testContent) {
   return indexes;
 }
 
+/**
+ * Find all anchor definitions in the YAML content.
+ * Returns a map of anchor names to their line ranges (start, end).
+ */
+function findAnchorDefinitions(testContent) {
+  const lines = testContent.split("\n");
+  const anchors = {};
+
+  // Parse the document to find anchors
+  const options = { maxAliasCount: 10000 };
+  const doc = yaml.parseDocument(testContent, options);
+
+  // Visit all nodes to find anchors
+  yaml.visit(doc, {
+    Node(key, node) {
+      if (node.anchor) {
+        // Find the line number of this anchor in the source
+        if (node.range) {
+          const startOffset = node.range[0];
+          let lineNumber = 0;
+          let currentOffset = 0;
+          for (let i = 0; i < lines.length; i++) {
+            if (currentOffset + lines[i].length >= startOffset) {
+              lineNumber = i;
+              break;
+            }
+            currentOffset += lines[i].length + 1; // +1 for newline
+          }
+          anchors[node.anchor] = { startLine: lineNumber, node };
+        }
+      }
+    },
+  });
+
+  return anchors;
+}
+
+/**
+ * Find all alias references in a given YAML content segment.
+ * Returns an array of alias names that are referenced.
+ */
+function findAliasReferences(segment) {
+  const aliasPattern = /\*([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  const aliases = new Set();
+  let match;
+  while ((match = aliasPattern.exec(segment)) !== null) {
+    aliases.add(match[1]);
+  }
+  return Array.from(aliases);
+}
+
+/**
+ * Extract anchor definition blocks from the original content.
+ * Returns the YAML content for each anchor that needs to be preserved.
+ */
+function extractAnchorBlocks(testContent, anchorNames, testIndexes) {
+  if (anchorNames.length === 0) {
+    return "";
+  }
+
+  const anchors = findAnchorDefinitions(testContent);
+  const lines = testContent.split("\n");
+
+  // Get sorted test start positions
+  const testPositions = Object.entries(testIndexes)
+    .map(([name, index]) => ({ name, index }))
+    .sort((a, b) => a.index - b.index);
+
+  const anchorBlocks = [];
+
+  for (const anchorName of anchorNames) {
+    const anchor = anchors[anchorName];
+    if (!anchor) continue;
+
+    const anchorLine = anchor.startLine;
+
+    // Find which test this anchor belongs to
+    let testStart = 0;
+    let testEnd = lines.length;
+
+    for (let i = 0; i < testPositions.length; i++) {
+      if (testPositions[i].index <= anchorLine) {
+        testStart = testPositions[i].index;
+        testEnd = i + 1 < testPositions.length ? testPositions[i + 1].index : lines.length;
+      }
+    }
+
+    // Extract the test block containing this anchor
+    const block = lines.slice(testStart, testEnd).join("\n").trimEnd();
+    anchorBlocks.push(block);
+  }
+
+  // Remove duplicates and return
+  const uniqueBlocks = [...new Set(anchorBlocks)];
+  return uniqueBlocks.join("\n\n");
+}
+
 function filterTestsByPattern(testContent, pattern, testIndexes) {
   const indexes = testIndexes || findTestRows(testContent);
   const matchingTests = Object.keys(indexes).filter((testName) => testName.includes(pattern));
@@ -73,9 +170,32 @@ function filterTestsByPattern(testContent, pattern, testIndexes) {
     segments.push(segment);
   });
 
-  const filteredContent = segments.join("\n\n").trim();
+  let filteredContent = segments.join("\n\n").trim();
   const orderedMatchingTests = orderedTests.filter((test) => matchingSet.has(test.name)).map((test) => test.name);
 
+  // Check for alias references in the filtered content and add missing anchor definitions
+  const aliasReferences = findAliasReferences(filteredContent);
+  if (aliasReferences.length > 0) {
+    // Find anchors that are defined in the filtered content
+    const definedAnchors = new Set();
+    const anchorPattern = /&([a-zA-Z_][a-zA-Z0-9_]*)/g;
+    let match;
+    while ((match = anchorPattern.exec(filteredContent)) !== null) {
+      definedAnchors.add(match[1]);
+    }
+
+    // Find aliases that reference anchors not in the filtered content
+    const missingAnchors = aliasReferences.filter((alias) => !definedAnchors.has(alias));
+
+    if (missingAnchors.length > 0) {
+      // Extract the test blocks containing the missing anchors
+      const anchorBlocks = extractAnchorBlocks(testContent, missingAnchors, indexes);
+      if (anchorBlocks) {
+        filteredContent = anchorBlocks + "\n\n" + filteredContent;
+      }
+    }
+  }
+
   const lineAdjustments = {};
   if (filteredContent) {
     const filteredIndexes = findTestRows(filteredContent);