feat: Set up Python testing infrastructure with Poetry and pytest

.gitignore

@@ -0,0 +1,82 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Claude settings
+.claude/*
+
+# Project specific
+*.log
+*.pkl
+*.pth
+*.h5
+*.hdf5
+*.weights
+model_checkpoints/
+logs/
+runs/

pyproject.toml

@@ -0,0 +1,83 @@
+[tool.poetry]
+name = "reinforcement-learning-project"
+version = "0.1.0"
+description = "A collection of reinforcement learning implementations"
+authors = ["Your Name <your.email@example.com>"]
+readme = "README.md"
+packages = [{include = "Alpha-Zero"}]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-cov = "^4.1.0"
+pytest-mock = "^3.12.0"
+
+[tool.poetry.scripts]
+test = "pytest:main"
+tests = "pytest:main"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = [
+    "-ra",
+    "--strict-markers",
+    "--ignore=data",
+    "--ignore=logs",
+    "--ignore=.eggs",
+    "--ignore=.git",
+    "--ignore=.tox",
+    "--ignore=dist",
+    "--ignore=build",
+    "--ignore=__pycache__",
+    "--cov=Alpha-Zero",
+    "--cov-branch",
+    "--cov-report=term-missing:skip-covered",
+    "--cov-report=html",
+    "--cov-report=xml",
+    "--cov-fail-under=0",
+]
+testpaths = ["tests"]
+pythonpath = ["."]
+markers = [
+    "unit: marks tests as unit tests",
+    "integration: marks tests as integration tests",
+    "slow: marks tests as slow tests",
+]
+
+[tool.coverage.run]
+source = ["Alpha-Zero"]
+branch = true
+omit = [
+    "*/tests/*",
+    "*/__pycache__/*",
+    "*/conftest.py",
+    "*/setup.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "def __str__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "if typing.TYPE_CHECKING:",
+]
+precision = 2
+show_missing = true
+skip_covered = true
+fail_under = 0
+
+[tool.coverage.html]
+directory = "htmlcov"
+
+[tool.coverage.xml]
+output = "coverage.xml"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

tests/conftest.py

@@ -0,0 +1,135 @@
+import os
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Generator
+import pytest
+
+
+@pytest.fixture(scope="session")
+def project_root() -> Path:
+    """Return the project root directory."""
+    return Path(__file__).parent.parent
+
+
+@pytest.fixture
+def temp_dir() -> Generator[Path, None, None]:
+    """Create a temporary directory for test files."""
+    temp_path = tempfile.mkdtemp()
+    yield Path(temp_path)
+    shutil.rmtree(temp_path)
+
+
+@pytest.fixture
+def mock_config():
+    """Return a mock configuration dictionary for testing."""
+    return {
+        "learning_rate": 0.001,
+        "batch_size": 32,
+        "epochs": 10,
+        "n_simulations": 100,
+        "c_puct": 1.0,
+        "temperature": 1.0,
+        "n_residual_blocks": 5,
+        "board_size": 15,
+        "model_path": "test_model.pth",
+    }
+
+
+@pytest.fixture
+def sample_game_state():
+    """Return a sample game state for testing."""
+    return {
+        "board": [[0 for _ in range(15)] for _ in range(15)],
+        "current_player": 1,
+        "last_move": None,
+        "game_over": False,
+        "winner": None,
+    }
+
+
+@pytest.fixture
+def mock_network(mocker):
+    """Return a mock neural network for testing."""
+    mock_net = mocker.MagicMock()
+    mock_net.predict.return_value = (
+        [[0.1] * 225],  # policy output
+        [[0.5]]  # value output
+    )
+    return mock_net
+
+
+@pytest.fixture
+def mock_env(mocker):
+    """Return a mock environment for testing."""
+    env = mocker.MagicMock()
+    env.reset.return_value = [[0 for _ in range(15)] for _ in range(15)]
+    env.step.return_value = (
+        [[0 for _ in range(15)] for _ in range(15)],  # next_state
+        0,  # reward
+        False,  # done
+        {}  # info
+    )
+    env.action_space = mocker.MagicMock()
+    env.action_space.n = 225
+    return env
+
+
+@pytest.fixture(autouse=True)
+def reset_random_seed():
+    """Reset random seeds for reproducible tests."""
+    import random
+
+    random.seed(42)
+
+    # If using NumPy
+    try:
+        import numpy as np
+        np.random.seed(42)
+    except ImportError:
+        pass
+
+    # If using PyTorch
+    try:
+        import torch
+        torch.manual_seed(42)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed_all(42)
+    except ImportError:
+        pass
+
+    # If using TensorFlow
+    try:
+        import tensorflow as tf
+        tf.random.set_seed(42)
+    except ImportError:
+        pass
+
+
+@pytest.fixture
+def capture_stdout(monkeypatch):
+    """Capture stdout for testing print statements."""
+    import io
+    buffer = io.StringIO()
+    monkeypatch.setattr(sys, 'stdout', buffer)
+    yield buffer
+    buffer.close()
+
+
+@pytest.fixture
+def mock_model_save(mocker, temp_dir):
+    """Mock model saving functionality."""
+    def _save_model(model, path):
+        save_path = temp_dir / Path(path).name
+        save_path.write_text("mock_model_data")
+        return str(save_path)
+
+    return mocker.patch('torch.save', side_effect=_save_model)
+
+
+@pytest.fixture
+def mock_model_load(mocker):
+    """Mock model loading functionality."""
+    mock_state_dict = {"layer1.weight": [[0.1, 0.2]], "layer1.bias": [0.3]}
+    return mocker.patch('torch.load', return_value=mock_state_dict)

