Added tests for api endpoints.

They use httpx and pytest. Pytest has been added to the dev-requirements

requirements-dev.txt

@@ -10,3 +10,4 @@ python-dotenv
 pymongo
 pandas
 python-multipart
+pytest

tests/routes/test_account_routes.py

@@ -0,0 +1,179 @@
+# tests/routes/test_account_routes.py
+
+from datetime import datetime, timezone
+from unittest.mock import MagicMock
+
+import pytest
+from fastapi import FastAPI, status
+from fastapi.testclient import TestClient
+
+from src.api.routes.account import router as account_router
+from src.core.state import get_state
+from src.data.connection import ActionFailed
+from src.models.account import Account
+
+# --- Test Setup: Mocking and Dependency Injection ---
+
+# Mock the service layer that the API routes depend on.
+mock_memory_manager = MagicMock()
+
+# This mock AppState and override function will replace the real dependencies.
+class MockAppState:
+	def __init__(self):
+		self.memory_manager = mock_memory_manager
+
+def override_get_state() -> MockAppState:
+	return MockAppState()
+
+# Create a FastAPI app instance for testing and apply the dependency override.
+app = FastAPI()
+app.include_router(account_router)
+app.dependency_overrides[get_state] = override_get_state
+
+
+# --- Fixtures ---
+
+@pytest.fixture
+def client():
+	"""Provides a TestClient for making requests to the app."""
+	with TestClient(app) as c:
+		yield c
+
+@pytest.fixture(autouse=True)
+def reset_mocks():
+	"""Resets mocks before each test to ensure test isolation."""
+	mock_memory_manager.reset_mock()
+
+
+# --- Test Data ---
+
+# A sample account object that can be reused in tests.
+fake_account_dict = {
+	"_id": "60c72b2f9b1d8b3b3c9d8b1a",
+	"name": "Dr. Test",
+	"role": "Doctor",
+	"specialty": "Testing",
+	"created_at": datetime.now(timezone.utc).isoformat(),
+	"updated_at": datetime.now(timezone.utc).isoformat(),
+	"last_seen": datetime.now(timezone.utc).isoformat(),
+}
+# Use model_validate to handle the string-based datetimes from the dict.
+fake_account = Account.model_validate(fake_account_dict)
+
+
+# --- Tests for GET /account ---
+
+def test_get_all_accounts_success(client: TestClient):
+	"""Tests successfully retrieving all accounts when no query is provided."""
+	mock_memory_manager.get_all_accounts.return_value = [fake_account]
+
+	response = client.get("/account?limit=10")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert len(response.json()) == 1
+	assert response.json()[0]["name"] == "Dr. Test"
+	mock_memory_manager.get_all_accounts.assert_called_once_with(limit=10)
+	mock_memory_manager.search_accounts.assert_not_called()
+
+def test_search_accounts_success(client: TestClient):
+	"""Tests successfully searching for accounts with a query."""
+	mock_memory_manager.search_accounts.return_value = [fake_account]
+
+	response = client.get("/account?q=Test&limit=5")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert response.json()[0]["name"] == "Dr. Test"
+	mock_memory_manager.search_accounts.assert_called_once_with("Test", limit=5)
+	mock_memory_manager.get_all_accounts.assert_not_called()
+
+def test_get_accounts_db_error(client: TestClient):
+	"""Tests that a 500 error is returned if the database fails."""
+	mock_memory_manager.get_all_accounts.side_effect = ActionFailed("DB connection lost")
+
+	response = client.get("/account")
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "A database error occurred."
+
+
+# --- Tests for POST /account ---
+
+def test_create_account_success(client: TestClient):
+	"""Tests successful creation of a new account."""
+	new_account_id = "new_fake_id_123"
+	mock_memory_manager.create_account.return_value = new_account_id
+	mock_memory_manager.get_account.return_value = fake_account
+
+	account_data = {"name": "Dr. Test", "role": "Doctor", "specialty": "Testing"}
+	response = client.post("/account", json=account_data)
+
+	assert response.status_code == status.HTTP_201_CREATED
+	assert response.json()["name"] == "Dr. Test"
+	mock_memory_manager.create_account.assert_called_once_with(
+		name="Dr. Test", role="Doctor", specialty="Testing"
+	)
+	mock_memory_manager.get_account.assert_called_once_with(new_account_id)
+
+def test_create_account_creation_fails(client: TestClient):
+	"""Tests the case where the memory manager fails to return an ID."""
+	mock_memory_manager.create_account.return_value = None
+
+	account_data = {"name": "Dr. Fail", "role": "Doctor"}
+	response = client.post("/account", json=account_data)
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "Failed to create account ID."
+
+def test_create_account_not_found_after_creation(client: TestClient):
+	"""Tests the edge case where the account can't be retrieved after creation."""
+	new_account_id = "new_fake_id_123"
+	mock_memory_manager.create_account.return_value = new_account_id
+	mock_memory_manager.get_account.return_value = None # Simulate not found
+
+	account_data = {"name": "Dr. Ghost", "role": "Doctor"}
+	response = client.post("/account", json=account_data)
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Could not find newly created account."
+
+def test_create_account_action_failed(client: TestClient):
+	"""Tests that a 400 error is returned for data-related creation failures."""
+	error_message = "Account with this name already exists."
+	mock_memory_manager.create_account.side_effect = ActionFailed(error_message)
+
+	account_data = {"name": "Dr. Duplicate", "role": "Doctor"}
+	response = client.post("/account", json=account_data)
+
+	assert response.status_code == status.HTTP_400_BAD_REQUEST
+	assert response.json()["detail"] == error_message
+
+
+# --- Tests for GET /account/{account_id} ---
+
+def test_get_account_by_id_success(client: TestClient):
+	"""Tests successfully retrieving a single account by its ID."""
+	mock_memory_manager.get_account.return_value = fake_account
+
+	response = client.get(f"/account/{fake_account.id}")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert response.json()["name"] == fake_account.name
+	mock_memory_manager.get_account.assert_called_once_with(str(fake_account.id))
+
+def test_get_account_by_id_not_found(client: TestClient):
+	"""Tests that a 404 error is returned for a non-existent account ID."""
+	mock_memory_manager.get_account.return_value = None
+
+	response = client.get("/account/non_existent_id")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Account not found"
+
+def test_get_account_by_id_db_error(client: TestClient):
+	"""Tests that a 500 error is returned if the database fails during retrieval."""
+	mock_memory_manager.get_account.side_effect = ActionFailed("DB connection lost")
+
+	response = client.get(f"/account/{fake_account.id}")
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "A database error occurred."

