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.

15.8 KB
Raw Blame
from collections.abc import Callable
from contextlib import AbstractContextManager
from dataclasses import dataclass
from datetime import UTC, datetime
from inspect import unwrap
from typing import Never
from unittest.mock import create_autospec, patch

import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden, NotFound

from controllers.common.controller_schemas import ChildChunkCreatePayload, ChildChunkUpdatePayload
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.datasets.datasets_segments import (
    BatchImportPayload,
    ChildChunkAddApi,
    ChildChunkBatchUpdatePayload,
    ChildChunkUpdateApi,
    DatasetDocumentSegmentAddApi,
    DatasetDocumentSegmentApi,
    DatasetDocumentSegmentBatchImportApi,
    DatasetDocumentSegmentBatchImportStatusApi,
    DatasetDocumentSegmentListApi,
    DatasetDocumentSegmentUpdateApi,
    SegmentCreatePayload,
    SegmentUpdatePayload,
    _raise_child_chunk_create_error,
    _raise_child_chunk_delete_error,
    _raise_child_chunk_write_error,
    _raise_segment_embedding_error,
    _raise_segment_error,
    _raise_segment_status_error,
)
from controllers.console.datasets.error import ChildChunkDeleteIndexError, ChildChunkIndexingError, InvalidActionError
from machinery.context import RequestContext
from services.knowledge.entities.segments import ChildChunkRecord, ChildChunkUpdateArgs, SegmentRecord
from services.knowledge.segments.application import (
    ChildChunkDeleteIndexApplicationError,
    ChildChunkIndexingApplicationError,
    ChildChunkNotFoundError,
    ChildChunkPage,
    DatasetSegmentApplicationService,
    SegmentBatchImport,
    SegmentBatchImportDispatchError,
    SegmentBatchImportNotFoundError,
    SegmentDatasetModelUnavailableError,
    SegmentDatasetNotFoundError,
    SegmentDetail,
    SegmentDocumentIndexingError,
    SegmentDocumentNotFoundError,
    SegmentEmbeddingModelUnavailableError,
    SegmentInvalidFileTypeError,
    SegmentListFilter,
    SegmentNotFoundError,
    SegmentPage,
    SegmentPermissionDeniedError,
    SegmentStatusUpdateError,
    SegmentUploadFileNotFoundError,
)


def _context() -> RequestContext:
    return RequestContext(
        request_id="request-1",
        trace_id=None,
        account_id="account-1",
        active_workspace_id="tenant-1",
    )


def _child_chunk_data() -> ChildChunkRecord:
    now = datetime(2026, 1, 1, tzinfo=UTC)
    return ChildChunkRecord.model_validate(
        {
            "id": "child-1",
            "segment_id": "segment-1",
            "content": "child",
            "position": 1,
            "word_count": 5,
            "type": "customized",
            "created_at": now,
            "updated_at": now,
        }
    )


def _segment_data() -> SegmentRecord:
    now = datetime(2026, 1, 1, tzinfo=UTC)
    return SegmentRecord.model_validate(
        {
            "id": "segment-1",
            "position": 1,
            "document_id": "document-1",
            "content": "content",
            "sign_content": "content",
            "answer": None,
            "word_count": 7,
            "tokens": 2,
            "keywords": [],
            "index_node_id": "node-1",
            "index_node_hash": "hash",
            "hit_count": 0,
            "enabled": True,
            "disabled_at": None,
            "disabled_by": None,
            "status": "completed",
            "created_by": "account-1",
            "created_at": now,
            "updated_at": now,
            "updated_by": None,
            "indexing_at": None,
            "completed_at": now,
            "error": None,
            "stopped_at": None,
            "child_chunks": [],
            "attachments": [],
            "summary": None,
        }
    )


@dataclass(frozen=True)
class KnowledgeServiceStub:
    segments: DatasetSegmentApplicationService


@dataclass(frozen=True)
class ApplicationServiceStub:
    knowledge: KnowledgeServiceStub


def _patch_services(segments: DatasetSegmentApplicationService) -> AbstractContextManager[object]:
    return patch(
        "controllers.console.datasets.datasets_segments.application_services",
        return_value=ApplicationServiceStub(knowledge=KnowledgeServiceStub(segments=segments)),
    )


