Fix: read the effective document version in the zone editor endpoints

The page image and test-zone endpoints now resolve the version like zone OCR runs do, including ?version=.
This commit is contained in:
stumpylog committed 2026-11-20 09:28:36 -08:00
1 parent f0c91bbd59
commit 36de14d2c5
2 files changed
+274 -11

No files matched your search

@@ -2920,3 +2920,246 @@ class TestOcrTemplatePreviewPermissions:
# Past validation; the factory document has no file on disk.
assert response.status_code == status.HTTP_404_NOT_FOUND
mock_preview.assert_not_called()
@pytest.fixture
def versioned_document(
preview_user: User,
paperless_dirs: PaperlessDirs,
) -> SimpleNamespace:
"""A root image document with an older and a newer version, each with its own file."""
root = DocumentFactory(owner=preview_user, mime_type="image/png", page_count=1)
older = DocumentFactory(
owner=preview_user,
root_document=root,
mime_type="image/png",
page_count=1,
version_index=1,
)
newer = DocumentFactory(
owner=preview_user,
root_document=root,
mime_type="image/png",
page_count=1,
version_index=2,
)
for doc, contents in ((root, b"root"), (older, b"older"), (newer, b"newer")):
doc.source_path.write_bytes(contents)
return SimpleNamespace(root=root, older=older, newer=newer)
@pytest.mark.django_db
@pytest.mark.usefixtures("paperless_dirs")
class TestZoneEditorVersions:
"""The page image and test-zone endpoints read the version zone OCR runs on."""
@pytest.mark.parametrize(
("which", "query", "expected"),
[
pytest.param("root", "", "newer", id="root-uses-latest-version"),
pytest.param("older", "", "older", id="version-uses-itself"),
pytest.param(
"root",
"?version={older}",
"older",
id="query-selects-version",
),
pytest.param(
"newer",
"?version={older}",
"older",
id="query-overrides-version-id",
),
],
)
def test_page_image_serves_the_effective_version(
self,
preview_client: APIClient,
versioned_document: SimpleNamespace,
which: str,
query: str,
expected: str,
) -> None:
"""
GIVEN:
- A root document with an older and a newer version
WHEN:
- A page image is requested by root id, by version id, or with ?version=
THEN:
- The file of the effective version is served
"""
document: Document = getattr(versioned_document, which)
response = preview_client.get(
preview_url(document) + query.format(older=versioned_document.older.pk),
)
assert response.status_code == status.HTTP_200_OK
assert response.content == expected.encode()
@pytest.mark.parametrize(
("which", "query", "expected"),
[
pytest.param("root", "", "newer", id="root-uses-latest-version"),
pytest.param("older", "", "older", id="version-uses-itself"),
pytest.param(
"root",
"?version={older}",
"older",
id="query-selects-version",
),
],
)
def test_test_zone_extracts_from_the_effective_version(
self,
preview_client: APIClient,
versioned_document: SimpleNamespace,
mock_preview: MagicMock,
which: str,
query: str,
expected: str,
) -> None:
"""
GIVEN:
- A root document with an older and a newer version
WHEN:
- A zone test is posted for the root id, a version id, or with ?version=
THEN:
- Extraction reads the file of the effective version
"""
mock_preview.return_value = ZoneExtraction()
document: Document = getattr(versioned_document, which)
effective = {
"newer": versioned_document.newer,
"older": versioned_document.older,
}[expected]
response = preview_client.post(
PREVIEW_ZONE_URL + query.format(older=versioned_document.older.pk),
{"document": document.pk, "zone": {"width": 100, "height": 50}},
format="json",
)
assert response.status_code == status.HTTP_200_OK
assert mock_preview.call_args.args[0] == effective.source_path
def test_page_image_uses_the_effective_versions_page_count(
self,
preview_client: APIClient,
versioned_document: SimpleNamespace,
) -> None:
"""
GIVEN:
- A root with one page and a newer version with three pages
WHEN:
- Page 2 is requested by the root id
THEN:
- The range check uses the version's page count and the file is served
"""
Document.objects.filter(pk=versioned_document.newer.pk).update(page_count=3)
response = preview_client.get(preview_url(versioned_document.root, 2))
assert response.status_code == status.HTTP_200_OK
assert response.content == b"newer"
@pytest.mark.parametrize("endpoint", ["page-image", "test-zone"])
@pytest.mark.parametrize("version", ["abc", "999999", "foreign"])
def test_bad_version_param_is_not_found(
self,
preview_client: APIClient,
preview_user: User,
versioned_document: SimpleNamespace,
mock_preview: MagicMock,
endpoint: str,
version: str,
) -> None:
"""
GIVEN:
- A root document with versions, and a version of an unrelated document
WHEN:
- ?version= is non-numeric, missing, or belongs to another document
THEN:
- 404 is returned and nothing is extracted
"""
if version == "foreign":
other = DocumentFactory(owner=preview_user)
version = str(DocumentFactory(owner=preview_user, root_document=other).pk)
query = f"?version={version}"
if endpoint == "page-image":
response = preview_client.get(preview_url(versioned_document.root) + query)
else:
response = preview_client.post(
PREVIEW_ZONE_URL + query,
{
"document": versioned_document.root.pk,
"zone": {"width": 100, "height": 50},
},
format="json",
)
assert response.status_code == status.HTTP_404_NOT_FOUND
mock_preview.assert_not_called()
def test_trashed_latest_version_falls_back_to_the_older_version(
self,
preview_client: APIClient,
versioned_document: SimpleNamespace,
) -> None:
"""
GIVEN:
- A root document whose newest version is in the trash
WHEN:
- A page image is requested by root id, and by the trashed version
THEN:
- The root serves the newest live version
- The trashed version is not found
"""
versioned_document.newer.delete()
by_root = preview_client.get(preview_url(versioned_document.root))
by_version = preview_client.get(
preview_url(versioned_document.root)
+ f"?version={versioned_document.newer.pk}",
)
assert by_root.status_code == status.HTTP_200_OK
assert by_root.content == b"older"
assert by_version.status_code == status.HTTP_404_NOT_FOUND
def test_test_zone_image_flag_follows_the_effective_version(
self,
preview_client: APIClient,
versioned_document: SimpleNamespace,
mock_preview: MagicMock,
) -> None:
"""
GIVEN:
- An image root document whose latest version is a PDF with an archive
WHEN:
- A zone test is posted for the root id
THEN:
- Extraction reads the version's archive and does not treat it as an image
"""
newer = versioned_document.newer
Document.objects.filter(pk=newer.pk).update(
mime_type="application/pdf",
archive_filename="newer.pdf",
)
newer.refresh_from_db()
newer.archive_path.write_bytes(b"archive")
mock_preview.return_value = ZoneExtraction()
response = preview_client.post(
PREVIEW_ZONE_URL,
{
"document": versioned_document.root.pk,
"zone": {"width": 100, "height": 50},
},
format="json",
)
assert response.status_code == status.HTTP_200_OK
assert mock_preview.call_args.args[0] == newer.archive_path
assert mock_preview.call_args.kwargs["is_image"] is False
+31 -11
View File
@@ -5861,6 +5861,19 @@ class OcrTemplateViewSet(BulkPermissionMixin, PassUserMixin, ModelViewSet[OcrTem
)
ordering_fields = ("name",)
@staticmethod
def _resolve_file_document(document: Document, request: Request) -> Document:
"""The version whose file zone OCR reads for this request."""
resolution = resolve_effective_document(document, request)
if resolution.error == VersionResolutionError.INVALID:
raise NotFound("Invalid version parameter")
if resolution.document is None:
raise Http404
resolved = resolution.document
if resolved.get_deferred_fields():
return Document.objects.get(pk=resolved.pk)
return resolved
def get_permissions(self) -> Sequence[Any]:
if self.action in {"document_page_image", "test_zone"}:
# Read-only previews: viewing templates is enough, even for the POST.
@@ -5891,20 +5904,25 @@ class OcrTemplateViewSet(BulkPermissionMixin, PassUserMixin, ModelViewSet[OcrTem
if not has_perms_owner_aware(request.user, "view_document", document):
return HttpResponseForbidden("Insufficient permissions")
file_doc = self._resolve_file_document(document, request)
page_num = int(page)
if document.page_count and page_num >= document.page_count:
if file_doc.page_count and page_num >= file_doc.page_count:
raise Http404(
f"Page {page_num} out of range (document has {document.page_count} pages)",
f"Page {page_num} out of range (document has {file_doc.page_count} pages)",
)
archive_path = document.archive_path
doc_path = archive_path or document.source_path
archive_path = file_doc.archive_path
doc_path = archive_path or file_doc.source_path
if not doc_path.is_file():
raise Http404("Document file not found")
if archive_path is None and document.mime_type.startswith("image/"):
return HttpResponse(doc_path.read_bytes(), content_type=document.mime_type)
if archive_path is None and file_doc.mime_type.startswith("image/"):
return HttpResponse(
doc_path.read_bytes(),
content_type=file_doc.mime_type,
)
with tempfile.TemporaryDirectory(dir=settings.SCRATCH_DIR) as tmp_dir:
rendered = Path(tmp_dir) / "page.png"
@@ -5920,7 +5938,7 @@ class OcrTemplateViewSet(BulkPermissionMixin, PassUserMixin, ModelViewSet[OcrTem
logger.warning(
"Failed to render page %s of document %s: %s",
page_num,
document.pk,
file_doc.pk,
error,
)
raise Http404("Failed to render page") from error
@@ -5951,7 +5969,9 @@ class OcrTemplateViewSet(BulkPermissionMixin, PassUserMixin, ModelViewSet[OcrTem
serializer.is_valid(raise_exception=True)
document: Document = serializer.validated_data["document"]
doc_path = document.archive_path or document.source_path
file_doc = self._resolve_file_document(document, request)
doc_path = file_doc.archive_path or file_doc.source_path
if not doc_path.is_file():
return Response(
{"error": "Document file not found"},
@@ -5965,9 +5985,9 @@ class OcrTemplateViewSet(BulkPermissionMixin, PassUserMixin, ModelViewSet[OcrTem
zone,
zone.zone_source_width or 0,
zone.zone_source_height or 0,
document.page_count,
is_image=document.archive_path is None
and document.mime_type.startswith("image/"),
file_doc.page_count,
is_image=file_doc.archive_path is None
and file_doc.mime_type.startswith("image/"),
)
regex_match = None