TO BE DELETED: Scripts for updating dependencies

Author: marinaaisa

fix-contains-deprecated.js

@@ -0,0 +1,186 @@
+const fs = require('fs');
+const path = require('path');
+
+// Function to recursively find all .spec.js files
+function findSpecFiles(dir) {
+  const files = [];
+  const items = fs.readdirSync(dir);
+
+  items.forEach((item) => {
+    const fullPath = path.join(dir, item);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...findSpecFiles(fullPath));
+    } else if (item.endsWith('.spec.js')) {
+      files.push(fullPath);
+    }
+  });
+
+  return files;
+}
+
+// Function to process a single file
+function processFile(filePath) {
+  console.log(`Processing: ${filePath}`);
+
+  let content = fs.readFileSync(filePath, 'utf8');
+  let modified = false;
+  const originalContent = content;
+
+  // Pattern 1: wrapper.contains(Component) -> wrapper.findComponent(Component).exists()
+  // This handles Vue component references
+  content = content.replace(
+    /(\w+)\.contains\(([A-Z][a-zA-Z0-9_]*)\)/g,
+    '$1.findComponent($2).exists()',
+  );
+
+  // Pattern 2: wrapper.contains('selector') -> wrapper.find('selector').exists()
+  // This handles CSS selectors and HTML tags
+  content = content.replace(
+    /(\w+)\.contains\((['"`][^'"`]+['"`])\)/g,
+    '$1.find($2).exists()',
+  );
+
+  // Pattern 3: wrapper.contains(variable) where variable is likely a selector string
+  // This is trickier - we need to handle cases where the argument is a variable
+  // that contains a selector string (not a component)
+  content = content.replace(
+    /(\w+)\.contains\(([a-z][a-zA-Z0-9_]*)\)/g,
+    (match, wrapper, variable) => {
+      // If the variable name suggests it's a component (starts with uppercase),
+      // use findComponent, otherwise use find
+      if (variable.match(/^[A-Z]/)) {
+        return `${wrapper}.findComponent(${variable}).exists()`;
+      }
+      return `${wrapper}.find(${variable}).exists()`;
+    },
+  );
+
+  // Special case: Handle chained contains calls like wrapper.findComponent('.foo').contains(Bar)
+  content = content.replace(
+    /(\w+\.findComponent\([^)]+\))\.contains\(([A-Z][a-zA-Z0-9_]*)\)/g,
+    '$1.findComponent($2).exists()',
+  );
+
+  content = content.replace(
+    /(\w+\.findComponent\([^)]+\))\.contains\((['"`][^'"`]+['"`])\)/g,
+    '$1.find($2).exists()',
+  );
+
+  // Special case: Handle DOM element contains (like document.activeElement.contains)
+  // These should NOT be changed as they're native DOM methods
+  content = content.replace(
+    /document\.activeElement\.findComponent\(([^)]+)\)\.exists\(\)/g,
+    'document.activeElement.contains($1)',
+  );
+
+  content = content.replace(
+    /document\.activeElement\.find\(([^)]+)\)\.exists\(\)/g,
+    'document.activeElement.contains($1)',
+  );
+
+  // Handle classList.contains - this should not be changed
+  content = content.replace(
+    /classList\.find\(([^)]+)\)\.exists\(\)/g,
+    'classList.contains($1)',
+  );
+
+  // Handle other native DOM contains methods that got incorrectly replaced
+  content = content.replace(
+    /focusedElement\.find\(([^)]+)\)\.exists\(\)/g,
+    'focusedElement.contains($1)',
+  );
+
+  // Pattern for expect().toBe(true/false) - these are boolean assertions
+  // We need to handle the boolean return value correctly
+
+  if (content !== originalContent) {
+    modified = true;
+    console.log('  - Replaced .contains() with .find().exists() or .findComponent().exists()');
+  }
+
+  // Write back the modified content
+  if (modified) {
+    fs.writeFileSync(filePath, content, 'utf8');
+    console.log('  ✓ File updated');
+  } else {
+    console.log('  - No changes needed');
+  }
+
+  return modified;
+}
+
+// Function to validate the changes by checking for common issues
+function validateFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const issues = [];
+
+  // Check for any remaining .contains() that might have been missed
+  const remainingContains = content.match(/\w+\.contains\(/g);
+  if (remainingContains) {
+    const validContains = remainingContains.filter(match => match.includes('classList.contains(')
+      || match.includes('activeElement.contains(')
+      || match.includes('focusedElement.contains('));
+
+    if (remainingContains.length !== validContains.length) {
+      issues.push(`Still has ${remainingContains.length - validContains.length} .contains() calls that might need fixing`);
+    }
+  }
+
+  // Check for potential syntax issues
+  if (content.includes('.find().exists()') || content.includes('.findComponent().exists()')) {
+    issues.push('Found empty .find() or .findComponent() calls');
+  }
+
+  return issues;
+}
+
+// Main execution
+function main() {
+  const testsDir = path.join(__dirname, 'tests', 'unit');
+
+  if (!fs.existsSync(testsDir)) {
+    console.error('Tests directory not found:', testsDir);
+    process.exit(1);
+  }
+
+  console.log('Finding all .spec.js files...');
+  const specFiles = findSpecFiles(testsDir);
+
+  console.log(`Found ${specFiles.length} spec files`);
+  console.log('');
+
+  let totalModified = 0;
+  let totalIssues = 0;
+
+  specFiles.forEach((file) => {
+    if (processFile(file)) {
+      totalModified++;
+    }
+
+    // Validate the changes
+    const issues = validateFile(file);
+    if (issues.length > 0) {
+      console.log('  ⚠️  Validation issues:');
+      issues.forEach(issue => console.log(`     - ${issue}`));
+      totalIssues++;
+    }
+
+    console.log('');
+  });
+
+  console.log(`Completed! Modified ${totalModified} out of ${specFiles.length} files.`);
+  if (totalIssues > 0) {
+    console.log(`⚠️  ${totalIssues} files have validation issues that may need manual review.`);
+  }
+  console.log('');
+  console.log('Summary of replacements:');
+  console.log('- wrapper.contains(Component) → wrapper.findComponent(Component).exists()');
+  console.log('- wrapper.contains("selector") → wrapper.find("selector").exists()');
+  console.log('- Preserved native DOM .contains() methods (classList, activeElement, etc.)');
+  console.log('- Handled chained calls like wrapper.findComponent().contains()');
+}
+
+// Run the script
+main();