Tests

tests/unit/test_gateway/test_dispatch_serialize.py

@@ -6,7 +6,7 @@ import pytest
 from unittest.mock import MagicMock
 
 from trustgraph.gateway.dispatch.serialize import to_value, to_subgraph, serialize_value
-from trustgraph.schema import Value, Triple
+from trustgraph.schema import Term, Triple, IRI, LITERAL
 
 
 class TestDispatchSerialize:
@@ -15,12 +15,12 @@ class TestDispatchSerialize:
     def test_to_value_with_uri(self):
         """Test to_value function with URI"""
         input_data = {"v": "http://example.com/resource", "e": True}
-        
+
         result = to_value(input_data)
-        
-        assert isinstance(result, Value)
-        assert result.value == "http://example.com/resource"
-        assert result.is_uri is True
+
+        assert isinstance(result, Term)
+        assert result.iri == "http://example.com/resource"
+        assert result.type == IRI
 
     def test_to_value_with_literal(self):
         """Test to_value function with literal value"""
@@ -28,9 +28,9 @@ class TestDispatchSerialize:
         
         result = to_value(input_data)
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "literal string"
-        assert result.is_uri is False
+        assert result.type == LITERAL
 
     def test_to_subgraph_with_multiple_triples(self):
         """Test to_subgraph function with multiple triples"""
@@ -53,16 +53,16 @@ class TestDispatchSerialize:
         assert all(isinstance(triple, Triple) for triple in result)
         
         # Check first triple
-        assert result[0].s.value == "subject1"
-        assert result[0].s.is_uri is True
-        assert result[0].p.value == "predicate1"
-        assert result[0].p.is_uri is True
+        assert result[0].s.iri == "subject1"
+        assert result[0].s.type == IRI
+        assert result[0].p.iri == "predicate1"
+        assert result[0].p.type == IRI
         assert result[0].o.value == "object1"
-        assert result[0].o.is_uri is False
-        
+        assert result[0].o.type == LITERAL
+
         # Check second triple
         assert result[1].s.value == "subject2"
-        assert result[1].s.is_uri is False
+        assert result[1].s.type == LITERAL
 
     def test_to_subgraph_with_empty_list(self):
         """Test to_subgraph function with empty input"""
@@ -74,16 +74,16 @@ class TestDispatchSerialize:
 
     def test_serialize_value_with_uri(self):
         """Test serialize_value function with URI value"""
-        value = Value(value="http://example.com/test", is_uri=True)
-        
-        result = serialize_value(value)
-        
+        term = Term(type=IRI, iri="http://example.com/test")
+
+        result = serialize_value(term)
+
         assert result == {"v": "http://example.com/test", "e": True}
 
     def test_serialize_value_with_literal(self):
         """Test serialize_value function with literal value"""
-        value = Value(value="test literal", is_uri=False)
-        
-        result = serialize_value(value)
-        
+        term = Term(type=LITERAL, value="test literal")
+
+        result = serialize_value(term)
+
         assert result == {"v": "test literal", "e": False}

tests/unit/test_query/test_graph_embeddings_milvus_query.py

@@ -6,7 +6,7 @@ import pytest
 from unittest.mock import MagicMock, patch
 
 from trustgraph.query.graph_embeddings.milvus.service import Processor
-from trustgraph.schema import Value, GraphEmbeddingsRequest
+from trustgraph.schema import Term, GraphEmbeddingsRequest, IRI, LITERAL
 
 
 class TestMilvusGraphEmbeddingsQueryProcessor:
@@ -69,49 +69,49 @@ class TestMilvusGraphEmbeddingsQueryProcessor:
         """Test create_value with HTTP URI"""
         result = processor.create_value("http://example.com/resource")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "http://example.com/resource"
-        assert result.is_uri is True
+        assert result.type == IRI
 
     def test_create_value_with_https_uri(self, processor):
         """Test create_value with HTTPS URI"""
         result = processor.create_value("https://example.com/resource")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "https://example.com/resource"
-        assert result.is_uri is True
+        assert result.type == IRI
 
     def test_create_value_with_literal(self, processor):
         """Test create_value with literal value"""
         result = processor.create_value("just a literal string")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "just a literal string"
-        assert result.is_uri is False
+        assert result.type == LITERAL
 
     def test_create_value_with_empty_string(self, processor):
         """Test create_value with empty string"""
         result = processor.create_value("")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == ""
-        assert result.is_uri is False
+        assert result.type == LITERAL
 
     def test_create_value_with_partial_uri(self, processor):
         """Test create_value with string that looks like URI but isn't complete"""
         result = processor.create_value("http")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "http"
