xtrm-tools 2.0.0

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

@@ -0,0 +1,296 @@
+"""Integration tests for tdd_guard_project_root configuration.
+
+Tests the pytest reporter's ability to save test results at a configured
+project root directory, regardless of where pytest is executed from.
+"""
+
+import textwrap
+
+import pytest
+
+from tdd_guard_pytest.pytest_reporter import DEFAULT_DATA_DIR
+from .helpers import (
+    assert_json_file_exists,
+    assert_json_file_not_exists,
+    copy_project_and_update_root,
+    create_multiple_test_files,
+    create_project_structure,
+    create_pytest_ini,
+    create_simple_passing_test,
+    create_test_file,
+    extract_all_test_names,
+    get_test_names_from_file,
+    load_test_results,
+    verify_test_results,
+)
+
+
+class TestProjectRootConfiguration:
+    """Test suite for tdd_guard_project_root configuration feature."""
+
+    def test_default_behavior_without_configuration(self, pytester):
+        """When no project root is configured, saves to default relative path."""
+        create_simple_passing_test(pytester)
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        assert_json_file_exists(pytester.path)
+
+    def test_relative_path_falls_back_to_default(self, pytester):
+        """Relative paths in configuration are ignored, falling back to default."""
+        create_pytest_ini(pytester, "./relative/path")
+        create_simple_passing_test(pytester)
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        # Should use default location, not the relative path
+        assert_json_file_exists(pytester.path)
+
+    def test_absolute_path_outside_current_directory(self, pytester, tmp_path):
+        """Absolute path is rejected when current directory is not within it."""
+        external_root = tmp_path / "external_project"
+        external_root.mkdir()
+        
+        create_pytest_ini(pytester, external_root)
+        create_simple_passing_test(pytester)
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        # Should fall back to default location
+        assert_json_file_exists(pytester.path)
+        
+        # Should NOT create file in the external root
+        assert_json_file_not_exists(external_root)
+
+    @pytest.mark.parametrize("config_file,content", [
+        ("pyproject.toml", """
+            [tool.pytest.ini_options]
+            tdd_guard_project_root = "{root}"
+        """),
+        ("setup.cfg", """
+            [tool:pytest]
+            tdd_guard_project_root = {root}
+        """),
+        ("pytest.ini", """
+            [pytest]
+            tdd_guard_project_root = {root}
+        """),
+    ])
+    def test_configuration_methods(self, pytester, tmp_path, config_file, content):
+        """Project root can be configured via pyproject.toml, setup.cfg, or pytest.ini."""
+        # Create external directory for testing fallback
+        external_root = tmp_path / "external"
+        external_root.mkdir()
+        
+        # Configure with external path (will fall back since cwd not within it)
+        if config_file == "pyproject.toml":
+            pytester.makefile(".toml", pyproject=content.format(root=external_root))
+        else:
+            config_content = textwrap.dedent(content.format(root=external_root)).strip()
+            pytester.makeini(config_content)
+        
+        create_simple_passing_test(pytester)
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        # Should use default since we're not within external_root
+        assert_json_file_exists(pytester.path)
+
+    def test_saves_to_project_root_from_subdirectory(self, pytester, tmp_path, monkeypatch):
+        """When running from subdirectory, saves results at project root."""
+        # Set up project with custom test content
+        project_root = tmp_path / "my_project"
+        structure = {
+            "src": {"__init__.py": ""},
+            "tests": {
+                "unit": {
+                    "test_user_service.py": """
+def test_create_user():
+    user = {"name": "Alice", "age": 30}
+    assert user["name"] == "Alice"
+
+def test_validate_age():
+    age = 25
+    assert age >= 18, "User must be an adult"
+                    """.strip()
+                }
+            },
+            "pytest.ini": f"""
+[pytest]
+tdd_guard_project_root = {project_root}
+            """.strip()
+        }
+        
+        project_root.mkdir()
+        create_project_structure(project_root, structure)
+        
+        # Copy and update paths
+        copied_project = copy_project_and_update_root(pytester, project_root)
+        
+        # Run pytest from subdirectory
+        monkeypatch.chdir(copied_project / "tests" / "unit")
+        result = pytester.runpytest("test_user_service.py")
+        result.assert_outcomes(passed=2)
+        
+        # Verify file created at project root, not in subdirectory
+        json_file = assert_json_file_exists(copied_project)
+        assert_json_file_not_exists(copied_project / "tests" / "unit")
+        
+        # Verify JSON content
+        verify_test_results(json_file, expected_tests=[
+            ("test_create_user", "passed"),
+            ("test_validate_age", "passed")
+        ])
+
+    def test_deeply_nested_directory_structure(self, pytester, tmp_path, monkeypatch):
+        """Handles deeply nested directory structures correctly."""
+        # Create complex project structure
+        project_root = tmp_path / "complex_project"
+        structure = {
+            "test_integration.py": """
+def test_system_integration():
+    components = ["auth", "database", "api"]
+    assert len(components) == 3
+            """.strip(),
+            "src": {
+                "components": {
+                    "widgets": {
+                        "tests": {
+                            "test_button_widget.py": """
+def test_button_click():
+    clicked = True
+    assert clicked
+
+def test_button_disabled_state():
+    button = {"enabled": False}
+    assert not button["enabled"]
+                            """.strip()
+                        }
+                    }
+                }
+            },
+            "pytest.ini": f"""
+[pytest]
+tdd_guard_project_root = {project_root}
+            """.strip()
+        }
+        
+        project_root.mkdir()
+        create_project_structure(project_root, structure)
+        
+        # Copy and update paths
+        copied_project = copy_project_and_update_root(pytester, project_root)
+        
+        # Run from deep directory
+        monkeypatch.chdir(copied_project / "src" / "components" / "widgets" / "tests")
+        result = pytester.runpytest(str(copied_project))
+        result.assert_outcomes(passed=3)
+        
+        # Verify results saved at project root
+        json_file = assert_json_file_exists(copied_project)
+        
+        # Verify all tests are captured
+        all_test_names = get_test_names_from_file(json_file)
+        assert "test_system_integration" in all_test_names
+        assert "test_button_click" in all_test_names
+        assert "test_button_disabled_state" in all_test_names
+
+    def test_current_directory_as_project_root(self, pytester):
+        """Tests using '.' (current directory) as project root."""
+        create_pytest_ini(pytester, ".")
+        create_simple_passing_test(pytester)
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        # "." should be treated as relative path and fall back to default
+        assert_json_file_exists(pytester.path)
+
+    def test_json_output_structure(self, pytester):
+        """Verifies the JSON output format matches expected structure."""
+        create_test_file(pytester)  # Uses default pass/fail tests
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1, failed=1)
+        
+        json_file = assert_json_file_exists(pytester.path)
+        data = load_test_results(json_file)
+        
+        # Verify structure
+        assert "testModules" in data
+        assert len(data["testModules"]) == 1
+        
+        module = data["testModules"][0]
+        assert "moduleId" in module
+        assert "tests" in module
+        assert len(module["tests"]) == 2
+        
+        # Verify each test has required fields
+        for test in module["tests"]:
+            assert "name" in test
+            assert "fullName" in test
+            assert "state" in test
+            assert test["state"] in ["passed", "failed"]
+            
+            if test["state"] == "failed":
+                assert "errors" in test
+                assert len(test["errors"]) > 0
+                assert "message" in test["errors"][0]
+
+    def test_multiple_test_modules(self, pytester):
+        """Correctly handles multiple test modules in a single run."""
+        # Create multiple test files
+        create_multiple_test_files(pytester, {
+            "test_auth": [
+                ("test_login", 'len("abc123") > 0'),
+                ("test_logout", 'not False')
+            ],
+            "test_database": [
+                ("test_connection", 'True'),
+                ("test_query_performance", '0.05 < 1.0')
+            ]
+        })
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=4)
+        
+        json_file = pytester.path / DEFAULT_DATA_DIR / "test.json"
+        data = load_test_results(json_file)
+        
+        # Should have 2 modules
+        assert len(data["testModules"]) == 2
+        
+        # Verify all tests are present
+        all_test_names = extract_all_test_names(data)
+        assert len(all_test_names) == 4
+        assert all(name in all_test_names for name in [
+            "test_login", "test_logout", "test_connection", "test_query_performance"
+        ])
+
+    def test_clears_results_between_sessions(self, pytester):
+        """Each test session should start fresh, not accumulate results."""
+        # First test run
+        create_simple_passing_test(pytester, "test_first_run")
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        json_file = assert_json_file_exists(pytester.path)
+        test_names = get_test_names_from_file(json_file)
+        assert len(test_names) == 1
+        
+        # Second test run with different test
+        create_simple_passing_test(pytester, "test_second_run")
+        
+        result = pytester.runpytest()
+        result.assert_outcomes(passed=1)
+        
+        # Should only have the second test, not both
+        test_names = get_test_names_from_file(json_file)
+        assert len(test_names) == 1
+        assert "test_second_run" in test_names
+        assert "test_first_run" not in test_names

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

