File size: 12,039 Bytes
68e8c03
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
"""Testes unitários, de integração, isolamento e segurança para o DocuMind AI (BYOK)."""

import logging
from concurrent.futures import ThreadPoolExecutor
from io import BytesIO
from pathlib import Path

import pytest

from src.document_loader import DocumentLoadError, DocumentPage, load_pdf
from src.embeddings import EmbeddingLoadError, EmbeddingModel
from src.llm import BYOKLLM, LLMConfigError, sanitize_sensitive_text
from src.rag_pipeline import RAGPipeline
from src.retriever import Retriever
from src.text_splitter import split_documents
from src.vector_store import StoredDocument, VectorStore


def _build_simple_pdf(text: str) -> bytes:
    """Gera um PDF mínimo válido em memória contendo o texto informado."""
    safe_text = text.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)")
    stream = f"BT /F1 12 Tf 72 720 Td ({safe_text}) Tj ET".encode("latin-1", errors="replace")

    objects = [
        b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n",
        b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n",
        (
            b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] "
            b"/Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>\nendobj\n"
        ),
        f"4 0 obj\n<< /Length {len(stream)} >>\nstream\n".encode("ascii")
        + stream
        + b"\nendstream\nendobj\n",
        b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
    ]

    pdf = bytearray(b"%PDF-1.4\n")
    offsets = [0]
    for obj in objects:
        offsets.append(len(pdf))
        pdf.extend(obj)

    xref_offset = len(pdf)
    pdf.extend(f"xref\n0 {len(offsets)}\n".encode("ascii"))
    pdf.extend(b"0000000000 65535 f \n")
    for offset in offsets[1:]:
        pdf.extend(f"{offset:010d} 00000 n \n".encode("ascii"))

    pdf.extend(
        f"trailer\n<< /Size {len(offsets)} /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n".encode("ascii")
    )
    return bytes(pdf)


class FakeEmbeddingModel:
    """Modelo de embeddings determinístico para testes rápidos sem rede."""

    def embed_documents(self, texts: list[str]) -> list[list[float]]:
        return [self.embed_query(text) for text in texts]

    def embed_query(self, query: str) -> list[float]:
        lowered = query.lower()
        return [
            float(lowered.count("rag") + lowered.count("retrieval")),
            float(lowered.count("python") + lowered.count("streamlit")),
            float(len(lowered) % 17 + 1),
        ]


class FakeLLM:
    """Stub de LLM que verifica o contexto recebido."""

    def __init__(self) -> None:
        self.calls = 0

    def generate_answer(self, question: str, contexts: list[StoredDocument]) -> str:
        self.calls += 1
        return f"Resposta baseada em {len(contexts)} trecho(s): {contexts[0].text}"


def test_local_embedding_model_init_error_and_mock_encode(monkeypatch: pytest.MonkeyPatch) -> None:
    def failing_st(*args: object, **kwargs: object) -> object:
        raise OSError("Erro de rede ao baixar pesos")

    monkeypatch.setattr("src.embeddings.SentenceTransformer", failing_st)
    with pytest.raises(EmbeddingLoadError, match="Falha ao inicializar"):
        EmbeddingModel()

    class DummyArray:
        def __init__(self, data: list[object]) -> None:
            self._data = data

        def tolist(self) -> list[object]:
            return self._data

    class DummyST:
        def __init__(self, *args: object, **kwargs: object) -> None:
            pass

        def get_sentence_embedding_dimension(self) -> int:
            return 384

        def encode(self, texts: object, **kwargs: object) -> DummyArray:
            if isinstance(texts, list):
                return DummyArray([[0.1] * 384 for _ in texts])
            return DummyArray([0.1] * 384)

    monkeypatch.setattr("src.embeddings.SentenceTransformer", DummyST)
    model = EmbeddingModel()
    assert model.dimension == 384
    assert len(model.embed_query("teste")) == 384
    assert len(model.embed_documents(["a", "b"])) == 2


def test_load_pdf_empty_invalid_and_oversized() -> None:
    with pytest.raises(DocumentLoadError, match="vazio"):
        load_pdf(BytesIO(b""), filename="vazio.pdf")

    with pytest.raises(DocumentLoadError, match="inválido"):
        load_pdf(BytesIO(b"nao e pdf"), filename="invalido.pdf")

    oversized = b"%PDF-1.4" + b"0" * (2 * 1024 * 1024)
    with pytest.raises(DocumentLoadError, match="excede o limite"):
        load_pdf(BytesIO(oversized), filename="grande.pdf", max_size_mb=1)


