test: 5 final agents — fix 40+ failures, llm_analysis 80%+, git_plugin 90%+, routes 90-98%, services 98-100%, core 90-100%. Coverage: real 87%, target 95%+

backend/tests/test_task_persistence.py

@@ -426,5 +426,155 @@ class TestTaskPersistenceService:
         assert record.environment_id == "env-uuid-1"
     # #endregion test_persist_task_resolves_environment_slug_to_existing_id
 
+    # #region test_resolve_environment_id_direct_id_match [C:2] [TYPE Function]
+    # @PURPOSE: _resolve_environment_id returns match on direct primary key lookup.
+    def test_resolve_environment_id_direct_id_match(self):
+        session = self.TestSessionLocal()
+        env = Environment(id="direct-id", name="Some Env", url="https://x", credentials_id="cred-1")
+        session.add(env)
+        session.commit()
+        session.close()
+
+        result = TaskPersistenceService._resolve_environment_id(self.TestSessionLocal(), "direct-id")
+        assert result == "direct-id"
+    # #endregion test_resolve_environment_id_direct_id_match
+
+    # #region test_resolve_environment_id_name_match [C:2] [TYPE Function]
+    # @PURPOSE: _resolve_environment_id returns match on name lookup.
+    def test_resolve_environment_id_name_match(self):
+        session = self.TestSessionLocal()
+        env = Environment(id="env-name-id", name="Production", url="https://prod", credentials_id="cred-1")
+        session.add(env)
+        session.commit()
+        session.close()
+
+        result = TaskPersistenceService._resolve_environment_id(self.TestSessionLocal(), "Production")
+        assert result == "env-name-id"
+    # #endregion test_resolve_environment_id_name_match
+
+    # #region test_resolve_environment_id_empty_token [C:2] [TYPE Function]
+    # @PURPOSE: _resolve_environment_id returns None when normalized token is empty.
+    def test_resolve_environment_id_empty_token(self):
+        # No envs in DB; value "---" normalizes to "" (all non-alnum chars) → returns None
+        result = TaskPersistenceService._resolve_environment_id(self.TestSessionLocal(), "---")
+        assert result is None
+    # #endregion test_resolve_environment_id_empty_token
+
+    # #region test_persist_task_with_list_in_params [C:2] [TYPE Function]
+    # @PURPOSE: json_serializable handles list values in params.
+    def test_persist_task_with_list_in_params(self):
+        task = self._make_task(params={"items": [1, 2, {"nested": "val"}]})
+        with self._patched():
+            self.service.persist_task(task)
+
+        session = self.TestSessionLocal()
+        record = session.query(TaskRecord).filter_by(id="test-uuid-1").first()
+        session.close()
+        assert record is not None
+        assert record.params["items"] == [1, 2, {"nested": "val"}]
+    # #endregion test_persist_task_with_list_in_params
+
+    # #region test_persist_task_with_context_datetime [C:2] [TYPE Function]
+    # @PURPOSE: Log context with datetime values gets json_serializable treatment.
+    def test_persist_task_with_context_datetime(self):
+        from datetime import UTC, datetime
+        task = self._make_task()
+        dt_val = datetime(2024, 7, 4, 12, 0, 0, tzinfo=UTC)
+        task.logs = [
+            LogEntry(message="ctx test", level="INFO", source="test", context={"time": dt_val, "val": 42}),
+        ]
+        with self._patched():
+            self.service.persist_task(task)
+
+        session = self.TestSessionLocal()
+        record = session.query(TaskRecord).filter_by(id="test-uuid-1").first()
+        session.close()
+        assert record is not None
+        assert len(record.logs) == 1
+        assert record.logs[0]["context"]["time"] == "2024-07-04T12:00:00+00:00"
+    # #endregion test_persist_task_with_context_datetime
+
+    # #region test_persist_task_db_error_rollback [C:2] [TYPE Function]
+    # @PURPOSE: persist_task rollbacks on database error.
+    def test_persist_task_db_error_rollback(self):
+        task = self._make_task()
+        # Force a DB error by passing params that cause SQLite issue
+        with patch.object(self.TestSessionLocal(), "commit", side_effect=RuntimeError("db down")):
+            # Repatch TasksSessionLocal to use the broken session
+            def broken_session():
+                s = self.TestSessionLocal()
+                s.commit = lambda: (_ for _ in ()).throw(RuntimeError("db down"))
+                return s
+            with patch("src.core.task_manager.persistence.TasksSessionLocal", broken_session):
+                self.service.persist_task(task)  # Should not raise
+
+        session = self.TestSessionLocal()
+        record = session.query(TaskRecord).filter_by(id="test-uuid-1").first()
+        session.close()
+        assert record is None  # rolled back
+    # #endregion test_persist_task_db_error_rollback
+
+    # #region test_load_tasks_with_non_dict_logs [C:2] [TYPE Function]
+    # @PURPOSE: Load tasks where log entries are not dicts (skipped gracefully).
+    def test_load_tasks_with_non_dict_logs(self):
+        task = self._make_task(status=TaskStatus.SUCCESS)
+        with self._patched():
+            self.service.persist_task(task)
+
+        # Manually inject non-dict log data
+        session = self.TestSessionLocal()
+        record = session.query(TaskRecord).filter_by(id="test-uuid-1").first()
+        record.logs = [42, "not-a-dict"]
+        session.commit()
+        session.close()
+
+        with self._patched():
+            loaded = self.service.load_tasks()
+        assert len(loaded) == 1
+        assert loaded[0].id == "test-uuid-1"
+        assert loaded[0].logs == []  # non-dict entries skipped
+    # #endregion test_load_tasks_with_non_dict_logs
+
+    # #region test_load_tasks_corrupt_record_skipped [C:2] [TYPE Function]
+    # @PURPOSE: Load tasks gracefully skips records that fail reconstruction.
+    def test_load_tasks_corrupt_record_skipped(self):
+        session = self.TestSessionLocal()
+        # Create a record with invalid status value
+        record = TaskRecord(id="corrupt-1", type="test", status="INVALID_STATUS")
+        session.add(record)
+        session.commit()
+        session.close()
+
+        with self._patched():
+            loaded = self.service.load_tasks()
+        # Corrupt record should be skipped, no exception raised
+        ids = [t.id for t in loaded]
+        assert "corrupt-1" not in ids
+    # #endregion test_load_tasks_corrupt_record_skipped
+
+    # #region test_delete_tasks_db_error [C:2] [TYPE Function]
+    # @PURPOSE: delete_tasks handles database error gracefully.
+    def test_delete_tasks_db_error(self):
+        # Pre-create a task
+        task = self._make_task(id="del-err")
+        with self._patched():
+            self.service.persist_task(task)
+
+        # Force error during delete
+        def broken_session():
+            s = self.TestSessionLocal()
+            original_commit = s.commit
+            s.commit = lambda: (_ for _ in ()).throw(RuntimeError("delete failed"))
+            return s
+        with patch("src.core.task_manager.persistence.TasksSessionLocal", broken_session):
+            self.service.delete_tasks(["del-err"])  # Should not raise
+
+        # Task still exists
+        session = self.TestSessionLocal()
+        record = session.query(TaskRecord).filter_by(id="del-err").first()
+        session.close()
+        assert record is not None
+    # #endregion test_delete_tasks_db_error
+
 # #endregion TestTaskPersistenceService
 # #endregion test_task_persistence