File size: 14,425 Bytes
73ddeba
 
 
 
 
 
 
 
 
 
 
 
d3f7d23
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
73ddeba
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
02cda1b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9c8bf34
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d3f7d23
9c8bf34
 
 
 
 
d3f7d23
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
73ddeba
 
 
 
02cda1b
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
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
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__]))