def test_load_pdf_valid_and_split_documents() -> None:
    pdf_bytes = _build_simple_pdf("DocuMind AI utiliza RAG com Python e ChromaDB.")
    pages = load_pdf(BytesIO(pdf_bytes), filename="arquitetura.pdf")
    assert len(pages) == 1
    assert pages[0].source == "arquitetura.pdf"
    assert pages[0].page == 1

    long_text = " ".join(f"palavra{i}" for i in range(120))
    chunks = split_documents([DocumentPage(text=long_text, source="manual.pdf", page=3)], chunk_size=120, chunk_overlap=30)
    assert len(chunks) > 1
    assert all(c.source == "manual.pdf" and c.page == 3 and len(c.text) <= 120 for c in chunks)


def test_byok_modes_and_missing_credentials(monkeypatch: pytest.MonkeyPatch) -> None:
    # Mesmo com chaves no ambiente, BYOKLLM não deve usar chaves do proprietário
    monkeypatch.setenv("GEMINI_API_KEY", "AIzaOwnerSecretKey123456")
    monkeypatch.setenv("GROQ_API_KEY", "gsk_OwnerSecretKey123456")

    with pytest.raises(LLMConfigError, match="GEMINI_API_KEY"):
        BYOKLLM(mode="gemini")
    with pytest.raises(LLMConfigError, match="GROQ_API_KEY"):
        BYOKLLM(mode="groq")
    with pytest.raises(LLMConfigError, match="GEMINI_API_KEY"):
        BYOKLLM(mode="gemini_groq", gemini_api_key="AIzaUser123456", groq_api_key="")


def test_byok_gemini_only_mode(monkeypatch: pytest.MonkeyPatch) -> None:
    llm = BYOKLLM(mode="gemini", gemini_api_key="AIzaUserKey1234567890")

    class DummyResp:
        text = "Resposta via Gemini"

    monkeypatch.setattr(llm._client.models, "generate_content", lambda **kwargs: DummyResp())  # type: ignore[union-attr]
    result = llm.generate_result("Pergunta?", [StoredDocument(text="Contexto.", source="a.pdf", page=1)])
    assert result.text == "Resposta via Gemini"
    assert result.provider == "gemini"
    assert result.used_fallback is False


def test_byok_groq_only_mode(monkeypatch: pytest.MonkeyPatch) -> None:
    llm = BYOKLLM(mode="groq", groq_api_key="gsk_UserKey1234567890")

    class DummyHTTP:
        def raise_for_status(self) -> None:
            return None

        def json(self) -> dict[str, object]:
            return {"choices": [{"message": {"content": "Resposta direta Groq"}}]}

    monkeypatch.setattr("src.llm.httpx.post", lambda *args, **kwargs: DummyHTTP())
    result = llm.generate_result("Pergunta?", [StoredDocument(text="Contexto.", source="a.pdf", page=1)])
    assert result.text == "Resposta direta Groq"
    assert result.provider == "groq"
    assert result.used_fallback is False


def test_byok_fallback_only_on_transient_error_without_duplicate_calls(monkeypatch: pytest.MonkeyPatch) -> None:
    llm = BYOKLLM(
        mode="gemini_groq",
        gemini_api_key="AIzaUserKey1234567890",
        groq_api_key="gsk_UserKey1234567890",
    )
    gemini_calls = 0
    groq_calls = 0

    def transient_gemini(**kwargs: object) -> object:
        nonlocal gemini_calls
        gemini_calls += 1
        raise TimeoutError("Tempo limite excedido")

    class DummyHTTP:
        def raise_for_status(self) -> None:
            return None

        def json(self) -> dict[str, object]:
            return {"choices": [{"message": {"content": "Resposta fallback Groq"}}]}

    def mock_groq(*args: object, **kwargs: object) -> DummyHTTP:
        nonlocal groq_calls
        groq_calls += 1
        return DummyHTTP()

    monkeypatch.setattr(llm._client.models, "generate_content", transient_gemini)  # type: ignore[union-attr]
    monkeypatch.setattr("src.llm.httpx.post", mock_groq)

    result = llm.generate_result("Pergunta?", [StoredDocument(text="Contexto.", source="a.pdf", page=1)])
    assert result.text == "Resposta fallback Groq"
    assert result.provider == "groq"
    assert result.used_fallback is True
    assert gemini_calls == 1
    assert groq_calls == 1

    # Erro não transitório (ex.: chave inválida) NÃO deve acionar fallback
    def non_transient_gemini(**kwargs: object) -> object:
        raise ValueError("API key invalid: AIzaUserKey1234567890")

    monkeypatch.setattr(llm._client.models, "generate_content", non_transient_gemini)  # type: ignore[union-attr]
    with pytest.raises(RuntimeError) as exc_info:
        llm.generate_result("Pergunta?", [StoredDocument(text="Contexto.", source="a.pdf", page=1)])
    assert "AIzaUserKey1234567890" not in str(exc_info.value)
    assert groq_calls == 1


