Feat: Implement DELETE /tasks/{task_id}/ API to soft delete a specific task (#46)

* feat: Add API to fetch a single task by ID

Implements the GET /tasks/{task_id} endpoint to retrieve details
of a specific task.

- Added get_by_id method to TaskRepository.
- Added get_task_by_id method to TaskService with error handling
  for TaskNotFoundException and invalid ObjectId format.
- Updated TaskView to handle requests for a single task ID,
  returning 404 for not found and 400 for invalid ID format.
- Added new URL pattern /tasks/<str:task_id> to todo/urls.py.
- Created GetTaskByIdResponse DTO for the response structure.
- Created TaskNotFoundException custom exception.
- Added PATH to ApiErrorSource enum for error reporting.
- Added new API error messages to todo/constants/messages.py.
- Added default SQLite DATABASES configuration to
  todo_project/settings/base.py to ensure Django's test runner
  operates correctly, resolving teardown errors.
- Added comprehensive unit tests for the new repository method,
  service method, and view logic.
- Added integration tests for the new endpoint, covering success (200),
  not found (404), and invalid ID format (400) scenarios.

* refactor: modified the class to include an __init__
method that sets a default descriptive error message, while still allowing a
custom message to be passed when raising the exception

* refactor(tests): address review feedback on task detail integration tests
.
- refactor  to use existing
  fixture instead of local mock data, improving test data consistency.

* refactor: address review feedback on exceptions and service logic

- Update  to use a predefined constant
  () for its default message,
  improving consistency with message management.

- Correct  instantiation in
  to use  instead of , aligning with Pydantic
  field definitions and alias usage.

* refactor: Standardize Task API Views, Error Handling, and URLS
    -   Refactored the monolithic TaskView into TaskListView (handling GET /tasks for listing and POST /tasks for creation) and TaskDetailView (handling GET /tasks/{task_id} for retrieval).
    -   Updated URL configurations in  to map to these new views, resolving previous Method Not Allowed errors and clarifying route responsibilities.
    -   Significantly enhanced the  to provide consistent  JSON structures for various error types.
    -   Ensured specific handling for  (and s indicating invalid ID format), mapping them to HTTP 400 with a standardized error message ().
    -   Corrected logic to ensure  objects consistently include a  for generic exceptions.
    -   Streamlined error message usage from .
    -   Updated  to explicitly raise  when  is encountered from the repository.
    -   Ensured pagination link generation in  uses the correct URL name () via .
    -   Refined exception handling within service methods to use constants from .
    -   Consolidated error messages: removed  and , relying on the primary messages ( and ).
    -   Removed an unnecessary docstring from  as per review feedback.
    -   Updated all relevant unit and integration tests to reflect changes in view names, URL structures, error response formats, and constant usage.
    -   Ensured tests for invalid task IDs now correctly expect HTTP 400 and the standardized error message.
    -   Modified tests for the custom exception handler to align with its comprehensive error formatting.

* refactor: fixed the grammer and also changed the constant message

* fix(tasks): standardize invalid task ID error to 404 TaskNotFound

- modifies  to handle
by raising a  with the message
. This results in a consistent
HTTP 404 response when a task ID is malformed.

- generic exception handler within  has also been
updated to raise .

- Integration tests (): Updated to expect an
  HTTP 404 status and the revised error structure for invalid task ID formats.
- Unit tests (): Updated to assert that
   is raised for invalid task ID formats.

* refactor: moved the  TASK_NOT_FOUND and INVALID_TASK_ID_FORMAT to ValidationErrors

* refactor: moved the  TASK_NOT_FOUND and INVALID_TASK_ID_FORMAT to ValidationErrors

* fix: Correct HTTP status and handling for invalid task ID format

* fix: Improve error handling for task ID issues and server errors

* refactor: Standardize InvalidId exception handling and naming

* refactor: Split TaskView, improve error handling & update tests

* refactor: Split TaskView, improve error handling & update tests

* fix: failing test

* chore: remove unnecessary comments

* feature: Implement the delete task API

* test: add test for view file

* test: add test for soft delete

* fix:merge conflicts

* fix: remove unnecessary spacing and simplify DB query logic

* fix: storing the task_id in variable

* refactor: remove unnecessary invalid ID exception handling

* refactor: remove unnecessary invalid ID exception handling

---------

Co-authored-by: Achintya-Chatterjee <[email protected]>

Author: AnujChhikara

todo/repositories/task_repository.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 from typing import List
 from bson import ObjectId
+from pymongo import ReturnDocument
 
 from todo.models.task import TaskModel
 from todo.repositories.common.mongo_repository import MongoRepository
@@ -82,3 +83,23 @@ def get_by_id(cls, task_id: str) -> TaskModel | None:
         if task_data:
             return TaskModel(**task_data)
         return None
+
+    @classmethod
+    def delete_by_id(cls, task_id: str) -> TaskModel | None:
+        tasks_collection = cls.get_collection()
+
+        deleted_task_data = tasks_collection.find_one_and_update(
+            {"_id": task_id, "isDeleted": False},
+            {
+                "$set": {
+                    "isDeleted": True,
+                    "updatedAt": datetime.now(timezone.utc),
+                    "updatedBy": "system",
+                }  # TODO: modify to use actual user after auth implementation,
+            },
+            return_document=ReturnDocument.AFTER,
+        )
+
+        if deleted_task_data:
+            return TaskModel(**deleted_task_data)
+        return None

todo/services/task_service.py

@@ -5,7 +5,6 @@
 from django.urls import reverse_lazy
 from urllib.parse import urlencode
 from datetime import datetime, timezone
-
 from todo.dto.label_dto import LabelDTO
 from todo.dto.task_dto import TaskDTO, CreateTaskDTO
 from todo.dto.user_dto import UserDTO
@@ -234,3 +233,10 @@ def create_task(cls, dto: CreateTaskDTO) -> CreateTaskResponse:
                     ],
                 )
             )
