xtrm-tools 2.0.0

package/project-skills/tdd-guard/reporters/pytest/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "tdd-guard-pytest"
+version = "0.1.2"
+description = "Pytest plugin for TDD Guard - enforces Test-Driven Development principles"
+authors = [{name = "Nizar Selander"}, {name = "Durafen"}]
+license = "MIT"
+readme = "README.md"
+keywords = ["tdd", "test-driven-development", "testing", "pytest", "claude"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Quality Assurance",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "pytest>=6.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/nizos/tdd-guard"
+"Repository" = "https://github.com/nizos/tdd-guard"
+"Bug Tracker" = "https://github.com/nizos/tdd-guard/issues"
+"Documentation" = "https://github.com/nizos/tdd-guard/tree/main/reporters/pytest"
+
+[project.entry-points."pytest11"]
+tdd-guard = "tdd_guard_pytest.pytest_reporter"
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]

package/project-skills/tdd-guard/reporters/pytest/pytest.ini.example

@@ -0,0 +1,7 @@
+# Example pytest configuration for TDD Guard development
+# Copy this file to pytest.ini and adjust the path to your project root
+
+[pytest]
+# Set this to the absolute path of your tdd-guard project root
+# This ensures test results are saved to the correct location
+tdd_guard_project_root = /path/to/tdd-guard

package/project-skills/tdd-guard/reporters/pytest/tdd_guard_pytest/__init__.py

@@ -0,0 +1 @@
+"""TDD Guard pytest plugin for capturing test results."""

package/project-skills/tdd-guard/reporters/pytest/tdd_guard_pytest/pytest_reporter.py

@@ -0,0 +1,134 @@
+"""
+TDD Guard pytest plugin - captures test results for TDD validation.
+
+This plugin automatically activates when tdd-guard-pytest is installed.
+No configuration needed - it registers via the pytest11 entry point.
+"""
+
+import json
+import os
+from pathlib import Path
+import pytest
+
+
+# Default storage directory relative to project root
+DEFAULT_DATA_DIR = Path('.claude/tdd-guard/data')
+
+
+class TDDGuardPytestPlugin:
+    """Pytest plugin that captures test results for TDD Guard"""
+    
+    def __init__(self, config=None, cwd=None):
+        self.test_results = []
+        self.storage_dir = self._determine_storage_dir(config, cwd)
+    
+    def _determine_storage_dir(self, config, cwd):
+        """Determine the storage directory based on config and current working directory."""
+        current_dir = cwd if cwd is not None else Path.cwd()
+        
+        # Try to get project root from config
+        project_root = self._get_project_root_from_config(config)
+        if not project_root:
+            return DEFAULT_DATA_DIR
+        
+        # Validate that it's an absolute path
+        if not os.path.isabs(project_root):
+            return DEFAULT_DATA_DIR
+        
+        # Validate that cwd is within project root
+        if self._is_cwd_within_project_root(current_dir, project_root):
+            return Path(project_root) / DEFAULT_DATA_DIR
+        else:
+            return DEFAULT_DATA_DIR
+    
+    def _get_project_root_from_config(self, config):
+        """Extract project root from config if available."""
+        if config and hasattr(config, 'getini'):
+            return config.getini('tdd_guard_project_root')
+        return None
+    
+    def _is_cwd_within_project_root(self, cwd, project_root):
+        """Check if current working directory is within the project root."""
+        try:
+            cwd.relative_to(Path(project_root))
+            return True
+        except ValueError:
+            return False
+    
+    def pytest_collectreport(self, report):
+        """Capture collection errors (import failures, etc.)"""
+        if report.failed:
+            # Create a synthetic test result for collection failures
+            test_result = {
+                'name': f"collection_error_{report.nodeid or 'unknown'}",
+                'fullName': report.nodeid or 'collection_error',
+                'state': 'failed',
+                'errors': [{'message': str(report.longrepr)}]
+            }
+            self.test_results.append(test_result)
+    
+    def pytest_runtest_logreport(self, report):
+        """Collect test results during pytest execution."""
+        if report.when == 'call':  # Only capture the main test execution phase
+            test_result = {
+                'name': report.nodeid.split('::')[-1] if '::' in report.nodeid else report.nodeid,
+                'fullName': report.nodeid,
+                'state': 'passed' if report.passed else ('failed' if report.failed else 'skipped')
+            }
+            
+            if report.failed and hasattr(report, 'longrepr') and report.longrepr:
+                test_result['errors'] = [{'message': str(report.longrepr)}]
+            
+            self.test_results.append(test_result)
+    
+    def pytest_sessionfinish(self, session, exitstatus):
+        """Save results to TDD Guard storage - equivalent to VitestReporter.onTestRunEnd()"""
+        # Group tests by module (same format as VitestReporter)
+        modules_map = {}
+        for test in self.test_results:
+            module_path = test['fullName'].split('::')[0]
+            if module_path not in modules_map:
+                modules_map[module_path] = {
+                    'moduleId': module_path,
+                    'tests': []
+                }
+            modules_map[module_path]['tests'].append(test)
+        
+        output = {
+            'testModules': list(modules_map.values())
+        }
+        
+        # Save to TDD Guard storage (same as VitestReporter.storage.saveTest())
+        # Create directory recursively like FileStorage.ensureDirectory()
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Save as JSON (matching FileStorage.saveTest format)
+        storage_path = self.storage_dir / 'test.json'
+        with open(storage_path, 'w') as f:
+            json.dump(output, f, indent=2)
+
+
+# Stash key for storing our plugin instance
+tdd_guard_stash_key = pytest.StashKey[TDDGuardPytestPlugin]()
+
+
+def pytest_addoption(parser):
+    """Register configuration options"""
+    parser.addini(
+        "tdd_guard_project_root",
+        help="Absolute path to project root for TDD Guard storage",
+        default=""
+    )
+
+def pytest_configure(config):
+    """Register and configure the plugin"""
+    plugin = TDDGuardPytestPlugin(config)
+    config.stash[tdd_guard_stash_key] = plugin
+    config.pluginmanager.register(plugin)
+
+
+def pytest_unconfigure(config):
+    """Unregister the plugin"""
+    plugin = config.stash.get(tdd_guard_stash_key, None)
+    if plugin is not None:
+        config.pluginmanager.unregister(plugin)

