feat(test): integrate MongoDB Testcontainer and refactor integration tests to use real DB (#75)

AnujChhikara · web-flow · commit d0875e51dac2 · 2025-06-16T01:01:08.000+05:30
* feat(test): add test database setup and refactor delete task integration test

* feat(test): add shared MongoDB test container for integration tests

* fix docker internal host ci

* refactor: test_task_detail integration test to use db

* fix: host name on linux machine

* test: add more check on invalid task id

* refactor: add error handling for mongo start and add proper spacing

* refactor: use constant value instead of hardcoded value

* fix: add logic to clear db with each test suite and use django inbuild reverse to generate url

* fix: replace 1s sleep with log-based wait for Mongo readiness

* fix: remove hardcoded host/port and use container IP for replica set init

* Fix: Properly close MongoDB connection in DatabaseManager.reset()
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -7,15 +7,6 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-    services:
-      db:
-        image: mongo:latest
-        ports:
-          - 27017:27017
-    
-    env:
-      MONGODB_URI: mongodb://db:27017
-      DB_NAME: todo-app
 
     steps:
       - name: Checkout code
@@ -36,4 +27,4 @@ jobs:
 
       - name: Run tests
         run: |
-          python3.11 manage.py test
+          python3.11 manage.py test
diff --git a/requirements.txt b/requirements.txt
@@ -20,3 +20,4 @@ ruff==0.7.1
 sqlparse==0.5.1
 typing_extensions==4.12.2
 virtualenv==20.27.0
+testcontainers[mongodb]==4.10.0
diff --git a/todo/tests/integration/base_mongo_test.py b/todo/tests/integration/base_mongo_test.py
@@ -0,0 +1,31 @@
+from django.test import TransactionTestCase, override_settings
+from pymongo import MongoClient
+from todo.tests.testcontainers.shared_mongo import get_shared_mongo_container
+from todo_project.db.config import DatabaseManager
+
+class BaseMongoTestCase(TransactionTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.mongo_container = get_shared_mongo_container()
+        cls.mongo_url = cls.mongo_container.get_connection_url()
+        cls.mongo_client = MongoClient(cls.mongo_url)
+        cls.db = cls.mongo_client.get_database("testdb")
+
+        cls.override = override_settings(
+            MONGODB_URI=cls.mongo_url,
+            DB_NAME="testdb",
+        )
+        cls.override.enable()
+        DatabaseManager.reset()
+        DatabaseManager().get_database()
+
+    def setUp(self):
+        for collection in self.db.list_collection_names():
+            self.db[collection].delete_many({})
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.mongo_client.close()
+        cls.override.disable()
+        super().tearDownClass()
diff --git a/todo/tests/integration/test_task_detail_api.py b/todo/tests/integration/test_task_detail_api.py
@@ -1,76 +1,60 @@
-from unittest.mock import patch
-from rest_framework import status
-from rest_framework.test import APITestCase
-from django.urls import reverse
+from http import HTTPStatus
 from bson import ObjectId
-
-from todo.services.task_service import TaskService
-from todo.constants.messages import ValidationErrors, ApiErrors
-from todo.dto.responses.error_response import ApiErrorSource
-from todo.exceptions.task_exceptions import TaskNotFoundException
-from todo.tests.fixtures.task import task_dtos
-from todo.constants.task import TaskPriority, TaskStatus
-
-
-class TaskDetailAPIIntegrationTest(APITestCase):
-    @patch("todo.services.task_service.TaskService.get_task_by_id")
-    def test_get_task_by_id_success(self, mock_get_task_by_id):
-        fixture_task_dto = task_dtos[0]
-        task_id_str = fixture_task_dto.id
-
-        mock_get_task_by_id.return_value = fixture_task_dto
-
-        url = reverse("task_detail", args=[task_id_str])
+from django.urls import reverse
+from rest_framework.test import APIClient
+from todo.tests.fixtures.task import tasks_db_data
+from todo.tests.integration.base_mongo_test import BaseMongoTestCase
+from todo.constants.messages import ApiErrors, ValidationErrors
+
+
+class TaskDetailAPIIntegrationTest(BaseMongoTestCase):
+    def setUp(self):
+        super().setUp()
+        self.db.tasks.delete_many({})  # Clear tasks to avoid DuplicateKeyError
+        self.task_doc = tasks_db_data[1].copy()
+        self.task_doc["_id"] = self.task_doc.pop("id")
+        self.db.tasks.insert_one(self.task_doc)
+        self.existing_task_id = str(self.task_doc["_id"])
+        self.non_existent_id = str(ObjectId())
+        self.invalid_task_id = "invalid-task-id"
+        self.client = APIClient()
+
+    def test_get_task_by_id_success(self):
+        url = reverse('task_detail', args=[self.existing_task_id])
         response = self.client.get(url)
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-        response_data_outer = response.data
-        response_data_inner = response_data_outer.get("data")
-        self.assertIsNotNone(response_data_inner)
-
-        self.assertEqual(response_data_inner["id"], fixture_task_dto.id)
-        self.assertEqual(response_data_inner["title"], fixture_task_dto.title)
-
-        self.assertEqual(response_data_inner["priority"], TaskPriority(fixture_task_dto.priority).name)
-        self.assertEqual(response_data_inner["status"], TaskStatus(fixture_task_dto.status).value)
-
-        self.assertEqual(response_data_inner["displayId"], fixture_task_dto.displayId)
-
-        if fixture_task_dto.createdBy:
-            self.assertEqual(response_data_inner["createdBy"]["id"], fixture_task_dto.createdBy.id)
-            self.assertEqual(response_data_inner["createdBy"]["name"], fixture_task_dto.createdBy.name)
-
-        mock_get_task_by_id.assert_called_once_with(task_id_str)
-
-    @patch("todo.services.task_service.TaskService.get_task_by_id")
-    def test_get_task_by_id_not_found(self, mock_get_task_by_id):
-        non_existent_id = str(ObjectId())
-        mock_get_task_by_id.side_effect = TaskNotFoundException()
-
-        url = reverse("task_detail", args=[non_existent_id])
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        data = response.json()["data"]
+        self.assertEqual(data["id"], self.existing_task_id)
+        self.assertEqual(data["title"], self.task_doc["title"])
+        self.assertEqual(data["priority"], "MEDIUM")
+        self.assertEqual(data["status"], self.task_doc["status"])
+        self.assertEqual(data["displayId"], self.task_doc["displayId"])
+        self.assertEqual(data["createdBy"]["id"],
+                         self.task_doc["createdBy"])
+
+    def test_get_task_by_id_not_found(self):
+        url = reverse('task_detail', args=[self.non_existent_id])
         response = self.client.get(url)
-
-        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
-        error_detail = response.data.get("errors", [{}])[0].get("detail")
-        self.assertEqual(error_detail, "Task not found.")
-        mock_get_task_by_id.assert_called_once_with(non_existent_id)
-
-    @patch.object(TaskService, "get_task_by_id", wraps=TaskService.get_task_by_id)
-    def test_get_task_by_id_invalid_format(self, mock_actual_get_task_by_id):
-        invalid_task_id = "invalid-id"
-        url = reverse("task_detail", args=[invalid_task_id])
+        self.assertEqual(response.status_code, HTTPStatus.NOT_FOUND)
+
+        data = response.json()
+        error_message = ApiErrors.TASK_NOT_FOUND.format(self.non_existent_id)
+        self.assertEqual(data["message"], error_message)
+        error = data["errors"][0]
+        self.assertEqual(error["source"]["path"], "task_id")
+        self.assertEqual(error["title"], ApiErrors.RESOURCE_NOT_FOUND_TITLE)
+        self.assertEqual(error["detail"], error_message)
+
+    def test_get_task_by_id_invalid_format(self):
+        url = reverse('task_detail', args=[self.invalid_task_id])
         response = self.client.get(url)
-
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(response.data["message"], ValidationErrors.INVALID_TASK_ID_FORMAT)
-        self.assertIsNotNone(response.data.get("errors"))
-        self.assertEqual(len(response.data["errors"]), 1)
-
-        error_obj = response.data["errors"][0]
-        self.assertEqual(error_obj["detail"], ValidationErrors.INVALID_TASK_ID_FORMAT)
-        self.assertIn(ApiErrorSource.PATH.value, error_obj["source"])
-        self.assertEqual(error_obj["source"][ApiErrorSource.PATH.value], "task_id")
-        self.assertEqual(error_obj["title"], ApiErrors.VALIDATION_ERROR)
-
-        mock_actual_get_task_by_id.assert_called_once_with(invalid_task_id)
+        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        data = response.json()
+        self.assertEqual(data["statusCode"], 400)
+        self.assertEqual(
+            data["message"], ValidationErrors.INVALID_TASK_ID_FORMAT)
+        self.assertEqual(data["errors"][0]["source"]["path"], "task_id")
+        self.assertEqual(data["errors"][0]["title"],
+                         ApiErrors.VALIDATION_ERROR)
+        self.assertEqual(data["errors"][0]["detail"],
+                         ValidationErrors.INVALID_TASK_ID_FORMAT)
diff --git a/todo/tests/integration/test_tasks_delete.py b/todo/tests/integration/test_tasks_delete.py
@@ -1,42 +1,51 @@
-from django.urls import reverse
-from rest_framework import status
-from rest_framework.test import APITestCase
+from http import HTTPStatus
 from bson import ObjectId
-from unittest.mock import patch
-from todo.constants.messages import ApiErrors
-from todo.tests.fixtures.task import task_dtos
+from django.urls import reverse
+from rest_framework.test import APIClient
+from todo.tests.fixtures.task import tasks_db_data
+from todo.tests.integration.base_mongo_test import BaseMongoTestCase
+from todo.constants.messages import ValidationErrors, ApiErrors
 
 
-class TaskDeleteAPIIntegrationTest(APITestCase):
+class TaskDeleteAPIIntegrationTest(BaseMongoTestCase):
     def setUp(self):
-        self.task_id = task_dtos[0].id
+        super().setUp()
+        self.db.tasks.delete_many({})
+        task_doc = tasks_db_data[0].copy()
+        task_doc["_id"] = task_doc.pop("id")
+        self.db.tasks.insert_one(task_doc)
+        self.existing_task_id = str(task_doc["_id"])
+        self.non_existent_id = str(ObjectId())
+        self.invalid_task_id = "invalid-task-id"
+        self.client = APIClient()
 
-    @patch("todo.repositories.task_repository.TaskRepository.delete_by_id")
-    def test_delete_task_success(self, mock_delete_by_id):
-        url = reverse("task_detail", args=[self.task_id])
+    def test_delete_task_success(self):
+        url = reverse('task_detail', args=[self.existing_task_id])
         response = self.client.delete(url)
-        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        self.assertEqual(response.status_code, HTTPStatus.NO_CONTENT)
 
-    @patch("todo.repositories.task_repository.TaskRepository.delete_by_id")
-    def test_delete_task_not_found(self, mock_delete_by_id):
-        mock_delete_by_id.return_value = None
-        non_existent_id = str(ObjectId())
-        url = reverse("task_detail", args=[non_existent_id])
+    def test_delete_task_not_found(self):
+        url = reverse('task_detail', args=[self.non_existent_id])
         response = self.client.delete(url)
-        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
-        error_detail = response.data.get("errors", [{}])[0].get("detail")
-        self.assertEqual(error_detail, ApiErrors.TASK_NOT_FOUND.format(non_existent_id))
+        self.assertEqual(response.status_code, HTTPStatus.NOT_FOUND)
+        response_data = response.json()
+        error_message = ApiErrors.TASK_NOT_FOUND.format(self.non_existent_id)
+        self.assertEqual(response_data["message"], error_message)
+        error = response_data["errors"][0]
+        self.assertEqual(error["source"]["path"], "task_id")
+        self.assertEqual(error["title"], ApiErrors.RESOURCE_NOT_FOUND_TITLE)
+        self.assertEqual(error["detail"], error_message)
 
     def test_delete_task_invalid_id_format(self):
-        invalid_task_id = "invalid-id"
-        url = reverse("task_detail", args=[invalid_task_id])
+        url = reverse('task_detail', args=[self.invalid_task_id])
         response = self.client.delete(url)
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
-        self.assertEqual(response.data["message"], "Please enter a valid Task ID format.")
-        self.assertIsNotNone(response.data.get("errors"))
-        self.assertEqual(len(response.data["errors"]), 1)
-
-        error_obj = response.data["errors"][0]
-        self.assertEqual(error_obj["detail"], "Please enter a valid Task ID format.")
-        self.assertEqual(error_obj["source"]["path"], "task_id")
-        self.assertEqual(error_obj["title"], "Validation Error")
+        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)
+        data = response.json()
+        self.assertEqual(data["statusCode"], 400)
+        self.assertEqual(
+            data["message"], ValidationErrors.INVALID_TASK_ID_FORMAT)
+        self.assertEqual(data["errors"][0]["source"]["path"], "task_id")
+        self.assertEqual(data["errors"][0]["title"],
+                         ApiErrors.VALIDATION_ERROR)
+        self.assertEqual(data["errors"][0]["detail"],
+                         ValidationErrors.INVALID_TASK_ID_FORMAT)
diff --git a/todo/tests/testcontainers/mongo_container.py b/todo/tests/testcontainers/mongo_container.py
@@ -0,0 +1,50 @@
+import time
+import json
+from testcontainers.core.generic import DockerContainer
+from pymongo import MongoClient
+from testcontainers.core.waiting_utils import wait_for_logs
+
+
+class MongoReplicaSetContainer(DockerContainer):
+    def __init__(self, image: str = "mongo:6.0"):
+        super().__init__(image=image)
+        self.with_exposed_ports(27017)
+        self.with_command(["mongod", "--replSet", "rs0", "--bind_ip_all"])
+        self._mongo_url = None
+
+    def start(self):
+        super().start()
+        self._container.reload()
+        mapped_port = self.get_exposed_port(27017)
+        container_ip = self._container.attrs["NetworkSettings"]["IPAddress"]
+        member_host = f"{container_ip}:27017"
+        initiate_js = json.dumps(
+            {"_id": "rs0", "members": [{"_id": 0, "host": member_host}]})
+        wait_for_logs(self, r"Waiting for connections", timeout=20)
+        cmd = ["mongosh", "--quiet", "--host", "localhost", "--port",
+               "27017", "--eval", f"rs.initiate({initiate_js})"]
+        exit_code, output = self.exec(cmd)
+        if exit_code != 0:
+            raise RuntimeError(
+                f"rs.initiate() failed (exit code {exit_code}):\n" f"{output.decode('utf-8', errors='ignore')}"
+            )
+        self._mongo_url = f"mongodb://localhost:{mapped_port}/testdb?directConnection=true"
+        self._wait_for_primary()
+        return self
+
+    def get_connection_url(self) -> str:
+        return self._mongo_url
+
+    def _wait_for_primary(self, timeout=10):
+        client = MongoClient(self.get_connection_url())
+        start = time.time()
+        while time.time() - start < timeout:
+            try:
+                status = client.admin.command("isMaster")
+                if status.get("ismaster", False):
+                    return
+            except Exception as e:
+                print(f"Waiting for PRIMARY: {e}")
+            time.sleep(0.5)
+        raise TimeoutError(
+            "Timed out waiting for replica set to become PRIMARY.")
diff --git a/todo/tests/testcontainers/shared_mongo.py b/todo/tests/testcontainers/shared_mongo.py
@@ -0,0 +1,26 @@
+from todo.tests.testcontainers.mongo_container import MongoReplicaSetContainer
+import atexit
+
+_mongo_container = None
+
+def _cleanup_mongo_container():
+    global _mongo_container
+    if _mongo_container is not None:
+        try:
+            _mongo_container.stop()
+        except Exception as e:
+            print("Failed to stop MongoDB container:", str(e))
+
+
+def get_shared_mongo_container():
+    global _mongo_container
+    if _mongo_container is None:
+        try:
+            _mongo_container = MongoReplicaSetContainer()
+            _mongo_container.start()
+            atexit.register(_cleanup_mongo_container)
+        except Exception as e:
+            print("Failed to start MongoDB container:", str(e))
+            raise
+
+    return _mongo_container
diff --git a/todo_project/db/config.py b/todo_project/db/config.py
@@ -39,3 +39,9 @@ def check_database_health(self):
         except ConnectionFailure as e:
             logger.error(f"Failed to establish database connection: {e}")
             return False
+        
+    @classmethod
+    def reset(cls):
+        if cls.__instance is not None and cls.__instance._database_client is not None:
+            cls.__instance._database_client.close()
+        cls.__instance = None
