Upgraded and reworked medical repo file.

Follows the same style, structure, and logic as the other data access layer files.
Also includes tests.

schemas/medical_memory_validator.json

@@ -0,0 +1,41 @@
+{
+	"$jsonSchema": {
+		"bsonType": "object",
+		"title": "Medical Memory validator",
+		"required": [
+			"patient_id",
+			"doctor_id",
+			"summary",
+			"created_at"
+		],
+		"properties": {
+			"patient_id": {
+				"bsonType": "objectId",
+				"description": "'patient_id' must be an objectId and is required."
+			},
+			"doctor_id": {
+				"bsonType": "objectId",
+				"description": "'doctor_id' must be an objectId and is required."
+			},
+			"session_id": {
+				"bsonType": "objectId",
+				"description": "'session_id' must be an objectId and is optional."
+			},
+			"summary": {
+				"bsonType": "string",
+				"description": "'summary' must be a string and is required."
+			},
+			"embedding": {
+				"bsonType": "array",
+				"description": "'embedding' must be an array of floats and is optional.",
+				"items": {
+					"bsonType": "double"
+				}
+			},
+			"created_at": {
+				"bsonType": "date",
+				"description": "'created_at' must be a date and is required."
+			}
+		}
+	}
+}

schemas/medical_record_validator.json

@@ -0,0 +1,40 @@
+{
+	"$jsonSchema": {
+		"bsonType": "object",
+		"title": "Medical Record validator",
+		"required": [
+			"patient_id",
+			"doctor_id",
+			"record_type",
+			"details",
+			"created_at",
+			"updated_at"
+		],
+		"properties": {
+			"patient_id": {
+				"bsonType": "objectId",
+				"description": "'patient_id' must be an objectId and is required."
+			},
+			"doctor_id": {
+				"bsonType": "objectId",
+				"description": "'doctor_id' must be an objectId and is required."
+			},
+			"record_type": {
+				"bsonType": "string",
+				"description": "'record_type' must be a string and is required."
+			},
+			"details": {
+				"bsonType": "object",
+				"description": "'details' must be an object and is required."
+			},
+			"created_at": {
+				"bsonType": "date",
+				"description": "'created_at' must be a date and is required."
+			},
+			"updated_at": {
+				"bsonType": "date",
+				"description": "'updated_at' must be a date and is required."
+			}
+		}
+	}
+}

src/data/repositories/medical.py

