File size: 4,155 Bytes
644f326
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from langchain_core.documents import Document

from src.service.embedding.base import BaseEmbeddingService
from src.service.embedding.sentence_transformer import SentenceTransformerEmbedding
from src.service.vector_store.base import BaseVectorStore
from src.service.vector_store.qdrant import QdrantVectorStore
from src.service.vector_store.pinecone import PineconeVectorStore
from src.service.vector_store import get_vector_store


class DummyEmbeddingService(BaseEmbeddingService):
    """Mock implementation of BaseEmbeddingService for testing."""
    def embed_documents(self, texts):
        return [[0.1, 0.2, 0.3] for _ in texts]

    def embed_query(self, text):
        return [0.1, 0.2, 0.3]


def test_embedding_service_abc():
    """Verify that BaseEmbeddingService enforces abstract methods."""
    class IncompleteEmbedder(BaseEmbeddingService):
        pass

    with pytest.raises(TypeError):
        IncompleteEmbedder()


def test_sentence_transformer_mocked():
    """Verify SentenceTransformerEmbedding delegates to underlying model."""
    embedder = SentenceTransformerEmbedding(model_name="dummy-model")
    mock_model = MagicMock()
    mock_model.encode.return_value = MagicMock(tolist=lambda: [0.5, 0.5])
    embedder._model = mock_model

    vec = embedder.embed_query("test query")
    assert vec == [0.5, 0.5]
    mock_model.encode.assert_called_once_with("test query")


def test_sentence_transformer_loads_cached_model_without_hub_requests():
    embedder = SentenceTransformerEmbedding(model_name="dummy-model")
    mock_model = MagicMock()

    with patch("sentence_transformers.SentenceTransformer", return_value=mock_model) as model_loader:
        assert embedder._get_model() is mock_model

    model_loader.assert_called_once_with("dummy-model", local_files_only=True)


def test_sentence_transformer_downloads_model_when_not_cached():
    embedder = SentenceTransformerEmbedding(model_name="dummy-model")
    mock_model = MagicMock()

    with patch(
        "sentence_transformers.SentenceTransformer",
        side_effect=[OSError("model is not cached"), mock_model],
    ) as model_loader:
        assert embedder._get_model() is mock_model

    assert model_loader.call_args_list[0].kwargs == {"local_files_only": True}
    assert model_loader.call_args_list[1].args == ("dummy-model",)


def test_vector_store_abc():
    """Verify that BaseVectorStore enforces abstract methods."""
    class IncompleteVectorStore(BaseVectorStore):
        pass

    with pytest.raises(TypeError):
        IncompleteVectorStore()


@pytest.mark.asyncio
async def test_qdrant_vector_store_dependency_injection():
    """Verify QdrantVectorStore accepts a custom embedding service."""
    custom_embedder = DummyEmbeddingService()
    vs = QdrantVectorStore(
        collection_name="test_collection",
        url="http://localhost:6333",
        embedding_service=custom_embedder,
    )
    assert vs.embedder is custom_embedder

    mock_client = AsyncMock()
    mock_client.collection_exists.return_value = True
    mock_client.upsert = AsyncMock(return_value=True)
    vs._async_client = mock_client

    docs = [Document(page_content="hello world", metadata={"source": "test"})]
    result = await vs.upsert(docs)

    assert result == True
    mock_client.upsert.assert_awaited_once()
    call_args = mock_client.upsert.call_args[1]
    assert call_args["collection_name"] == "test_collection"
    assert len(call_args["points"]) == 1
    assert call_args["points"][0].vector == [0.1, 0.2, 0.3]
    assert call_args["points"][0].payload["page_content"] == "hello world"


def test_get_vector_store_factory():
    """Test get_vector_store factory."""
    custom_embedder = DummyEmbeddingService()
    qdrant_store = get_vector_store("qdrant", embedding_service=custom_embedder)
    assert isinstance(qdrant_store, QdrantVectorStore)

    pinecone_store = get_vector_store("pinecone", embedding_service=custom_embedder)
    assert isinstance(pinecone_store, PineconeVectorStore)

    with pytest.raises(ValueError):
        get_vector_store("unsupported_db")