unit tests

Signed-off-by: Anxhela Coba <[email protected]>

Author: Anxhela21

tests/unit/models/responses/test_query_response.py

@@ -1,6 +1,6 @@
 """Unit tests for QueryResponse model."""
 
-from models.responses import QueryResponse
+from models.responses import QueryResponse, RAGChunk, ToolCall, ReferencedDocument
 
 
 class TestQueryResponse:
@@ -20,3 +20,110 @@ def test_optional_conversation_id(self) -> None:
         qr = QueryResponse(response="LLM answer")
         assert qr.conversation_id is None
         assert qr.response == "LLM answer"
+
+    def test_rag_chunks_empty_by_default(self) -> None:
+        """Test that rag_chunks is empty by default."""
+        qr = QueryResponse(response="LLM answer")
+        assert not qr.rag_chunks
+
+    def test_rag_chunks_with_data(self) -> None:
+        """Test QueryResponse with RAG chunks."""
+        rag_chunks = [
+            RAGChunk(
+                content="Kubernetes is an open-source container orchestration system",
+                source="kubernetes-docs/overview.md",
+                score=0.95,
+            ),
+            RAGChunk(
+                content="Container orchestration automates deployment and management",
+                source="kubernetes-docs/concepts.md",
+                score=0.87,
+            ),
+        ]
+
+        qr = QueryResponse(
+            conversation_id="123e4567-e89b-12d3-a456-426614174000",
+            response="LLM answer with RAG context",
+            rag_chunks=rag_chunks,
+        )
+
+        assert len(qr.rag_chunks) == 2
+        assert (
+            qr.rag_chunks[0].content
+            == "Kubernetes is an open-source container orchestration system"
+        )
+        assert qr.rag_chunks[0].source == "kubernetes-docs/overview.md"
+        assert qr.rag_chunks[0].score == 0.95
+        assert (
+            qr.rag_chunks[1].content
+            == "Container orchestration automates deployment and management"
+        )
+        assert qr.rag_chunks[1].source == "kubernetes-docs/concepts.md"
+        assert qr.rag_chunks[1].score == 0.87
+
+    def test_rag_chunks_with_optional_fields(self) -> None:
+        """Test RAG chunks with optional source and score fields."""
+        rag_chunks = [
+            RAGChunk(content="Some content without source or score"),
+            RAGChunk(content="Content with source only", source="docs/guide.md"),
+            RAGChunk(content="Content with score only", score=0.75),
+        ]
+
+        qr = QueryResponse(response="LLM answer", rag_chunks=rag_chunks)
+
+        assert len(qr.rag_chunks) == 3
+        assert qr.rag_chunks[0].source is None
+        assert qr.rag_chunks[0].score is None
+        assert qr.rag_chunks[1].source == "docs/guide.md"
+        assert qr.rag_chunks[1].score is None
+        assert qr.rag_chunks[2].source is None
+        assert qr.rag_chunks[2].score == 0.75
+
+    def test_complete_query_response_with_all_fields(self) -> None:
+        """Test QueryResponse with all fields including RAG chunks, tool calls, and docs."""
+        rag_chunks = [
+            RAGChunk(
+                content="OLM is a component of the Operator Framework toolkit",
+                source="kubernetes-docs/operators.md",
+                score=0.95,
+            )
+        ]
+
+        tool_calls = [
+            ToolCall(
+                tool_name="knowledge_search",
+                arguments={"query": "operator lifecycle manager"},
+                result={"chunks_found": 5},
+            )
+        ]
+
+        referenced_documents = [
+            ReferencedDocument(
+                doc_url=(
+                    "https://docs.openshift.com/container-platform/4.15/operators/olm/index.html"
+                ),
+                doc_title="Operator Lifecycle Manager (OLM)",
+            )
+        ]
+
+        qr = QueryResponse(
+            conversation_id="123e4567-e89b-12d3-a456-426614174000",
+            response="Operator Lifecycle Manager (OLM) helps users install...",
+            rag_chunks=rag_chunks,
+            tool_calls=tool_calls,
+            referenced_documents=referenced_documents,
+        )
+
+        assert qr.conversation_id == "123e4567-e89b-12d3-a456-426614174000"
+        assert qr.response == "Operator Lifecycle Manager (OLM) helps users install..."
+        assert len(qr.rag_chunks) == 1
+        assert (
+            qr.rag_chunks[0].content
+            == "OLM is a component of the Operator Framework toolkit"
+        )
+        assert len(qr.tool_calls) == 1
+        assert qr.tool_calls[0].tool_name == "knowledge_search"
+        assert len(qr.referenced_documents) == 1
+        assert (
+            qr.referenced_documents[0].doc_title == "Operator Lifecycle Manager (OLM)"
+        )