def test_list_segments_delegates_typed_query_and_serializes_page(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.list_segments.return_value = SegmentPage(
        items=(_segment_data(),), total=1, total_pages=1, page=2, limit=10
    )
    method = unwrap(DatasetDocumentSegmentListApi.get)

    with (
        app.test_request_context("/?status=completed&limit=10&page=2&enabled=true&keyword=needle"),
        _patch_services(segments),
    ):
        response, status = method(DatasetDocumentSegmentListApi(), _context(), "dataset-1", "document-1")

    assert status == 200
    assert response["data"][0]["id"] == "segment-1"
    assert response["data"][0]["created_at"] == 1767225600
    assert response["data"][0]["keywords"] == []
    assert response["data"][0]["disabled_at"] is None
    query = segments.list_segments.call_args.kwargs["query"]
    assert query == SegmentListFilter(
        page=2,
        limit=10,
        statuses=("completed",),
        enabled="true",
        keyword="needle",
    )


def test_delete_segments_delegates_all_selected_ids(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    method = unwrap(DatasetDocumentSegmentListApi.delete)

    with app.test_request_context("/?segment_id=one&segment_id=two"), _patch_services(segments):
        response, status = method(DatasetDocumentSegmentListApi(), _context(), "dataset-1", "document-1")

    assert (response, status) == ("", 204)
    assert segments.delete_segments.call_args.kwargs["segment_ids"] == ["one", "two"]


@pytest.mark.parametrize("action", ["enable", "disable"])
def test_change_segment_status_delegates_action(app: Flask, action: str) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    method = unwrap(DatasetDocumentSegmentApi.patch)

    with app.test_request_context("/?segment_id=one"), _patch_services(segments):
        response, status = method(DatasetDocumentSegmentApi(), _context(), "dataset-1", "document-1", action)

    assert status == 200
    assert response == {"result": "success"}
    assert segments.change_segment_status.call_args.kwargs["action"] == action


@pytest.mark.parametrize("action", ["typo", "ENABLE", "enable "])
def test_change_segment_status_rejects_unknown_action_before_service_call(app: Flask, action: str) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    method = unwrap(DatasetDocumentSegmentApi.patch)

    with (
        app.test_request_context("/?segment_id=one"),
        _patch_services(segments),
        pytest.raises(InvalidActionError) as error,
    ):
        method(DatasetDocumentSegmentApi(), _context(), "dataset-1", "document-1", action)

    assert error.value.code == 400
    segments.change_segment_status.assert_not_called()


def test_create_segment_delegates_payload_and_serializes_detail(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.create_segment.return_value = SegmentDetail(data=_segment_data(), doc_form="text_model")
    method = unwrap(DatasetDocumentSegmentAddApi.post)

    with app.test_request_context("/"), _patch_services(segments):
        response, status = method(
            DatasetDocumentSegmentAddApi(),
            SegmentCreatePayload(content="content"),
            _context(),
            "dataset-1",
            "document-1",
        )

    assert status == 200
    assert response["data"]["id"] == "segment-1"
    assert segments.create_segment.call_args.kwargs["values"] == {"content": "content"}


def test_update_and_delete_segment_delegate_owned_ids(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.update_segment.return_value = SegmentDetail(data=_segment_data(), doc_form="text_model")

    with app.test_request_context("/"), _patch_services(segments):
        update_response, update_status = unwrap(DatasetDocumentSegmentUpdateApi.patch)(
            DatasetDocumentSegmentUpdateApi(),
            SegmentUpdatePayload(content="updated"),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
        )
        delete_response, delete_status = unwrap(DatasetDocumentSegmentUpdateApi.delete)(
            DatasetDocumentSegmentUpdateApi(),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
        )

    assert update_status == 200
    assert update_response["data"]["content"] == "content"
    assert (delete_response, delete_status) == ("", 204)
    assert segments.update_segment.call_args.kwargs["segment_id"] == "segment-1"
    assert segments.delete_segment.call_args.kwargs["segment_id"] == "segment-1"


def test_batch_import_delegates_and_preserves_dispatch_failure_response(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.start_batch_import.return_value = SegmentBatchImport(job_id="job-1", job_status="waiting")
    method = unwrap(DatasetDocumentSegmentBatchImportApi.post)

    with app.test_request_context("/"), _patch_services(segments):
        response, status = method(
            DatasetDocumentSegmentBatchImportApi(),
            BatchImportPayload(upload_file_id="file-1"),
            _context(),
            "dataset-1",
            "document-1",
        )
    assert status == 200
    assert response == {"job_id": "job-1", "job_status": "waiting"}

    segments.start_batch_import.side_effect = SegmentBatchImportDispatchError("redis down")
    with app.test_request_context("/"), _patch_services(segments):
        response, status = method(
            DatasetDocumentSegmentBatchImportApi(),
            BatchImportPayload(upload_file_id="file-1"),
            _context(),
            "dataset-1",
            "document-1",
        )
    assert (response, status) == ({"error": "redis down"}, 500)


def test_batch_import_status_preserves_missing_job_contract(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    method = unwrap(DatasetDocumentSegmentBatchImportStatusApi.get)

    segments.get_batch_import_status.side_effect = SegmentBatchImportNotFoundError("The job does not exist.")
    with (
        app.test_request_context("/"),
        _patch_services(segments),
        pytest.raises(ValueError, match="The job does not exist\\."),
    ):
        method(DatasetDocumentSegmentBatchImportStatusApi(), _context(), "job-1")

    segments.get_batch_import_status.side_effect = None
    segments.get_batch_import_status.return_value = SegmentBatchImport(job_id="job-1", job_status="completed")
    with app.test_request_context("/"), _patch_services(segments):
        response, status = method(DatasetDocumentSegmentBatchImportStatusApi(), _context(), "job-1")
    assert status == 200
    assert response == {"job_id": "job-1", "job_status": "completed"}


def test_child_chunk_create_and_list_delegate(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.create_child_chunk.return_value = _child_chunk_data()
    segments.list_child_chunks.return_value = ChildChunkPage(
        items=(_child_chunk_data(),), total=1, total_pages=1, page=1, limit=20
    )

    with app.test_request_context("/"), _patch_services(segments):
        create_response, create_status = unwrap(ChildChunkAddApi.post)(
            ChildChunkAddApi(),
            ChildChunkCreatePayload(content="child"),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
        )
        list_response, list_status = unwrap(ChildChunkAddApi.get)(
            ChildChunkAddApi(), _context(), "dataset-1", "document-1", "segment-1"
        )

    assert create_status == list_status == 200
    assert create_response["data"]["id"] == "child-1"
    assert create_response["data"]["created_at"] == 1767225600
    assert list_response["data"][0]["id"] == "child-1"


def test_child_chunk_mutations_delegate(app: Flask) -> None:
    segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
    segments.update_child_chunks.return_value = (_child_chunk_data(),)
    segments.update_child_chunk.return_value = _child_chunk_data()
    chunks = [ChildChunkUpdateArgs(id="child-1", content="updated")]

    with app.test_request_context("/"), _patch_services(segments):
        batch_response, batch_status = unwrap(ChildChunkAddApi.patch)(
            ChildChunkAddApi(),
            ChildChunkBatchUpdatePayload(chunks=chunks),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
        )
        update_response, update_status = unwrap(ChildChunkUpdateApi.patch)(
            ChildChunkUpdateApi(),
            ChildChunkUpdatePayload(content="updated"),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
            "child-1",
        )
        delete_response, delete_status = unwrap(ChildChunkUpdateApi.delete)(
            ChildChunkUpdateApi(),
            _context(),
            "dataset-1",
            "document-1",
            "segment-1",
            "child-1",
        )

    assert batch_status == update_status == 200
    assert batch_response["data"][0]["id"] == "child-1"
    assert update_response["data"]["id"] == "child-1"
    assert (delete_response, delete_status) == ("", 204)


@pytest.mark.parametrize(
    ("translate", "error", "expected"),
    [
        (_raise_segment_error, SegmentDatasetNotFoundError(), NotFound),
        (_raise_segment_error, SegmentDocumentNotFoundError(), NotFound),
        (_raise_segment_error, SegmentNotFoundError(), NotFound),
        (_raise_segment_error, ChildChunkNotFoundError(), NotFound),
        (_raise_segment_error, SegmentUploadFileNotFoundError(), NotFound),
        (_raise_segment_error, SegmentPermissionDeniedError(), Forbidden),
        (_raise_segment_error, SegmentDatasetModelUnavailableError(), ValueError),
        (_raise_segment_error, SegmentInvalidFileTypeError(), ValueError),
        (_raise_segment_embedding_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
        (_raise_segment_status_error, SegmentDocumentIndexingError(), InvalidActionError),
        (_raise_segment_status_error, SegmentStatusUpdateError(), InvalidActionError),
        (_raise_segment_status_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
        (_raise_child_chunk_write_error, ChildChunkIndexingApplicationError(), ChildChunkIndexingError),
        (_raise_child_chunk_create_error, ChildChunkIndexingApplicationError(), ChildChunkIndexingError),
        (_raise_child_chunk_create_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
        (_raise_child_chunk_delete_error, ChildChunkDeleteIndexApplicationError(), ChildChunkDeleteIndexError),
        # Every narrow translator falls back to the shared scope mapping.
        (_raise_child_chunk_delete_error, SegmentNotFoundError(), NotFound),
    ],
)
def test_segment_application_errors_map_to_existing_http_contract(
    translate: Callable[[Exception], Never], error: Exception, expected: type[Exception]
) -> None:
    with pytest.raises(expected):
        translate(error)


def test_scope_translator_does_not_map_other_operations_errors() -> None:
    error = ChildChunkIndexingApplicationError()
    with pytest.raises(ChildChunkIndexingApplicationError) as raised:
        _raise_segment_error(error)
    assert raised.value is error