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.

3.2 KB
Raw Blame
"""Testcontainers integration tests for AttachmentService."""

import base64
from datetime import UTC, datetime
from unittest.mock import patch
from uuid import uuid4

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import NotFound

import services.attachment_service as attachment_service_module
from extensions.ext_database import db
from extensions.storage.storage_type import StorageType
from models.enums import CreatorUserRole
from models.model import UploadFile
from services.attachment_service import AttachmentService


class TestAttachmentService:
    def _create_upload_file(self, db_session_with_containers: Session, *, tenant_id: str | None = None) -> UploadFile:
        upload_file = UploadFile(
            tenant_id=tenant_id or str(uuid4()),
            storage_type=StorageType.OPENDAL,
            key=f"upload/{uuid4()}.txt",
            name="test-file.txt",
            size=100,
            extension="txt",
            mime_type="text/plain",
            created_by_role=CreatorUserRole.ACCOUNT,
            created_by=str(uuid4()),
            created_at=datetime.now(UTC),
            used=False,
        )
        db_session_with_containers.add(upload_file)
        db_session_with_containers.commit()
        return upload_file

    def test_should_initialize_with_sessionmaker(self):
        session_factory = sessionmaker()

        service = AttachmentService(session_factory=session_factory)

        assert service._session_maker is session_factory

    def test_should_initialize_with_engine(self):
        engine = create_engine("sqlite:///:memory:")

        service = AttachmentService(session_factory=engine)
        session = service._session_maker()
        try:
            assert session.bind == engine
        finally:
            session.close()
            engine.dispose()

    @pytest.mark.parametrize("invalid_session_factory", [None, "not-a-session-factory", 1])
    def test_should_raise_assertion_error_for_invalid_session_factory(self, invalid_session_factory):
        with pytest.raises(AssertionError, match="must be a sessionmaker or an Engine."):
            AttachmentService(session_factory=invalid_session_factory)

    def test_should_return_base64_when_file_exists(self, db_session_with_containers: Session):
        upload_file = self._create_upload_file(db_session_with_containers)
        service = AttachmentService(session_factory=sessionmaker(bind=db.engine))

        with patch.object(attachment_service_module.storage, "load_once", return_value=b"binary-content") as mock_load:
            result = service.get_file_base64(upload_file.id)

        assert result == base64.b64encode(b"binary-content").decode()
        mock_load.assert_called_once_with(upload_file.key)

    def test_should_raise_not_found_when_file_missing(self, db_session_with_containers: Session):
        service = AttachmentService(session_factory=sessionmaker(bind=db.engine))

        with patch.object(attachment_service_module.storage, "load_once") as mock_load:
            with pytest.raises(NotFound, match="File not found"):
                service.get_file_base64(str(uuid4()))

        mock_load.assert_not_called()