feat: B3 uit voor veilige archive-downloads - cancel knop toegevoegd

2026-03-14 14:39:57 +01:00
parent d463b3977d
commit 2981ac2796
24 changed files with 471 additions and 37 deletions
@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import sys
 import tempfile
+import threading
 import time
 import unittest
 from pathlib import Path
@@ -11,12 +12,13 @@ import httpx

 sys.path.insert(0, str(Path(__file__).resolve().parents[3]))

-from backend.app.dependencies import get_copy_task_service, get_file_ops_service, get_history_service, get_move_task_service, get_task_service
+from backend.app.dependencies import get_archive_download_task_service, get_copy_task_service, get_file_ops_service, get_history_service, get_move_task_service, get_task_service
 from backend.app.db.history_repository import HistoryRepository
 from backend.app.db.task_repository import TaskRepository
 from backend.app.fs.filesystem_adapter import FilesystemAdapter
 from backend.app.main import app
 from backend.app.security.path_guard import PathGuard
+from backend.app.services.archive_download_task_service import ArchiveDownloadTaskService
 from backend.app.services.copy_task_service import CopyTaskService
 from backend.app.services.file_ops_service import FileOpsService
 from backend.app.services.history_service import HistoryService
@@ -30,6 +32,21 @@ class FailingCopyFilesystemAdapter(FilesystemAdapter):
        raise OSError('forced copy failure')