package/project-skills/tdd-guard/reporters/pytest/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for TDD Guard pytest reporter."""

package/project-skills/tdd-guard/reporters/pytest/tests/conftest.py

@@ -0,0 +1,3 @@
+"""Pytest configuration for integration tests."""
+
+pytest_plugins = ["pytester"]

package/project-skills/tdd-guard/reporters/pytest/tests/helpers.py

@@ -0,0 +1,293 @@
+"""Shared test helpers for pytest reporter tests"""
+import json
+import shutil
+import tempfile
+import subprocess
+import sys
+from pathlib import Path
+
+from tdd_guard_pytest.pytest_reporter import DEFAULT_DATA_DIR
+
+
+def create_config(project_root_value):
+    """Helper to create a config object that returns a specific project root value"""
+    class TestConfig:
+        def getini(self, name):
+            if name == 'tdd_guard_project_root':
+                return project_root_value
+            return ""
+    return TestConfig()
+
+
+def check_pytest_accepts_config(config_content, config_filename="pytest.ini"):
+    """Check that pytest accepts tdd_guard_project_root in a config file
+    
+    Args:
+        config_content: The configuration file content
+        config_filename: Name of the config file (pytest.ini, pyproject.toml, setup.cfg)
+    
+    Returns:
+        subprocess result
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create a test file
+        test_file = Path(tmpdir) / "test_dummy.py"
+        test_file.write_text("def test_dummy(): pass")
+        
+        # Create config file
+        config_file = Path(tmpdir) / config_filename
+        config_file.write_text(config_content)
+        
+        # Run pytest with the config
+        result = subprocess.run(
+            [sys.executable, "-m", "pytest", "--version", "-c", str(config_file)],
+            cwd=tmpdir,
+            capture_output=True,
+            text=True
+        )
+        
+        return result
+
+
+# Integration test helpers
+def create_test_file(pytester, filename=None, content=None):
+    """Create a test file with default content if not specified."""
+    if content is None:
+        content = """
+def test_example_pass():
+    assert True
+
+def test_example_fail():
+    assert False
+        """.strip()
+    
+    if filename:
+        return pytester.makepyfile(**{filename: content})
+    else:
+        return pytester.makepyfile(content)
+
+
+def create_simple_passing_test(pytester, test_name="test_simple", filename=None):
+    """Create a simple passing test file."""
+    content = f"""
+def {test_name}():
+    assert True
+    """.strip()
+    
+    return create_test_file(pytester, filename, content)
+
+
+def create_pytest_ini(pytester, project_root=None):
+    """Create pytest.ini with optional project root configuration."""
+    if project_root:
+        content = f"""
+[pytest]
+tdd_guard_project_root = {project_root}
+        """.strip()
+    else:
+        content = """
+[pytest]
+        """.strip()
+    
+    return pytester.makeini(content)
+
+
+def create_project_structure(base_path, structure):
+    """Create a directory structure from a dict specification.
+    
+    Example:
+        create_project_structure(tmp_path, {
+            "src": {
+                "models": {},
+                "tests": {
+                    "test_models.py": "def test_model():\\n    assert True"
+                }
+            },
+            "pytest.ini": "[pytest]\\naddopts = -v"
+        })
+    """
+    for name, content in structure.items():
+        path = base_path / name
+        if isinstance(content, dict):
+            # It's a directory
+            path.mkdir(exist_ok=True)
+            create_project_structure(path, content)
+        else:
+            # It's a file
+            path.write_text(content)
+
+
+def verify_test_results(json_file, expected_tests):
+    """Verify that test results match expected outcomes."""
+    with open(json_file) as f:
+        data = json.load(f)
+    
+    all_tests = []
+    for module in data["testModules"]:
+        if isinstance(module, dict) and "tests" in module:
+            all_tests.extend(module["tests"])
+        elif isinstance(module, dict):
+            # Handle nested structure
+            for module_data in module.values():
+                if isinstance(module_data, dict) and "tests" in module_data:
+                    all_tests.extend(module_data["tests"])
+    
+    assert len(all_tests) == len(expected_tests)
+    
+    for test_name, expected_state in expected_tests:
+        matching_test = next((t for t in all_tests if t["name"] == test_name), None)
+        assert matching_test is not None, f"Test '{test_name}' not found"
+        assert matching_test["state"] == expected_state, \
+            f"Test '{test_name}' has state '{matching_test['state']}', expected '{expected_state}'"
+
+
+def extract_all_test_names(data):
+    """Extract all test names from the JSON data structure."""
+    test_names = []
+    for module in data["testModules"]:
+        if isinstance(module, dict) and "tests" in module:
+            test_names.extend(t["name"] for t in module["tests"])
+        elif isinstance(module, dict):
+            # Handle nested structure
+            for module_data in module.values():
+                if isinstance(module_data, dict) and "tests" in module_data:
+                    test_names.extend(t["name"] for t in module_data["tests"])
+    return test_names
+
+
+def assert_json_file_exists(path, data_dir=DEFAULT_DATA_DIR):
+    """Assert that the JSON test results file exists at the given path."""
+    json_file = path / data_dir / "test.json"
+    assert json_file.exists(), f"Expected test results at {json_file}"
+    return json_file
+
+
+def assert_json_file_not_exists(path, data_dir=DEFAULT_DATA_DIR):
+    """Assert that the JSON test results file does NOT exist at the given path."""
+    json_file = path / data_dir / "test.json"
+    assert not json_file.exists(), f"Unexpected test results at {json_file}"
+
+
+def create_multiple_test_files(pytester, test_specs):
+    """Create multiple test files from a dictionary specification.
+    
+    Args:
+        pytester: The pytester fixture
+        test_specs: Dict mapping filename to test content or list of (test_name, should_pass) tuples
+        
+    Example:
+        create_multiple_test_files(pytester, {
+            "test_auth": [("test_login", True), ("test_logout", True)],
+            "test_db": "def test_connection():\\n    assert True"
+        })
+    """
+    files = {}
+    for filename, spec in test_specs.items():
+        if isinstance(spec, str):
+            # Direct content provided
+            files[filename] = spec
+        elif isinstance(spec, list):
+            # Generate tests from (name, should_pass) tuples
+            test_lines = []
+            for test_name, should_pass in spec:
+                test_lines.append(f"""
+def {test_name}():
+    assert {should_pass}
+""".strip())
+            files[filename] = "\n\n".join(test_lines)
+        else:
+            raise ValueError(f"Invalid spec type for {filename}: {type(spec)}")
+    
+    return pytester.makepyfile(**files)
+
+
+def copy_project_and_update_root(pytester, source_project, project_name=None):
+    """Copy a project to pytester directory and update its pytest.ini with new path.
+    
+    Args:
+        pytester: The pytester fixture
+        source_project: Path to the source project
+        project_name: Optional name for the copied project (defaults to source name)
+        
+    Returns:
+        Path to the copied project
+    """
+    if project_name is None:
+        project_name = source_project.name
+    
+    copied_project = pytester.path / project_name
+    shutil.copytree(source_project, copied_project)
+    
+    # Update pytest.ini with new path
+    ini_file = copied_project / "pytest.ini"
+    if ini_file.exists():
+        ini_file.write_text(f"""
+[pytest]
+tdd_guard_project_root = {copied_project}
+""".strip())
+    
+    return copied_project
+
+
+def create_passing_test(test_name="test_example", content=None):
+    """Generate a simple passing test function.
+    
+    Args:
+        test_name: Name of the test function
+        content: Optional custom assertion content
+        
+    Returns:
+        String containing the test function
+    """
+    if content is None:
+        content = "assert True"
+    
+    return f"""
+def {test_name}():
+    {content}
+""".strip()
+
+
+def create_failing_test(test_name="test_example", content=None):
+    """Generate a simple failing test function.
+    
+    Args:
+        test_name: Name of the test function
+        content: Optional custom assertion content
+        
+    Returns:
+        String containing the test function
+    """
+    if content is None:
+        content = "assert False"
+    
+    return f"""
+def {test_name}():
+    {content}
+""".strip()
+
+
+def load_test_results(json_file):
+    """Load test results from JSON file.
+    
+    Args:
+        json_file: Path to the JSON file
+        
+    Returns:
+        Dict containing the test results data
+    """
+    with open(json_file) as f:
+        return json.load(f)
+
+
+def get_test_names_from_file(json_file):
+    """Load JSON file and extract all test names.
+    
+    Args:
+        json_file: Path to the JSON file
+        
+    Returns:
+        List of test names
+    """
+    data = load_test_results(json_file)
+    return extract_all_test_names(data)

