feat:Implements the GET /tasks/{task_id} endpoint to retrieve details of a specific task (#39)

* 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

Author: Achintya-Chatterjee

todo/constants/messages.py

@@ -1,12 +1,14 @@
 # Application Messages
 class AppMessages:
     TASK_CREATED = "Task created successfully"
-    
+
+
 # Repository error messages
 class RepositoryErrors:
     TASK_CREATION_FAILED = "Failed to create task: {0}"
     DB_INIT_FAILED = "Failed to initialize database: {0}"
 
+
 # API error messages
 class ApiErrors:
     REPOSITORY_ERROR = "Repository Error"
@@ -18,6 +20,10 @@ class ApiErrors:
     INVALID_LABEL_IDS = "Invalid Label IDs"
     PAGE_NOT_FOUND = "Requested page exceeds available results"
     UNEXPECTED_ERROR_OCCURRED = "An unexpected error occurred"
+    TASK_NOT_FOUND = "Task with ID {0} not found."
+    TASK_NOT_FOUND_GENERIC = "Task not found."
+    RESOURCE_NOT_FOUND_TITLE = "Resource Not Found"
+
 
 # Validation error messages
 class ValidationErrors:
@@ -27,4 +33,5 @@ class ValidationErrors:
     PAGE_POSITIVE = "Page must be a positive integer"
     LIMIT_POSITIVE = "Limit must be a positive integer"
     MAX_LIMIT_EXCEEDED = "Maximum limit of {0} exceeded"
-    MISSING_LABEL_IDS = "The following label IDs do not exist: {0}"
+    MISSING_LABEL_IDS = "The following label ID(s) do not exist: {0}."
+    INVALID_TASK_ID_FORMAT = "Please enter a valid Task ID format."

todo/dto/responses/create_task_response.py

@@ -2,6 +2,7 @@
 from todo.dto.task_dto import TaskDTO
 from todo.constants.messages import AppMessages
 
+
 class CreateTaskResponse(BaseModel):
     statusCode: int = 201
     successMessage: str = AppMessages.TASK_CREATED

todo/dto/responses/error_response.py

@@ -7,6 +7,7 @@ class ApiErrorSource(Enum):
     PARAMETER = "parameter"
     POINTER = "pointer"
     HEADER = "header"
+    PATH = "path"
 
 
 class ApiErrorDetail(BaseModel):

todo/dto/responses/get_task_by_id_response.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+from todo.dto.task_dto import TaskDTO
+
+
+class GetTaskByIdResponse(BaseModel):
+    data: TaskDTO

todo/exceptions/exception_handler.py

@@ -1,36 +1,128 @@
 from typing import List
-from rest_framework.exceptions import ValidationError
+from rest_framework.exceptions import ValidationError as DRFValidationError
 from rest_framework.response import Response
 from rest_framework import status
-from rest_framework.views import exception_handler
+from rest_framework.views import exception_handler as drf_exception_handler
 from rest_framework.utils.serializer_helpers import ReturnDict
+from django.conf import settings
+from bson.errors import InvalidId as BsonInvalidId
 
 from todo.dto.responses.error_response import ApiErrorDetail, ApiErrorResponse, ApiErrorSource
-
-
-def handle_exception(exc, context):
-    if isinstance(exc, ValidationError):
-        return Response(
-            ApiErrorResponse(
-                statusCode=status.HTTP_400_BAD_REQUEST,
-                message="Invalid request",
-                errors=format_validation_errors(exc.detail),
-            ).model_dump(mode="json", exclude_none=True),
-            status=status.HTTP_400_BAD_REQUEST,
-        )
-    return exception_handler(exc, context)
+from todo.constants.messages import ApiErrors, ValidationErrors
+from todo.exceptions.task_exceptions import TaskNotFoundException
 
 
 def format_validation_errors(errors) -> List[ApiErrorDetail]:
     formatted_errors = []
     if isinstance(errors, ReturnDict | dict):
         for field, messages in errors.items():
-            if isinstance(messages, list):
-                for message in messages:
-                    formatted_errors.append(ApiErrorDetail(detail=message, source={ApiErrorSource.PARAMETER: field}))
-            elif isinstance(messages, dict):
-                nested_errors = format_validation_errors(messages)
-                formatted_errors.extend(nested_errors)
-            else:
-                formatted_errors.append(ApiErrorDetail(detail=messages, source={ApiErrorSource.PARAMETER: field}))
+            details = messages if isinstance(messages, list) else [messages]
+            for message_detail in details:
+                if isinstance(message_detail, dict):
+                    nested_errors = format_validation_errors(message_detail)
+                    formatted_errors.extend(nested_errors)
+                else:
+                    formatted_errors.append(
+                        ApiErrorDetail(detail=str(message_detail), source={ApiErrorSource.PARAMETER: field})
+                    )
+    elif isinstance(errors, list):
+        for message_detail in errors:
+            formatted_errors.append(ApiErrorDetail(detail=str(message_detail)))
     return formatted_errors
+
+
+def handle_exception(exc, context):
+    response = drf_exception_handler(exc, context)
+    task_id = context.get("kwargs", {}).get("task_id")
+
+    error_list = []
+    status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+    determined_message = ApiErrors.UNEXPECTED_ERROR_OCCURRED
+
+    if isinstance(exc, TaskNotFoundException):
+        status_code = status.HTTP_404_NOT_FOUND
+        detail_message_str = str(exc)
+        determined_message = detail_message_str
+        error_list.append(
+            ApiErrorDetail(
+                source={ApiErrorSource.PATH: "task_id"} if task_id else None,
+                title=ApiErrors.RESOURCE_NOT_FOUND_TITLE,
+                detail=detail_message_str,
+            )
+        )
+    elif isinstance(exc, BsonInvalidId):
+        status_code = status.HTTP_400_BAD_REQUEST
+        determined_message = ValidationErrors.INVALID_TASK_ID_FORMAT
+        error_list.append(
+            ApiErrorDetail(
+                source={ApiErrorSource.PATH: "task_id"} if task_id else None,
+                title=ApiErrors.VALIDATION_ERROR,
+                detail=ValidationErrors.INVALID_TASK_ID_FORMAT,
+            )
+        )
+    elif (
+        isinstance(exc, ValueError)
+        and hasattr(exc, "args")
+        and exc.args
+        and (exc.args[0] == ValidationErrors.INVALID_TASK_ID_FORMAT or exc.args[0] == "Invalid ObjectId format")
+    ):
+        status_code = status.HTTP_400_BAD_REQUEST
+        determined_message = ValidationErrors.INVALID_TASK_ID_FORMAT
+        error_list.append(
+            ApiErrorDetail(
+                source={ApiErrorSource.PATH: "task_id"} if task_id else None,
+                title=ApiErrors.VALIDATION_ERROR,
+                detail=ValidationErrors.INVALID_TASK_ID_FORMAT,
+            )
+        )
+    elif (
+        isinstance(exc, ValueError) and hasattr(exc, "args") and exc.args and isinstance(exc.args[0], ApiErrorResponse)
+    ):
+        api_error_response = exc.args[0]
+        return Response(
+            data=api_error_response.model_dump(mode="json", exclude_none=True), status=api_error_response.statusCode
+        )
+    elif isinstance(exc, DRFValidationError):
+        status_code = status.HTTP_400_BAD_REQUEST
+        determined_message = "Invalid request"
+        error_list = format_validation_errors(exc.detail)
+        if not error_list and exc.detail:
+            error_list.append(ApiErrorDetail(detail=str(exc.detail), title=ApiErrors.VALIDATION_ERROR))
+
+    else:
+        if response is not None:
+            status_code = response.status_code
+            if isinstance(response.data, dict) and "detail" in response.data:
+                detail_str = str(response.data["detail"])
+                determined_message = detail_str
+                error_list.append(ApiErrorDetail(detail=detail_str, title=detail_str))
+            elif isinstance(response.data, list):
+                for item_error in response.data:
+                    error_list.append(ApiErrorDetail(detail=str(item_error), title=determined_message))
+            else:
+                error_list.append(
+                    ApiErrorDetail(
+                        detail=str(response.data) if settings.DEBUG else ApiErrors.INTERNAL_SERVER_ERROR,
+                        title=determined_message,
+                    )
+                )
+        else:
+            error_list.append(
+                ApiErrorDetail(
+                    detail=str(exc) if settings.DEBUG else ApiErrors.INTERNAL_SERVER_ERROR, title=determined_message
+                )
+            )
+
+    if not error_list and not (
+        isinstance(exc, ValueError) and hasattr(exc, "args") and exc.args and isinstance(exc.args[0], ApiErrorResponse)
+    ):
+        default_detail_str = str(exc) if settings.DEBUG else ApiErrors.INTERNAL_SERVER_ERROR
+
+        error_list.append(ApiErrorDetail(detail=default_detail_str, title=determined_message))
+
+    final_response_data = ApiErrorResponse(
+        statusCode=status_code,
+        message=determined_message,
+        errors=error_list,
+    )
+    return Response(data=final_response_data.model_dump(mode="json", exclude_none=True), status=status_code)

todo/exceptions/task_exceptions.py

@@ -0,0 +1,10 @@
+from todo.constants.messages import ApiErrors
+
+
+class TaskNotFoundException(Exception):
+    def __init__(self, task_id: str | None = None, message_template: str = ApiErrors.TASK_NOT_FOUND):
+        if task_id:
+            self.message = message_template.format(task_id)
+        else:
+            self.message = ApiErrors.TASK_NOT_FOUND_GENERIC
+        super().__init__(self.message)

todo/repositories/task_repository.py

@@ -1,5 +1,6 @@
 from datetime import datetime, timezone
 from typing import List
+from bson import ObjectId
 
 from todo.models.task import TaskModel
 from todo.repositories.common.mongo_repository import MongoRepository
@@ -73,3 +74,11 @@ def create(cls, task: TaskModel) -> TaskModel:
 
             except Exception as e:
                 raise ValueError(RepositoryErrors.TASK_CREATION_FAILED.format(str(e)))
+
+    @classmethod
+    def get_by_id(cls, task_id: str) -> TaskModel | None:
+        tasks_collection = cls.get_collection()
+        task_data = tasks_collection.find_one({"_id": ObjectId(task_id)})
+        if task_data:
+            return TaskModel(**task_data)
+        return None

todo/services/task_service.py

@@ -19,6 +19,8 @@
 from todo.constants.task import TaskStatus
 from todo.constants.messages import ApiErrors, ValidationErrors
 from django.conf import settings
+from todo.exceptions.task_exceptions import TaskNotFoundException
+from bson.errors import InvalidId as BsonInvalidId
 
 
 @dataclass
@@ -56,15 +58,15 @@ def get_tasks(
                 return GetTasksResponse(
                     tasks=[],
                     links=None,
-                    error={"message": "Requested page exceeds available results", "code": "PAGE_NOT_FOUND"},
+                    error={"message": ApiErrors.PAGE_NOT_FOUND, "code": "PAGE_NOT_FOUND"},
                 )
 
         except ValidationError as e:
             return GetTasksResponse(tasks=[], links=None, error={"message": str(e), "code": "VALIDATION_ERROR"})
 
         except Exception:
             return GetTasksResponse(
-                tasks=[], links=None, error={"message": "An unexpected error occurred", "code": "INTERNAL_ERROR"}
+                tasks=[], links=None, error={"message": ApiErrors.UNEXPECTED_ERROR_OCCURRED, "code": "INTERNAL_ERROR"}
             )
 
     @classmethod
@@ -147,6 +149,16 @@ def _prepare_label_dtos(cls, label_ids: List[str]) -> List[LabelDTO]:
     def prepare_user_dto(cls, user_id: str) -> UserDTO:
         return UserDTO(id=user_id, name="SYSTEM")
 
+    @classmethod
+    def get_task_by_id(cls, task_id: str) -> TaskDTO:
+        try:
+            task_model = TaskRepository.get_by_id(task_id)
+            if not task_model:
+                raise TaskNotFoundException(task_id)
+            return cls.prepare_task_dto(task_model)
+        except BsonInvalidId as exc:
+            raise exc
+
     @classmethod
     def create_task(cls, dto: CreateTaskDTO) -> CreateTaskResponse:
         now = datetime.now(timezone.utc)
@@ -173,6 +185,7 @@ def create_task(cls, dto: CreateTaskDTO) -> CreateTaskResponse:
                 )
 
         task = TaskModel(
+            id=None,
             title=dto.title,
             description=dto.description,
             priority=dto.priority,

todo/tests/integration/test_task_detail_api.py

@@ -0,0 +1,76 @@
+from unittest.mock import patch
+from rest_framework import status
+from rest_framework.test import APITestCase
+from django.urls import reverse
+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])
+        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])
+        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])
+        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)

todo/tests/integration/test_tasks_pagination.py

@@ -3,7 +3,7 @@
 from django.conf import settings
 from rest_framework.test import APIRequestFactory
 
-from todo.views.task import TaskView
+from todo.views.task import TaskListView
 from todo.dto.responses.get_tasks_response import GetTasksResponse
 from todo.tests.fixtures.task import task_dtos
 
@@ -13,7 +13,7 @@ class TaskPaginationIntegrationTest(TestCase):
 
     def setUp(self):
         self.factory = APIRequestFactory()
-        self.view = TaskView.as_view()
+        self.view = TaskListView.as_view()
 
     @patch("todo.services.task_service.TaskService.get_tasks")
     def test_pagination_settings_integration(self, mock_get_tasks):