tests/routes/test_patient_routes.py

@@ -0,0 +1,214 @@
+# tests/routes/test_patient_routes.py
+
+from datetime import datetime, timezone
+from unittest.mock import MagicMock
+
+import pytest
+from fastapi import FastAPI, status
+from fastapi.testclient import TestClient
+
+from src.api.routes.patient import router as patient_router
+from src.core.state import get_state
+from src.models.patient import Patient
+from src.models.session import Session
+
+# --- Test Setup: Mocking and Dependency Injection ---
+
+# Mock the service layer that the API routes depend on.
+mock_memory_manager = MagicMock()
+
+# This mock AppState and override function will replace the real dependencies.
+class MockAppState:
+	def __init__(self):
+		self.memory_manager = mock_memory_manager
+
+def override_get_state() -> MockAppState:
+	return MockAppState()
+
+# Create a FastAPI app instance for testing and apply the dependency override.
+app = FastAPI()
+app.include_router(patient_router)
+app.dependency_overrides[get_state] = override_get_state
+
+
+# --- Fixtures ---
+
+@pytest.fixture
+def client():
+	"""Provides a TestClient for making requests to the app."""
+	with TestClient(app) as c:
+		yield c
+
+@pytest.fixture(autouse=True)
+def reset_mocks():
+	"""Resets mocks before each test to ensure test isolation."""
+	mock_memory_manager.reset_mock()
+
+
+# --- Test Data ---
+
+fake_patient_dict = {
+	"_id": "patient123",
+	"name": "Jane Doe",
+	"age": 42,
+	"sex": "Female",
+	"ethnicity": "Caucasian",
+	"created_at": datetime.now(timezone.utc).isoformat(),
+	"updated_at": datetime.now(timezone.utc).isoformat(),
+}
+fake_patient = Patient.model_validate(fake_patient_dict)
+
+fake_session_dict = {
+	"_id": "session456",
+	"account_id": "doctor789",
+	"patient_id": "patient123",
+	"title": "Checkup",
+	"created_at": datetime.now(timezone.utc).isoformat(),
+	"updated_at": datetime.now(timezone.utc).isoformat(),
+	"messages": [],
+}
+fake_session = Session.model_validate(fake_session_dict)
+
+
+# --- Tests for GET /patient ---
+
+def test_search_patients_success(client: TestClient):
+	"""Tests successfully searching for patients with a query."""
+	mock_memory_manager.search_patients.return_value = [fake_patient]
+
+	response = client.get("/patient?q=Jane&limit=5")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert len(response.json()) == 1
+	assert response.json()[0]["name"] == "Jane Doe"
+	mock_memory_manager.search_patients.assert_called_once_with("Jane", limit=5)
+
+def test_search_patients_requires_query(client: TestClient):
+	"""Tests that a 400 error is returned if the search query 'q' is missing."""
+	response = client.get("/patient")
+
+	assert response.status_code == status.HTTP_400_BAD_REQUEST
+	assert response.json()["detail"] == "A search query 'q' is required."
+
+
+# --- Tests for POST /patient ---
+
+def test_create_patient_success(client: TestClient):
+	"""Tests successful creation of a new patient profile."""
+	new_patient_id = "new_patient_abc"
+	mock_memory_manager.create_patient.return_value = new_patient_id
+	mock_memory_manager.get_patient_by_id.return_value = fake_patient
+
+	patient_data = {"name": "Jane Doe", "age": 42, "sex": "Female", "ethnicity": "Caucasian"}
+	response = client.post("/patient", json=patient_data)
+
+	assert response.status_code == status.HTTP_201_CREATED
+	assert response.json()["name"] == "Jane Doe"
+	mock_memory_manager.create_patient.assert_called_once()
+	mock_memory_manager.get_patient_by_id.assert_called_once_with(new_patient_id)
+
+def test_create_patient_invalid_data(client: TestClient):
+	"""Tests failure when the memory manager cannot create a patient (e.g., bad data)."""
+	mock_memory_manager.create_patient.return_value = None
+
+	patient_data = {"name": "Invalid", "age": -5, "sex": "F", "ethnicity": "Unknown"}
+	response = client.post("/patient", json=patient_data)
+
+	assert response.status_code == status.HTTP_400_BAD_REQUEST
+	assert response.json()["detail"] == "Patient could not be created due to invalid data."
+
+def test_create_patient_not_found_after_creation(client: TestClient):
+	"""Tests the edge case where the patient can't be retrieved after creation."""
+	new_patient_id = "new_patient_abc"
+	mock_memory_manager.create_patient.return_value = new_patient_id
+	mock_memory_manager.get_patient_by_id.return_value = None
+
+	patient_data = {"name": "Jane Doe", "age": 42, "sex": "Female", "ethnicity": "Caucasian"}
+	response = client.post("/patient", json=patient_data)
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "Could not find newly created patient."
+
+
+# --- Tests for GET /patient/{patient_id} ---
+
+def test_get_patient_by_id_success(client: TestClient):
+	"""Tests successfully retrieving a single patient by their ID."""
+	mock_memory_manager.get_patient_by_id.return_value = fake_patient
+
+	response = client.get(f"/patient/{fake_patient.id}")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert response.json()["name"] == fake_patient.name
+	mock_memory_manager.get_patient_by_id.assert_called_once_with(str(fake_patient.id))
+
+def test_get_patient_by_id_not_found(client: TestClient):
+	"""Tests that a 404 error is returned for a non-existent patient ID."""
+	mock_memory_manager.get_patient_by_id.return_value = None
+
+	response = client.get("/patient/non_existent_id")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Patient not found"
+
+
+# --- Tests for PATCH /patient/{patient_id} ---
+
+def test_update_patient_success(client: TestClient):
+	"""Tests a successful patient profile update."""
+	mock_memory_manager.update_patient_profile.return_value = 1  # 1 document modified
+	mock_memory_manager.get_patient_by_id.return_value = fake_patient
+
+	update_data = {"age": 43}
+	response = client.patch(f"/patient/{fake_patient.id}", json=update_data)
+
+	assert response.status_code == status.HTTP_200_OK
+	assert response.json()["name"] == fake_patient.name
+	mock_memory_manager.update_patient_profile.assert_called_once_with(str(fake_patient.id), update_data)
+
+def test_update_patient_no_fields_provided(client: TestClient):
+	"""Tests that a 400 error is returned if the update request body is empty."""
+	response = client.patch(f"/patient/{fake_patient.id}", json={})
+
+	assert response.status_code == status.HTTP_400_BAD_REQUEST
+	assert response.json()["detail"] == "No update fields provided."
+
+def test_update_patient_not_found(client: TestClient):
+	"""Tests updating a non-existent patient."""
+	mock_memory_manager.update_patient_profile.return_value = 0
+	# The route logic then checks if the patient exists. Simulate it not existing.
+	mock_memory_manager.get_patient_by_id.return_value = None
+
+	response = client.patch("/patient/non_existent_id", json={"age": 50})
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Patient not found"
+	# Check that get_patient_by_id was called as part of the 404 check
+	mock_memory_manager.get_patient_by_id.assert_called_once_with("non_existent_id")
+
+
+# --- Tests for GET /patient/{patient_id}/session ---
+
+def test_list_sessions_for_patient_success(client: TestClient):
+	"""Tests successfully listing all sessions for a given patient."""
+	mock_memory_manager.get_patient_by_id.return_value = fake_patient
+	mock_memory_manager.list_patient_sessions.return_value = [fake_session]
+
+	response = client.get(f"/patient/{fake_patient.id}/session")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert len(response.json()) == 1
+	assert response.json()[0]["title"] == "Checkup"
+	# Verify it first checked that the patient exists
+	mock_memory_manager.get_patient_by_id.assert_called_once_with(str(fake_patient.id))
+	mock_memory_manager.list_patient_sessions.assert_called_once_with(str(fake_patient.id))
+
+def test_list_sessions_for_patient_not_found(client: TestClient):
+	"""Tests listing sessions for a non-existent patient."""
+	mock_memory_manager.get_patient_by_id.return_value = None
+
+	response = client.get("/patient/non_existent_id/session")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Patient not found"
+	mock_memory_manager.list_patient_sessions.assert_not_called()

