From 1d6c58f8cd9b4599a4a71798f241e5fd8726d0b6 Mon Sep 17 00:00:00 2001 From: Cyber MacGeddon Date: Tue, 27 Jan 2026 00:35:05 +0000 Subject: [PATCH] Tests --- .../test_gateway/test_dispatch_serialize.py | 46 +++++++++---------- .../test_graph_embeddings_milvus_query.py | 42 ++++++++--------- .../test_graph_embeddings_pinecone_query.py | 20 ++++---- 3 files changed, 54 insertions(+), 54 deletions(-) diff --git a/tests/unit/test_gateway/test_dispatch_serialize.py b/tests/unit/test_gateway/test_dispatch_serialize.py index e117629b..59b380c3 100644 --- a/tests/unit/test_gateway/test_dispatch_serialize.py +++ b/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} \ No newline at end of file diff --git a/tests/unit/test_query/test_graph_embeddings_milvus_query.py b/tests/unit/test_query/test_graph_embeddings_milvus_query.py index ebacfaaf..7bd096fe 100644 --- a/tests/unit/test_query/test_graph_embeddings_milvus_query.py +++ b/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 diff --git a/tests/unit/test_query/test_graph_embeddings_pinecone_query.py b/tests/unit/test_query/test_graph_embeddings_pinecone_query.py index 0c13e9c9..1b243113 100644 --- a/tests/unit/test_query/test_graph_embeddings_pinecone_query.py +++ b/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):