feat: Implement PATCH /tasks/{task_id} endpoint unit tests (#73)

* feat: Implement PATCH /tasks/{task_id} to update tasks
- Added  method to handle update requests.
- Introduced  for validating incoming update data,
  ensuring all fields are optional and  is a future date.
- Added  method to  to perform the MongoDB
   operation, ensuring  is set.
- Implemented  to orchestrate the update logic:
    - Fetches the task or raises .
    - Processes validated data from the serializer.
    - Converts label string IDs to  and validates their existence.
    - Converts priority and status string names to their enum values for
      database storage.
    - Sets  (currently placeholder).
    - Calls the repository to persist changes.
- Corrected an issue where enum objects (Priority, Status) were passed
  directly to the database layer, causing a serialization error. Now,
  their primitive values are stored.
- Refined  construction in  to ensure
  all valid fields from the serializer are correctly prepared for update.

* refactor(tasks): Standardize error handling in TaskService update

- Removes redundant format validation for label ObjectIds, as this is
  already handled by .
- For missing (but validly formatted) label IDs,
  now raises  instead of a
  custom

* rfactor:  PATCH /tasks/{task_id} endpoint to have task title blank true

* refactor: improve error handling for task updates and ID validation

centralizes error handling for task update operations:

- Removes specific ObjectId validation from . Invalid ID formats will now correctly raise , which is handled by the global DRF exception handler to return a 400 Bad Request.
- Modifies  to raise  if the task to be updated is not found. This is also handled by the global exception handler, resulting in a 404 Not Found response

* refactor: Enhance serializer validations and repository clarity
    - Implemented validation to ensure `startedAt` cannot be a future date.
    - Added `FUTURE_STARTED_AT` to `ValidationErrors` in `constants/messages.py`
      for the new validation message.
    - Added an explicit type check to ensure `labels` input is a list or tuple.
    - Modified to collect all invalid ObjectId formats within the `labels` list
      and report them in a single `ValidationError` for better client feedback.
    - Moved the "Labels must be a list or tuple..." message to
      `ValidationErrors.INVALID_LABELS_STRUCTURE` in `constants/messages.py`
      and updated the serializer to use this constant.
    - Deleted an unreachable `if not update_data_with_timestamp: pass` block,
      as the updatedAt field ensures the dictionary is never empty at that point.

* Update todo/serializers/update_task_serializer.py

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

* Update todo/views/task.py

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

* fix: gramatical errors on the constants

* fix: added missing imports

* fix: used global exception handler for catching errors

* Refactor(TaskRepository): modify update method for input validation and ObjectId handling

* refactor(serializers): align validate_dueAt error handling pattern

-refactors the  method in
to collect validation errors in a list and raise a single
 with this list.

* refactor(services): reduce complexity of TaskService.update_task

-Refactors the  method in  to improve
readability and reduce cognitive complexity. The core logic for
processing specific field types (labels, enums) has been extracted
into dedicated helper methods:  and

* refactor(services): reduce complexity of TaskService.update_task

-Refactors the  method in  to improve
readability and reduce cognitive complexity. The core logic for
processing specific field types (labels, enums) has been extracted
into dedicated helper methods:  and

* refactor: refactor the code to improve maintainability

* feat: Implement PATCH `/tasks/{task_id}` endpoint unit tests (#53)

* feat: Implement PATCH /tasks/{task_id} endpoint unit tests
- Developed a comprehensive suite of unit tests for:
    -  (various valid/invalid payloads).
    -  (success, task not found, invalid ID).
    -  (success, task not found, label
      validation errors, repository update failures, enum handling).
    -  (success, serializer errors, service-layer
      exceptions like TaskNotFound, BsonInvalidId, DRFValidationError)

* refactor: improve error handling and update associated tests

Centralizes error handling for task update operations:
- Removes specific ObjectId validation from . Invalid ID formats now correctly raise , handled by the global DRF exception handler (400 Bad Request).
- Modifies  to raise  if the task to be updated is not found by the repository. This is also handled by the global exception handler (404 Not Found).

Updates unit tests to align with these changes:
-  now asserts  is raised.
-  is renamed to  and now asserts  is raised.

* refactor: adjust serializer tests for ListField behavior and add validation coverage

* fix: import errors

* refactor: harden TaskRepository.update and align tests

* fix: test assertions

* chore: remove test description

* chore: update develop branch into this branch

---------

Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

Author: Achintya-Chatterjee

todo/tests/unit/repositories/test_task_repository.py

@@ -3,7 +3,7 @@
 from pymongo import ReturnDocument
 from pymongo.collection import Collection
 from bson import ObjectId, errors as bson_errors
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 import copy
 
 from todo.models.task import TaskModel
@@ -208,6 +208,124 @@ def test_create_task_handles_exception(self, mock_create):
         mock_create.assert_called_once_with(task)
 
 
+class TaskRepositoryUpdateTests(TestCase):
+    def setUp(self):
+        self.patcher_get_collection = patch("todo.repositories.task_repository.TaskRepository.get_collection")
+        self.mock_get_collection = self.patcher_get_collection.start()
+        self.mock_collection = MagicMock(spec=Collection)
+        self.mock_get_collection.return_value = self.mock_collection
+
+        self.task_id_str = str(ObjectId())
+        self.task_id_obj = ObjectId(self.task_id_str)
+        self.valid_update_data = {
+            "title": "Updated Title",
+            "description": "Updated description",
+            "priority": TaskPriority.HIGH.value,
+            "status": TaskStatus.IN_PROGRESS.value,
+        }
+        self.updated_doc_from_db = {
+            "_id": self.task_id_obj,
+            "displayId": "#123",
+            "title": "Updated Title",
+            "description": "Updated description",
+            "priority": TaskPriority.HIGH.value,
+            "status": TaskStatus.IN_PROGRESS.value,
+            "assignee": "user1",
+            "labels": [],
+            "createdAt": datetime.now(timezone.utc) - timedelta(days=1),
+            "updatedAt": datetime.now(timezone.utc),
+            "createdBy": "system_user",
+            "updatedBy": "patch_user",
+            "isAcknowledged": False,
+            "isDeleted": False,
+        }
+
+    def tearDown(self):
+        self.patcher_get_collection.stop()
+
+    def test_update_task_success(self):
+        self.mock_collection.find_one_and_update.return_value = self.updated_doc_from_db
+
+        result_task = TaskRepository.update(self.task_id_str, self.valid_update_data)
+
+        self.assertIsNotNone(result_task)
+        self.assertIsInstance(result_task, TaskModel)
+        self.assertEqual(str(result_task.id), self.task_id_str)
+        self.assertEqual(result_task.title, self.valid_update_data["title"])
+        self.assertEqual(result_task.description, self.valid_update_data["description"])
+        self.assertIsNotNone(result_task.updatedAt)
+
+        args, kwargs = self.mock_collection.find_one_and_update.call_args
+        self.assertEqual(args[0], {"_id": self.task_id_obj})
+        self.assertEqual(kwargs["return_document"], ReturnDocument.AFTER)
+
+        update_doc_arg = args[1]
+        self.assertIn("$set", update_doc_arg)
+        set_payload = update_doc_arg["$set"]
+        self.assertIn("updatedAt", set_payload)
+        self.assertIsInstance(set_payload["updatedAt"], datetime)
+
+        for key, value in self.valid_update_data.items():
+            self.assertEqual(set_payload[key], value)
+
+    def test_update_task_returns_none_if_task_not_found(self):
+        self.mock_collection.find_one_and_update.return_value = None
+
+        result_task = TaskRepository.update(self.task_id_str, self.valid_update_data)
+
+        self.assertIsNone(result_task)
+        self.mock_collection.find_one_and_update.assert_called_once()
+
+        args, kwargs = self.mock_collection.find_one_and_update.call_args
+        self.assertEqual(args[0], {"_id": self.task_id_obj})
+        update_doc_arg = args[1]
+        self.assertIn("updatedAt", update_doc_arg["$set"])
+
+    def test_update_task_returns_none_for_invalid_task_id_format(self):
+        invalid_id_str = "not-an-object-id"
+
+        result_task = TaskRepository.update(invalid_id_str, self.valid_update_data)
+        self.assertIsNone(result_task)
+
+        self.mock_collection.find_one_and_update.assert_not_called()
+
+    def test_update_task_raises_value_error_for_non_dict_update_data(self):
+        with self.assertRaises(ValueError) as context:
+            TaskRepository.update(self.task_id_str, "not-a-dict")
+        self.assertEqual(str(context.exception), "update_data must be a dictionary.")
+        self.mock_collection.find_one_and_update.assert_not_called()
+
+    def test_update_task_empty_update_data_still_calls_find_one_and_update(self):
+        self.mock_collection.find_one_and_update.return_value = {**self.updated_doc_from_db, "title": "Original Title"}
+
+        result_task = TaskRepository.update(self.task_id_str, {})
+
+        self.assertIsNotNone(result_task)
+        self.mock_collection.find_one_and_update.assert_called_once()
+        args, kwargs = self.mock_collection.find_one_and_update.call_args
+        self.assertEqual(args[0], {"_id": self.task_id_obj})
+        update_doc_arg = args[1]["$set"]
+        self.assertIn("updatedAt", update_doc_arg)
+        self.assertEqual(len(update_doc_arg), 1)
+
+    def test_update_task_does_not_pass_id_or_underscore_id_in_update_payload(self):
+        self.mock_collection.find_one_and_update.return_value = self.updated_doc_from_db
+
+        data_with_ids = {"_id": "some_other_id", "id": "yet_another_id", "title": "Title with IDs"}
+
+        TaskRepository.update(self.task_id_str, data_with_ids)
+
+        self.mock_collection.find_one_and_update.assert_called_once()
+        args, _ = self.mock_collection.find_one_and_update.call_args
+        set_payload = args[1]["$set"]
+
+        self.assertNotIn("_id", set_payload)
+        self.assertNotIn("id", set_payload)
+        self.assertIn("title", set_payload)
+        self.assertEqual(set_payload["title"], "Title with IDs")
+        self.assertIn("updatedAt", set_payload)
+
+
 class TestRepositoryDeleteTaskById(TestCase):
     def setUp(self):
         self.task_id = tasks_db_data[0]["id"]

todo/tests/unit/serializers/test_update_task_serializer.py

@@ -0,0 +1,241 @@
+from unittest import TestCase
+from datetime import datetime, timezone, timedelta
+from bson import ObjectId
+
+from todo.serializers.update_task_serializer import UpdateTaskSerializer
+from todo.constants.task import TaskPriority, TaskStatus
+from todo.constants.messages import ValidationErrors
+
+
+class UpdateTaskSerializerTests(TestCase):
+    def setUp(self):
+        self.valid_object_id_str = str(ObjectId())
+        self.future_date = datetime.now(timezone.utc) + timedelta(days=1)
+        self.past_date = datetime.now(timezone.utc) - timedelta(days=1)
+
+    def test_valid_full_payload(self):
+        data = {
+            "title": "Updated Test Task",
+            "description": "This is an updated description.",
+            "priority": TaskPriority.HIGH.name,
+            "status": TaskStatus.IN_PROGRESS.name,
+            "assignee": "user_assignee_id",
+            "labels": [str(ObjectId()), str(ObjectId())],
+            "dueAt": self.future_date.isoformat(),
+            "startedAt": (datetime.now(timezone.utc) - timedelta(hours=1)).isoformat(),
+            "isAcknowledged": True,
+        }
+        serializer = UpdateTaskSerializer(data=data)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        validated_data = serializer.validated_data
+        self.assertEqual(validated_data["title"], data["title"])
+        self.assertEqual(validated_data["description"], data["description"])
+        self.assertEqual(validated_data["priority"], data["priority"])
+        self.assertEqual(validated_data["status"], data["status"])
+        self.assertEqual(validated_data["assignee"], data["assignee"])
+        self.assertEqual(validated_data["labels"], data["labels"])
+        self.assertEqual(validated_data["dueAt"], datetime.fromisoformat(data["dueAt"]))
+        self.assertEqual(validated_data["startedAt"], datetime.fromisoformat(data["startedAt"]))
+        self.assertEqual(validated_data["isAcknowledged"], data["isAcknowledged"])
+
+    def test_partial_payload_title_only(self):
+        data = {"title": "Only Title Update"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["title"], data["title"])
+        self.assertEqual(len(serializer.validated_data), 1)
+
+    def test_all_fields_can_be_null_or_empty_if_allowed(self):
+        data = {
+            "description": None,
+            "priority": None,
+            "status": None,
+            "assignee": None,
+            "labels": None,
+            "dueAt": None,
+            "startedAt": None,
+        }
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+
+        self.assertNotIn("title", serializer.validated_data)
+        self.assertIsNone(serializer.validated_data.get("description"))
+        self.assertIsNone(serializer.validated_data.get("priority"))
+        self.assertIsNone(serializer.validated_data.get("status"))
+        self.assertIsNone(serializer.validated_data.get("assignee"))
+        self.assertIsNone(serializer.validated_data.get("labels"))
+        self.assertIsNone(serializer.validated_data.get("dueAt"))
+        self.assertIsNone(serializer.validated_data.get("startedAt"))
+
+    def test_title_validation_blank(self):
+        data = {"title": "   "}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("title", serializer.errors)
+        self.assertEqual(str(serializer.errors["title"][0]), ValidationErrors.BLANK_TITLE)
+
+    def test_title_valid(self):
+        data = {"title": "Valid Title"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["title"], "Valid Title")
+
+    def test_labels_validation_invalid_object_id(self):
+        data = {"labels": [self.valid_object_id_str, "invalid-id"]}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("labels", serializer.errors)
+        self.assertIn(ValidationErrors.INVALID_OBJECT_ID.format("invalid-id"), str(serializer.errors["labels"]))
+
+    def test_labels_validation_valid_object_ids(self):
+        valid_ids = [str(ObjectId()), str(ObjectId())]
+        data = {"labels": valid_ids}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["labels"], valid_ids)
+
+    def test_labels_can_be_empty_list(self):
+        data = {"labels": []}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["labels"], [])
+
+    def test_due_at_validation_past_date(self):
+        data = {"dueAt": self.past_date.isoformat()}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("dueAt", serializer.errors)
+        self.assertEqual(str(serializer.errors["dueAt"][0]), ValidationErrors.PAST_DUE_DATE)
+
+    def test_due_at_validation_future_date(self):
+        data = {"dueAt": self.future_date.isoformat()}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["dueAt"], datetime.fromisoformat(data["dueAt"]))
+
+    def test_due_at_can_be_null(self):
+        data = {"dueAt": None}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertIsNone(serializer.validated_data["dueAt"])
+
+    def test_assignee_validation_blank_string_becomes_none(self):
+        data = {"assignee": "   "}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertIsNone(serializer.validated_data["assignee"])
+
+    def test_assignee_valid_string(self):
+        data = {"assignee": "user123"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["assignee"], "user123")
+
+    def test_assignee_can_be_null(self):
+        data = {"assignee": None}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertIsNone(serializer.validated_data["assignee"])
+
+    def test_priority_invalid_choice(self):
+        data = {"priority": "VERY_HIGH"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("priority", serializer.errors)
+        self.assertIn("is not a valid choice.", str(serializer.errors["priority"][0]))
+
+    def test_status_invalid_choice(self):
+        data = {"status": "PENDING_APPROVAL"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("status", serializer.errors)
+        self.assertIn("is not a valid choice.", str(serializer.errors["status"][0]))
+
+    def test_is_acknowledged_valid(self):
+        data = {"isAcknowledged": True}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertTrue(serializer.validated_data["isAcknowledged"])
+
+        data = {"isAcknowledged": False}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertFalse(serializer.validated_data["isAcknowledged"])
+
+    def test_description_can_be_null(self):
+        data = {"description": None}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertIsNone(serializer.validated_data.get("description"))
+
+    def test_description_can_be_empty_string(self):
+        data = {"description": ""}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data.get("description"), "")
+
+    def test_started_at_can_be_null(self):
+        data = {"startedAt": None}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertIsNone(serializer.validated_data.get("startedAt"))
+
+    def test_started_at_valid_datetime(self):
+        date_val = (datetime.now(timezone.utc) - timedelta(hours=1)).isoformat()
+        data = {"startedAt": date_val}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["startedAt"], datetime.fromisoformat(date_val))
+
+    def test_started_at_validation_future_date(self):
+        future_started_at = (datetime.now(timezone.utc) + timedelta(days=1)).isoformat()
+        data = {"startedAt": future_started_at}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("startedAt", serializer.errors)
+        self.assertEqual(str(serializer.errors["startedAt"][0]), ValidationErrors.FUTURE_STARTED_AT)
+
+    def test_labels_validation_not_list_or_tuple(self):
+        data = {"labels": "not-a-list-or-tuple"}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("labels", serializer.errors)
+        self.assertEqual(str(serializer.errors["labels"][0]), 'Expected a list of items but got type "str".')
+
+    def test_labels_validation_multiple_invalid_object_ids(self):
+        invalid_id_1 = "invalid-id-1"
+        invalid_id_2 = "invalid-id-2"
+        data = {"labels": [self.valid_object_id_str, invalid_id_1, invalid_id_2]}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("labels", serializer.errors)
+
+        label_errors = serializer.errors["labels"]
+        self.assertIsInstance(label_errors, list)
+
+        self.assertEqual(len(label_errors), 2)
+        self.assertIn(ValidationErrors.INVALID_OBJECT_ID.format(invalid_id_1), label_errors)
+        self.assertIn(ValidationErrors.INVALID_OBJECT_ID.format(invalid_id_2), label_errors)
+
+    def test_labels_validation_mixed_valid_and_multiple_invalid_ids(self):
+        valid_id_1 = str(ObjectId())
+        invalid_id_1 = "bad-id-format-1"
+        valid_id_2 = str(ObjectId())
+        invalid_id_2 = "another-invalid"
+
+        data = {"labels": [valid_id_1, invalid_id_1, valid_id_2, invalid_id_2]}
+        serializer = UpdateTaskSerializer(data=data, partial=True)
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("labels", serializer.errors)
+
+        label_errors = serializer.errors["labels"]
+        self.assertIsInstance(label_errors, list)
+        self.assertEqual(len(label_errors), 2)
+
+        expected_error_messages = [
+            ValidationErrors.INVALID_OBJECT_ID.format(invalid_id_1),
+            ValidationErrors.INVALID_OBJECT_ID.format(invalid_id_2),
+        ]
+
+        for msg in expected_error_messages:
+            self.assertIn(msg, label_errors)