tests/routes/test_session_routes.py

@@ -0,0 +1,208 @@
+# tests/routes/test_session_routes.py
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI, status
+from fastapi.testclient import TestClient
+
+from src.api.routes.session import router as session_router
+from src.core.state import get_state
+from src.models.session import Message, Session
+
+# --- Test Setup: Mocking and Dependency Injection ---
+
+mock_memory_manager = MagicMock()
+
+class MockAppState:
+	def __init__(self):
+		self.memory_manager = mock_memory_manager
+		# Add mock rotators for the session endpoint
+		self.gemini_rotator = MagicMock()
+		self.nvidia_rotator = MagicMock()
+
+def override_get_state() -> MockAppState:
+	return MockAppState()
+
+app = FastAPI()
+app.include_router(session_router)
+app.dependency_overrides[get_state] = override_get_state
+
+
+# --- Fixtures ---
+
+@pytest.fixture
+def client():
+	"""Provides a TestClient for making requests to the app."""
+	with TestClient(app) as c:
+		yield c
+
+@pytest.fixture(autouse=True)
+def reset_mocks():
+	"""Resets mocks before each test to ensure test isolation."""
+	mock_memory_manager.reset_mock()
+
+
+# --- Test Data ---
+
+fake_session_dict = {
+	"_id": "session456",
+	"account_id": "doctor789",
+	"patient_id": "patient123",
+	"title": "Checkup",
+	"created_at": datetime.now(timezone.utc).isoformat(),
+	"updated_at": datetime.now(timezone.utc).isoformat(),
+	"messages": [],
+}
+fake_session = Session.model_validate(fake_session_dict)
+
+fake_message_dict = {
+	"_id": 1,
+	"sent_by_user": True,
+	"content": "Hello",
+	"timestamp": datetime.now(timezone.utc).isoformat(),
+}
+fake_message = Message.model_validate(fake_message_dict)
+
+
+# --- Tests for POST /session ---
+
+def test_create_session_success(client: TestClient):
+	"""Tests successful creation of a new chat session."""
+	mock_memory_manager.create_session.return_value = fake_session
+
+	session_data = {"account_id": "doctor789", "patient_id": "patient123", "title": "Checkup"}
+	response = client.post("/session", json=session_data)
+
+	assert response.status_code == status.HTTP_201_CREATED
+	assert response.json()["title"] == "Checkup"
+	mock_memory_manager.create_session.assert_called_once_with(
+		user_id="doctor789", patient_id="patient123", title="Checkup"
+	)
+
+def test_create_session_failure(client: TestClient):
+	"""Tests that a 500 error is returned if session creation fails."""
+	mock_memory_manager.create_session.return_value = None
+
+	session_data = {"account_id": "doctor789", "patient_id": "patient123"}
+	response = client.post("/session", json=session_data)
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "Failed to create session."
+
+
+# --- Tests for GET /session/{session_id} ---
+
+def test_get_session_success(client: TestClient):
+	"""Tests successfully retrieving a session by its ID."""
+	mock_memory_manager.get_session.return_value = fake_session
+
+	response = client.get(f"/session/{fake_session.id}")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert response.json()["title"] == fake_session.title
+	mock_memory_manager.get_session.assert_called_once_with(str(fake_session.id))
+
+def test_get_session_not_found(client: TestClient):
+	"""Tests that a 404 error is returned for a non-existent session."""
+	mock_memory_manager.get_session.return_value = None
+
+	response = client.get("/session/non_existent_id")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Session not found"
+
+
+# --- Tests for DELETE /session/{session_id} ---
+
+def test_delete_session_success(client: TestClient):
+	"""Tests successful deletion of a session."""
+	mock_memory_manager.delete_session.return_value = True
+
+	response = client.delete(f"/session/{fake_session.id}")
+
+	assert response.status_code == status.HTTP_204_NO_CONTENT
+	mock_memory_manager.delete_session.assert_called_once_with(str(fake_session.id))
+
+def test_delete_session_not_found(client: TestClient):
+	"""Tests that a 404 is returned when trying to delete a non-existent session."""
+	mock_memory_manager.delete_session.return_value = False
+
+	response = client.delete("/session/non_existent_id")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Session not found or already deleted"
+
+
+# --- Tests for GET /session/{session_id}/messages ---
+
+def test_list_messages_success(client: TestClient):
+	"""Tests successfully listing messages for a session."""
+	mock_memory_manager.get_session.return_value = fake_session
+	mock_memory_manager.get_session_messages.return_value = [fake_message]
+
+	response = client.get(f"/session/{fake_session.id}/messages?limit=10")
+
+	assert response.status_code == status.HTTP_200_OK
+	assert len(response.json()) == 1
+	assert response.json()[0]["content"] == "Hello"
+	mock_memory_manager.get_session.assert_called_once_with(str(fake_session.id))
+	mock_memory_manager.get_session_messages.assert_called_once_with(str(fake_session.id), 10)
+
+def test_list_messages_session_not_found(client: TestClient):
+	"""Tests listing messages for a non-existent session."""
+	mock_memory_manager.get_session.return_value = None
+
+	response = client.get("/session/non_existent_id/messages")
+
+	assert response.status_code == status.HTTP_404_NOT_FOUND
+	assert response.json()["detail"] == "Session not found"
+
+
+# --- Tests for POST /session/{session_id}/messages ---
+
+@patch('src.api.routes.session.generate_medical_response', new_callable=AsyncMock)
+def test_post_chat_message_success(mock_generate_response: AsyncMock, client: TestClient):
+	"""Tests the full, successful flow of posting a message and getting a response."""
+	# Arrange: Mock all async dependencies
+	mock_memory_manager.get_enhanced_context = AsyncMock(return_value="Enhanced context.")
+	mock_memory_manager.process_medical_exchange = AsyncMock(return_value="Generated summary.")
+	mock_generate_response.return_value = "This is the AI response."
+
+	chat_data = {"account_id": "doc1", "patient_id": "pat1", "message": "Patient has a fever."}
+	response = client.post(f"/session/{fake_session.id}/messages", json=chat_data)
+
+	assert response.status_code == status.HTTP_200_OK
+	json_response = response.json()
+	assert json_response["response"] == "This is the AI response."
+	assert json_response["medical_context"] == "Enhanced context."
+
+	# Assert that all async functions were called correctly
+	mock_memory_manager.get_enhanced_context.assert_awaited_once()
+	mock_generate_response.assert_awaited_once()
+	mock_memory_manager.process_medical_exchange.assert_awaited_once()
+
+@patch('src.api.routes.session.generate_medical_response', new_callable=AsyncMock)
+def test_post_chat_message_context_error(mock_generate_response: AsyncMock, client: TestClient):
+	"""Tests failure during the context generation step."""
+	mock_memory_manager.get_enhanced_context = AsyncMock(side_effect=Exception("Context DB failed"))
+
+	chat_data = {"account_id": "doc1", "patient_id": "pat1", "message": "Patient has a fever."}
+	response = client.post(f"/session/{fake_session.id}/messages", json=chat_data)
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "Failed to build medical context."
+	mock_generate_response.assert_not_awaited() # Should fail before this is called
+
+@patch('src.api.routes.session.generate_medical_response', new_callable=AsyncMock)
+def test_post_chat_message_generation_error(mock_generate_response: AsyncMock, client: TestClient):
+	"""Tests failure during the AI response generation step."""
+	mock_memory_manager.get_enhanced_context = AsyncMock(return_value="Context")
+	mock_generate_response.side_effect = Exception("AI model API is down")
+
+	chat_data = {"account_id": "doc1", "patient_id": "pat1", "message": "Patient has a fever."}
+	response = client.post(f"/session/{fake_session.id}/messages", json=chat_data)
+
+	assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+	assert response.json()["detail"] == "Failed to generate AI response."