refactor(tests): streamline issue repository tests and add filters

Author: getmarkus

main.py

@@ -14,7 +14,6 @@
 from src.interface_adapters import api_router
 from src.interface_adapters.exceptions import AppException
 from src.interface_adapters.middleware.error_handler import app_exception_handler
-from src.resource_adapters.persistence.sqlmodel.database import init_db
 
 # https://brandur.org/logfmt
 # https://github.com/Delgan/loguru
@@ -37,11 +36,8 @@ async def lifespan(app: FastAPI):
     logger.info(f"App state: {dict(app.state.__dict__)}")
     logger.info(app.state.running)
 
-    # Initialize database if using SQLModel
-    if Settings.get_settings().execution_mode == "sqlmodel" and not Settings.get_settings().migrate_database:
-        init_db()
-
     yield
+
     app.state.running = False
     logger.info("Lifespan stopped")
 

pyproject.toml

@@ -6,6 +6,7 @@ authors = [{ name = "Chris Markus", email = "[email protected]" }]
 requires-python = "~=3.12"
 readme = "README.md"
 dependencies = [
+  "dynaconf>=3.2.7",
   "fastapi[standard]>=0.115.6",
   "httpx>=0.28.1",
   "loguru>=0.7.3",
@@ -22,7 +23,9 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
-dev = ["pytest>=8.3.4", "pytest-asyncio>=0.23.5", "pytest-anyio>=0.1.0"]
+dev = [
+    "pytest>=8.3.4",
+]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

src/resource_adapters/persistence/sqlmodel/database.py

@@ -27,6 +27,10 @@ def get_engine(database_url: str | None = None) -> Engine:
     _engine = create_engine(
         database_url, connect_args={"check_same_thread": False}, echo=True
     )
+    # Initialize database if using SQLModel
+    if Settings.get_settings().execution_mode == "sqlmodel" and not Settings.get_settings().migrate_database:
+        init_db()
+        
     return _engine
 
 

src/resource_adapters/persistence/sqlmodel/issues.py

@@ -1,6 +1,7 @@
-from typing import Callable, List
+from typing import Callable, List, Union
 
 from loguru import logger
+from sqlalchemy.sql.elements import BinaryExpression, BooleanClauseList, ClauseElement
 from sqlmodel import Session, select
 
 from src.app.ports.repositories.issues import IssueRepository
@@ -25,11 +26,19 @@ def list(self) -> List[Issue]:
         results = self.session.exec(statement).all()
         return results
 
-    def list_with_predicate(self, predicate: Callable[[Issue], bool]) -> List[Issue]:
-        # First get all issues and then filter in memory
-        # For better performance, specific predicates could be translated to SQL filters
-        all_issues = self.list()
-        return [issue for issue in all_issues if predicate(issue)]
+    def list_with_predicate(
+        self, predicate: Union[Callable[[Issue], bool], ClauseElement]
+    ) -> List[Issue]:
+        if isinstance(predicate, (BinaryExpression, BooleanClauseList)):
+            # If we're passed a SQLModel/SQLAlchemy filter condition, use it directly
+            # open_issues = repo.list_with_predicate(Issue.issue_state == IssueState.OPEN)
+            statement = select(Issue).where(predicate)
+            return self.session.exec(statement).all()
+        else:
+            # Fall back to in-memory filtering for complex predicates that can't be expressed in SQL
+            # open_issues = repository.list_with_predicate(lambda issue: issue.issue_state == IssueState.OPEN)
+            all_issues = self.list()
+            return [issue for issue in all_issues if predicate(issue)]
 
     def add(self, entity: Issue) -> None:
         logger.info(f"adding issue: {entity.issue_number}")
@@ -45,6 +54,7 @@ def update(self, entity: Issue) -> None:
             # Update fields from the detached entity
             existing.issue_state = entity.issue_state
             existing.version = entity.version
+            self.session.add(existing)
 
     def remove(self, entity: Issue) -> None:
         logger.info(f"removing issue: {entity}")

tests/__init__.py

@@ -3,64 +3,63 @@
 from src.domain.issue import IssueState, IssueTransitionType
 
 
-class TestIssueState:
-    def test_initial_state(self):
-        """Test that initial states are created correctly"""
-        assert IssueState.OPEN.value == "OPEN"
-        assert IssueState.CLOSED.value == "CLOSED"
+def test_initial_state():
+    """Test that initial states are created correctly"""
+    assert IssueState.OPEN.value == "OPEN"
+    assert IssueState.CLOSED.value == "CLOSED"
 
-    def test_is_open_property(self):
-        """Test the is_open property returns correct values"""
-        assert IssueState.OPEN.is_open is True
-        assert IssueState.CLOSED.is_open is False
+def test_is_open_property():
+    """Test the is_open property returns correct values"""
+    assert IssueState.OPEN.is_open is True
+    assert IssueState.CLOSED.is_open is False
 
-    def test_valid_transitions(self):
-        """Test all valid state transitions"""
-        # Test closing an open issue
-        state = IssueState.OPEN
-        new_state = state.transition(IssueTransitionType.CLOSE_AS_COMPLETE)
-        assert new_state == IssueState.CLOSED
+def test_valid_transitions():
+    """Test all valid state transitions"""
+    # Test closing an open issue
+    state = IssueState.OPEN
+    new_state = state.transition(IssueTransitionType.CLOSE_AS_COMPLETE)
+    assert new_state == IssueState.CLOSED
 
-        state = IssueState.OPEN
-        new_state = state.transition(IssueTransitionType.CLOSE_AS_NOT_PLANNED)
-        assert new_state == IssueState.CLOSED
+    state = IssueState.OPEN
+    new_state = state.transition(IssueTransitionType.CLOSE_AS_NOT_PLANNED)
+    assert new_state == IssueState.CLOSED
 
-        # Test reopening a closed issue
-        state = IssueState.CLOSED
-        new_state = state.transition(IssueTransitionType.REOPEN)
-        assert new_state == IssueState.OPEN
+    # Test reopening a closed issue
+    state = IssueState.CLOSED
+    new_state = state.transition(IssueTransitionType.REOPEN)
+    assert new_state == IssueState.OPEN
 
-    def test_invalid_transitions(self):
-        """Test that invalid transitions raise appropriate errors"""
-        # Test cannot close an already closed issue
-        with pytest.raises(ValueError) as exc_info:
-            IssueState.CLOSED.transition(IssueTransitionType.CLOSE_AS_COMPLETE)
-        assert "Cannot perform CLOSE_AS_COMPLETE transition from state CLOSED" in str(
-            exc_info.value
-        )
+def test_invalid_transitions():
+    """Test that invalid transitions raise appropriate errors"""
+    # Test cannot close an already closed issue
+    with pytest.raises(ValueError) as exc_info:
+        IssueState.CLOSED.transition(IssueTransitionType.CLOSE_AS_COMPLETE)
+    assert "Cannot perform CLOSE_AS_COMPLETE transition from state CLOSED" in str(
+        exc_info.value
+    )
 
-        # Test cannot reopen an already open issue
-        with pytest.raises(ValueError) as exc_info:
-            IssueState.OPEN.transition(IssueTransitionType.REOPEN)
-        assert "Cannot perform REOPEN transition from state OPEN" in str(exc_info.value)
+    # Test cannot reopen an already open issue
+    with pytest.raises(ValueError) as exc_info:
+        IssueState.OPEN.transition(IssueTransitionType.REOPEN)
+    assert "Cannot perform REOPEN transition from state OPEN" in str(exc_info.value)
 
-    def test_unknown_transition_type(self):
-        """Test that using an undefined transition type raises an error"""
+def test_unknown_transition_type():
+    """Test that using an undefined transition type raises an error"""
 
-        # Create a new enum value that isn't in the transitions dictionary
-        class FakeTransitionType:
-            def __str__(self):
-                return "FAKE_TRANSITION"
+    # Create a new enum value that isn't in the transitions dictionary
+    class FakeTransitionType:
+        def __str__(self):
+            return "FAKE_TRANSITION"
 
-        with pytest.raises(ValueError) as exc_info:
-            IssueState.OPEN.transition(FakeTransitionType())
-        assert "Unknown transition type: FAKE_TRANSITION" in str(exc_info.value)
+    with pytest.raises(ValueError) as exc_info:
+        IssueState.OPEN.transition(FakeTransitionType())
+    assert "Unknown transition type: FAKE_TRANSITION" in str(exc_info.value)
 
-    def test_transitions_immutability(self):
-        """Test that the transitions dictionary cannot be modified at runtime"""
-        transitions = IssueState.transitions()
-        with pytest.raises((TypeError, AttributeError)):
-            transitions[IssueTransitionType.REOPEN] = {
-                "from": IssueState.OPEN.value,
-                "to": IssueState.CLOSED.value,
-            }
+def test_transitions_immutability():
+    """Test that the transitions dictionary cannot be modified at runtime"""
+    transitions = IssueState.transitions()
+    with pytest.raises((TypeError, AttributeError)):
+        transitions[IssueTransitionType.REOPEN] = {
+            "from": IssueState.OPEN.value,
+            "to": IssueState.CLOSED.value,
+        }

tests/domain/test_issue.py

@@ -1,14 +1,14 @@
-from fastapi.testclient import TestClient
 import pytest
-from sqlmodel import SQLModel, Session, create_engine
+from fastapi.testclient import TestClient
+from sqlmodel import Session, SQLModel, create_engine
 from sqlmodel.pool import StaticPool
 
 from main import app
+from src.app.usecases.analyze_issue import AnalyzeIssue
 from src.domain.issue import Issue, IssueState
+from src.interface_adapters.exceptions import NotFoundException
 from src.resource_adapters.persistence.sqlmodel.database import get_db
 from src.resource_adapters.persistence.sqlmodel.issues import SQLModelIssueRepository
-from src.app.usecases.analyze_issue import AnalyzeIssue
-from src.interface_adapters.exceptions import NotFoundException
 
 
 # https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/
@@ -24,71 +24,78 @@ def session_fixture():
 
 @pytest.fixture(name="client")
 def client_fixture(session: Session):
-    def get_session_override():
-        return session
-
-    app.dependency_overrides[get_db] = get_session_override
-    app.state.running = True
-    client = TestClient(app)
-    yield client
-    app.dependency_overrides.clear()
-    app.state.running = False
-
-
-class TestAnalyzeIssue:
-    def test_analyze_issue_command(self, client: TestClient, session: Session):
-        # Test case 1: Successful analysis
-        issue_number = 1
-        test_issue = Issue(issue_number=issue_number, issue_state=IssueState.OPEN)
-
-        repository = SQLModelIssueRepository(session)
-
-        repository.add(test_issue)
-        repository.commit()
-        retrieved_issue = repository.get_by_id(issue_number)
-        assert retrieved_issue.issue_number == issue_number
-
-        use_case = AnalyzeIssue(issue_number=issue_number, repo=repository)
-        response = use_case.analyze()
-        assert response.issue_number == issue_number
-
-    def test_analyze_issue_client(self, client: TestClient, session: Session):
-        # Test case 1: Successful analysis
-        response = client.post("/issues/1/analyze")
-        #assert response.status_code == 200
-        assert response.json() == {"version": 1, "issue_number": 1}
-    
-    def test_analyze_issue_not_found(self, client: TestClient, session: Session):
-        # Test case 1: Successful analysis
-        issue_number = 1
-
-        repository = SQLModelIssueRepository(session)
-        retrieved_issue = repository.get_by_id(issue_number)
-        assert retrieved_issue.issue_number == 0
-
-        use_case = AnalyzeIssue(issue_number=issue_number, repo=repository)
-        with pytest.raises(NotFoundException) as exc_info:
-            use_case.analyze()
-        assert exc_info.value.message == "Issue not found"
-
-        response = client.post("/issues/1/analyze")
-        assert response.status_code == 404
-
-    def test_analyze_issue_invalid_number(self, client: TestClient, session: Session):
-        """Test analyzing an issue with an invalid issue number."""
-
-        response = client.post("/issues/abc/analyze")
-        assert response.status_code == 422
-        # Validate error response structure
-        error_detail = response.json()["detail"]
-        assert isinstance(error_detail, list)
-        assert error_detail[0]["type"] == "int_parsing"
-        assert error_detail[0]["loc"] == ["path", "issue_number"]
-
-    def test_analyze_issue_unauthorized(self, client: TestClient):
-        # Test case 3: Unauthorized access
-        response = client.post("/issues/456/analyze")
-        assert response.status_code == 401
-        assert response.js_on() == {"detail": "Unauthorized"}
-
-        # Add more test cases as needed
+    # def get_session_override():
+    #     return session
+
+    # app.dependency_overrides[get_db] = get_session_override
+    with TestClient(app, raise_server_exceptions=False) as client:
+        yield client
+        #app.dependency_overrides.clear()
+
+
+def test_analyze_issue_command(client: TestClient, session: Session):
+    # Test case 1: Successful analysis
+    issue_number = 1
+    test_issue = Issue(issue_number=issue_number, issue_state=IssueState.OPEN)
+
+    repository = SQLModelIssueRepository(session)
+
+    repository.add(test_issue)
+    repository.commit()
+    retrieved_issue = repository.get_by_id(issue_number)
+    assert retrieved_issue.issue_number == issue_number
+
+    use_case = AnalyzeIssue(issue_number=issue_number, repo=repository)
+    response = use_case.analyze()
+    assert response.issue_number == issue_number
+
+
+def test_analyze_issue_client(client: TestClient, session: Session):
+    # Test case 1: Successful analysis
+    issue_number = 1
+    test_issue = Issue(issue_number=issue_number, issue_state=IssueState.OPEN)
+
+    repository = SQLModelIssueRepository(session)
+
+    repository.add(test_issue)
+    repository.commit()
+
+    response = client.post("/issues/1/analyze")
+    # assert response.status_code == 200
+    assert response.json() == {"version": 1, "issue_number": 1}
+
+
+def test_analyze_issue_not_found(client: TestClient, session: Session):
+    # Test case 1: Successful analysis
+    issue_number = 1
+
+    repository = SQLModelIssueRepository(session)
+    retrieved_issue = repository.get_by_id(issue_number)
+    assert retrieved_issue.issue_number == 0
+
+    use_case = AnalyzeIssue(issue_number=issue_number, repo=repository)
+    with pytest.raises(NotFoundException) as exc_info:
+        use_case.analyze()
+    assert exc_info.value.message == "Issue not found"
+
+    response = client.post("/issues/1/analyze")
+    assert response.status_code == 404
+
+
+def test_analyze_issue_invalid_number(client: TestClient, session: Session):
+    """Test analyzing an issue with an invalid issue number."""
+
+    response = client.post("/issues/abc/analyze")
+    assert response.status_code == 422
+    # Validate error response structure
+    error_detail = response.json()["detail"]
+    assert isinstance(error_detail, list)
+    assert error_detail[0]["type"] == "int_parsing"
+    assert error_detail[0]["loc"] == ["path", "issue_number"]
+
+
+def test_analyze_issue_unauthorized(client: TestClient):
+    # Test case 3: Unauthorized access
+    response = client.post("/issues/456/analyze")
+    assert response.status_code == 401
+    assert response.js_on() == {"detail": "Unauthorized"}