xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,296 +0,0 @@
-"""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

@@ -1,137 +0,0 @@
-"""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

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