Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

27.2 KB
Raw Blame
"""
Unit tests for Service API Metadata controllers.

Tests coverage for:
- DatasetMetadataCreateServiceApi (post, get)
- DatasetMetadataServiceApi (patch, delete)
- DatasetMetadataBuiltInFieldServiceApi (get)
- DatasetMetadataBuiltInFieldActionServiceApi (post)
- DocumentMetadataEditServiceApi (post)

Decorator strategy:
- ``@cloud_edition_billing_rate_limit_check`` preserves ``__wrapped__``
  via ``functools.wraps`` → call the unwrapped method directly.
- Methods without billing decorators → call directly; only patch ``db``,
  services, and ``current_user``.
- ``@model_validate`` injects the parsed payload as the first argument after
  ``self``, so unwrapped calls must pass the validated model explicitly.
"""

import uuid
from inspect import unwrap
from unittest.mock import ANY, MagicMock, Mock, create_autospec, patch

import pytest
from flask import Flask, request
from flask.typing import ResponseReturnValue
from flask_restx import Api, Resource
from sqlalchemy.orm import Session
from werkzeug.exceptions import NotFound

from controllers.common.controller_schemas import MetadataUpdatePayload
from controllers.service_api import api as service_api
from controllers.service_api.dataset import metadata as metadata_module
from controllers.service_api.dataset.metadata import (
    DatasetMetadataBuiltInFieldActionServiceApi,
    DatasetMetadataBuiltInFieldServiceApi,
    DatasetMetadataCreateServiceApi,
    DatasetMetadataServiceApi,
    DocumentMetadataEditServiceApi,
)
from models.account import Account, Tenant
from models.dataset import Dataset
from models.enums import PermissionEnum
from services.errors.base import NoPermissionError
from services.errors.metadata import MetadataResourceNotFoundError
from services.knowledge.entities.knowledge_entities import MetadataArgs, MetadataOperationData
from services.knowledge.metadata.application import MetadataService
from services.knowledge.resource_scope import DatasetRef


@pytest.mark.parametrize(
    ("error", "status", "code", "message"),
    [
        (NoPermissionError("Access denied"), 400, "invalid_param", "Access denied"),
        (RuntimeError("backend detail"), 500, "unknown", "Internal Server Error"),
    ],
)
def test_metadata_permission_error_http_contract(
    monkeypatch: pytest.MonkeyPatch,
    account: Account,
    mock_dataset: Dataset,
    sqlite_session: Session,
    error: Exception,
    status: int,
    code: str,
    message: str,
) -> None:
    monkeypatch.setattr(metadata_module, "current_user", account)
    monkeypatch.setattr(
        metadata_module.DatasetService,
        "get_dataset_for_tenant",
        create_autospec(
            metadata_module.DatasetService.get_dataset_for_tenant, return_value=mock_dataset, instance=True
        ),
    )
    monkeypatch.setattr(
        metadata_module.DatasetService,
        "check_dataset_permission",
        create_autospec(metadata_module.DatasetService.check_dataset_permission, side_effect=error, instance=True),
    )
    metadata = create_autospec(MetadataService, instance=True)
    services = Mock()
    services.knowledge.metadata = metadata
    monkeypatch.setattr(metadata_module, "application_services", lambda: services)
    http_app = Flask(__name__)
    http_api = Api(http_app, doc=False)
    http_api.error_handlers = service_api.error_handlers.copy()

    class Endpoint(Resource):
        def post(self) -> ResponseReturnValue:
            return unwrap(DatasetMetadataCreateServiceApi.post)(
                DatasetMetadataCreateServiceApi(),
                MetadataArgs(type="string", name="author"),
                sqlite_session,
                mock_dataset.tenant_id,
                uuid.UUID(mock_dataset.id),
            )

    http_api.add_resource(Endpoint, "/metadata")
    response = http_app.test_client().post("/metadata")
    assert response.status_code == status
    assert response.json == {"code": code, "message": message, "status": status}
    metadata.create_metadata.assert_not_called()


@pytest.fixture
def mock_tenant() -> Tenant:
    tenant = Tenant(name="Metadata API Tenant")
    tenant.id = str(uuid.uuid4())
    return tenant


@pytest.fixture
def account() -> Account:
    account = Account(name="Metadata API User", email=f"metadata-api-{uuid.uuid4()}@example.com")
    account.id = str(uuid.uuid4())
    return account