+
+    @classmethod
+    def delete_task(cls, task_id: str) -> None:
+        deleted_task_model = TaskRepository.delete_by_id(task_id)
+        if deleted_task_model is None:
+            raise TaskNotFoundException(task_id)
+        return None

todo/tests/fixtures/task.py

@@ -16,6 +16,7 @@
         "isAcknowledged": True,
         "labels": [ObjectId("67588c1ac2195684a575840c"), ObjectId("67478036eac9d93db7f59c35")],
         "createdAt": "2024-11-08T10:14:35",
+        "isDeleted": False,
         "updatedAt": "2024-11-08T15:14:35",
         "createdBy": "qMbT6M2GB65W7UHgJS4g",
         "updatedBy": "qMbT6M2GB65W7UHgJS4g",

todo/tests/integration/test_tasks_delete.py

@@ -0,0 +1,41 @@
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.test import APITestCase
+from bson import ObjectId
+from unittest.mock import patch
+from todo.constants.messages import ApiErrors
+from todo.tests.fixtures.task import task_dtos
+
+class TaskDeleteAPIIntegrationTest(APITestCase):
+    def setUp(self):
+        self.task_id = task_dtos[0].id
+
+    @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])
+        response = self.client.delete(url)
+        self.assertEqual(response.status_code, status.HTTP_204_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])
+        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))
+
+    def test_delete_task_invalid_id_format(self):
+        invalid_task_id = "invalid-id"
+        url = reverse("task_detail", args=[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")

todo/tests/unit/repositories/test_task_repository.py

@@ -1,5 +1,6 @@
 from unittest import TestCase
-from unittest.mock import patch, MagicMock
+from unittest.mock import ANY, patch, MagicMock
+from pymongo import ReturnDocument
 from pymongo.collection import Collection
 from bson import ObjectId, errors as bson_errors
 from datetime import datetime, timezone
@@ -205,3 +206,45 @@ def test_create_task_handles_exception(self, mock_create):
 
         self.assertIn("Failed to create task", str(context.exception))
         mock_create.assert_called_once_with(task)
+
+
+class TestRepositoryDeleteTaskById(TestCase):
+    def setUp(self):
+        self.task_id = tasks_db_data[0]["id"]
+        self.mock_task_data = tasks_db_data[0]
+        self.updated_task_data = self.mock_task_data.copy()
+        self.updated_task_data.update(
+            {
+                "isDeleted": True,
+                "updatedBy": "system",
+                "updatedAt": datetime.now(timezone.utc),
+            }
+        )
+
+    @patch("todo.repositories.task_repository.TaskRepository.get_collection")
+    def test_delete_task_success_when_isDeleted_false(self, mock_get_collection):
+        mock_collection = MagicMock()
+        mock_get_collection.return_value = mock_collection
+        mock_collection.find_one_and_update.return_value = self.updated_task_data
+
+        result = TaskRepository.delete_by_id(self.task_id)
+
+        self.assertIsInstance(result, TaskModel)
+        self.assertEqual(result.title, tasks_db_data[0]["title"])
+        self.assertTrue(result.isDeleted)
+        self.assertEqual(result.updatedBy, "system")
+        self.assertIsNotNone(result.updatedAt)
+        mock_collection.find_one_and_update.assert_called_once_with(
+            {"_id": ObjectId(self.task_id), "isDeleted": False},
+            {"$set": {"isDeleted": True, "updatedAt": ANY, "updatedBy": "system"}},
+            return_document=ReturnDocument.AFTER,
+        )
+
+    @patch("todo.repositories.task_repository.TaskRepository.get_collection")
+    def test_delete_task_returns_none_when_already_deleted(self, mock_get_collection):
+        mock_collection = MagicMock()
+        mock_get_collection.return_value = mock_collection
+        mock_collection.find_one_and_update.return_value = None
+
+        result = TaskRepository.delete_by_id(self.task_id)
+        self.assertIsNone(result)

todo/tests/unit/services/test_task_service.py

@@ -247,3 +247,15 @@ def test_get_task_by_id_invalid_id_format(self, mock_get_by_id_repo_method: Mock
 
         self.assertEqual(str(context.exception), "Invalid ObjectId")
         mock_get_by_id_repo_method.assert_called_once_with(invalid_id)
+
+    @patch("todo.services.task_service.TaskRepository.delete_by_id")
+    def test_delete_task_success(self, mock_delete_by_id):
+        mock_delete_by_id.return_value = {"id": "123", "title": "Sample Task"}
+        result = TaskService.delete_task("123")
+        self.assertIsNone(result)
+
+    @patch("todo.services.task_service.TaskRepository.delete_by_id")
+    def test_delete_task_not_found(self, mock_delete_by_id):
+        mock_delete_by_id.return_value = None
+        with self.assertRaises(TaskNotFoundException):
+            TaskService.delete_task("nonexistent_id")

todo/tests/unit/views/test_task.py

@@ -7,7 +7,7 @@
 from django.conf import settings
 from datetime import datetime, timedelta, timezone
 from bson.objectid import ObjectId
-
+from bson.errors import InvalidId as BsonInvalidId
 from todo.views.task import TaskListView
 from todo.dto.user_dto import UserDTO
 from todo.dto.task_dto import TaskDTO
@@ -19,7 +19,6 @@
 from todo.exceptions.task_exceptions import TaskNotFoundException
 from todo.constants.messages import ValidationErrors, ApiErrors
 
-
 class TaskViewTests(APISimpleTestCase):
     def setUp(self):
         self.client = APIClient()
@@ -300,3 +299,32 @@ def test_create_task_returns_500_on_internal_error(self, mock_create_task):
             self.assertIn("An unexpected error occurred", str(response.data))
         except Exception as e:
             self.assertEqual(str(e), "Database exploded")
+
+
+class TaskDeleteViewTests(APISimpleTestCase):
+    def setUp(self):
+        self.valid_task_id = str(ObjectId())
+        self.url = reverse("task_detail", kwargs={"task_id": self.valid_task_id})
+
+    @patch("todo.services.task_service.TaskService.delete_task")
+    def test_delete_task_returns_204_on_success(self, mock_delete_task: Mock):
+        mock_delete_task.return_value = None
+        response = self.client.delete(self.url)
+        mock_delete_task.assert_called_once_with(ObjectId(self.valid_task_id))
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        self.assertEqual(response.data, None)
+
+    @patch("todo.services.task_service.TaskService.delete_task")
+    def test_delete_task_returns_404_when_not_found(self, mock_delete_task: Mock):
+        mock_delete_task.side_effect = TaskNotFoundException(self.valid_task_id)
+        response = self.client.delete(self.url)
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+        self.assertIn(ApiErrors.TASK_NOT_FOUND.format(self.valid_task_id), response.data["message"])
+
+    @patch("todo.services.task_service.TaskService.delete_task")
+    def test_delete_task_returns_400_for_invalid_id_format(self, mock_delete_task: Mock):
+        mock_delete_task.side_effect = BsonInvalidId()
+        invalid_url = reverse("task_detail", kwargs={"task_id": "invalid-id"})
+        response = self.client.delete(invalid_url)
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(ValidationErrors.INVALID_TASK_ID_FORMAT, response.data["message"])

todo/views/task.py

@@ -1,16 +1,15 @@
+from bson import ObjectId
 from rest_framework.views import APIView
 from rest_framework.response import Response
 from rest_framework import status
 from rest_framework.request import Request
 from django.conf import settings
-
 from todo.serializers.get_tasks_serializer import GetTaskQueryParamsSerializer
 from todo.serializers.create_task_serializer import CreateTaskSerializer
 from todo.services.task_service import TaskService
 from todo.dto.task_dto import CreateTaskDTO
 from todo.dto.responses.create_task_response import CreateTaskResponse
 from todo.dto.responses.get_task_by_id_response import GetTaskByIdResponse
-
 from todo.dto.responses.error_response import ApiErrorResponse, ApiErrorDetail, ApiErrorSource
 from todo.constants.messages import ApiErrors
 
@@ -93,3 +92,8 @@ def get(self, request: Request, task_id: str):
         task_dto = TaskService.get_task_by_id(task_id)
         response_data = GetTaskByIdResponse(data=task_dto)
         return Response(data=response_data.model_dump(mode="json"), status=status.HTTP_200_OK)
+
+    def delete(self, request: Request, task_id: str):
+        task_id = ObjectId(task_id)
+        TaskService.delete_task(task_id)
+        return Response(status=status.HTTP_204_NO_CONTENT)