@@ -0,0 +1,137 @@
+"""Tests for TDD Guard pytest reporter."""
+
+import json
+from unittest.mock import Mock, patch, mock_open
+
+from tdd_guard_pytest.pytest_reporter import TDDGuardPytestPlugin, DEFAULT_DATA_DIR
+
+
+class TestTDDGuardPytestPlugin:
+    """Test the TDD Guard pytest plugin."""
+
+    def test_init_creates_empty_test_results(self):
+        """Plugin should initialize with empty test results."""
+        plugin = TDDGuardPytestPlugin()
+        assert plugin.test_results == []
+        assert plugin.storage_dir == DEFAULT_DATA_DIR
+
+    def test_pytest_runtest_logreport_captures_passed_test(self):
+        """Should capture passed test results."""
+        plugin = TDDGuardPytestPlugin()
+        report = Mock()
+        report.when = 'call'
+        report.nodeid = 'test_module.py::test_example'
+        report.passed = True
+        report.failed = False
+        
+        plugin.pytest_runtest_logreport(report)
+        
+        assert len(plugin.test_results) == 1
+        assert plugin.test_results[0] == {
+            'name': 'test_example',
+            'fullName': 'test_module.py::test_example',
+            'state': 'passed'
+        }
+
+    def test_pytest_runtest_logreport_captures_failed_test(self):
+        """Should capture failed test results with error message."""
+        plugin = TDDGuardPytestPlugin()
+        report = Mock()
+        report.when = 'call'
+        report.nodeid = 'test_module.py::TestClass::test_method'
+        report.passed = False
+        report.failed = True
+        report.longrepr = 'AssertionError: Expected True'
+        
+        plugin.pytest_runtest_logreport(report)
+        
+        assert len(plugin.test_results) == 1
+        assert plugin.test_results[0] == {
+            'name': 'test_method',
+            'fullName': 'test_module.py::TestClass::test_method',
+            'state': 'failed',
+            'errors': [{'message': 'AssertionError: Expected True'}]
+        }
+
+    def test_pytest_runtest_logreport_ignores_non_call_phase(self):
+        """Should only capture 'call' phase, not setup or teardown."""
+        plugin = TDDGuardPytestPlugin()
+        report = Mock()
+        report.when = 'setup'
+        report.nodeid = 'test_module.py::test_example'
+        
+        plugin.pytest_runtest_logreport(report)
+        
+        assert len(plugin.test_results) == 0
+
+    def test_pytest_collectreport_captures_collection_errors(self):
+        """Should capture import/collection failures."""
+        plugin = TDDGuardPytestPlugin()
+        report = Mock()
+        report.failed = True
+        report.nodeid = 'test_broken.py'
+        report.longrepr = 'ImportError: No module named missing_module'
+        
+        plugin.pytest_collectreport(report)
+        
+        assert len(plugin.test_results) == 1
+        assert plugin.test_results[0] == {
+            'name': 'collection_error_test_broken.py',
+            'fullName': 'test_broken.py',
+            'state': 'failed',
+            'errors': [{'message': 'ImportError: No module named missing_module'}]
+        }
+
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('pathlib.Path.mkdir')
+    def test_pytest_sessionfinish_saves_results(self, mock_mkdir, mock_file):
+        """Should save test results to JSON file in correct format."""
+        plugin = TDDGuardPytestPlugin()
+        
+        # Add some test results
+        plugin.test_results = [
+            {
+                'name': 'test_one',
+                'fullName': 'test_module.py::test_one',
+                'state': 'passed'
+            },
+            {
+                'name': 'test_two',
+                'fullName': 'test_module.py::test_two',
+                'state': 'failed',
+                'errors': [{'message': 'Error'}]
+            },
+            {
+                'name': 'test_other',
+                'fullName': 'other_module.py::test_other',
+                'state': 'passed'
+            }
+        ]
+        
+        session = Mock()
+        plugin.pytest_sessionfinish(session, 0)
+        
+        # Verify directory was created
+        mock_mkdir.assert_called_once_with(parents=True, exist_ok=True)
+        
+        # Verify file was opened for writing
+        mock_file.assert_called_once_with(DEFAULT_DATA_DIR / 'test.json', 'w')
+        
+        # Get the data that was written
+        written_data = ''.join(call.args[0] for call in mock_file().write.call_args_list)
+        parsed_data = json.loads(written_data)
+        
+        # Verify the structure matches what TDD Guard expects
+        assert 'testModules' in parsed_data
+        assert len(parsed_data['testModules']) == 2
+        
+        # Check first module
+        module1 = next(m for m in parsed_data['testModules'] if m['moduleId'] == 'test_module.py')
+        assert len(module1['tests']) == 2
+        assert module1['tests'][0]['name'] == 'test_one'
+        assert module1['tests'][1]['name'] == 'test_two'
+        
+        # Check second module
+        module2 = next(m for m in parsed_data['testModules'] if m['moduleId'] == 'other_module.py')
+        assert len(module2['tests']) == 1
+        assert module2['tests'][0]['name'] == 'test_other'

package/project-skills/tdd-guard/reporters/rspec/Gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"