AdryanAzul's picture
feat: deploy DocuMind AI (RAG + BYOK + local embeddings)
68e8c03 verified
Raw History Blame Contribute Delete
12 kB
"""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) == []