fix(ci): resolve pytest import errors and correct pattern validation tests

Author: rookiestar28

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-doctor"
 description = "A real-time runtime diagnostics suite for ComfyUI, featuring interactive debugging chat, and 50+ fix patterns. Automatically intercepts terminal output from startup, and delivers prioritized fix suggestions with node-level context extraction. Now supports JSON-based pattern management with hot-reload and full i18n support for 9 languages."
-version = "1.3.1"
+version = "1.3.2"
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.10"

pytest.ini

@@ -1,3 +1,32 @@
-# Explicitly exclude root __init__.py fromPytest collection
-[tool:pytest]
-collect_ignore = ['__init__.py']
+# ═══════════════════════════════════════════════════════════════════════════
+# Pytest Configuration for ComfyUI-Doctor
+# ═══════════════════════════════════════════════════════════════════════════
+# Purpose: Prevent pytest from importing __init__.py as a test module
+#
+# Problem (without this config):
+#   - pytest auto-discovers all Python files
+#   - Tries to import __init__.py as a test module
+#   - __init__.py uses relative imports (from .logger import ...)
+#   - Relative imports fail with "no known parent package" error
+#
+# Solution:
+#   - Explicitly tell pytest to only look in tests/ directory
+#   - Ignore __init__.py and other non-test files
+#
+# Last Modified: 2026-01-03 (Fixed CI import errors)
+# ═══════════════════════════════════════════════════════════════════════════
+[pytest]
+# Only collect tests from these directories
+testpaths = tests
+
+# Ignore these files during test collection
+norecursedirs = .git .github REFERENCE web patterns __pycache__ *.egg-info
+
+# Don't try to import __init__.py as a test module
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# CRITICAL: Use importlib mode to prevent pytest from treating root as package
+# This prevents pytest from trying to import the root __init__.py
+addopts = --import-mode=importlib

tests/__init__.py

@@ -0,0 +1,2 @@
+# Empty __init__.py for tests package
+# This prevents pytest from trying to import the root __init__.py

tests/conftest.py

@@ -1,19 +1,60 @@
 """
-Pytest configuration for ComfyUI-Doctor tests
+Pytest configuration for ComfyUI-Doctor tests.
+
+CRITICAL: This conftest.py prevents pytest from treating the project root as a Python package.
+
+Problem:
+  - ComfyUI-Doctor/__init__.py uses relative imports (from .logger import ...)
+  - These only work when the module is imported as part of a package (e.g., custom_nodes.ComfyUI-Doctor)
+  - Pytest tries to import __init__.py directly, causing "no known parent package" errors
+
+Solution:
+  - Tell pytest to NOT treat the root directory as a package
+  - Rename root __init__.py temporarily during test collection
+
+Last Modified: 2026-01-03 (Fixed CI import errors)
 """
 
 import sys
 from pathlib import Path
 
-# Add project root to path
+# Add project root to sys.path for absolute imports
 project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root))
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
 
 def pytest_ignore_collect(collection_path, config):
     """
-    Ignore __init__.py in project root (it's a ComfyUI extension with relative imports)
+    Prevent pytest from collecting __init__.py in the project root.
+
+    This prevents the "attempted relative import with no known parent package" error
+    that occurs when pytest tries to import __init__.py as a standalone module.
     """
     if collection_path.name == "__init__.py" and collection_path.parent == project_root:
         return True
     return False
 
+def pytest_configure(config):
+    """
+    Rename root __init__.py before test collection to prevent pytest from treating root as package.
+    """
+    root_init = project_root / "__init__.py"
+    backup_init = project_root / "__init__.py.bak"
+
+    if root_init.exists() and not backup_init.exists():
+        root_init.rename(backup_init)
+        config._comfyui_doctor_init_renamed = True
+    else:
+        config._comfyui_doctor_init_renamed = False
+
+def pytest_unconfigure(config):
+    """
+    Restore root __init__.py after tests complete.
+    """
+    if getattr(config, '_comfyui_doctor_init_renamed', False):
+        root_init = project_root / "__init__.py"
+        backup_init = project_root / "__init__.py.bak"
+
+        if backup_init.exists():
+            backup_init.rename(root_init)
+

tests/test_pattern_validation.py

@@ -5,6 +5,25 @@
 Validates JSON schema, regex syntax, i18n completeness, and metadata.
 
 Run: pytest tests/test_pattern_validation.py -v