package/project-skills/tdd-guard/reporters/pytest/tests/test_config_option.py

@@ -0,0 +1,38 @@
+"""Test configuration option for project root"""
+from .helpers import check_pytest_accepts_config
+
+
+def test_pytest_ini_accepts_project_root():
+    """Test that pytest.ini accepts tdd_guard_project_root configuration"""
+    result = check_pytest_accepts_config("""
+[pytest]
+tdd_guard_project_root = /some/path
+""", "pytest.ini")
+    
+    # Should succeed without "unknown config option" error
+    assert result.returncode == 0
+    assert "unknown config option" not in result.stderr.lower()
+
+
+def test_pyproject_toml_accepts_project_root():
+    """Test that pyproject.toml accepts tdd_guard_project_root configuration"""
+    result = check_pytest_accepts_config("""
+[tool.pytest.ini_options]
+tdd_guard_project_root = "/some/path"
+""", "pyproject.toml")
+    
+    # Should succeed without "unknown config option" error
+    assert result.returncode == 0
+    assert "unknown config option" not in result.stderr.lower()
+
+
+def test_setup_cfg_accepts_project_root():
+    """Test that setup.cfg accepts tdd_guard_project_root configuration"""
+    result = check_pytest_accepts_config("""
+[tool:pytest]
+tdd_guard_project_root = /some/path
+""", "setup.cfg")
+    
+    # Should succeed without "unknown config option" error
+    assert result.returncode == 0
+    assert "unknown config option" not in result.stderr.lower()