-        assert result.is_uri is False
+        assert result.type == LITERAL
 
     def test_create_value_with_ftp_uri(self, processor):
         """Test create_value with FTP URI (should not be detected as URI)"""
         result = processor.create_value("ftp://example.com/file")
         
-        assert isinstance(result, Value)
+        assert isinstance(result, Term)
         assert result.value == "ftp://example.com/file"
-        assert result.is_uri is False
+        assert result.type == LITERAL
 
     @pytest.mark.asyncio
     async def test_query_graph_embeddings_single_vector(self, processor):
@@ -140,15 +140,15 @@ class TestMilvusGraphEmbeddingsQueryProcessor:
         
         # Verify results are converted to Value objects
         assert len(result) == 3
-        assert isinstance(result[0], Value)
+        assert isinstance(result[0], Term)
         assert result[0].value == "http://example.com/entity1"
-        assert result[0].is_uri is True
-        assert isinstance(result[1], Value)
+        assert result[0].type == IRI
+        assert isinstance(result[1], Term)
         assert result[1].value == "http://example.com/entity2"
-        assert result[1].is_uri is True
-        assert isinstance(result[2], Value)
+        assert result[1].type == IRI
+        assert isinstance(result[2], Term)
         assert result[2].value == "literal entity"
-        assert result[2].is_uri is False
+        assert result[2].type == LITERAL
 
     @pytest.mark.asyncio
     async def test_query_graph_embeddings_multiple_vectors(self, processor):
@@ -346,14 +346,14 @@ class TestMilvusGraphEmbeddingsQueryProcessor:
         assert len(result) == 4
         
         # Check URI entities
-        uri_results = [r for r in result if r.is_uri]
+        uri_results = [r for r in result if r.type == IRI]
         assert len(uri_results) == 2
         uri_values = [r.value for r in uri_results]
         assert "http://example.com/uri_entity" in uri_values
         assert "https://example.com/another_uri" in uri_values
         
         # Check literal entities
-        literal_results = [r for r in result if not r.is_uri]
+        literal_results = [r for r in result if not r.type == IRI]
         assert len(literal_results) == 2
         literal_values = [r.value for r in literal_results]
         assert "literal entity text" in literal_values

tests/unit/test_query/test_graph_embeddings_pinecone_query.py

@@ -9,7 +9,7 @@ from unittest.mock import MagicMock, patch
 pytest.skip("Pinecone library missing protoc_gen_openapiv2 dependency", allow_module_level=True)
 
 from trustgraph.query.graph_embeddings.pinecone.service import Processor
-from trustgraph.schema import Value
+from trustgraph.schema import Term, IRI, LITERAL
 
 
 class TestPineconeGraphEmbeddingsQueryProcessor:
@@ -105,27 +105,27 @@ class TestPineconeGraphEmbeddingsQueryProcessor:
         uri_entity = "http://example.org/entity"
         value = processor.create_value(uri_entity)
         
-        assert isinstance(value, Value)
+        assert isinstance(value, Term)
         assert value.value == uri_entity
-        assert value.is_uri == True
+        assert value.type == IRI
 
     def test_create_value_https_uri(self, processor):
         """Test create_value method for HTTPS URI entities"""
         uri_entity = "https://example.org/entity"
         value = processor.create_value(uri_entity)
         
-        assert isinstance(value, Value)
+        assert isinstance(value, Term)
         assert value.value == uri_entity
-        assert value.is_uri == True
+        assert value.type == IRI
 
     def test_create_value_literal(self, processor):
         """Test create_value method for literal entities"""
         literal_entity = "literal_entity"
         value = processor.create_value(literal_entity)
         
-        assert isinstance(value, Value)
+        assert isinstance(value, Term)
         assert value.value == literal_entity
-        assert value.is_uri == False
+        assert value.type == LITERAL
 
     @pytest.mark.asyncio
     async def test_query_graph_embeddings_single_vector(self, processor):
@@ -165,11 +165,11 @@ class TestPineconeGraphEmbeddingsQueryProcessor:
         # Verify results
         assert len(entities) == 3
         assert entities[0].value == 'http://example.org/entity1'
-        assert entities[0].is_uri == True
+        assert entities[0].type == IRI
         assert entities[1].value == 'entity2'
-        assert entities[1].is_uri == False
+        assert entities[1].type == LITERAL
         assert entities[2].value == 'http://example.org/entity3'
-        assert entities[2].is_uri == True
+        assert entities[2].type == IRI
 
     @pytest.mark.asyncio
     async def test_query_graph_embeddings_multiple_vectors(self, processor, mock_query_message):