Updated patient tests

tests/test_patient.py

@@ -1,148 +1,145 @@
 import unittest
+from unittest.mock import patch
 
 from bson import ObjectId
+from pymongo.errors import ConnectionFailure
 
-from src.data.connection import Collections, close_connection, get_collection
+from src.data.connection import (ActionFailed, Collections, close_connection,
+                                 get_collection)
 from src.data.repositories import patient as patient_repo
 from src.utils.logger import logger
 from tests.base_test import BaseMongoTest
 
 
 class TestPatientRepository(BaseMongoTest):
+	"""Test class for the 'happy path' and edge cases of patient repository functions."""
 
 	def setUp(self):
 		"""Set up a clean test environment before each test."""
 		super().setUp()
 		self.test_collection = self._collections[Collections.PATIENT]
-		# Initialize the collection with schema and indexes for each test
 		patient_repo.init(collection_name=self.test_collection, drop=True)
 
 	def test_init_functionality(self):
 		"""Test that the init function correctly sets up the collection and its indexes."""
-		# Verify collection exists
 		self.assertIn(self.test_collection, self.db.list_collection_names())
-
-		# Verify that the index on assigned_doctor_id was created
 		index_info = get_collection(self.test_collection).index_information()
 		self.assertIn("assigned_doctor_id_1", index_info)
 
 	def test_create_patient(self):
-		"""Test patient creation with required and optional fields."""
+		"""Test patient creation with minimal and full data."""
 		# Test minimal creation
 		patient_id = patient_repo.create_patient(
-			name="John Doe",
-			age=45,
-			sex="Male",
-			ethnicity="Caucasian",
-			collection_name=self.test_collection
+			"John Doe", 45, "Male", "Caucasian", collection_name=self.test_collection
 		)
 		self.assertIsInstance(patient_id, str)
 		doc = self.get_doc_by_id(Collections.PATIENT, patient_id)
 		self.assertIsNotNone(doc)
 		self.assertEqual(doc["name"], "John Doe") # type: ignore
-		self.assertIn("created_at", doc) # type: ignore
-		self.assertEqual(doc["created_at"], doc["updated_at"]) # type: ignore
 