@pytest.fixture
def mock_dataset(mock_tenant: Tenant, account: Account) -> Dataset:
    return Dataset(
        id=str(uuid.uuid4()),
        tenant_id=mock_tenant.id,
        name="Metadata Dataset",
        description="",
        provider="vendor",
        permission=PermissionEnum.ONLY_ME,
        indexing_technique="economy",
        created_by=account.id,
    )


@pytest.fixture(autouse=True)
def _use_current_user(monkeypatch: pytest.MonkeyPatch, account: Account) -> None:
    monkeypatch.setattr(metadata_module, "current_user", account)


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


# ---------------------------------------------------------------------------
# DatasetMetadataCreateServiceApi
# ---------------------------------------------------------------------------


class _UsesSQLiteSession:
    session: Session

    @pytest.fixture(autouse=True)
    def _inject_sqlite_session(self, sqlite_session: Session) -> None:
        self.session = sqlite_session


@pytest.mark.parametrize("method", ["patch", "delete"])
def test_metadata_mutation_translates_missing_resource(
    method: str, sqlite_session: Session, mock_tenant: Tenant, mock_dataset: Dataset
) -> None:
    with (
        patch.object(metadata_module, "DatasetService") as datasets,
        patch.object(metadata_module, "application_services") as services,
    ):
        datasets.get_dataset_for_tenant.return_value = mock_dataset
        metadata = services.return_value.knowledge.metadata
        operation = metadata.update_metadata_name if method == "patch" else metadata.delete_metadata
        operation.side_effect = MetadataResourceNotFoundError("Metadata not found.")
        resource = DatasetMetadataServiceApi()
        arguments: dict[str, object] = {
            "session": sqlite_session,
            "tenant_id": mock_tenant.id,
            "dataset_id": mock_dataset.id,
            "metadata_id": uuid.uuid4(),
        }
        if method == "patch":
            arguments["payload"] = MetadataUpdatePayload(name="renamed")
        endpoint = DatasetMetadataServiceApi.patch if method == "patch" else DatasetMetadataServiceApi.delete
        with pytest.raises(NotFound, match="Metadata not found"):
            unwrap(endpoint)(resource, **arguments)


class TestDatasetMetadataCreatePost(_UsesSQLiteSession):
    """Tests for DatasetMetadataCreateServiceApi.post().

    ``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``
    which preserves ``__wrapped__``.
    """

    @staticmethod
    def _call_post(
        api: DatasetMetadataCreateServiceApi, session: Session, **kwargs: object
    ) -> tuple[dict[str, object], int]:
        # `post` is wrapped in @model_validate, so the unwrapped view expects the
        # validated model where the decorator would have injected it.
        metadata_args = MetadataArgs.model_validate(request.get_json() or {})
        return unwrap(api.post)(api, metadata_args, session, **kwargs)

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_create_metadata_success(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test successful metadata creation."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None
        mock_metadata = {"id": "meta-1", "type": "string", "name": "Author"}
        mock_meta_svc.create_metadata.return_value = mock_metadata

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata",
            method="POST",
            json={"type": "string", "name": "Author"},
        ):
            api = DatasetMetadataCreateServiceApi()
            session = self.session
            response, status = self._call_post(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
            )

        assert status == 201
        assert response == {"id": "meta-1", "type": "string", "name": "Author"}
        mock_meta_svc.create_metadata.assert_called_once()

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_create_metadata_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata",
            method="POST",
            json={"type": "string", "name": "Author"},
        ):
            api = DatasetMetadataCreateServiceApi()
            session = self.session
            with pytest.raises(NotFound):
                self._call_post(
                    api,
                    session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                )


class TestDatasetMetadataCreateGet(_UsesSQLiteSession):
    """Tests for DatasetMetadataCreateServiceApi.get()."""

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_get_metadata_success(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test successful metadata list retrieval."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_meta_svc.get_dataset_metadatas.return_value = {
            "doc_metadata": [{"id": "m1", "name": "Author", "type": "string", "count": 0}],
            "built_in_field_enabled": False,
        }

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata",
            method="GET",
        ):
            api = DatasetMetadataCreateServiceApi()
            response, status = api.get(
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
            )

        assert status == 200
        assert response == {
            "doc_metadata": [{"id": "m1", "name": "Author", "type": "string", "count": 0}],
            "built_in_field_enabled": False,
        }

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_get_metadata_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata",
            method="GET",
        ):
            api = DatasetMetadataCreateServiceApi()
            with pytest.raises(NotFound):
                api.get(tenant_id=mock_tenant.id, dataset_id=uuid.UUID(mock_dataset.id))


