Spaces:
Runtime error
Runtime error
Download test_api.py from its-seraj/rag-backend-api: direct link, hf CLI and curl.
- Browser
- Download file 14.4 kB
-
https://huggingface.co/spaces/its-seraj/rag-backend-api/resolve/main/test_api.py
- Command line
-
hf download hf://spaces/its-seraj/rag-backend-api/test_api.py
-
curl -L -o test_api.py https://huggingface.co/spaces/its-seraj/rag-backend-api/resolve/main/test_api.py
14.4 kB
| import os | |
| import pytest | |
| from fastapi.testclient import TestClient | |
| # Set environment variables for testing before importing main | |
| os.environ["QDRANT_COLLECTION"] = "test_rag_documents" | |
| # Ensure we run in memory during tests by clearing cloud credentials if any exist in env | |
| if "QDRANT_URL" in os.environ: | |
| del os.environ["QDRANT_URL"] | |
| if "QDRANT_API_KEY" in os.environ: | |
| del os.environ["QDRANT_API_KEY"] | |
| from unittest.mock import MagicMock, patch | |
| # Create a mock graph store globally for testing | |
| mock_graph_store = MagicMock() | |
| mock_graph_store.is_connected = True | |
| mock_graph_store.get_status.return_value = { | |
| "connection_type": "Mock Neo4j", | |
| "status": "online", | |
| "nodes_count": 5, | |
| "relationships_count": 4 | |
| } | |
| mock_graph_store.query_subgraph.return_value = "(Alice) -[WORKS_AT]-> (BobCorp)" | |
| mock_graph_store.clear.return_value = True | |
| with patch("graph_store.Neo4jGraphStore", return_value=mock_graph_store): | |
| from main import app | |
| # Mock Gemini extraction functions globally for test stability | |
| from agent import GraphExtractionModel, EntityModel, RelationshipModel | |
| mock_extraction_result = GraphExtractionModel( | |
| entities=[ | |
| EntityModel(name="Alice", type="Person", description="A software engineer."), | |
| EntityModel(name="BobCorp", type="Organization", description="A software company.") | |
| ], | |
| relationships=[ | |
| RelationshipModel(source="Alice", target="BobCorp", type="WORKS_AT", description="works at") | |
| ] | |
| ) | |
| patcher_extract_graph = patch("main.extract_graph_elements", return_value=mock_extraction_result) | |
| patcher_extract_graph.start() | |
| patcher_extract_entities = patch("main.extract_query_entities", return_value=["Alice", "BobCorp"]) | |
| patcher_extract_entities.start() | |
| client = TestClient(app) | |
| def test_root_endpoint(): | |
| response = client.get("/") | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["app"] == "RAG Backend Service" | |
| assert data["status"] == "online" | |
| def test_health_endpoint(): | |
| response = client.get("/health") | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["status"] == "healthy" | |
| assert "vector_store" in data | |
| assert data["vector_store"]["connection_type"] == "In-Memory (Local)" | |
| def test_rag_pipeline_flow(): | |
| # 1. Clear database before starting | |
| client.delete("/documents") | |
| # Check stats are empty | |
| status_response = client.get("/documents") | |
| assert status_response.status_code == 200 | |
| assert status_response.json()["vectors_count"] == 0 | |
| # 2. Ingest documents | |
| payload = { | |
| "documents": [ | |
| { | |
| "text": "Antigravity is a concept of creating a place or object that is free from the force of gravity. It does not refer to the lack of weight under gravity experienced in free fall.", | |
| "metadata": {"source": "physics_101", "category": "gravity"} | |
| }, | |
| { | |
| "text": "Photosynthesis is the process used by plants, algae and certain bacteria to harness energy from sunlight and turn it into chemical energy.", | |
| "metadata": {"source": "biology_101", "category": "plants"} | |
| } | |
| ], | |
| "chunk_size": 100, | |
| "chunk_overlap": 10 | |
| } | |
| ingest_response = client.post("/documents", json=payload) | |
| assert ingest_response.status_code == 201 | |
| ingest_data = ingest_response.json() | |
| assert ingest_data["status"] == "success" | |
| assert ingest_data["documents_processed"] == 2 | |
| assert ingest_data["chunks_created"] > 0 | |
| # 3. Verify statistics updated | |
| status_response = client.get("/documents") | |
| assert status_response.json()["vectors_count"] == ingest_data["chunks_created"] | |
| # 4. Search retrieval for gravity topic | |
| retrieve_payload = { | |
| "query": "How does antigravity work or what is it?", | |
| "top_k": 2 | |
| } | |
| retrieve_response = client.post("/retrieve", json=retrieve_payload) | |
| assert retrieve_response.status_code == 200 | |
| retrieve_data = retrieve_response.json() | |
| assert retrieve_data["query"] == retrieve_payload["query"] | |
| assert len(retrieve_data["results"]) > 0 | |
| assert len(retrieve_data["context"]) > 0 | |
| # First result should match the antigravity text (higher similarity score) | |
| assert "Antigravity" in retrieve_data["results"][0]["text"] | |
| assert retrieve_data["results"][0]["metadata"]["category"] == "gravity" | |
| # 5. Search retrieval for photosynthesis | |
| retrieve_payload_bio = { | |
| "query": "How do plants harness energy from sunlight?", | |
| "top_k": 1 | |
| } | |
| retrieve_response_bio = client.post("/retrieve", json=retrieve_payload_bio) | |
| assert retrieve_response_bio.status_code == 200 | |
| retrieve_data_bio = retrieve_response_bio.json() | |
| assert "Photosynthesis" in retrieve_data_bio["results"][0]["text"] | |
| assert retrieve_data_bio["results"][0]["metadata"]["category"] == "plants" | |
| # 6. Clear database | |
| clear_response = client.delete("/documents") | |
| assert clear_response.status_code == 200 | |
| assert clear_response.json()["status"] == "success" | |
| # Check stats are empty again | |
| status_response = client.get("/documents") | |
| assert status_response.json()["vectors_count"] == 0 | |
| def test_upload_text_document(): | |
| # 1. Clear database before starting | |
| client.delete("/documents") | |
| # 2. Upload a txt file | |
| dummy_text_data = "This is raw text content about photosynthesis from an uploaded text file." | |
| response = client.post( | |
| "/documents/upload", | |
| files={"file": ("test.txt", dummy_text_data.encode("utf-8"), "text/plain")}, | |
| data={"chunk_size": 100, "chunk_overlap": 10, "metadata": '{"category": "test_txt"}'} | |
| ) | |
| assert response.status_code == 201 | |
| data = response.json() | |
| assert data["status"] == "success" | |
| assert data["documents_processed"] == 1 | |
| assert data["chunks_created"] > 0 | |
| # Verify retrieval | |
| retrieve_response = client.post("/retrieve", json={"query": "photosynthesis", "top_k": 1}) | |
| assert retrieve_response.status_code == 200 | |
| retrieve_data = retrieve_response.json() | |
| assert len(retrieve_data["results"]) > 0 | |
| assert "photosynthesis" in retrieve_data["results"][0]["text"] | |
| assert retrieve_data["results"][0]["metadata"]["source"] == "test.txt" | |
| assert retrieve_data["results"][0]["metadata"]["category"] == "test_txt" | |
| from unittest.mock import MagicMock, patch | |
| def test_upload_pdf_document(): | |
| # 1. Clear database before starting | |
| client.delete("/documents") | |
| # 2. Mock PdfReader to return a dummy page with text | |
| mock_page = MagicMock() | |
| mock_page.extract_text.return_value = "This is text extracted from a mock PDF file about gravity." | |
| mock_reader = MagicMock() | |
| mock_reader.pages = [mock_page] | |
| with patch("main.PdfReader", return_value=mock_reader) as mock_pdf_reader: | |
| # Create a dummy PDF byte stream | |
| dummy_pdf_data = b"%PDF-1.4 dummy content" | |
| response = client.post( | |
| "/documents/upload", | |
| files={"file": ("test.pdf", dummy_pdf_data, "application/pdf")}, | |
| data={"chunk_size": 100, "chunk_overlap": 10, "metadata": '{"category": "test_pdf"}'} | |
| ) | |
| assert response.status_code == 201 | |
| data = response.json() | |
| assert data["status"] == "success" | |
| assert data["documents_processed"] == 1 | |
| assert data["chunks_created"] > 0 | |
| # Verify PdfReader was initialized with the file bytes | |
| mock_pdf_reader.assert_called_once() | |
| called_args, _ = mock_pdf_reader.call_args | |
| assert called_args[0].getvalue() == dummy_pdf_data | |
| # Verify retrieval | |
| retrieve_response = client.post("/retrieve", json={"query": "gravity", "top_k": 1}) | |
| assert retrieve_response.status_code == 200 | |
| retrieve_data = retrieve_response.json() | |
| assert len(retrieve_data["results"]) > 0 | |
| assert "gravity" in retrieve_data["results"][0]["text"] | |
| assert retrieve_data["results"][0]["metadata"]["source"] == "test.pdf" | |
| assert retrieve_data["results"][0]["metadata"]["category"] == "test_pdf" | |
| def test_upload_invalid_file_type(): | |
| response = client.post( | |
| "/documents/upload", | |
| files={"file": ("test.png", b"fake png bytes", "image/png")}, | |
| data={"chunk_size": 100, "chunk_overlap": 10} | |
| ) | |
| assert response.status_code == 400 | |
| assert "Unsupported file format" in response.json()["detail"] | |
| def test_upload_invalid_metadata(): | |
| response = client.post( | |
| "/documents/upload", | |
| files={"file": ("test.txt", b"some text", "text/plain")}, | |
| data={"metadata": "{invalid json}"} | |
| ) | |
| assert response.status_code == 400 | |
| assert "valid JSON" in response.json()["detail"] | |
| def test_upload_invalid_parameters(): | |
| # Invalid chunk_size | |
| response = client.post( | |
| "/documents/upload", | |
| files={"file": ("test.txt", b"some text", "text/plain")}, | |
| data={"chunk_size": 10} # Below 50 limit | |
| ) | |
| assert response.status_code == 400 | |
| assert "chunk_size must be between" in response.json()["detail"] | |
| def test_agent_chat_endpoint_missing_api_key(): | |
| # Ensure GEMINI_API_KEY is not in env | |
| with patch.dict(os.environ, {}, clear=True): | |
| # Keep QDRANT_COLLECTION so the app can start/connect to memory db | |
| with patch.dict(os.environ, {"QDRANT_COLLECTION": "test_rag_documents"}): | |
| response = client.post("/agent/chat", json={"prompt": "hello"}) | |
| assert response.status_code == 500 | |
| assert "GEMINI_API_KEY environment variable is not set" in response.json()["detail"] | |
| def test_agent_chat_endpoint_success(): | |
| mock_result = { | |
| "answer": "This is a mock answer about antigravity.", | |
| "tool_calls": [ | |
| { | |
| "query": "antigravity", | |
| "top_k": 3, | |
| "results_count": 1, | |
| "results": [ | |
| { | |
| "text": "Antigravity is a concept...", | |
| "score": 0.9, | |
| "metadata": {"source": "physics_101"} | |
| } | |
| ] | |
| } | |
| ], | |
| "sources": [ | |
| { | |
| "text": "Antigravity is a concept...", | |
| "score": 0.9, | |
| "metadata": {"source": "physics_101"} | |
| } | |
| ] | |
| } | |
| with patch("main.run_agent_rag", return_value=mock_result) as mock_run: | |
| with patch.dict(os.environ, {"GEMINI_API_KEY": "mock-key"}): | |
| response = client.post( | |
| "/agent/chat", | |
| json={ | |
| "prompt": "explain antigravity", | |
| "chat_history": [ | |
| {"role": "user", "content": "hi"}, | |
| {"role": "model", "content": "hello"} | |
| ] | |
| } | |
| ) | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["answer"] == "This is a mock answer about antigravity." | |
| assert len(data["tool_calls"]) == 1 | |
| assert data["tool_calls"][0]["query"] == "antigravity" | |
| assert len(data["sources"]) == 1 | |
| assert data["sources"][0]["metadata"]["source"] == "physics_101" | |
| # Verify mock was called with correct parameters | |
| mock_run.assert_called_once() | |
| called_args, called_kwargs = mock_run.call_args | |
| assert called_kwargs["user_message"] == "explain antigravity" | |
| assert called_kwargs["graph_store"] == mock_graph_store | |
| assert called_kwargs["chat_history"] == [ | |
| {"role": "user", "content": "hi"}, | |
| {"role": "model", "content": "hello"} | |
| ] | |
| def test_health_endpoint_includes_graph(): | |
| response = client.get("/health") | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert "graph_store" in data | |
| assert data["graph_store"]["connection_type"] == "Mock Neo4j" | |
| assert data["graph_store"]["status"] == "online" | |
| def test_documents_ingest_calls_graph_store(): | |
| mock_graph_store.reset_mock() | |
| # Ingest document | |
| payload = { | |
| "documents": [ | |
| { | |
| "text": "Alice works at BobCorp.", | |
| "metadata": {"source": "test_doc"} | |
| } | |
| ], | |
| "chunk_size": 100, | |
| "chunk_overlap": 10 | |
| } | |
| response = client.post("/documents", json=payload) | |
| assert response.status_code == 201 | |
| # Verify graph store add_graph_data was called | |
| mock_graph_store.add_graph_data.assert_called_once() | |
| called_args, called_kwargs = mock_graph_store.add_graph_data.call_args | |
| assert called_kwargs["source"] == "test_doc" | |
| assert called_kwargs["chunk_text"] == "Alice works at BobCorp." | |
| assert called_kwargs["entities"][0]["name"] == "Alice" | |
| assert called_kwargs["relationships"][0]["type"] == "WORKS_AT" | |
| def test_retrieve_graph_endpoint(): | |
| response = client.post( | |
| "/retrieve/graph", | |
| json={"query": "Alice BobCorp", "top_k_entities": 2} | |
| ) | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["query"] == "Alice BobCorp" | |
| assert data["extracted_entities"] == ["Alice", "BobCorp"] | |
| assert "WORKS_AT" in data["relationships"] | |
| def test_query_graph_endpoint(): | |
| mock_genai_client = MagicMock() | |
| mock_response = MagicMock() | |
| mock_response.text = "Based on the graph, Alice works at BobCorp." | |
| mock_genai_client.models.generate_content.return_value = mock_response | |
| with patch("google.genai.Client", return_value=mock_genai_client): | |
| with patch.dict(os.environ, {"GEMINI_API_KEY": "mock-key"}): | |
| response = client.post( | |
| "/query/graph", | |
| json={"query": "Where does Alice work?"} | |
| ) | |
| assert response.status_code == 200 | |
| data = response.json() | |
| assert data["query"] == "Where does Alice work?" | |
| assert "Alice works at BobCorp" in data["answer"] | |
| assert "WORKS_AT" in data["context"] | |
| def test_clear_documents_clears_graph(): | |
| mock_graph_store.reset_mock() | |
| response = client.delete("/documents") | |
| assert response.status_code == 200 | |
| mock_graph_store.clear.assert_called_once() | |
| if __name__ == "__main__": | |
| import sys | |
| import pytest | |
| sys.exit(pytest.main([__file__])) | |