Add tests, CI/CD (#3)

* Add tests, CI/CD

* Migrate to actions/setup-python@v4

* Move to Python 3.10 as minimum

Author: NolanTrem

.github/workflows/python-tests.yml

@@ -0,0 +1,54 @@
+name: Python Tests
+
+on:
+  push:
+    branches: main
+  pull_request:
+    branches: main
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install -e ".[dev]"
+        
+    - name: Run tests
+      run: |
+        pytest --junitxml=pytest-report-${{ matrix.python-version }}.xml
+        
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: always()  # Upload even if tests fail
+      with:
+        name: pytest-results-${{ matrix.python-version }}
+        path: |
+          .pytest_cache
+          pytest-report-${{ matrix.python-version }}.xml
+        retention-days: 5
+
+  merge-results:
+    needs: test
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Merge test results
+        uses: actions/upload-artifact/merge@v4
+        with:
+          name: all-pytest-results
+          pattern: pytest-results-*

pyproject.toml

@@ -7,7 +7,7 @@ name = "toller"
 version = "0.0.1"
 description = "Intelligent async flow controller for Python - making complex asyncio workflows manageable"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {file = "LICENSE"}
 authors = [
     {name = "Nolan Tremelling", email = "nolantremelling@gmail.com"}
@@ -53,9 +53,9 @@ docs = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/yourusername/toller"
-Issues = "https://github.com/yourusername/toller/issues"
-Documentation = "https://toller.readthedocs.io"
+Homepage = "https://github.com/NolanTrem/toller"
+Issues = "https://github.com/NolanTrem/toller/issues"
+Documentation = "https://tollerlib.dev"
 
 [tool.hatch.build.targets.wheel]
 packages = ["toller"]
@@ -74,7 +74,7 @@ disallow_untyped_defs = true
 disallow_incomplete_defs = true
 
 [tool.ruff]
-target-version = "py39"
+target-version = "py310"
 line-length = 88
 select = ["E", "F", "B"]
 ignore = []

tests/conftest.py

@@ -0,0 +1,5 @@
+# pytest_plugins = ["pytest_asyncio"]
+
+
+# def pytest_configure(config):
+#     config.addinivalue_line("markers", "asyncio: mark tests as asyncio coroutines")

tests/test_breakers.py

@@ -1,10 +1,10 @@
 import asyncio
 import pytest
+from typing import Any
+import contextlib
 
 from toller import CircuitBreaker, CircuitState, OpenCircuitError
 
-pytestmark = pytest.mark.asyncio
-
 
 class MockException(Exception):
     """Custom exception for testing."""
@@ -18,26 +18,26 @@ class AnotherMockException(Exception):
     pass
 
 
-async def mock_successful_call():
+async def mock_successful_call() -> str:
     """Simulates a call that succeeds."""
     await asyncio.sleep(0.01)
     return "Success"
 
 
-async def mock_failing_call(exception_type=MockException):
+async def mock_failing_call(exception_type: Any = MockException) -> None:
     """Simulates a call that fails."""
     await asyncio.sleep(0.01)
     raise exception_type("Operation failed")
 
 
-async def test_initial_state_is_closed():
+async def test_initial_state_is_closed() -> None:
     """Test that the initial state of the circuit breaker is CLOSED."""
     breaker = CircuitBreaker()
     assert breaker.state == CircuitState.CLOSED
     assert breaker.current_failures == 0
 
 
-async def test_successful_calls_keep_closed():
+async def test_successful_calls_keep_closed() -> None:
     """Test that successful calls keep the circuit breaker in CLOSED state."""
     breaker = CircuitBreaker()
     for _ in range(5):
@@ -47,8 +47,8 @@ async def test_successful_calls_keep_closed():
     assert breaker.current_failures == 0
 
 
-async def test_failures_increment_count():
-    """Failures should increment the failure count but not open the circuit if below threshold."""
+async def test_failures_increment_count() -> None:
+    """Increment failure count but don't open the circuit if below threshold."""
     breaker = CircuitBreaker(failure_threshold=5)
     for i in range(3):
         with pytest.raises(MockException):
@@ -58,7 +58,7 @@ async def test_failures_increment_count():
     assert breaker.state == CircuitState.CLOSED
 
 
-async def test_failure_threshold_opens_circuit():
+async def test_failure_threshold_opens_circuit() -> None:
     """Test that reaching the failure threshold opens the circuit."""
     threshold = 3
     breaker = CircuitBreaker(failure_threshold=threshold)
@@ -70,7 +70,7 @@ async def test_failure_threshold_opens_circuit():
     assert breaker.current_failures == threshold
 
 
-async def test_open_circuit_blocks_calls():
+async def test_open_circuit_blocks_calls() -> None:
     """Test that an open circuit blocks calls immediately."""
     breaker = CircuitBreaker(failure_threshold=1)
     with pytest.raises(MockException):
@@ -83,7 +83,7 @@ async def test_open_circuit_blocks_calls():
             await mock_failing_call()
 
 
-async def test_recovery_timeout_moves_to_half_open():
+async def test_recovery_timeout_moves_to_half_open() -> None:
     """Test that after the recovery timeout, the circuit moves to HALF_OPEN state."""
     recovery_time = 0.1
     breaker = CircuitBreaker(failure_threshold=1, recovery_timeout=recovery_time)
@@ -106,7 +106,7 @@ async def test_recovery_timeout_moves_to_half_open():
     assert breaker.state == CircuitState.OPEN
 
 
-async def test_success_in_half_open_closes_circuit():
+async def test_success_in_half_open_closes_circuit() -> None:
     """Test that a successful call in HALF_OPEN state closes the circuit."""
     recovery_time = 0.1
     breaker = CircuitBreaker(failure_threshold=1, recovery_timeout=recovery_time)
@@ -125,7 +125,7 @@ async def test_success_in_half_open_closes_circuit():
     assert breaker.current_failures == 0
 
 
-async def test_failure_in_half_open_reopens_circuit():
+async def test_failure_in_half_open_reopens_circuit() -> None:
     """Test that a failure in HALF_OPEN state reopens the circuit."""
     recovery_time = 0.1
     breaker = CircuitBreaker(failure_threshold=1, recovery_timeout=recovery_time)
@@ -148,7 +148,7 @@ async def test_failure_in_half_open_reopens_circuit():
             await mock_failing_call()
 
 
-async def test_success_resets_failure_count_when_closed():
+async def test_success_resets_failure_count_when_closed() -> None:
     """Test that a successful call resets the failure count when in CLOSED state."""
     breaker = CircuitBreaker(failure_threshold=3)
 
@@ -172,7 +172,7 @@ async def test_success_resets_failure_count_when_closed():
     assert breaker.current_failures == 1
 
 
-async def test_expected_exception_filtering():
+async def test_expected_exception_filtering() -> None:
     """Test that only expected exceptions trip the circuit breaker."""
     breaker = CircuitBreaker(failure_threshold=2, expected_exception=MockException)
 
@@ -194,7 +194,7 @@ async def test_expected_exception_filtering():
     assert breaker.state == CircuitState.OPEN
 
 
-async def test_expected_exception_tuple():
+async def test_expected_exception_tuple() -> None:
     """Test that a tuple of exceptions can be used to trip the circuit breaker."""
     breaker = CircuitBreaker(
         failure_threshold=2, expected_exception=(MockException, AnotherMockException)
@@ -212,18 +212,16 @@ async def test_expected_exception_tuple():
     assert breaker.state == CircuitState.OPEN
 
 
-async def test_concurrent_failures_open_circuit():
+async def test_concurrent_failures_open_circuit() -> None:
     """Test that concurrent failures can open the circuit."""
     threshold = 5
     breaker = CircuitBreaker(failure_threshold=threshold)
     num_concurrent = 10
 
-    async def concurrent_task():
-        try:
+    async def concurrent_task() -> None:
+        with contextlib.suppress(MockException, OpenCircuitError):
             async with breaker:
                 await mock_failing_call()
-        except (MockException, OpenCircuitError):
-            pass
 
     tasks = [asyncio.create_task(concurrent_task()) for _ in range(num_concurrent)]
     await asyncio.gather(*tasks)
@@ -232,7 +230,7 @@ async def concurrent_task():
     assert breaker.current_failures >= threshold
 
 
-async def test_invalid_init_args():
+async def test_invalid_init_args() -> None:
     with pytest.raises(ValueError):
         CircuitBreaker(failure_threshold=0)
     with pytest.raises(ValueError):