@@ -1,183 +0,0 @@
-# data/repositories/medical.py
-"""
-Medical records and memory management operations for MongoDB.
-
-@Note Could this be split into two? One for records and one for memory.
-"""
-
-from datetime import datetime, timezone
-from typing import Any
-
-from bson import ObjectId
-from pymongo import ASCENDING, DESCENDING
-from pymongo.errors import (ConnectionFailure, DuplicateKeyError,
-                            OperationFailure, PyMongoError)
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.utils.logger import logger
-
-
-#def init(
-#	*,
-#	collection_name: str = Collections.MEDICAL_MEMORY,
-#	validator_path: str = "schemas/account_validator.json",
-#	drop: bool = False
-#):
-#	if drop:
-#		get_collection(collection_name).drop()
-#	setup_collection(collection_name, validator_path)
-
-def create_medical_record(
-	record_data: dict[str, Any],
-	/, *,
-	collection_name: str = Collections.MEDICAL_RECORDS
-) -> str:
-	"""Creates a new medical record."""
-	collection = get_collection(collection_name)
-	now = datetime.now(timezone.utc)
-	record_data.update({"created_at": now, "updated_at": now})
-	result = collection.insert_one(record_data)
-	return str(result.inserted_id)
-
-def get_user_medical_records(
-	user_id: str,
-	/, *,
-	collection_name: str = Collections.MEDICAL_RECORDS
-) -> list[dict[str, Any]]:
-	"""Retrieves all medical records for a specific user."""
-	collection = get_collection(collection_name)
-	cursor = collection.find(
-		{"user_id": user_id}
-	).sort(
-		"created_at", ASCENDING
-	)
-	return list(cursor)
-
-def add_medical_context(
-	user_id: str,
-	/,
-	summary: str,
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> str:
-	"""Adds a medical context summary for a user."""
-	collection = get_collection(collection_name)
-	doc = {
-		"_id": str(ObjectId()),
-		"user_id": user_id,
-		"summary": summary,
-		"timestamp": datetime.now(timezone.utc)
-	}
-	result = collection.insert_one(doc)
-	return str(result.inserted_id)
-
-def get_medical_context(
-	user_id: str,
-	/,
-	limit: int | None = None,
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> list[dict[str, Any]]:
-	"""Retrieves medical context summaries for a user."""
-	collection = get_collection(collection_name)
-	cursor = collection.find(
-		{"user_id": user_id}
-	).sort(
-		"timestamp", DESCENDING
-	)
-	if limit:
-		cursor = cursor.limit(limit)
-	return list(cursor)
-
-# TODO Delete context
-
-def save_memory_summary(
-	*,
-	patient_id: str,
-	doctor_id: str,
-	summary: str,
-	embedding: list[float] | None = None,
-	created_at: datetime | None = None,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> str:
-	collection = get_collection(collection_name)
-	ts = created_at or datetime.now(timezone.utc)
-	doc = {
-		"patient_id": patient_id,
-		"doctor_id": doctor_id,
-		"summary": summary,
-		"created_at": ts
-	}
-	if embedding is not None:
-		doc["embedding"] = embedding
-	result = collection.insert_one(doc)
-	return str(result.inserted_id)
-
-def get_recent_memory_summaries(
-	patient_id: str,
-	/,
-	*,
-	limit: int = 20,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> list[str]:
-	collection = get_collection(collection_name)
-	docs = list(collection.find({"patient_id": patient_id}).sort("created_at", DESCENDING).limit(limit))
-	return [d.get("summary", "") for d in docs]
-
-def search_memory_summaries_semantic(
-	patient_id: str,
-	query_embedding: list[float],
-	/,
-	*,
-	limit: int = 5,
-	similarity_threshold: float = 0.5,  # >= 50% semantic similarity
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> list[dict[str, Any]]:
-	"""
-	Search memory summaries using semantic similarity with embeddings.
-	Returns list of {summary, similarity_score, created_at} sorted by similarity.
-	"""
-	collection = get_collection(collection_name)
-
-	# Get all summaries with embeddings for this patient
-	docs = list(collection.find({
-		"patient_id": patient_id,
-		"embedding": {"$exists": True}
-	}))
-
-	if not docs:
-		return []
-
-	# Calculate similarities
-	import numpy as np
-	query_vec = np.array(query_embedding, dtype="float32")
-	results = []
-
-	for doc in docs:
-		embedding = doc.get("embedding")
-		if not embedding:
-			continue
-
-		# Calculate cosine similarity
-		doc_vec = np.array(embedding, dtype="float32")
-		dot_product = np.dot(query_vec, doc_vec)
-		norm_query = np.linalg.norm(query_vec)
-		norm_doc = np.linalg.norm(doc_vec)
-
-		if norm_query == 0 or norm_doc == 0:
-			similarity = 0.0
-		else:
-			similarity = float(dot_product / (norm_query * norm_doc))
-
-		if similarity >= similarity_threshold:
-			results.append({
-					"summary": doc.get("summary", ""),
-					"similarity_score": similarity,
-					"created_at": doc.get("created_at"),
-					"session_id": doc.get("session_id")  # if we add this field later
-			})
-
-	# Sort by similarity (highest first) and return top results
-	results.sort(key=lambda x: x["similarity_score"], reverse=True)
-	return results[:limit]

src/data/repositories/medical_memory.py

@@ -0,0 +1,148 @@
+# src/data/repositories/medical_memory.py
+"""
+Medical memory management operations for MongoDB.
+Medical memories are unstructured summaries, often with vector embeddings for semantic search.
+
+## Fields
+	_id: index
+	patient_id: The patient this memory relates to
+	doctor_id: The doctor involved in the context of this memory
+	session_id: The chat session this memory was derived from (optional)
+	summary: The unstructured text summary of the medical context
+	embedding: The vector embedding of the summary for semantic search (optional)
+	created_at: The timestamp when the memory was created
+"""
+from datetime import datetime, timezone
+
+import numpy as np
+from bson import ObjectId
+from bson.errors import InvalidId
+from pymongo import DESCENDING
+from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
+
+from src.data.connection import (ActionFailed, Collections, get_collection,
+                                 setup_collection)
+from src.models.medical import MedicalMemory, SemanticSearchResult
+from src.utils.logger import logger
+
+
+def init(
+	*,
+	collection_name: str = Collections.MEDICAL_MEMORY,
+	validator_path: str = "schemas/medical_memory_validator.json",
+	drop: bool = False
+):
+	"""Initializes the medical_memory collection, applying schema validation."""
+	try:
+		if drop:
+			get_collection(collection_name).drop()
+		setup_collection(collection_name, validator_path)
+	except (ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
+		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
+
+def create_memory(
+	patient_id: str,
+	doctor_id: str,
+	summary: str,
+	session_id: str | None = None,
+	embedding: list[float] | None = None,
+	*,
+	collection_name: str = Collections.MEDICAL_MEMORY
+) -> str:
+	"""Saves a new medical memory summary, raising ActionFailed on error."""
+	try:
+		collection = get_collection(collection_name)
+		doc = {
+			"patient_id": ObjectId(patient_id),
+			"doctor_id": ObjectId(doctor_id),
+			"summary": summary,
+			"created_at": datetime.now(timezone.utc)
+		}
+		if session_id:
+			doc["session_id"] = ObjectId(session_id)
+		if embedding:
+			doc["embedding"] = embedding
+
+		result = collection.insert_one(doc)
+		return str(result.inserted_id)
+	except InvalidId as e:
+		logger().error(f"Invalid ObjectId format provided for medical memory: {e}")
+		raise ActionFailed("Patient, Doctor, or Session ID is not a valid format.") from e
+	except (WriteError, ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Failed to create medical memory: {e}")
+		raise ActionFailed("A database error occurred while creating the medical memory.") from e
+
+def get_recent_memories(
+	patient_id: str,
+	limit: int = 20,
+	*,
+	collection_name: str = Collections.MEDICAL_MEMORY
+) -> list[MedicalMemory]:
+	"""Retrieves the most recent memory summaries for a patient."""
+	try:
+		obj_patient_id = ObjectId(patient_id)
+		collection = get_collection(collection_name)
+		cursor = collection.find(
+			{"patient_id": obj_patient_id}
+		).sort("created_at", DESCENDING).limit(limit)
+
+		return [MedicalMemory.model_validate(doc) for doc in cursor]
+	except InvalidId as e:
+		logger().error(f"Invalid patient_id format for get_recent_memories: '{patient_id}'")
+		raise ActionFailed("The provided patient ID is not a valid format.") from e
+	except (ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Database error retrieving recent memories for patient '{patient_id}': {e}")
+		raise ActionFailed("A database error occurred while retrieving recent memories.") from e
+
+def search_memories_semantic(
+	patient_id: str,
+	query_embedding: list[float],
+	limit: int = 5,
+	*,
+	collection_name: str = Collections.MEDICAL_MEMORY
+) -> list[SemanticSearchResult]:
+	"""Searches memory summaries using semantic similarity with embeddings."""
+	try:
+		obj_patient_id = ObjectId(patient_id)
+		collection = get_collection(collection_name)
+
+		# In a real-world scenario, this would be an Atlas Vector Search query.
+		# This implementation fetches all docs and calculates similarity in the client.
+		docs = list(collection.find({
+			"patient_id": obj_patient_id,
+			"embedding": {"$exists": True}
+		}))
+
+		if not docs:
+			return []
+
+		query_vec = np.array(query_embedding, dtype="float32")
+		results = []
+		for doc in docs:
+			doc_vec = np.array(doc["embedding"], dtype="float32")
+
+			# Calculate cosine similarity
+			dot_product = np.dot(query_vec, doc_vec)
+			norm_query = np.linalg.norm(query_vec)
+			norm_doc = np.linalg.norm(doc_vec)
+
+			if norm_query > 0 and norm_doc > 0:
+				similarity = float(dot_product / (norm_query * norm_doc))
+				result_data = {
+					"summary": doc["summary"],
+					"similarity_score": similarity,
+					"created_at": doc["created_at"],
+					"session_id": doc.get("session_id")
+				}
+				results.append(SemanticSearchResult.model_validate(result_data))
+
+		# Sort by similarity (highest first) and return top results
+		results.sort(key=lambda x: x.similarity_score, reverse=True)
+		return results[:limit]
+	except InvalidId as e:
+		logger().error(f"Invalid patient_id format for semantic search: '{patient_id}'")
+		raise ActionFailed("The provided patient ID is not a valid format.") from e
+	except (ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Database error during semantic search for patient '{patient_id}': {e}")
+		raise ActionFailed("A database error occurred during the semantic search.") from e

src/data/repositories/medical_record.py

@@ -0,0 +1,93 @@
+# src/data/repositories/medical_record.py
+"""
+Medical record management operations for MongoDB.
+Medical records are structured, factual pieces of information about a patient.
+
+## Fields
+	_id: index
+	patient_id: The patient this record belongs to
+	doctor_id: The doctor who created or is associated with this record
+	record_type: The category of the record (e.g., 'Consultation', 'LabResult')
+	details: An object containing the specific, structured data for the record
+	created_at: The timestamp when the record was created
+	updated_at: The timestamp when the record was last modified
+"""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from bson import ObjectId
+from bson.errors import InvalidId
+from pymongo import ASCENDING
+from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
+
+from src.data.connection import (ActionFailed, Collections, get_collection,
+                                 setup_collection)
+from src.models.medical import MedicalRecord
+from src.utils.logger import logger
+
+
+def init(
+	*,
+	collection_name: str = Collections.MEDICAL_RECORDS,
+	validator_path: str = "schemas/medical_record_validator.json",
+	drop: bool = False
+):
+	"""Initializes the medical_records collection, applying schema validation."""
+	try:
+		if drop:
+			get_collection(collection_name).drop()
+		setup_collection(collection_name, validator_path)
+	except (ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
+		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
+
+def create_medical_record(
+	patient_id: str,
+	doctor_id: str,
+	record_type: str,
+	details: dict[str, Any],
+	*,
+	collection_name: str = Collections.MEDICAL_RECORDS
+) -> str:
+	"""Creates a new medical record, raising ActionFailed on error."""
+	now = datetime.now(timezone.utc)
+	try:
+		collection = get_collection(collection_name)
+		record_data = {
+			"patient_id": ObjectId(patient_id),
+			"doctor_id": ObjectId(doctor_id),
+			"record_type": record_type,
+			"details": details,
+			"created_at": now,
+			"updated_at": now
+		}
+		result = collection.insert_one(record_data)
+		return str(result.inserted_id)
+	except InvalidId as e:
+		logger().error(f"Invalid ObjectId format provided for medical record: {e}")
+		raise ActionFailed("Patient ID or Doctor ID is not a valid format.") from e
+	except (WriteError, ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Failed to create medical record: {e}")
+		raise ActionFailed("A database error occurred while creating the medical record.") from e
+
+def get_records_for_patient(
+	patient_id: str,
+	*,
+	collection_name: str = Collections.MEDICAL_RECORDS
+) -> list[MedicalRecord]:
+	"""Retrieves all medical records for a patient, sorted by creation date."""
+	try:
+		obj_patient_id = ObjectId(patient_id)
+		collection = get_collection(collection_name)
+		cursor = collection.find(
+			{"patient_id": obj_patient_id}
+		).sort("created_at", ASCENDING)
+
+		return [MedicalRecord.model_validate(doc) for doc in cursor]
+	except InvalidId as e:
+		logger().error(f"Invalid patient_id format for get_records_for_patient: '{patient_id}'")
+		raise ActionFailed("The provided patient ID is not a valid format.") from e
+	except (ConnectionFailure, PyMongoError) as e:
+		logger().error(f"Database error retrieving records for patient '{patient_id}': {e}")
+		raise ActionFailed("A database error occurred while retrieving medical records.") from e

src/models/medical.py

@@ -0,0 +1,38 @@
+# src/models/medical.py
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from models.repositories import BaseMongoModel, PyObjectId
+
+
+class MedicalRecord(BaseMongoModel):
+	"""A Pydantic model for a structured medical record."""
+	patient_id: PyObjectId
+	doctor_id: PyObjectId
+	record_type: str
+	details: dict[str, Any]
+	created_at: datetime
+	updated_at: datetime
+
+
+class MedicalMemory(BaseMongoModel):
+	"""A Pydantic model for a medical memory summary, used for semantic search."""
+	patient_id: PyObjectId
+	doctor_id: PyObjectId
+	session_id: PyObjectId | None = None
+	summary: str
+	embedding: list[float] | None = None
+	created_at: datetime
+
+
+class SemanticSearchResult(BaseModel):
+	"""A Pydantic model for the result of a semantic search."""
+	summary: str
+	similarity_score: float
+	created_at: datetime
+	session_id: PyObjectId | None = None
+
+	model_config = ConfigDict(frozen=True, from_attributes=True)

tests/test_medical_memory.py

@@ -0,0 +1,122 @@
+import unittest
+from unittest.mock import patch
+
+from bson import ObjectId
+from pymongo.errors import ConnectionFailure
+
+from src.data.connection import ActionFailed, Collections
+from src.data.repositories import medical_memory as medical_memory_repo
+from src.models.medical import MedicalMemory, SemanticSearchResult
+from src.utils.logger import logger
+from tests.base_test import BaseMongoTest
+
+
+class TestMedicalMemoryRepository(BaseMongoTest):
+	"""Test class for the 'happy path' of medical memory repository functions."""
+
+	def setUp(self):
+		"""Set up a clean test environment before each test."""
+		super().setUp()
+		self.test_collection = self._collections[Collections.MEDICAL_MEMORY]
+		medical_memory_repo.init(collection_name=self.test_collection, drop=True)
+		self.patient_id = str(ObjectId())
+		self.doctor_id = str(ObjectId())
+		self.session_id = str(ObjectId())
+		self.embedding = [0.1, 0.2, 0.3]
+
+	def test_init_functionality(self):
+		"""Test that the init function correctly sets up the collection."""
+		self.assertIn(self.test_collection, self.db.list_collection_names())
+
+	def test_create_memory(self):
+		"""Test successful creation of a medical memory with and without optional fields."""
+		# Test full creation
+		memory_id = medical_memory_repo.create_memory(
+			self.patient_id, self.doctor_id, "Full summary", self.session_id, self.embedding,
+			collection_name=self.test_collection
+		)
+		self.assertIsInstance(memory_id, str)
+		doc = self.get_doc_by_id(Collections.MEDICAL_MEMORY, memory_id)
+		self.assertIsNotNone(doc)
+		self.assertEqual(doc["summary"], "Full summary") # type: ignore
+		self.assertEqual(len(doc["embedding"]), 3) # type: ignore
+
+		# Test minimal creation
+		min_id = medical_memory_repo.create_memory(
+			self.patient_id, self.doctor_id, "Minimal summary", collection_name=self.test_collection
+		)
+		self.assertIsInstance(min_id, str)
+
+	def test_get_recent_memories(self):
+		"""Test retrieving recent memories, verifying sorting, filtering, and limit."""
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "Oldest", collection_name=self.test_collection)
+		medical_memory_repo.create_memory(str(ObjectId()), self.doctor_id, "Other Patient", collection_name=self.test_collection)
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "Newest", collection_name=self.test_collection)
+
+		memories = medical_memory_repo.get_recent_memories(self.patient_id, collection_name=self.test_collection)
+		self.assertEqual(len(memories), 2)
+		self.assertIsInstance(memories[0], MedicalMemory)
+		self.assertEqual(memories[0].summary, "Newest") # Descending sort order
+
+		# Test limit
+		limited = medical_memory_repo.get_recent_memories(self.patient_id, limit=1, collection_name=self.test_collection)
+		self.assertEqual(len(limited), 1)
+
+	def test_search_memories_semantic(self):
+		"""Test semantic search functionality, verifying similarity logic and sorting."""
+		# Create memories with known embeddings
+		vec_a = [1.0, 0.0, 0.0] # Most similar
+		vec_b = [0.7, 0.7, 0.0] # Less similar
+		vec_c = [0.0, 0.0, 1.0] # Not similar
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "Vec A", embedding=vec_a, collection_name=self.test_collection)
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "Vec B", embedding=vec_b, collection_name=self.test_collection)
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "Vec C", embedding=vec_c, collection_name=self.test_collection)
+		medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "No Embedding", collection_name=self.test_collection)
+
+		query_embedding = [0.9, 0.1, 0.0]
+		results = medical_memory_repo.search_memories_semantic(self.patient_id, query_embedding, collection_name=self.test_collection)
+
+		self.assertEqual(len(results), 3) # Vec C should be filtered by default numpy math
+		self.assertIsInstance(results[0], SemanticSearchResult)
+		self.assertEqual(results[0].summary, "Vec A") # Most similar should be first
+		self.assertGreater(results[0].similarity_score, results[1].similarity_score)
+
+
+class TestMedicalMemoryRepositoryExceptions(BaseMongoTest):
+	"""Test class for the exception handling of medical memory repository functions."""
+
+	def setUp(self):
+		"""Set up the test environment before each test."""
+		super().setUp()
+		self.test_collection = self._collections[Collections.MEDICAL_MEMORY]
+		medical_memory_repo.init(collection_name=self.test_collection, drop=True)
+		self.patient_id = str(ObjectId())
+		self.doctor_id = str(ObjectId())
+
+	def test_invalid_id_raises_action_failed(self):
+		"""Test that functions raise ActionFailed when given a malformed ObjectId string."""
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.create_memory("bad-id", self.doctor_id, "t", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.get_recent_memories("bad-id", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.search_memories_semantic("bad-id", [], collection_name=self.test_collection)
+
+	@patch('src.data.repositories.medical_memory.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):
+			medical_memory_repo.init(collection_name=self.test_collection, drop=True)
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.create_memory(self.patient_id, self.doctor_id, "t", collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.get_recent_memories(self.patient_id, collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_memory_repo.search_memories_semantic(self.patient_id, [], collection_name=self.test_collection)
+
+if __name__ == "__main__":
+	logger().info("Starting MongoDB repository integration tests...")
+	unittest.main(verbosity=2)
+	logger().info("Tests completed and database connection closed.")

tests/test_medical_record.py

@@ -0,0 +1,104 @@
+import time
+import unittest
+from unittest.mock import patch
+
+from bson import ObjectId
+from pymongo.errors import ConnectionFailure
+
+from src.data.connection import ActionFailed, Collections
+from src.data.repositories import medical_record as medical_record_repo
+from src.models.medical import MedicalRecord
+from src.utils.logger import logger
+from tests.base_test import BaseMongoTest
+
+
+class TestMedicalRecordRepository(BaseMongoTest):
+	"""Test class for the 'happy path' of medical record repository functions."""
+
+	def setUp(self):
+		"""Set up a clean test environment before each test."""
+		super().setUp()
+		self.test_collection = self._collections[Collections.MEDICAL_RECORDS]
+		medical_record_repo.init(collection_name=self.test_collection, drop=True)
+		self.patient_id = str(ObjectId())
+		self.doctor_id = str(ObjectId())
+
+	def test_init_functionality(self):
+		"""Test that the init function correctly sets up the collection."""
+		self.assertIn(self.test_collection, self.db.list_collection_names())
+
+	def test_create_medical_record(self):
+		"""Test successful creation of a medical record."""
+		record_id = medical_record_repo.create_medical_record(
+			patient_id=self.patient_id,
+			doctor_id=self.doctor_id,
+			record_type="Consultation",
+			details={"symptoms": "Fever, cough", "diagnosis": "Common cold"},
+			collection_name=self.test_collection
+		)
+		self.assertIsInstance(record_id, str)
+		doc = self.get_doc_by_id(Collections.MEDICAL_RECORDS, record_id)
+		self.assertIsNotNone(doc)
+		self.assertEqual(doc["record_type"], "Consultation") # type: ignore
+		self.assertEqual(str(doc["patient_id"]), self.patient_id) # type: ignore
+
+	def test_get_records_for_patient(self):
+		"""Test retrieving all records for a patient, verifying sorting and filtering."""
+		other_patient_id = str(ObjectId())
+		# Create records, sleeping to ensure distinct creation timestamps for sorting check
+		r1_id = medical_record_repo.create_medical_record(self.patient_id, self.doctor_id, "R1", {}, collection_name=self.test_collection)
+		time.sleep(0.01)
+		medical_record_repo.create_medical_record(other_patient_id, self.doctor_id, "Other", {}, collection_name=self.test_collection)
+		time.sleep(0.01)
+		r2_id = medical_record_repo.create_medical_record(self.patient_id, self.doctor_id, "R2", {}, collection_name=self.test_collection)
+
+		# Retrieve records for the target patient
+		records = medical_record_repo.get_records_for_patient(self.patient_id, collection_name=self.test_collection)
+
+		# Verify correct filtering, count, and type
+		self.assertEqual(len(records), 2)
+		self.assertIsInstance(records[0], MedicalRecord)
+
+		# Verify sorting (ascending by creation date)
+		self.assertEqual(records[0].id, r1_id)
+		self.assertEqual(records[1].id, r2_id)
+
+		# Test edge case: patient with no records
+		no_records = medical_record_repo.get_records_for_patient(str(ObjectId()), collection_name=self.test_collection)
+		self.assertEqual(len(no_records), 0)
+
+
+class TestMedicalRecordRepositoryExceptions(BaseMongoTest):
+	"""Test class for the exception handling of medical record repository functions."""
+
+	def setUp(self):
+		"""Set up the test environment before each test."""
+		super().setUp()
+		self.test_collection = self._collections[Collections.MEDICAL_RECORDS]
+		medical_record_repo.init(collection_name=self.test_collection, drop=True)
+		self.patient_id = str(ObjectId())
+		self.doctor_id = str(ObjectId())
+
+	def test_invalid_id_raises_action_failed(self):
+		"""Test that functions raise ActionFailed when given a malformed ObjectId string."""
+		with self.assertRaises(ActionFailed):
+			medical_record_repo.create_medical_record("bad-id", self.doctor_id, "t", {}, collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_record_repo.get_records_for_patient("bad-id", collection_name=self.test_collection)
+
+	@patch('src.data.repositories.medical_record.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):
+			medical_record_repo.init(collection_name=self.test_collection, drop=True)
+		with self.assertRaises(ActionFailed):
+			medical_record_repo.create_medical_record(self.patient_id, self.doctor_id, "t", {}, collection_name=self.test_collection)
+		with self.assertRaises(ActionFailed):
+			medical_record_repo.get_records_for_patient(self.patient_id, collection_name=self.test_collection)
+
+if __name__ == "__main__":
+	logger().info("Starting MongoDB repository integration tests...")
+	unittest.main(verbosity=2)
+	logger().info("Tests completed and database connection closed.")