package/project-skills/tdd-guard/reporters/pytest/tests/test_path_validation.py

@@ -0,0 +1,59 @@
+"""Test path validation for project root configuration"""
+from pathlib import Path
+from tdd_guard_pytest.pytest_reporter import TDDGuardPytestPlugin, DEFAULT_DATA_DIR
+from .helpers import create_config
+
+
+def test_plugin_only_accepts_absolute_paths():
+    """Test that plugin ignores relative paths"""
+    config = create_config("../some/relative/path")
+    plugin = TDDGuardPytestPlugin(config)
+    
+    # Should fall back to default when relative path is provided
+    assert plugin.storage_dir == DEFAULT_DATA_DIR
+
+
+def test_plugin_rejects_project_root_when_cwd_is_outside():
+    """Test that plugin rejects project root if cwd is not within it"""
+    project_root = Path("/other/project")
+    cwd = Path("/test/current")
+    
+    config = create_config(str(project_root))
+    plugin = TDDGuardPytestPlugin(config, cwd=cwd)
+    
+    # Should fall back to default since cwd is not within project_root
+    assert plugin.storage_dir == DEFAULT_DATA_DIR
+
+
+def test_plugin_accepts_project_root_same_as_cwd():
+    """Test that plugin accepts project root when it equals cwd"""
+    cwd = Path("/test/project")
+    
+    config = create_config(str(cwd))
+    plugin = TDDGuardPytestPlugin(config, cwd=cwd)
+    
+    # Should use the configured directory since cwd == project root
+    expected_storage = cwd / DEFAULT_DATA_DIR
+    assert plugin.storage_dir == expected_storage
+
+
+def test_plugin_accepts_project_root_when_cwd_is_child():
+    """Test that plugin accepts project root when cwd is a child of it"""
+    project_root = Path("/test/project")
+    cwd = project_root / "subdir"
+    
+    config = create_config(str(project_root))
+    plugin = TDDGuardPytestPlugin(config, cwd=cwd)
+    
+    # Should use the configured directory since cwd is within parent
+    expected_storage = project_root / DEFAULT_DATA_DIR
+    assert plugin.storage_dir == expected_storage
+
+
+def test_plugin_handles_empty_config_value():
+    """Test that plugin uses default when config returns empty string"""
+    config = create_config("")
+    plugin = TDDGuardPytestPlugin(config)
+    
+    # Should fall back to default when config is empty
+    assert plugin.storage_dir == DEFAULT_DATA_DIR

package/project-skills/tdd-guard/reporters/pytest/tests/test_plugin_config.py

@@ -0,0 +1,32 @@
+"""Test plugin configuration functionality"""
+from pathlib import Path
+from tdd_guard_pytest.pytest_reporter import TDDGuardPytestPlugin, DEFAULT_DATA_DIR
+from .helpers import create_config
+
+
+def test_plugin_accepts_config_parameter():
+    """Test that TDDGuardPytestPlugin can be initialized with a config parameter"""
+    # Create a minimal config object
+    class MinimalConfig:
+        pass
+    
+    config = MinimalConfig()
+    
+    # Plugin should accept config parameter without error
+    plugin = TDDGuardPytestPlugin(config)
+    
+    # Default behavior - should still use default storage dir
+    assert plugin.storage_dir == DEFAULT_DATA_DIR
+
+
+def test_plugin_uses_configured_project_root():
+    """Test that plugin uses tdd_guard_project_root from config"""
+    project_root = Path("/test/project")
+    cwd = project_root / "subdir"
+    
+    config = create_config(str(project_root))
+    plugin = TDDGuardPytestPlugin(config, cwd=cwd)
+    
+    # Plugin should use the configured directory
+    expected_storage = project_root / DEFAULT_DATA_DIR
+    assert plugin.storage_dir == expected_storage