tests/unit/models/responses/test_rag_chunk.py

@@ -0,0 +1,98 @@
+"""Unit tests for RAGChunk model."""
+
+from models.responses import RAGChunk
+
+
+class TestRAGChunk:
+    """Test cases for the RAGChunk model."""
+
+    def test_constructor_with_content_only(self) -> None:
+        """Test RAGChunk constructor with content only."""
+        chunk = RAGChunk(content="Sample content")
+        assert chunk.content == "Sample content"
+        assert chunk.source is None
+        assert chunk.score is None
+
+    def test_constructor_with_all_fields(self) -> None:
+        """Test RAGChunk constructor with all fields."""
+        chunk = RAGChunk(
+            content="Kubernetes is an open-source container orchestration system",
+            source="kubernetes-docs/overview.md",
+            score=0.95,
+        )
+        assert (
+            chunk.content
+            == "Kubernetes is an open-source container orchestration system"
+        )
+        assert chunk.source == "kubernetes-docs/overview.md"
+        assert chunk.score == 0.95
+
+    def test_constructor_with_content_and_source(self) -> None:
+        """Test RAGChunk constructor with content and source."""
+        chunk = RAGChunk(
+            content="Container orchestration automates deployment",
+            source="docs/concepts.md",
+        )
+        assert chunk.content == "Container orchestration automates deployment"
+        assert chunk.source == "docs/concepts.md"
+        assert chunk.score is None
+
+    def test_constructor_with_content_and_score(self) -> None:
+        """Test RAGChunk constructor with content and score."""
+        chunk = RAGChunk(content="Pod is the smallest deployable unit", score=0.82)
+        assert chunk.content == "Pod is the smallest deployable unit"
+        assert chunk.source is None
+        assert chunk.score == 0.82
+
+    def test_score_range_validation(self) -> None:
+        """Test that RAGChunk accepts valid score ranges."""
+        # Test minimum score
+        chunk_min = RAGChunk(content="Test content", score=0.0)
+        assert chunk_min.score == 0.0
+
+        # Test maximum score
+        chunk_max = RAGChunk(content="Test content", score=1.0)
+        assert chunk_max.score == 1.0
+
+        # Test decimal score
+        chunk_decimal = RAGChunk(content="Test content", score=0.751)
+        assert chunk_decimal.score == 0.751
+
+    def test_empty_content(self) -> None:
+        """Test RAGChunk with empty content."""
+        chunk = RAGChunk(content="")
+        assert chunk.content == ""
+        assert chunk.source is None
+        assert chunk.score is None
+
+    def test_multiline_content(self) -> None:
+        """Test RAGChunk with multiline content."""
+        multiline_content = """This is a multiline content
+        that spans multiple lines
+        and contains various information."""
+
+        chunk = RAGChunk(
+            content=multiline_content, source="docs/multiline.md", score=0.88
+        )
+        assert chunk.content == multiline_content
+        assert chunk.source == "docs/multiline.md"
+        assert chunk.score == 0.88
+
+    def test_long_source_path(self) -> None:
+        """Test RAGChunk with long source path."""
+        long_source = (
+            "very/deep/nested/directory/structure/with/many/levels/document.md"
+        )
+        chunk = RAGChunk(
+            content="Content from deeply nested document", source=long_source
+        )
+        assert chunk.source == long_source
+
+    def test_url_as_source(self) -> None:
+        """Test RAGChunk with URL as source."""
+        url_source = "https://docs.example.com/api/v1/documentation"
+        chunk = RAGChunk(
+            content="API documentation content", source=url_source, score=0.92
+        )
+        assert chunk.source == url_source
+        assert chunk.score == 0.92