tests/test_setup_validation.py

@@ -0,0 +1,86 @@
+import pytest
+import sys
+from pathlib import Path
+
+
+class TestSetupValidation:
+    """Validation tests to ensure the testing infrastructure is properly configured."""
+
+    def test_pytest_installed(self):
+        """Test that pytest is properly installed."""
+        assert "pytest" in sys.modules or True  # Will be true after installation
+
+    def test_project_structure_exists(self):
+        """Test that the basic project structure exists."""
+        project_root = Path(__file__).parent.parent
+        assert project_root.exists()
+        assert (project_root / "Alpha-Zero").exists()
+        assert (project_root / "README.md").exists()
+
+    def test_testing_directories_exist(self):
+        """Test that testing directories are properly created."""
+        tests_dir = Path(__file__).parent
+        assert tests_dir.exists()
+        assert (tests_dir / "unit").exists()
+        assert (tests_dir / "integration").exists()
+        assert (tests_dir / "conftest.py").exists()
+
+    def test_configuration_files_exist(self):
+        """Test that configuration files are in place."""
+        project_root = Path(__file__).parent.parent
+        assert (project_root / "pyproject.toml").exists()
+        assert (project_root / ".gitignore").exists()
+
+    @pytest.mark.unit
+    def test_unit_marker(self):
+        """Test that the unit marker works."""
+        assert True
+
+    @pytest.mark.integration
+    def test_integration_marker(self):
+        """Test that the integration marker works."""
+        assert True
+
+    @pytest.mark.slow
+    def test_slow_marker(self):
+        """Test that the slow marker works."""
+        assert True
+
+    def test_fixtures_available(self, temp_dir, mock_config, project_root):
+        """Test that custom fixtures are available and working."""
+        assert temp_dir.exists()
+        assert isinstance(mock_config, dict)
+        assert "learning_rate" in mock_config
+        assert project_root.exists()
+
+    def test_temp_dir_cleanup(self, temp_dir):
+        """Test that temp_dir fixture properly cleans up."""
+        test_file = temp_dir / "test.txt"
+        test_file.write_text("test content")
+        assert test_file.exists()
+        # Cleanup will happen after test completes
+
+    def test_mock_fixtures(self, mock_network, mock_env):
+        """Test that mock fixtures are properly configured."""
+        # Test mock network
+        policy, value = mock_network.predict([[0] * 225])
+        assert len(policy) == 1
+        assert len(policy[0]) == 225
+        assert len(value) == 1
+        assert len(value[0]) == 1
+
+        # Test mock environment
+        state = mock_env.reset()
+        assert len(state) == 15
+        assert len(state[0]) == 15
+        assert mock_env.action_space.n == 225
+
+    def test_coverage_configured(self):
+        """Test that coverage is properly configured."""
+        # This test validates that coverage will run with proper settings
+        # The actual coverage check happens when running pytest with coverage
+        assert True
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])