+
+═══════════════════════════════════════════════════════════════════════════
+⚠️ CRITICAL: Field Name Consistency Warning
+═══════════════════════════════════════════════════════════════════════════
+This test suite validates JSON pattern files against the schema.
+
+IMPORTANT: JSON Schema Field Names (DO NOT CHANGE):
+  - patterns/schema.json uses "regex" (NOT "pattern")
+  - patterns/schema.json uses "error_key" (NOT "suggestion_key")
+
+Common Mistake:
+  ❌ required_fields = ["id", "pattern", "suggestion_key", ...]
+  ✅ required_fields = ["id", "regex", "error_key", ...]
+
+If tests fail with "missing required field", check that test expectations
+match the actual schema definition in patterns/schema.json.
+
+Last Modified: 2026-01-03 (Fixed field name mismatch)
+═══════════════════════════════════════════════════════════════════════════
 """
 
 import json
@@ -51,28 +70,34 @@ def load_pattern_file(file_path: Path) -> Dict:
         return json.load(f)
 
 
-def extract_error_keys_from_i18n() -> Set[str]:
-    """Extract all ERROR_KEYS from i18n.py"""
+def extract_error_keys_from_i18n() -> Dict[str, str]:
+    """
+    Extract ERROR_KEYS mapping from i18n.py.
+
+    Returns:
+        Dict mapping uppercase keys to lowercase suggestion keys.
+        Example: {"TYPE_MISMATCH": "type_mismatch", "CUDNN_ERROR": "cudnn_error", ...}
+    """
     with open(I18N_PATH, "r", encoding="utf-8") as f:
         content = f.read()
-    
+
     # Find ERROR_KEYS dictionary
-    start = content.find("ERROR_KEYS")
+    start = content.find("ERROR_KEYS = {")
     if start == -1:
-        return set()
-    
-    # Extract keys (simplified parsing)
-    keys = set()
+        return {}
+
+    # Extract key-value pairs (simplified parsing)
+    error_keys_dict = {}
     lines = content[start:].split("\n")
     for line in lines:
         if '"' in line and ":" in line:
-            # Extract key from line like: "oom": "oom",
-            match = re.search(r'"([^"]+)":\s*"', line)
+            # Extract key-value from line like: "TYPE_MISMATCH": "type_mismatch",
+            match = re.search(r'"([^"]+)":\s*"([^"]+)"', line)
             if match:
-                keys.add(match.group(1))
+                error_keys_dict[match.group(1)] = match.group(2)
         if line.strip() == "}":
             break
-    return keys
+    return error_keys_dict
 
 
 def extract_suggestions_from_i18n() -> Dict[str, Set[str]]:
@@ -152,8 +177,11 @@ def test_all_patterns_valid_json(self):
 
     def test_all_patterns_have_required_fields(self, all_patterns):
         """Test 2: All patterns have required fields"""
-        required_fields = ["id", "pattern", "priority", "category", "suggestion_key"]
-        
+        # ⚠️ CRITICAL: These field names MUST match patterns/schema.json
+        # DO NOT change "regex" to "pattern" or "error_key" to "suggestion_key"
+        # See file docstring for detailed explanation
+        required_fields = ["id", "regex", "error_key", "priority", "category"]
+
         for pattern in all_patterns:
             for field in required_fields:
                 assert field in pattern, (
@@ -165,43 +193,46 @@ def test_all_regex_compile(self, all_patterns):
         """Test 3: All regex patterns compile successfully"""
         for pattern in all_patterns:
             pattern_id = pattern.get("id", "UNKNOWN")
-            regex_str = pattern.get("pattern", "")
-            
+            # ⚠️ CRITICAL: Use "regex" (schema field name), NOT "pattern"
+            regex_str = pattern.get("regex", "")
+
             try:
                 re.compile(regex_str)
             except re.error as e:
                 pytest.fail(
                     f"Pattern {pattern_id} in {pattern['_source_file']} "
                     f"has invalid regex: {e}"
                 )
-    
+
     def test_all_suggestions_exist(self, all_patterns, error_keys, suggestions):
-        """Test 4: All suggestion_key values exist in i18n.py"""
+        """Test 4: All error_key values exist in i18n.py ERROR_KEYS and SUGGESTIONS"""
         # Check ERROR_KEYS mapping
         for pattern in all_patterns:
             pattern_id = pattern.get("id", "UNKNOWN")
-            suggestion_key = pattern.get("suggestion_key", "")
-            
-            assert suggestion_key in error_keys, (
+            # ⚠️ CRITICAL: Use "error_key" (schema field name), NOT "suggestion_key"
+            error_key = pattern.get("error_key", "")
+
+            assert error_key in error_keys, (
                 f"Pattern {pattern_id} in {pattern['_source_file']} "
-                f"has suggestion_key '{suggestion_key}' not found in ERROR_KEYS"
+                f"has error_key '{error_key}' not found in ERROR_KEYS"
             )
-        
+
         # Check all languages have translations
         for lang in SUPPORTED_LANGUAGES:
             assert lang in suggestions, f"Language '{lang}' not found in SUGGESTIONS"
-            
+
             for pattern in all_patterns:
                 pattern_id = pattern.get("id", "UNKNOWN")
-                suggestion_key = pattern.get("suggestion_key", "")
-                
-                # Map through ERROR_KEYS to get the actual key
-                if suggestion_key in error_keys:
-                    # For simplicity, assume suggestion_key IS the final key
-                    # (in reality, ERROR_KEYS maps pattern keys to suggestion keys)
-                    assert suggestion_key in suggestions[lang], (
-                        f"Pattern {pattern_id} missing {lang} translation for '{suggestion_key}'"
-                    )
+                error_key = pattern.get("error_key", "")
+
+                # Get the suggestion key from ERROR_KEYS mapping
+                # Example: error_key="CUDNN_ERROR" -> suggestion_key="cudnn_error"
+                suggestion_key = error_keys.get(error_key, "")
+
+                assert suggestion_key in suggestions[lang], (
+                    f"Pattern {pattern_id} (error_key: {error_key}) missing {lang} translation. "
+                    f"Expected suggestion key '{suggestion_key}' in SUGGESTIONS['{lang}']"
+                )
 
     def test_priority_ranges(self, all_patterns):
         """Test 5: All priorities are within valid range 50-95"""