+class BlockingArchiveBuildFileOpsService(FileOpsService):
+    def __init__(self, *args, entered: threading.Event, release: threading.Event, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._entered = entered
+        self._release = release
+
+    def _write_download_target_to_zip(self, archive, resolved_target, on_each_item=None) -> None:
+        archive.writestr("partial.txt", b"partial")
+        self._entered.set()
+        self._release.wait(timeout=2.0)
+        if on_each_item:
+            on_each_item()
+        super()._write_download_target_to_zip(archive, resolved_target, on_each_item=on_each_item)
+
+
 class HistoryApiGoldenTest(unittest.TestCase):
    def setUp(self) -> None:
        self.temp_dir = tempfile.TemporaryDirectory()
@@ -38,6 +55,7 @@ class HistoryApiGoldenTest(unittest.TestCase):
        self.root1.mkdir(parents=True, exist_ok=True)
        self.root2.mkdir(parents=True, exist_ok=True)
        db_path = str(Path(self.temp_dir.name) / 'tasks.db')
+        self.artifact_root = Path(self.temp_dir.name) / "archive_tmp"
        self.task_repo = TaskRepository(db_path)
        self.history_repo = HistoryRepository(db_path)
        self.path_guard = PathGuard({'storage1': str(self.root1), 'storage2': str(self.root2)})
@@ -47,9 +65,17 @@ class HistoryApiGoldenTest(unittest.TestCase):
        app.dependency_overrides.clear()
        self.temp_dir.cleanup()

-    def _set_services(self, filesystem: FilesystemAdapter) -> None:
+    def _set_services(self, filesystem: FilesystemAdapter, file_ops_service: FileOpsService | None = None) -> None:
        runner = TaskRunner(repository=self.task_repo, filesystem=filesystem, history_repository=self.history_repo)
-        file_ops_service = FileOpsService(path_guard=self.path_guard, filesystem=filesystem, history_repository=self.history_repo)
+        file_ops_service = file_ops_service or FileOpsService(path_guard=self.path_guard, filesystem=filesystem, history_repository=self.history_repo)
+        archive_service = ArchiveDownloadTaskService(
+            path_guard=self.path_guard,
+            repository=self.task_repo,
+            runner=runner,
+            history_repository=self.history_repo,
+            file_ops_service=file_ops_service,
+            artifact_root=self.artifact_root,
+        )
        copy_service = CopyTaskService(path_guard=self.path_guard, repository=self.task_repo, runner=runner, history_repository=self.history_repo)
        move_service = MoveTaskService(path_guard=self.path_guard, repository=self.task_repo, runner=runner, history_repository=self.history_repo)
        task_service = TaskService(repository=self.task_repo)
@@ -58,6 +84,9 @@ class HistoryApiGoldenTest(unittest.TestCase):
        async def _override_file_ops_service() -> FileOpsService:
            return file_ops_service

+        async def _override_archive_service() -> ArchiveDownloadTaskService:
+            return archive_service
+
        async def _override_copy_service() -> CopyTaskService:
            return copy_service

@@ -71,6 +100,7 @@ class HistoryApiGoldenTest(unittest.TestCase):
            return history_service

        app.dependency_overrides[get_file_ops_service] = _override_file_ops_service
+        app.dependency_overrides[get_archive_download_task_service] = _override_archive_service
        app.dependency_overrides[get_copy_task_service] = _override_copy_service
        app.dependency_overrides[get_move_task_service] = _override_move_service
        app.dependency_overrides[get_task_service] = _override_task_service
@@ -91,7 +121,7 @@ class HistoryApiGoldenTest(unittest.TestCase):
        while time.time() < deadline:
            response = self._request('GET', f'/api/tasks/{task_id}')
            body = response.json()
-            if body['status'] in {'completed', 'failed', 'ready'}:
+            if body['status'] in {'completed', 'failed', 'ready', 'cancelled'}:
                return body
            time.sleep(0.02)
        self.fail('task did not reach terminal state in time')
@@ -244,6 +274,38 @@ class HistoryApiGoldenTest(unittest.TestCase):
        self.assertEqual(history[0]['error_code'], 'download_preflight_failed')
        self.assertEqual(history[0]['error_message'], 'Zip download preflight failed')

+    def test_download_cancellation_writes_cancelled_history_item(self) -> None:
+        entered = threading.Event()
+        release = threading.Event()
+        file_ops_service = BlockingArchiveBuildFileOpsService(
+            path_guard=self.path_guard,
+            filesystem=FilesystemAdapter(),
+            history_repository=self.history_repo,
+            entered=entered,
+            release=release,
+        )
+        self._set_services(FilesystemAdapter(), file_ops_service=file_ops_service)
+        (self.root1 / 'docs').mkdir()
+        (self.root1 / 'docs' / 'a.txt').write_text('A', encoding='utf-8')
+
+        response = self._request('POST', '/api/files/download/archive-prepare', {'paths': ['storage1/docs']})
+
+        self.assertEqual(response.status_code, 202)
+        self.assertTrue(entered.wait(timeout=2.0))
+        cancel = self._request('POST', f"/api/files/download/archive/{response.json()['task_id']}/cancel")
+        release.set()
+        self._wait_task(response.json()['task_id'])
+        history = self._request('GET', '/api/history').json()['items']
+
+        self.assertEqual(cancel.status_code, 200)
+        self.assertEqual(history[0]['operation'], 'download')
+        self.assertEqual(history[0]['status'], 'cancelled')
+        self.assertEqual(history[0]['source'], 'single_directory_zip')
+        self.assertEqual(history[0]['path'], 'storage1/docs')
+        self.assertEqual(history[0]['destination'], 'docs.zip')
+        self.assertEqual(history[0]['error_code'], None)
+        self.assertEqual(history[0]['error_message'], None)
+
    def test_download_history_uses_server_certain_statuses_only(self) -> None:
        (self.root1 / 'report.txt').write_text('hello download', encoding='utf-8')

@@ -251,5 +313,5 @@ class HistoryApiGoldenTest(unittest.TestCase):

        self.assertEqual(response.status_code, 200)
        history = self._request('GET', '/api/history').json()['items']
-        self.assertIn(history[0]['status'], {'requested', 'ready', 'preflight_failed', 'failed'})
+        self.assertIn(history[0]['status'], {'requested', 'ready', 'preflight_failed', 'failed', 'cancelled'})
        self.assertNotIn(history[0]['status'], {'completed', 'downloaded', 'saved'})