# ---------------------------------------------------------------------------
# DatasetMetadataServiceApi
# ---------------------------------------------------------------------------


class TestDatasetMetadataServiceApiPatch(_UsesSQLiteSession):
    """Tests for DatasetMetadataServiceApi.patch().

    ``patch`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
    """

    @staticmethod
    def _call_patch(
        api: DatasetMetadataServiceApi, session: Session, **kwargs: object
    ) -> tuple[dict[str, object], int]:
        payload = MetadataUpdatePayload.model_validate(request.get_json() or {})
        return unwrap(api.patch)(api, payload, session, **kwargs)

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_update_metadata_name_success(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
        account: Account,
    ) -> None:
        """Test successful metadata name update."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        metadata_id = str(uuid.uuid4())
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None
        mock_meta_svc.update_metadata_name.return_value = {"id": metadata_id, "type": "string", "name": "New Name"}

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
            method="PATCH",
            json={"name": "New Name"},
        ):
            api = DatasetMetadataServiceApi()
            session = self.session
            response, status = self._call_patch(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
                metadata_id=metadata_id,
            )

        assert status == 200
        assert response == {"id": metadata_id, "type": "string", "name": "New Name"}
        mock_dataset_svc.get_dataset_for_tenant.assert_called_once_with(
            mock_dataset.id, mock_tenant.id, session=session
        )
        mock_meta_svc.update_metadata_name.assert_called_once_with(
            DatasetRef(mock_tenant.id, mock_dataset.id), metadata_id, "New Name", actor_id=account.id
        )

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_update_metadata_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        metadata_id = str(uuid.uuid4())
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
            method="PATCH",
            json={"name": "x"},
        ):
            api = DatasetMetadataServiceApi()
            session = self.session
            with pytest.raises(NotFound):
                self._call_patch(
                    api,
                    session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                    metadata_id=metadata_id,
                )


class TestDatasetMetadataServiceApiDelete(_UsesSQLiteSession):
    """Tests for DatasetMetadataServiceApi.delete().

    ``delete`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
    """

    @staticmethod
    def _call_delete(api: DatasetMetadataServiceApi, session: Session, **kwargs: object) -> tuple[str, int]:
        return unwrap(api.delete)(api, session, **kwargs)

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_delete_metadata_success(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test successful metadata deletion."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        metadata_id = str(uuid.uuid4())
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None
        mock_meta_svc.delete_metadata.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
            method="DELETE",
        ):
            api = DatasetMetadataServiceApi()
            session = self.session
            response = self._call_delete(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
                metadata_id=metadata_id,
            )

        assert response == ("", 204)
        mock_dataset_svc.get_dataset_for_tenant.assert_called_once_with(
            mock_dataset.id, mock_tenant.id, session=session
        )
        mock_meta_svc.delete_metadata.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id), metadata_id)

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_delete_metadata_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        metadata_id = str(uuid.uuid4())
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/{metadata_id}",
            method="DELETE",
        ):
            api = DatasetMetadataServiceApi()
            session = self.session
            with pytest.raises(NotFound):
                self._call_delete(
                    api,
                    session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                    metadata_id=metadata_id,
                )


# ---------------------------------------------------------------------------
# DatasetMetadataBuiltInFieldServiceApi
# ---------------------------------------------------------------------------


class TestDatasetMetadataBuiltInFieldGet(_UsesSQLiteSession):
    """Tests for DatasetMetadataBuiltInFieldServiceApi.get()."""

    @patch("controllers.service_api.dataset.metadata.application_services")
    def test_get_built_in_fields_success(
        self,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test successful built-in fields retrieval."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_meta_svc.get_built_in_fields.return_value = [
            {"name": "source", "type": "string"},
        ]

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/built-in",
            method="GET",
        ):
            api = DatasetMetadataBuiltInFieldServiceApi()
            response, status = api.get(
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
            )

        assert status == 200
        assert response == {"fields": [{"name": "source", "type": "string"}]}


# ---------------------------------------------------------------------------
# DatasetMetadataBuiltInFieldActionServiceApi
# ---------------------------------------------------------------------------


class TestDatasetMetadataBuiltInFieldAction(_UsesSQLiteSession):
    """Tests for DatasetMetadataBuiltInFieldActionServiceApi.post().

    ``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
    """

    @staticmethod
    def _call_post(
        api: DatasetMetadataBuiltInFieldActionServiceApi, session: Session, **kwargs: object
    ) -> tuple[dict[str, object], int]:
        return unwrap(api.post)(api, session, **kwargs)

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_enable_built_in_field(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test enabling built-in metadata field."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/built-in/enable",
            method="POST",
        ):
            api = DatasetMetadataBuiltInFieldActionServiceApi()
            session = self.session
            response, status = self._call_post(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
                action="enable",
            )

        assert status == 200
        assert response["result"] == "success"
        mock_meta_svc.enable_built_in_field.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id))

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_disable_built_in_field(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test disabling built-in metadata field."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/built-in/disable",
            method="POST",
        ):
            api = DatasetMetadataBuiltInFieldActionServiceApi()
            session = self.session
            response, status = self._call_post(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
                action="disable",
            )

        assert status == 200
        mock_meta_svc.disable_built_in_field.assert_called_once_with(DatasetRef(mock_tenant.id, mock_dataset.id))

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_action_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/metadata/built-in/enable",
            method="POST",
        ):
            api = DatasetMetadataBuiltInFieldActionServiceApi()
            session = self.session
            with pytest.raises(NotFound):
                self._call_post(
                    api,
                    session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                    action="enable",
                )


# ---------------------------------------------------------------------------
# DocumentMetadataEditServiceApi
# ---------------------------------------------------------------------------


class TestDocumentMetadataEditPost(_UsesSQLiteSession):
    """Tests for DocumentMetadataEditServiceApi.post().

    ``post`` is wrapped by ``@cloud_edition_billing_rate_limit_check``.
    """

    @staticmethod
    def _call_post(
        api: DocumentMetadataEditServiceApi, session: Session, **kwargs: object
    ) -> tuple[dict[str, object], int]:
        metadata_args = MetadataOperationData.model_validate(request.get_json() or {})
        return unwrap(api.post)(api, metadata_args, session, **kwargs)

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_update_documents_metadata_success(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
        account: Account,
    ) -> None:
        """Test successful documents metadata update."""
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_dataset_svc.check_dataset_permission.return_value = None
        mock_meta_svc.update_documents_metadata.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/documents/metadata",
            method="POST",
            json={"operation_data": []},
        ):
            api = DocumentMetadataEditServiceApi()
            session = self.session
            response, status = self._call_post(
                api,
                session,
                tenant_id=mock_tenant.id,
                dataset_id=uuid.UUID(mock_dataset.id),
            )

        assert status == 200
        assert response["result"] == "success"
        mock_meta_svc.update_documents_metadata.assert_called_once_with(
            DatasetRef(mock_tenant.id, mock_dataset.id),
            ANY,
            actor_id=account.id,
        )

    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_update_documents_metadata_dataset_not_found(
        self,
        mock_dataset_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        """Test 404 when dataset not found."""
        mock_dataset_svc.get_dataset_for_tenant.return_value = None

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/documents/metadata",
            method="POST",
            json={"operation_data": []},
        ):
            api = DocumentMetadataEditServiceApi()
            session = self.session
            with pytest.raises(NotFound):
                self._call_post(
                    api,
                    session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                )

    @patch("controllers.service_api.dataset.metadata.application_services")
    @patch("controllers.service_api.dataset.metadata.DatasetService")
    def test_update_documents_metadata_translates_missing_resource(
        self,
        mock_dataset_svc: MagicMock,
        mock_meta_svc: MagicMock,
        app: Flask,
        mock_tenant: Tenant,
        mock_dataset: Dataset,
    ) -> None:
        mock_meta_svc = mock_meta_svc.return_value.knowledge.metadata
        mock_dataset_svc.get_dataset_for_tenant.return_value = mock_dataset
        mock_meta_svc.update_documents_metadata.side_effect = MetadataResourceNotFoundError("Document not found.")

        with app.test_request_context(
            f"/datasets/{mock_dataset.id}/documents/metadata",
            method="POST",
            json={"operation_data": []},
        ):
            api = DocumentMetadataEditServiceApi()
            with pytest.raises(NotFound) as exc_info:
                self._call_post(
                    api,
                    self.session,
                    tenant_id=mock_tenant.id,
                    dataset_id=uuid.UUID(mock_dataset.id),
                )

        assert exc_info.value.description == "Document not found."