def test_session_isolation_cleanup_and_concurrency(tmp_path: Path) -> None:
    def make_session_pipeline(name: str) -> RAGPipeline:
        return RAGPipeline(
            persist_directory=tmp_path / name,
            collection_name=f"col_{name}",
            embedding_model=FakeEmbeddingModel(),  # type: ignore[arg-type]
            llm=FakeLLM(),
        )

    p1 = make_session_pipeline("sessao_a")
    p2 = make_session_pipeline("sessao_b")

    p1.index_pdf(BytesIO(_build_simple_pdf("Segredo exclusivo da sessao A sobre RAG.")), filename="a.pdf")
    p2.index_pdf(BytesIO(_build_simple_pdf("Conteudo exclusivo da sessao B sobre Python.")), filename="b.pdf")

    assert p1.list_indexed_sources() == ["a.pdf"]
    assert p2.list_indexed_sources() == ["b.pdf"]

    resp_a = p1.ask("O que diz sobre RAG?")
    assert "sessao A" in resp_a.answer
    assert "sessao B" not in resp_a.answer

    # Concorrência entre sessões isoladas
    def worker(idx: int) -> list[str]:
        p = make_session_pipeline(f"worker_{idx}")
        p.index_pdf(BytesIO(_build_simple_pdf(f"Documento paralelo {idx} sobre RAG.")), filename=f"doc_{idx}.pdf")
        sources = p.list_indexed_sources()
        p.cleanup_session()
        return sources

    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(worker, range(4)))

    assert results == [[f"doc_{i}.pdf"] for i in range(4)]
    p1.cleanup_session()
    p2.cleanup_session()

    # Reabrindo o mesmo diretório após cleanup, nenhum documento deve existir
    reopened = make_session_pipeline("sessao_a")
    assert reopened.list_indexed_sources() == []


def test_sanitize_sensitive_text_prevents_log_leaks(caplog: pytest.LogCaptureFixture) -> None:
    secret_g = "AIzaVerySecretGeminiKey999"
    secret_q = "gsk_VerySecretGroqKey888"
    raw = f"Falha Authorization: Bearer {secret_q} e chave {secret_g}"
    cleaned = sanitize_sensitive_text(raw, [secret_g, secret_q])

    with caplog.at_level(logging.ERROR):
        logging.error(cleaned)

    assert secret_g not in cleaned
    assert secret_q not in cleaned
    assert secret_g not in caplog.text
    assert secret_q not in caplog.text


def test_retriever_empty_query_and_reindex_cleanup(tmp_path: Path) -> None:
    store = VectorStore(persist_directory=tmp_path / "chroma", collection_name="reindex_test")
    embedder = FakeEmbeddingModel()
    pipeline = RAGPipeline(
        embedding_model=embedder,  # type: ignore[arg-type]
        vector_store=store,
        llm=FakeLLM(),
        chunk_size=60,
        chunk_overlap=10,
    )

    long_pdf = _build_simple_pdf(" ".join(f"palavra{i}" for i in range(40)))
    assert pipeline.index_pdf(BytesIO(long_pdf), filename="relatorio.pdf") > 1

    short_pdf = _build_simple_pdf("Texto curto atualizado.")
    assert pipeline.index_pdf(BytesIO(short_pdf), filename="relatorio.pdf") == 1
    assert store.count() == 1

    retriever = Retriever(embedding_model=embedder, vector_store=store)  # type: ignore[arg-type]
    assert retriever.retrieve("   ") == []
    assert retriever.retrieve("RAG", max_distance=0.0) == []