-		# Test full creation
-		doctor_id = ObjectId()
-		patient_id_full = patient_repo.create_patient(
+		# Test full creation with all optional parameters
+		doctor_id = str(ObjectId())
+		full_id = patient_repo.create_patient(
 			name="Jane Doe",
 			age=30,
 			sex="Female",
 			ethnicity="Asian",
-			address="123 Test St",
-			phone="555-0123",
-			email="jane@test.com",
-			medications=["Med A", "Med B"],
-			past_assessment_summary="Previous checkup normal",
-			assigned_doctor_id=str(doctor_id),
+			address="123 Wellness Way",
+			phone="555-123-4567",
+			email="jane.doe@example.com",
+			medications=["Lisinopril", "Metformin"],
+			past_assessment_summary="Routine check-up, generally healthy.",
+			assigned_doctor_id=doctor_id,
 			collection_name=self.test_collection
 		)
-		doc_full = self.get_doc_by_id(Collections.PATIENT, patient_id_full)
-		self.assertIsNotNone(doc_full)
-		self.assertEqual(doc_full["email"], "jane@test.com") # type: ignore
-		self.assertEqual(len(doc_full["medications"]), 2) # type: ignore
-		self.assertIsInstance(doc_full["assigned_doctor_id"], ObjectId) # type: ignore
-		self.assertEqual(doc_full["assigned_doctor_id"], doctor_id) # type: ignore
+		self.assertIsInstance(full_id, str)
+		full_doc = self.get_doc_by_id(Collections.PATIENT, full_id)
+
+		# Verify all fields were saved correctly
+		self.assertIsNotNone(full_doc)
+		self.assertEqual(full_doc["address"], "123 Wellness Way") # type: ignore
+		self.assertEqual(full_doc["phone"], "555-123-4567") # type: ignore
+		self.assertEqual(full_doc["email"], "jane.doe@example.com") # type: ignore
+		self.assertEqual(len(full_doc["medications"]), 2) # type: ignore
+		self.assertIn("Lisinopril", full_doc["medications"]) # type: ignore
+		self.assertEqual(full_doc["past_assessment_summary"], "Routine check-up, generally healthy.") # type: ignore
+		self.assertEqual(str(full_doc["assigned_doctor_id"]), doctor_id) # type: ignore
 
 	def test_get_patient_by_id(self):
-		"""Test retrieving a single patient by their ID."""
+		"""Test retrieving an existing patient by ID."""
 		patient_id = patient_repo.create_patient("GetMe", 33, "Female", "Other", collection_name=self.test_collection)
-
 		patient = patient_repo.get_patient_by_id(patient_id, collection_name=self.test_collection)
 		self.assertIsNotNone(patient)
 		self.assertEqual(patient["_id"], patient_id) # type: ignore
-		self.assertEqual(patient["name"], "GetMe") # type: ignore
-		self.assertIsInstance(patient["_id"], str) # type: ignore
-
 		# Test retrieval of a non-existent patient returns None
-		non_existent_id = str(ObjectId())
-		patient = patient_repo.get_patient_by_id(non_existent_id, collection_name=self.test_collection)
-		self.assertIsNone(patient)
+		self.assertIsNone(patient_repo.get_patient_by_id(str(ObjectId()), collection_name=self.test_collection))
 
 	def test_update_patient_profile(self):
-		"""Test patient profile updates for existing and non-existing patients."""
-		patient_id = patient_repo.create_patient(
-			name="Update Test",
-			age=25,
-			sex="Male",
-			ethnicity="Hispanic",
-			collection_name=self.test_collection
-		)
-		original_doc = self.get_doc_by_id(Collections.PATIENT, patient_id)
-		self.assertIsNotNone(original_doc)
-
-		# Test partial update
+		"""Test successfully updating an existing patient's profile."""
+		patient_id = patient_repo.create_patient("Update Test", 25, "Male", "Hispanic", collection_name=self.test_collection)
 		updates = {"age": 26, "phone": "555-9999"}
-		modified_count = patient_repo.update_patient_profile(
-			patient_id, updates, collection_name=self.test_collection
-		)
+		modified_count = patient_repo.update_patient_profile(patient_id, updates, collection_name=self.test_collection)
 		self.assertEqual(modified_count, 1)
-
-		updated_doc = self.get_doc_by_id(Collections.PATIENT, patient_id)
-		self.assertIsNotNone(updated_doc)
-		self.assertEqual(updated_doc["age"], 26) # type: ignore
-		self.assertEqual(updated_doc["phone"], "555-9999") # type: ignore
-		self.assertLess(original_doc["updated_at"], updated_doc["updated_at"]) # type: ignore
-
+		doc = self.get_doc_by_id(Collections.PATIENT, patient_id)
+		self.assertEqual(doc["age"], 26) # type: ignore
 		# Test updating a non-existent patient returns a modified count of 0
-		non_existent_id = str(ObjectId())
-		modified_count = patient_repo.update_patient_profile(
-			non_existent_id, {"name": "Ghost"}, collection_name=self.test_collection
-		)
-		self.assertEqual(modified_count, 0)
+		self.assertEqual(patient_repo.update_patient_profile(str(ObjectId()), {"name": "Ghost"}, collection_name=self.test_collection), 0)
 
 	def test_search_patients(self):
 		"""Test patient search functionality with various queries and limits."""
-		# Create test patients
 		patient_repo.create_patient("Alice Smith", 30, "Female", "Asian", collection_name=self.test_collection)
 		patient_repo.create_patient("Bob Smith", 45, "Male", "Caucasian", collection_name=self.test_collection)
-		patient_repo.create_patient("Charlie Brown", 60, "Male", "African", collection_name=self.test_collection)
-
-		# Test search by partial name, should be case-insensitive
 		results = patient_repo.search_patients("smith", collection_name=self.test_collection)
 		self.assertEqual(len(results), 2)
-
-		# Test search is sorted ascending by name
 		self.assertEqual(results[0]["name"], "Alice Smith")
-		self.assertEqual(results[1]["name"], "Bob Smith")
+		# Test limit parameter
+		self.assertEqual(len(patient_repo.search_patients("s", limit=1, collection_name=self.test_collection)), 1)
 
-		# Test case-insensitive exact match
-		results = patient_repo.search_patients("charlie brown", collection_name=self.test_collection)
-		self.assertEqual(len(results), 1)
-		self.assertEqual(results[0]["name"], "Charlie Brown")
 
-		# Test limit parameter
-		results = patient_repo.search_patients("S", limit=1, collection_name=self.test_collection)
-		self.assertEqual(len(results), 1)
+class TestPatientRepositoryExceptions(BaseMongoTest):
+	"""Test class for the exception handling of all patient repository functions."""
 
-		# Test query with no results
-		results = patient_repo.search_patients("Zebra", collection_name=self.test_collection)
-		self.assertEqual(len(results), 0)
+	def setUp(self):
+		"""Set up the test environment before each test."""
+		super().setUp()
+		self.test_collection = self._collections[Collections.PATIENT]
+		patient_repo.init(collection_name=self.test_collection, drop=True)
 
-		# Test empty query string returns an empty list
-		results = patient_repo.search_patients("", collection_name=self.test_collection)
-		self.assertEqual(len(results), 0)
+	def test_write_error_raises_action_failed(self):
+		"""Test that creating or updating with data violating schema raises ActionFailed."""
+		# Test creating a patient with a 'sex' value not in the schema's enum
+		with self.assertRaises(ActionFailed):
+			patient_repo.create_patient("Schema Test", 25, "InvalidValue", "Other", collection_name=self.test_collection)
+
+		# Test updating a patient with an invalid value
+		patient_id = patient_repo.create_patient("UpdateSchema", 30, "Male", "Other", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.update_patient_profile(patient_id, {"ethnicity": 123}, collection_name=self.test_collection)
+
+	def test_invalid_id_raises_action_failed(self):
+		"""Test that functions raise ActionFailed when given a malformed ObjectId string."""
+		with self.assertRaises(ActionFailed):
+			patient_repo.create_patient("Test", 30, "Male", "Other", assigned_doctor_id="not-a-valid-id", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.get_patient_by_id("not-a-valid-id", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.update_patient_profile("not-a-valid-id", {"name": "test"}, collection_name=self.test_collection)
+
+	@patch('src.data.repositories.patient.get_collection')
+	def test_all_functions_raise_on_connection_error(self, mock_get_collection):
+		"""Test that all repo functions catch generic PyMongoErrors and raise ActionFailed."""
+		mock_get_collection.side_effect = ConnectionFailure("Simulated connection error")
+
+		with self.assertRaises(ActionFailed):
+			patient_repo.init(collection_name=self.test_collection, drop=True)
+		with self.assertRaises(ActionFailed):
+			patient_repo.create_patient("Test", 30, "Male", "Other", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.get_patient_by_id(str(ObjectId()), collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.update_patient_profile(str(ObjectId()), {"name": "test"}, collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			patient_repo.search_patients("test", collection_name=self.test_collection)
 
 if __name__ == "__main__":
 	try: