apunkt/trustgraph
1
0
Fork 0
mirror of https://github.com/trustgraph-ai/trustgraph.git synced 2026-04-25 00:16:23 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Fix tests (#593)

Browse source 
* Fix unit/integration/contract tests which were broken by messaging fabric work
This commit is contained in:
cybermaggedon 2025-12-19 08:53:21 +00:00 • committed by GitHub
parent 34eb083836
commit 5304f96fe6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 461 additions and 439 deletions
Download patch file Download diff file Expand all files Collapse all files

50
tests/conftest.py Normal file
View file

@ -0,0 +1,50 @@
"""
Global pytest configuration for all tests.
This conftest.py applies to all test directories.
"""
import pytest
from unittest.mock import MagicMock
@pytest.fixture(scope="session", autouse=True)
def mock_loki_handler(session_mocker=None):
"""
Mock LokiHandler to prevent connection attempts during tests.
This fixture runs once per test session and prevents the logging
module from trying to connect to a Loki server that doesn't exist
in the test environment.
"""
# Try to import logging_loki and mock it if available
try:
import logging_loki
# Create a mock LokiHandler that does nothing
original_loki_handler = logging_loki.LokiHandler
class MockLokiHandler:
"""Mock LokiHandler that doesn't make network calls."""
def __init__(self, *args, **kwargs):
pass
def emit(self, record):
pass
def flush(self):
pass
def close(self):
pass
# Replace the real LokiHandler with our mock
logging_loki.LokiHandler = MockLokiHandler
yield
# Restore original after tests
logging_loki.LokiHandler = original_loki_handler
except ImportError:
# If logging_loki isn't installed, no need to mock
yield

2
tests/contract/test_message_contracts.py
View file

@ -257,7 +257,6 @@ class TestAgentMessageContracts:
# Act
request = AgentRequest(
question="What comes next?",
plan="Multi-step plan",
state="processing",
history=history_steps
)
@ -588,7 +587,6 @@ class TestSerializationContracts:
request = AgentRequest(
question="Test with array",
plan="Test plan",
state="Test state",
history=steps
)

2
tests/contract/test_objects_cassandra_contracts.py
View file

@ -189,6 +189,7 @@ class TestObjectsCassandraContracts:
assert result == expected_val
assert isinstance(result, expected_type) or result is None
@pytest.mark.skip(reason="ExtractedObject is a dataclass, not a Pulsar Record type")
def test_extracted_object_serialization_contract(self):
"""Test that ExtractedObject can be serialized/deserialized correctly"""
# Create test object
@ -408,6 +409,7 @@ class TestObjectsCassandraContractsBatch:
assert isinstance(single_batch_object.values[0], dict)
assert single_batch_object.values[0]["customer_id"] == "CUST999"
@pytest.mark.skip(reason="ExtractedObject is a dataclass, not a Pulsar Record type")
def test_extracted_object_batch_serialization_contract(self):
"""Test that batched ExtractedObject can be serialized/deserialized correctly"""
# Create batch object

68
tests/integration/test_import_export_graceful_shutdown.py
View file

@ -59,17 +59,17 @@ class MockWebSocket:
@pytest.fixture
def mock_pulsar_client():
"""Mock Pulsar client for integration testing."""
client = MagicMock()
def mock_backend():
"""Mock backend for integration testing."""
backend = MagicMock()
# Mock producer
producer = MagicMock()
producer.send = MagicMock()
producer.flush = MagicMock()
producer.close = MagicMock()
client.create_producer.return_value = producer
backend.create_producer.return_value = producer
# Mock consumer
consumer = MagicMock()
consumer.receive = AsyncMock()
@ -78,33 +78,31 @@ def mock_pulsar_client():
consumer.pause_message_listener = MagicMock()
consumer.unsubscribe = MagicMock()
consumer.close = MagicMock()
client.subscribe.return_value = consumer
return client
backend.create_consumer.return_value = consumer
return backend
@pytest.mark.asyncio
async def test_import_graceful_shutdown_integration():
async def test_import_graceful_shutdown_integration(mock_backend):
"""Test import path handles shutdown gracefully with real message flow."""
mock_client = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_producer = mock_backend.create_producer.return_value
# Track sent messages
sent_messages = []
def track_send(message, properties=None):
sent_messages.append((message, properties))
mock_producer.send.side_effect = track_send
ws = MockWebSocket()
running = Running()
# Create import handler
import_handler = TriplesImport(
ws=ws,
running=running,
pulsar_client=mock_client,
backend=mock_backend,
queue="test-triples-import"
)
@ -151,11 +149,9 @@ async def test_import_graceful_shutdown_integration():
@pytest.mark.asyncio
async def test_export_no_message_loss_integration():
async def test_export_no_message_loss_integration(mock_backend):
"""Test export path doesn't lose acknowledged messages."""
mock_client = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_consumer = mock_backend.create_consumer.return_value
# Create test messages
test_messages = []
@ -202,7 +198,7 @@ async def test_export_no_message_loss_integration():
export_handler = TriplesExport(
ws=ws,
running=running,
pulsar_client=mock_client,
backend=mock_backend,
queue="test-triples-export",
consumer="test-consumer",
subscriber="test-subscriber"
@ -245,14 +241,14 @@ async def test_export_no_message_loss_integration():
async def test_concurrent_import_export_shutdown():
"""Test concurrent import and export shutdown scenarios."""
# Setup mock clients
import_client = MagicMock()
export_client = MagicMock()
import_backend = MagicMock()
export_backend = MagicMock()
import_producer = MagicMock()
export_consumer = MagicMock()
import_client.create_producer.return_value = import_producer
export_client.subscribe.return_value = export_consumer
import_backend.create_producer.return_value = import_producer
export_backend.subscribe.return_value = export_consumer
# Track operations
import_operations = []
@ -280,14 +276,14 @@ async def test_concurrent_import_export_shutdown():
import_handler = TriplesImport(
ws=import_ws,
running=import_running,
pulsar_client=import_client,
backend=import_backend,
queue="concurrent-import"
)
export_handler = TriplesExport(
ws=export_ws,
running=export_running,
pulsar_client=export_client,
backend=export_backend,
queue="concurrent-export",
consumer="concurrent-consumer",
subscriber="concurrent-subscriber"
@ -328,9 +324,9 @@ async def test_concurrent_import_export_shutdown():
@pytest.mark.asyncio
async def test_websocket_close_during_message_processing():
"""Test graceful handling when websocket closes during active message processing."""
mock_client = MagicMock()
mock_backend_local = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend_local.create_producer.return_value = mock_producer
# Simulate slow message processing
processed_messages = []
@ -346,7 +342,7 @@ async def test_websocket_close_during_message_processing():
import_handler = TriplesImport(
ws=ws,
running=running,
pulsar_client=mock_client,
backend=mock_backend_local,
queue="slow-processing-import"
)
@ -395,9 +391,9 @@ async def test_websocket_close_during_message_processing():
@pytest.mark.asyncio
async def test_backpressure_during_shutdown():
"""Test graceful shutdown under backpressure conditions."""
mock_client = MagicMock()
mock_backend_local = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend_local.subscribe.return_value = mock_consumer
# Mock slow websocket
class SlowWebSocket(MockWebSocket):
@ -410,8 +406,8 @@ async def test_backpressure_during_shutdown():
export_handler = TriplesExport(
ws=ws,
running=running,
pulsar_client=mock_client,
running=running,
backend=mock_backend_local,
queue="backpressure-export",
consumer="backpressure-consumer",
subscriber="backpressure-subscriber"

21
tests/unit/test_base/test_async_processor.py
View file

@ -14,19 +14,20 @@ from trustgraph.base.async_processor import AsyncProcessor
class TestAsyncProcessorSimple(IsolatedAsyncioTestCase):
"""Test AsyncProcessor base class functionality"""
@patch('trustgraph.base.async_processor.PulsarClient')
@patch('trustgraph.base.async_processor.get_pubsub')
@patch('trustgraph.base.async_processor.Consumer')
@patch('trustgraph.base.async_processor.ProcessorMetrics')
@patch('trustgraph.base.async_processor.ConsumerMetrics')
async def test_async_processor_initialization_basic(self, mock_consumer_metrics, mock_processor_metrics,
mock_consumer, mock_pulsar_client):
async def test_async_processor_initialization_basic(self, mock_consumer_metrics, mock_processor_metrics,
mock_consumer, mock_get_pubsub):
"""Test basic AsyncProcessor initialization"""
# Arrange
mock_pulsar_client.return_value = MagicMock()
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_consumer.return_value = MagicMock()
mock_processor_metrics.return_value = MagicMock()
mock_consumer_metrics.return_value = MagicMock()
config = {
'id': 'test-async-processor',
'taskgroup': AsyncMock()
@ -42,14 +43,14 @@ class TestAsyncProcessorSimple(IsolatedAsyncioTestCase):
assert processor.running == True
assert hasattr(processor, 'config_handlers')
assert processor.config_handlers == []
# Verify PulsarClient was created
mock_pulsar_client.assert_called_once_with(**config)
# Verify get_pubsub was called to create backend
mock_get_pubsub.assert_called_once_with(**config)
# Verify metrics were initialized
mock_processor_metrics.assert_called_once()
mock_consumer_metrics.assert_called_once()
# Verify Consumer was created for config subscription
mock_consumer.assert_called_once()

50
tests/unit/test_base/test_publisher_graceful_shutdown.py
View file

@ -8,22 +8,22 @@ from trustgraph.base.publisher import Publisher
@pytest.fixture
def mock_pulsar_client():
"""Mock Pulsar client for testing."""
client = MagicMock()
def mock_pulsar_backend():
"""Mock Pulsar backend for testing."""
backend = MagicMock()
producer = AsyncMock()
producer.send = MagicMock()
producer.flush = MagicMock()
producer.close = MagicMock()
client.create_producer.return_value = producer
return client
backend.create_producer.return_value = producer
return backend
@pytest.fixture
def publisher(mock_pulsar_client):
def publisher(mock_pulsar_backend):
"""Create Publisher instance for testing."""
return Publisher(
client=mock_pulsar_client,
backend=mock_pulsar_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -34,12 +34,12 @@ def publisher(mock_pulsar_client):
@pytest.mark.asyncio
async def test_publisher_queue_drain():
"""Verify Publisher drains queue on shutdown."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -85,12 +85,12 @@ async def test_publisher_queue_drain():
@pytest.mark.asyncio
async def test_publisher_rejects_messages_during_drain():
"""Verify Publisher rejects new messages during shutdown."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -113,12 +113,12 @@ async def test_publisher_rejects_messages_during_drain():
@pytest.mark.asyncio
async def test_publisher_drain_timeout():
"""Verify Publisher respects drain timeout."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -169,12 +169,12 @@ async def test_publisher_drain_timeout():
@pytest.mark.asyncio
async def test_publisher_successful_drain():
"""Verify Publisher drains successfully under normal conditions."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -224,12 +224,12 @@ async def test_publisher_successful_drain():
@pytest.mark.asyncio
async def test_publisher_state_transitions():
"""Test Publisher state transitions during graceful shutdown."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,
@ -276,9 +276,9 @@ async def test_publisher_state_transitions():
@pytest.mark.asyncio
async def test_publisher_exception_handling():
"""Test Publisher handles exceptions during drain gracefully."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_producer = MagicMock()
mock_client.create_producer.return_value = mock_producer
mock_backend.create_producer.return_value = mock_producer
# Mock producer.send to raise exception on second call
call_count = 0
@ -291,7 +291,7 @@ async def test_publisher_exception_handling():
mock_producer.send.side_effect = failing_send
publisher = Publisher(
client=mock_client,
backend=mock_backend,
topic="test-topic",
schema=dict,
max_size=10,

90
tests/unit/test_base/test_subscriber_graceful_shutdown.py
View file

@ -6,23 +6,11 @@ import uuid
from unittest.mock import AsyncMock, MagicMock, patch
from trustgraph.base.subscriber import Subscriber
# Mock JsonSchema globally to avoid schema issues in tests
# Patch at the module level where it's imported in subscriber
@patch('trustgraph.base.subscriber.JsonSchema')
def mock_json_schema_global(mock_schema):
mock_schema.return_value = MagicMock()
return mock_schema
# Apply the global patch
_json_schema_patch = patch('trustgraph.base.subscriber.JsonSchema')
_mock_json_schema = _json_schema_patch.start()
_mock_json_schema.return_value = MagicMock()
@pytest.fixture
def mock_pulsar_client():
"""Mock Pulsar client for testing."""
client = MagicMock()
def mock_pulsar_backend():
"""Mock Pulsar backend for testing."""
backend = MagicMock()
consumer = MagicMock()
consumer.receive = MagicMock()
consumer.acknowledge = MagicMock()
@ -30,15 +18,15 @@ def mock_pulsar_client():
consumer.pause_message_listener = MagicMock()
consumer.unsubscribe = MagicMock()
consumer.close = MagicMock()
client.subscribe.return_value = consumer
return client
backend.create_consumer.return_value = consumer
return backend
@pytest.fixture
def subscriber(mock_pulsar_client):
def subscriber(mock_pulsar_backend):
"""Create Subscriber instance for testing."""
return Subscriber(
client=mock_pulsar_client,
backend=mock_pulsar_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",
@ -60,14 +48,14 @@ def create_mock_message(message_id="test-id", data=None):
@pytest.mark.asyncio
async def test_subscriber_deferred_acknowledgment_success():
"""Verify Subscriber only acks on successful delivery."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
subscription="test-subscription",
consumer_name="test-consumer",
schema=dict,
max_size=10,
@ -102,15 +90,15 @@ async def test_subscriber_deferred_acknowledgment_success():
@pytest.mark.asyncio
async def test_subscriber_deferred_acknowledgment_failure():
"""Verify Subscriber negative acks on delivery failure."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",
consumer_name="test-consumer",
schema=dict,
max_size=1, # Very small queue
backpressure_strategy="drop_new"
@ -140,14 +128,14 @@ async def test_subscriber_deferred_acknowledgment_failure():
@pytest.mark.asyncio
async def test_subscriber_backpressure_strategies():
"""Test different backpressure strategies."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
# Test drop_oldest strategy
subscriber = Subscriber(
client=mock_client,
topic="test-topic",
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",
schema=dict,
@ -187,12 +175,12 @@ async def test_subscriber_backpressure_strategies():
@pytest.mark.asyncio
async def test_subscriber_graceful_shutdown():
"""Test Subscriber graceful shutdown with queue draining."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",
@ -253,14 +241,14 @@ async def test_subscriber_graceful_shutdown():
@pytest.mark.asyncio
async def test_subscriber_drain_timeout():
"""Test Subscriber respects drain timeout."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
subscription="test-subscription",
consumer_name="test-consumer",
schema=dict,
max_size=10,
@ -288,12 +276,12 @@ async def test_subscriber_drain_timeout():
@pytest.mark.asyncio
async def test_subscriber_pending_acks_cleanup():
"""Test Subscriber cleans up pending acknowledgments on shutdown."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",
@ -342,12 +330,12 @@ async def test_subscriber_pending_acks_cleanup():
@pytest.mark.asyncio
async def test_subscriber_multiple_subscribers():
"""Test Subscriber with multiple concurrent subscribers."""
mock_client = MagicMock()
mock_backend = MagicMock()
mock_consumer = MagicMock()
mock_client.subscribe.return_value = mock_consumer
mock_backend.create_consumer.return_value = mock_consumer
subscriber = Subscriber(
client=mock_client,
backend=mock_backend,
topic="test-topic",
subscription="test-subscription",
consumer_name="test-consumer",

62
tests/unit/test_gateway/test_config_receiver.py
View file

@ -22,18 +22,18 @@ class TestConfigReceiver:
def test_config_receiver_initialization(self):
"""Test ConfigReceiver initialization"""
mock_pulsar_client = Mock()
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
config_receiver = ConfigReceiver(mock_backend)
assert config_receiver.pulsar_client == mock_pulsar_client
assert config_receiver.backend == mock_backend
assert config_receiver.flow_handlers == []
assert config_receiver.flows == {}
def test_add_handler(self):
"""Test adding flow handlers"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
handler1 = Mock()
handler2 = Mock()
@ -48,8 +48,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_with_new_flows(self):
"""Test on_config method with new flows"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Track calls manually instead of using AsyncMock
start_flow_calls = []
@ -87,8 +87,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_with_removed_flows(self):
"""Test on_config method with removed flows"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Pre-populate with existing flows
config_receiver.flows = {
@ -128,8 +128,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_with_no_flows(self):
"""Test on_config method with no flows in config"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Mock the start_flow and stop_flow methods with async functions
async def mock_start_flow(*args):
@ -158,8 +158,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_exception_handling(self):
"""Test on_config method handles exceptions gracefully"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Create mock message that will cause an exception
mock_msg = Mock()
@ -174,8 +174,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_start_flow_with_handlers(self):
"""Test start_flow method with multiple handlers"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Add mock handlers
handler1 = Mock()
@ -197,8 +197,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_start_flow_with_handler_exception(self):
"""Test start_flow method handles handler exceptions"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Add mock handler that raises exception
handler = Mock()
@ -217,8 +217,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_stop_flow_with_handlers(self):
"""Test stop_flow method with multiple handlers"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Add mock handlers
handler1 = Mock()
@ -240,8 +240,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_stop_flow_with_handler_exception(self):
"""Test stop_flow method handles handler exceptions"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Add mock handler that raises exception
handler = Mock()
@ -260,9 +260,9 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_config_loader_creates_consumer(self):
"""Test config_loader method creates Pulsar consumer"""
mock_pulsar_client = Mock()
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
config_receiver = ConfigReceiver(mock_backend)
# Temporarily restore the real config_loader for this test
config_receiver.config_loader = _real_config_loader.__get__(config_receiver)
@ -291,8 +291,8 @@ class TestConfigReceiver:
# Verify Consumer was created with correct parameters
mock_consumer_class.assert_called_once()
call_args = mock_consumer_class.call_args
assert call_args[1]['client'] == mock_pulsar_client
assert call_args[1]['backend'] == mock_backend
assert call_args[1]['subscriber'] == "gateway-test-uuid"
assert call_args[1]['handler'] == config_receiver.on_config
assert call_args[1]['start_of_messages'] is True
@ -301,8 +301,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_start_creates_config_loader_task(self, mock_create_task):
"""Test start method creates config loader task"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Mock create_task to avoid actually creating tasks with real coroutines
mock_task = Mock()
@ -320,8 +320,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_mixed_flow_operations(self):
"""Test on_config with mixed add/remove operations"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Pre-populate with existing flows
config_receiver.flows = {
@ -380,8 +380,8 @@ class TestConfigReceiver:
@pytest.mark.asyncio
async def test_on_config_invalid_json_flow_data(self):
"""Test on_config handles invalid JSON in flow data"""
mock_pulsar_client = Mock()
config_receiver = ConfigReceiver(mock_pulsar_client)
mock_backend = Mock()
config_receiver = ConfigReceiver(mock_backend)
# Mock the start_flow method with an async function
async def mock_start_flow(*args):

8
tests/unit/test_gateway/test_dispatch_config.py
View file

@ -24,10 +24,10 @@ class TestConfigRequestor:
mock_translator_registry.get_response_translator.return_value = mock_response_translator
# Mock dependencies
mock_pulsar_client = Mock()
mock_backend = Mock()
requestor = ConfigRequestor(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
consumer="test-consumer",
subscriber="test-subscriber",
timeout=60
@ -55,7 +55,7 @@ class TestConfigRequestor:
with patch.object(ServiceRequestor, 'start', return_value=None), \
patch.object(ServiceRequestor, 'process', return_value=None):
requestor = ConfigRequestor(
pulsar_client=Mock(),
backend=Mock(),
consumer="test-consumer",
subscriber="test-subscriber"
)
@ -79,7 +79,7 @@ class TestConfigRequestor:
mock_response_translator.from_response_with_completion.return_value = "translated_response"
requestor = ConfigRequestor(
pulsar_client=Mock(),
backend=Mock(),
consumer="test-consumer",
subscriber="test-subscriber"
)

128
tests/unit/test_gateway/test_dispatch_manager.py
View file

@ -39,12 +39,12 @@ class TestDispatcherManager:
def test_dispatcher_manager_initialization(self):
"""Test DispatcherManager initialization"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
assert manager.pulsar_client == mock_pulsar_client
assert manager.backend == mock_backend
assert manager.config_receiver == mock_config_receiver
assert manager.prefix == "api-gateway" # default prefix
assert manager.flows == {}
@ -55,19 +55,19 @@ class TestDispatcherManager:
def test_dispatcher_manager_initialization_with_custom_prefix(self):
"""Test DispatcherManager initialization with custom prefix"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver, prefix="custom-prefix")
manager = DispatcherManager(mock_backend, mock_config_receiver, prefix="custom-prefix")
assert manager.prefix == "custom-prefix"
@pytest.mark.asyncio
async def test_start_flow(self):
"""Test start_flow method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
flow_data = {"name": "test_flow", "steps": []}
@ -79,9 +79,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_stop_flow(self):
"""Test stop_flow method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Pre-populate with a flow
flow_data = {"name": "test_flow", "steps": []}
@ -93,9 +93,9 @@ class TestDispatcherManager:
def test_dispatch_global_service_returns_wrapper(self):
"""Test dispatch_global_service returns DispatcherWrapper"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
wrapper = manager.dispatch_global_service()
@ -104,9 +104,9 @@ class TestDispatcherManager:
def test_dispatch_core_export_returns_wrapper(self):
"""Test dispatch_core_export returns DispatcherWrapper"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
wrapper = manager.dispatch_core_export()
@ -115,9 +115,9 @@ class TestDispatcherManager:
def test_dispatch_core_import_returns_wrapper(self):
"""Test dispatch_core_import returns DispatcherWrapper"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
wrapper = manager.dispatch_core_import()
@ -127,9 +127,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_core_import(self):
"""Test process_core_import method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
with patch('trustgraph.gateway.dispatch.manager.CoreImport') as mock_core_import:
mock_importer = Mock()
@ -138,16 +138,16 @@ class TestDispatcherManager:
result = await manager.process_core_import("data", "error", "ok", "request")
mock_core_import.assert_called_once_with(mock_pulsar_client)
mock_core_import.assert_called_once_with(mock_backend)
mock_importer.process.assert_called_once_with("data", "error", "ok", "request")
assert result == "import_result"
@pytest.mark.asyncio
async def test_process_core_export(self):
"""Test process_core_export method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
with patch('trustgraph.gateway.dispatch.manager.CoreExport') as mock_core_export:
mock_exporter = Mock()
@ -156,16 +156,16 @@ class TestDispatcherManager:
result = await manager.process_core_export("data", "error", "ok", "request")
mock_core_export.assert_called_once_with(mock_pulsar_client)
mock_core_export.assert_called_once_with(mock_backend)
mock_exporter.process.assert_called_once_with("data", "error", "ok", "request")
assert result == "export_result"
@pytest.mark.asyncio
async def test_process_global_service(self):
"""Test process_global_service method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
manager.invoke_global_service = AsyncMock(return_value="global_result")
@ -178,9 +178,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_global_service_with_existing_dispatcher(self):
"""Test invoke_global_service with existing dispatcher"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Pre-populate with existing dispatcher
mock_dispatcher = Mock()
@ -195,9 +195,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_global_service_creates_new_dispatcher(self):
"""Test invoke_global_service creates new dispatcher"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
with patch('trustgraph.gateway.dispatch.manager.global_dispatchers') as mock_dispatchers:
mock_dispatcher_class = Mock()
@ -211,7 +211,7 @@ class TestDispatcherManager:
# Verify dispatcher was created with correct parameters
mock_dispatcher_class.assert_called_once_with(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
timeout=120,
consumer="api-gateway-config-request",
subscriber="api-gateway-config-request",
@ -227,9 +227,9 @@ class TestDispatcherManager:
def test_dispatch_flow_import_returns_method(self):
"""Test dispatch_flow_import returns correct method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
result = manager.dispatch_flow_import()
@ -237,9 +237,9 @@ class TestDispatcherManager:
def test_dispatch_flow_export_returns_method(self):
"""Test dispatch_flow_export returns correct method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
result = manager.dispatch_flow_export()
@ -247,9 +247,9 @@ class TestDispatcherManager:
def test_dispatch_socket_returns_method(self):
"""Test dispatch_socket returns correct method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
result = manager.dispatch_socket()
@ -257,9 +257,9 @@ class TestDispatcherManager:
def test_dispatch_flow_service_returns_wrapper(self):
"""Test dispatch_flow_service returns DispatcherWrapper"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
wrapper = manager.dispatch_flow_service()
@ -269,9 +269,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_flow_import_with_valid_flow_and_kind(self):
"""Test process_flow_import with valid flow and kind"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow
manager.flows["test_flow"] = {
@ -294,7 +294,7 @@ class TestDispatcherManager:
result = await manager.process_flow_import("ws", "running", params)
mock_dispatcher_class.assert_called_once_with(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
ws="ws",
running="running",
queue={"queue": "test_queue"}
@ -305,9 +305,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_flow_import_with_invalid_flow(self):
"""Test process_flow_import with invalid flow"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
params = {"flow": "invalid_flow", "kind": "triples"}
@ -320,9 +320,9 @@ class TestDispatcherManager:
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow
manager.flows["test_flow"] = {
@ -342,9 +342,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_flow_export_with_valid_flow_and_kind(self):
"""Test process_flow_export with valid flow and kind"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow
manager.flows["test_flow"] = {
@ -366,7 +366,7 @@ class TestDispatcherManager:
result = await manager.process_flow_export("ws", "running", params)
mock_dispatcher_class.assert_called_once_with(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
ws="ws",
running="running",
queue={"queue": "test_queue"},
@ -378,9 +378,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_socket(self):
"""Test process_socket method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
with patch('trustgraph.gateway.dispatch.manager.Mux') as mock_mux:
mock_mux_instance = Mock()
@ -394,9 +394,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_process_flow_service(self):
"""Test process_flow_service method"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
manager.invoke_flow_service = AsyncMock(return_value="flow_result")
@ -409,9 +409,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_with_existing_dispatcher(self):
"""Test invoke_flow_service with existing dispatcher"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Add flow to the flows dictionary
manager.flows["test_flow"] = {"services": {"agent": {}}}
@ -429,9 +429,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_creates_request_response_dispatcher(self):
"""Test invoke_flow_service creates request-response dispatcher"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow
manager.flows["test_flow"] = {
@ -456,7 +456,7 @@ class TestDispatcherManager:
# Verify dispatcher was created with correct parameters
mock_dispatcher_class.assert_called_once_with(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
request_queue="agent_request_queue",
response_queue="agent_response_queue",
timeout=120,
@ -473,9 +473,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_creates_sender_dispatcher(self):
"""Test invoke_flow_service creates sender dispatcher"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow
manager.flows["test_flow"] = {
@ -500,7 +500,7 @@ class TestDispatcherManager:
# Verify dispatcher was created with correct parameters
mock_dispatcher_class.assert_called_once_with(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue={"queue": "text_load_queue"}
)
mock_dispatcher.start.assert_called_once()
@ -513,9 +513,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_invalid_flow(self):
"""Test invoke_flow_service with invalid flow"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
with pytest.raises(RuntimeError, match="Invalid flow"):
await manager.invoke_flow_service("data", "responder", "invalid_flow", "agent")
@ -523,9 +523,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_unsupported_kind_by_flow(self):
"""Test invoke_flow_service with kind not supported by flow"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow without agent interface
manager.flows["test_flow"] = {
@ -540,9 +540,9 @@ class TestDispatcherManager:
@pytest.mark.asyncio
async def test_invoke_flow_service_invalid_kind(self):
"""Test invoke_flow_service with invalid kind"""
mock_pulsar_client = Mock()
mock_backend = Mock()
mock_config_receiver = Mock()
manager = DispatcherManager(mock_pulsar_client, mock_config_receiver)
manager = DispatcherManager(mock_backend, mock_config_receiver)
# Setup test flow with interface but unsupported kind
manager.flows["test_flow"] = {

22
tests/unit/test_gateway/test_dispatch_requestor.py
View file

@ -15,12 +15,12 @@ class TestServiceRequestor:
@patch('trustgraph.gateway.dispatch.requestor.Subscriber')
def test_service_requestor_initialization(self, mock_subscriber, mock_publisher):
"""Test ServiceRequestor initialization"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_request_schema = MagicMock()
mock_response_schema = MagicMock()
requestor = ServiceRequestor(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
request_queue="test-request-queue",
request_schema=mock_request_schema,
response_queue="test-response-queue",
@ -32,12 +32,12 @@ class TestServiceRequestor:
# Verify Publisher was created correctly
mock_publisher.assert_called_once_with(
mock_pulsar_client, "test-request-queue", schema=mock_request_schema
mock_backend, "test-request-queue", schema=mock_request_schema
)
# Verify Subscriber was created correctly
mock_subscriber.assert_called_once_with(
mock_pulsar_client, "test-response-queue",
mock_backend, "test-response-queue",
"test-subscription", "test-consumer", mock_response_schema
)
@ -48,12 +48,12 @@ class TestServiceRequestor:
@patch('trustgraph.gateway.dispatch.requestor.Subscriber')
def test_service_requestor_with_defaults(self, mock_subscriber, mock_publisher):
"""Test ServiceRequestor initialization with default parameters"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_request_schema = MagicMock()
mock_response_schema = MagicMock()
requestor = ServiceRequestor(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
request_queue="test-queue",
request_schema=mock_request_schema,
response_queue="response-queue",
@ -62,7 +62,7 @@ class TestServiceRequestor:
# Verify default values
mock_subscriber.assert_called_once_with(
mock_pulsar_client, "response-queue",
mock_backend, "response-queue",
"api-gateway", "api-gateway", mock_response_schema
)
assert requestor.timeout == 600 # Default timeout
@ -72,14 +72,14 @@ class TestServiceRequestor:
@pytest.mark.asyncio
async def test_service_requestor_start(self, mock_subscriber, mock_publisher):
"""Test ServiceRequestor start method"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_sub_instance = AsyncMock()
mock_pub_instance = AsyncMock()
mock_subscriber.return_value = mock_sub_instance
mock_publisher.return_value = mock_pub_instance
requestor = ServiceRequestor(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
request_queue="test-queue",
request_schema=MagicMock(),
response_queue="response-queue",
@ -98,14 +98,14 @@ class TestServiceRequestor:
@patch('trustgraph.gateway.dispatch.requestor.Subscriber')
def test_service_requestor_attributes(self, mock_subscriber, mock_publisher):
"""Test ServiceRequestor has correct attributes"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_pub_instance = AsyncMock()
mock_sub_instance = AsyncMock()
mock_publisher.return_value = mock_pub_instance
mock_subscriber.return_value = mock_sub_instance
requestor = ServiceRequestor(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
request_queue="test-queue",
request_schema=MagicMock(),
response_queue="response-queue",

16
tests/unit/test_gateway/test_dispatch_sender.py
View file

@ -14,18 +14,18 @@ class TestServiceSender:
@patch('trustgraph.gateway.dispatch.sender.Publisher')
def test_service_sender_initialization(self, mock_publisher):
"""Test ServiceSender initialization"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_schema = MagicMock()
sender = ServiceSender(
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue",
schema=mock_schema
)
# Verify Publisher was created correctly
mock_publisher.assert_called_once_with(
mock_pulsar_client, "test-queue", schema=mock_schema
mock_backend, "test-queue", schema=mock_schema
)
@patch('trustgraph.gateway.dispatch.sender.Publisher')
@ -36,7 +36,7 @@ class TestServiceSender:
mock_publisher.return_value = mock_pub_instance
sender = ServiceSender(
pulsar_client=MagicMock(),
backend=MagicMock(),
queue="test-queue",
schema=MagicMock()
)
@ -55,7 +55,7 @@ class TestServiceSender:
mock_publisher.return_value = mock_pub_instance
sender = ServiceSender(
pulsar_client=MagicMock(),
backend=MagicMock(),
queue="test-queue",
schema=MagicMock()
)
@ -70,7 +70,7 @@ class TestServiceSender:
def test_service_sender_to_request_not_implemented(self, mock_publisher):
"""Test ServiceSender to_request method raises RuntimeError"""
sender = ServiceSender(
pulsar_client=MagicMock(),
backend=MagicMock(),
queue="test-queue",
schema=MagicMock()
)
@ -91,7 +91,7 @@ class TestServiceSender:
return {"processed": request}
sender = ConcreteSender(
pulsar_client=MagicMock(),
backend=MagicMock(),
queue="test-queue",
schema=MagicMock()
)
@ -111,7 +111,7 @@ class TestServiceSender:
mock_publisher.return_value = mock_pub_instance
sender = ServiceSender(
pulsar_client=MagicMock(),
backend=MagicMock(),
queue="test-queue",
schema=MagicMock()
)

60
tests/unit/test_gateway/test_objects_import_dispatcher.py
View file

@ -16,7 +16,7 @@ from trustgraph.schema import Metadata, ExtractedObject
@pytest.fixture
def mock_pulsar_client():
def mock_backend():
"""Mock Pulsar client."""
client = Mock()
return client
@ -96,7 +96,7 @@ class TestObjectsImportInitialization:
"""Test ObjectsImport initialization."""
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
def test_init_creates_publisher_with_correct_params(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
def test_init_creates_publisher_with_correct_params(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that ObjectsImport creates Publisher with correct parameters."""
mock_publisher_instance = Mock()
mock_publisher_class.return_value = mock_publisher_instance
@ -104,13 +104,13 @@ class TestObjectsImportInitialization:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-objects-queue"
)
# Verify Publisher was created with correct parameters
mock_publisher_class.assert_called_once_with(
mock_pulsar_client,
mock_backend,
topic="test-objects-queue",
schema=ExtractedObject
)
@ -121,12 +121,12 @@ class TestObjectsImportInitialization:
assert objects_import.publisher == mock_publisher_instance
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
def test_init_stores_references_correctly(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
def test_init_stores_references_correctly(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that ObjectsImport stores all required references."""
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="objects-queue"
)
@ -139,7 +139,7 @@ class TestObjectsImportLifecycle:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_start_calls_publisher_start(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_start_calls_publisher_start(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that start() calls publisher.start()."""
mock_publisher_instance = Mock()
mock_publisher_instance.start = AsyncMock()
@ -148,7 +148,7 @@ class TestObjectsImportLifecycle:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -158,7 +158,7 @@ class TestObjectsImportLifecycle:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_destroy_stops_and_closes_properly(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_destroy_stops_and_closes_properly(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that destroy() properly stops publisher and closes websocket."""
mock_publisher_instance = Mock()
mock_publisher_instance.stop = AsyncMock()
@ -167,7 +167,7 @@ class TestObjectsImportLifecycle:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -180,7 +180,7 @@ class TestObjectsImportLifecycle:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_destroy_handles_none_websocket(self, mock_publisher_class, mock_pulsar_client, mock_running):
async def test_destroy_handles_none_websocket(self, mock_publisher_class, mock_backend, mock_running):
"""Test that destroy() handles None websocket gracefully."""
mock_publisher_instance = Mock()
mock_publisher_instance.stop = AsyncMock()
@ -189,7 +189,7 @@ class TestObjectsImportLifecycle:
objects_import = ObjectsImport(
ws=None, # None websocket
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -205,7 +205,7 @@ class TestObjectsImportMessageProcessing:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_processes_full_message_correctly(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running, sample_objects_message):
async def test_receive_processes_full_message_correctly(self, mock_publisher_class, mock_backend, mock_websocket, mock_running, sample_objects_message):
"""Test that receive() processes complete message correctly."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock()
@ -214,7 +214,7 @@ class TestObjectsImportMessageProcessing:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -248,7 +248,7 @@ class TestObjectsImportMessageProcessing:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_handles_minimal_message(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running, minimal_objects_message):
async def test_receive_handles_minimal_message(self, mock_publisher_class, mock_backend, mock_websocket, mock_running, minimal_objects_message):
"""Test that receive() handles message with minimal required fields."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock()
@ -257,7 +257,7 @@ class TestObjectsImportMessageProcessing:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -281,7 +281,7 @@ class TestObjectsImportMessageProcessing:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_uses_default_values(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_receive_uses_default_values(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that receive() uses appropriate default values for optional fields."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock()
@ -290,7 +290,7 @@ class TestObjectsImportMessageProcessing:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -323,7 +323,7 @@ class TestObjectsImportRunMethod:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@patch('trustgraph.gateway.dispatch.objects_import.asyncio.sleep')
@pytest.mark.asyncio
async def test_run_loops_while_running(self, mock_sleep, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_run_loops_while_running(self, mock_sleep, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that run() loops while running.get() returns True."""
mock_sleep.return_value = None
mock_publisher_class.return_value = Mock()
@ -334,7 +334,7 @@ class TestObjectsImportRunMethod:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -353,7 +353,7 @@ class TestObjectsImportRunMethod:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@patch('trustgraph.gateway.dispatch.objects_import.asyncio.sleep')
@pytest.mark.asyncio
async def test_run_handles_none_websocket_gracefully(self, mock_sleep, mock_publisher_class, mock_pulsar_client, mock_running):
async def test_run_handles_none_websocket_gracefully(self, mock_sleep, mock_publisher_class, mock_backend, mock_running):
"""Test that run() handles None websocket gracefully."""
mock_sleep.return_value = None
mock_publisher_class.return_value = Mock()
@ -363,7 +363,7 @@ class TestObjectsImportRunMethod:
objects_import = ObjectsImport(
ws=None, # None websocket
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -417,7 +417,7 @@ class TestObjectsImportBatchProcessing:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_processes_batch_message_correctly(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running, batch_objects_message):
async def test_receive_processes_batch_message_correctly(self, mock_publisher_class, mock_backend, mock_websocket, mock_running, batch_objects_message):
"""Test that receive() processes batch message correctly."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock()
@ -426,7 +426,7 @@ class TestObjectsImportBatchProcessing:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -467,7 +467,7 @@ class TestObjectsImportBatchProcessing:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_handles_empty_batch(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_receive_handles_empty_batch(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that receive() handles empty batch correctly."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock()
@ -476,7 +476,7 @@ class TestObjectsImportBatchProcessing:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -507,7 +507,7 @@ class TestObjectsImportErrorHandling:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_propagates_publisher_errors(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running, sample_objects_message):
async def test_receive_propagates_publisher_errors(self, mock_publisher_class, mock_backend, mock_websocket, mock_running, sample_objects_message):
"""Test that receive() propagates publisher send errors."""
mock_publisher_instance = Mock()
mock_publisher_instance.send = AsyncMock(side_effect=Exception("Publisher error"))
@ -516,7 +516,7 @@ class TestObjectsImportErrorHandling:
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)
@ -528,14 +528,14 @@ class TestObjectsImportErrorHandling:
@patch('trustgraph.gateway.dispatch.objects_import.Publisher')
@pytest.mark.asyncio
async def test_receive_handles_malformed_json(self, mock_publisher_class, mock_pulsar_client, mock_websocket, mock_running):
async def test_receive_handles_malformed_json(self, mock_publisher_class, mock_backend, mock_websocket, mock_running):
"""Test that receive() handles malformed JSON appropriately."""
mock_publisher_class.return_value = Mock()
objects_import = ObjectsImport(
ws=mock_websocket,
running=mock_running,
pulsar_client=mock_pulsar_client,
backend=mock_backend,
queue="test-queue"
)

101
tests/unit/test_gateway/test_service.py
View file

@ -19,23 +19,21 @@ class TestApi:
def test_api_initialization_with_defaults(self):
"""Test Api initialization with default values"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_backend = Mock()
mock_get_pubsub.return_value = mock_backend
api = Api()
assert api.port == default_port
assert api.timeout == default_timeout
assert api.pulsar_host == default_pulsar_host
assert api.pulsar_api_key is None
assert api.prometheus_url == default_prometheus_url + "/"
assert api.auth.allow_all is True
# Verify Pulsar client was created without API key
mock_client.assert_called_once_with(
default_pulsar_host,
listener_name=None
)
# Verify get_pubsub was called
mock_get_pubsub.assert_called_once()
def test_api_initialization_with_custom_config(self):
"""Test Api initialization with custom configuration"""
@ -48,14 +46,13 @@ class TestApi:
"prometheus_url": "http://custom-prometheus:9090",
"api_token": "secret-token"
}
with patch('pulsar.Client') as mock_client, \
patch('pulsar.AuthenticationToken') as mock_auth:
mock_client.return_value = Mock()
mock_auth.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_backend = Mock()
mock_get_pubsub.return_value = mock_backend
api = Api(**config)
assert api.port == 9000
assert api.timeout == 300
assert api.pulsar_host == "pulsar://custom-host:6650"
@ -63,35 +60,25 @@ class TestApi:
assert api.prometheus_url == "http://custom-prometheus:9090/"
assert api.auth.token == "secret-token"
assert api.auth.allow_all is False
# Verify Pulsar client was created with API key
mock_auth.assert_called_once_with("test-api-key")
mock_client.assert_called_once_with(
"pulsar://custom-host:6650",
listener_name="custom-listener",
authentication=mock_auth.return_value
)
# Verify get_pubsub was called with config
mock_get_pubsub.assert_called_once_with(**config)
def test_api_initialization_with_pulsar_api_key(self):
"""Test Api initialization with Pulsar API key authentication"""
with patch('pulsar.Client') as mock_client, \
patch('pulsar.AuthenticationToken') as mock_auth:
mock_client.return_value = Mock()
mock_auth.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api(pulsar_api_key="test-key")
mock_auth.assert_called_once_with("test-key")
mock_client.assert_called_once_with(
default_pulsar_host,
listener_name=None,
authentication=mock_auth.return_value
)
# Verify api key was stored
assert api.pulsar_api_key == "test-key"
mock_get_pubsub.assert_called_once()
def test_api_initialization_prometheus_url_normalization(self):
"""Test that prometheus_url gets normalized with trailing slash"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
# Test URL without trailing slash
api = Api(prometheus_url="http://prometheus:9090")
@ -103,16 +90,16 @@ class TestApi:
def test_api_initialization_empty_api_token_means_no_auth(self):
"""Test that empty API token results in allow_all authentication"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api(api_token="")
assert api.auth.allow_all is True
def test_api_initialization_none_api_token_means_no_auth(self):
"""Test that None API token results in allow_all authentication"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api(api_token=None)
assert api.auth.allow_all is True
@ -120,8 +107,8 @@ class TestApi:
@pytest.mark.asyncio
async def test_app_factory_creates_application(self):
"""Test that app_factory creates aiohttp application"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api()
@ -147,8 +134,8 @@ class TestApi:
@pytest.mark.asyncio
async def test_app_factory_with_custom_endpoints(self):
"""Test app_factory with custom endpoints"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api()
@ -180,13 +167,13 @@ class TestApi:
def test_run_method_calls_web_run_app(self):
"""Test that run method calls web.run_app"""
with patch('pulsar.Client') as mock_client, \
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub, \
patch('aiohttp.web.run_app') as mock_run_app:
mock_client.return_value = Mock()
mock_get_pubsub.return_value = Mock()
api = Api(port=8080)
api.run()
# Verify run_app was called once with the correct port
mock_run_app.assert_called_once()
args, kwargs = mock_run_app.call_args
@ -195,19 +182,19 @@ class TestApi:
def test_api_components_initialization(self):
"""Test that all API components are properly initialized"""
with patch('pulsar.Client') as mock_client:
mock_client.return_value = Mock()
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
mock_get_pubsub.return_value = Mock()
api = Api()
# Verify all components are initialized
assert api.config_receiver is not None
assert api.dispatcher_manager is not None
assert api.endpoint_manager is not None
assert api.endpoints == []
# Verify component relationships
assert api.dispatcher_manager.pulsar_client == api.pulsar_client
assert api.dispatcher_manager.backend == api.pubsub_backend
assert api.dispatcher_manager.config_receiver == api.config_receiver
assert api.endpoint_manager.dispatcher_manager == api.dispatcher_manager
# EndpointManager doesn't store auth directly, it passes it to individual endpoints

18
tests/unit/test_retrieval/test_structured_diag/test_schema_contracts.py
View file

@ -23,9 +23,9 @@ class TestStructuredDiagnosisSchemaContract:
assert request.operation == "detect-type"
assert request.sample == "test data"
assert request.type is None # Optional, defaults to None
assert request.schema_name is None # Optional, defaults to None
assert request.options is None # Optional, defaults to None
assert request.type == "" # Optional, defaults to empty string
assert request.schema_name == "" # Optional, defaults to empty string
assert request.options == {} # Optional, defaults to empty dict
def test_request_schema_all_operations(self):
"""Test request schema supports all operations"""
@ -66,9 +66,9 @@ class TestStructuredDiagnosisSchemaContract:
assert response.detected_type == "xml"
assert response.confidence == 0.9
assert response.error is None
assert response.descriptor is None
assert response.metadata is None
assert response.schema_matches is None # New field, defaults to None
assert response.descriptor == "" # Defaults to empty string
assert response.metadata == {} # Defaults to empty dict
assert response.schema_matches == [] # Defaults to empty list
def test_response_schema_with_error(self):
"""Test response schema with error"""
@ -140,6 +140,7 @@ class TestStructuredDiagnosisSchemaContract:
assert response.metadata == metadata
assert response.metadata["field_count"] == "5"
@pytest.mark.skip(reason="JsonSchema requires Pulsar Record types, not dataclasses")
def test_schema_serialization(self):
"""Test that schemas can be serialized and deserialized correctly"""
# Test request serialization
@ -158,6 +159,7 @@ class TestStructuredDiagnosisSchemaContract:
assert deserialized.sample == request.sample
assert deserialized.options == request.options
@pytest.mark.skip(reason="JsonSchema requires Pulsar Record types, not dataclasses")
def test_response_serialization_with_schema_matches(self):
"""Test response serialization with schema_matches array"""
response = StructuredDataDiagnosisResponse(
@ -185,7 +187,7 @@ class TestStructuredDiagnosisSchemaContract:
)
# Verify default value for new field
assert response.schema_matches is None # Defaults to None when not set
assert response.schema_matches == [] # Defaults to empty list when not set
# Verify old fields still work
assert response.detected_type == "json"
@ -221,7 +223,7 @@ class TestStructuredDiagnosisSchemaContract:
)
assert error_response.error is not None
assert error_response.schema_matches is None # Default None when not set
assert error_response.schema_matches == [] # Default empty list when not set
def test_all_operations_supported(self):
"""Verify all operations are properly supported in the contract"""

10
tests/unit/test_rev_gateway/test_dispatcher.py
View file

@ -72,7 +72,7 @@ class TestMessageDispatcher:
assert dispatcher.max_workers == 10
assert dispatcher.semaphore._value == 10
assert dispatcher.active_tasks == set()
assert dispatcher.pulsar_client is None
assert dispatcher.backend is None
assert dispatcher.dispatcher_manager is None
assert len(dispatcher.service_mapping) > 0
@ -86,7 +86,7 @@ class TestMessageDispatcher:
@patch('trustgraph.rev_gateway.dispatcher.DispatcherManager')
def test_message_dispatcher_initialization_with_pulsar_client(self, mock_dispatcher_manager):
"""Test MessageDispatcher initialization with pulsar_client and config_receiver"""
mock_pulsar_client = MagicMock()
mock_backend = MagicMock()
mock_config_receiver = MagicMock()
mock_dispatcher_instance = MagicMock()
mock_dispatcher_manager.return_value = mock_dispatcher_instance
@ -94,14 +94,14 @@ class TestMessageDispatcher:
dispatcher = MessageDispatcher(
max_workers=8,
config_receiver=mock_config_receiver,
pulsar_client=mock_pulsar_client
backend=mock_backend
)
assert dispatcher.max_workers == 8
assert dispatcher.pulsar_client == mock_pulsar_client
assert dispatcher.backend == mock_backend
assert dispatcher.dispatcher_manager == mock_dispatcher_instance
mock_dispatcher_manager.assert_called_once_with(
mock_pulsar_client, mock_config_receiver, prefix="rev-gateway"
mock_backend, mock_config_receiver, prefix="rev-gateway"
)
def test_message_dispatcher_service_mapping(self):

186
tests/unit/test_rev_gateway/test_rev_gateway_service.py
View file

@ -16,11 +16,11 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_initialization_defaults(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_initialization_defaults(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway initialization with default parameters"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
@ -38,11 +38,11 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_initialization_custom_params(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_initialization_custom_params(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway initialization with custom parameters"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway(
websocket_uri="wss://example.com:8080/websocket",
@ -65,11 +65,11 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_initialization_with_missing_path(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_initialization_with_missing_path(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway initialization with WebSocket URI missing path"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway(websocket_uri="ws://example.com")
@ -78,53 +78,49 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_initialization_invalid_scheme(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_initialization_invalid_scheme(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway initialization with invalid WebSocket scheme"""
with pytest.raises(ValueError, match="WebSocket URI must use ws:// or wss:// scheme"):
ReverseGateway(websocket_uri="http://example.com")
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_initialization_missing_hostname(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_initialization_missing_hostname(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway initialization with missing hostname"""
with pytest.raises(ValueError, match="WebSocket URI must include hostname"):
ReverseGateway(websocket_uri="ws://")
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_pulsar_client_with_auth(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway creates Pulsar client with authentication"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
with patch('pulsar.AuthenticationToken') as mock_auth:
mock_auth_instance = MagicMock()
mock_auth.return_value = mock_auth_instance
gateway = ReverseGateway(
pulsar_api_key="test-key",
pulsar_listener="test-listener"
)
mock_auth.assert_called_once_with("test-key")
mock_pulsar_client.assert_called_once_with(
"pulsar://pulsar:6650",
listener_name="test-listener",
authentication=mock_auth_instance
)
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_pulsar_client_with_auth(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway creates backend with authentication"""
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway(
pulsar_api_key="test-key",
pulsar_listener="test-listener"
)
# Verify get_pubsub was called with the correct parameters
mock_get_pubsub.assert_called_once_with(
pulsar_host="pulsar://pulsar:6650",
pulsar_api_key="test-key",
pulsar_listener="test-listener"
)
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@patch('trustgraph.rev_gateway.service.ClientSession')
@pytest.mark.asyncio
async def test_reverse_gateway_connect_success(self, mock_session_class, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_connect_success(self, mock_session_class, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway successful connection"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_session = AsyncMock()
mock_ws = AsyncMock()
@ -142,13 +138,13 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@patch('trustgraph.rev_gateway.service.ClientSession')
@pytest.mark.asyncio
async def test_reverse_gateway_connect_failure(self, mock_session_class, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_connect_failure(self, mock_session_class, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway connection failure"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_session = AsyncMock()
mock_session.ws_connect.side_effect = Exception("Connection failed")
@ -162,12 +158,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_disconnect(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_disconnect(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway disconnect"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
@ -189,12 +185,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_send_message(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_send_message(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway send message"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
@ -211,12 +207,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_send_message_closed_connection(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_send_message_closed_connection(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway send message with closed connection"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
@ -234,12 +230,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_handle_message(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_handle_message(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway handle message"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_dispatcher_instance = AsyncMock()
mock_dispatcher_instance.handle_message.return_value = {"response": "success"}
@ -263,12 +259,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_handle_message_invalid_json(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_handle_message_invalid_json(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway handle message with invalid JSON"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
@ -285,12 +281,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_listen_text_message(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_listen_text_message(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway listen with text message"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
gateway.running = True
@ -318,12 +314,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_listen_binary_message(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_listen_binary_message(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway listen with binary message"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
gateway.running = True
@ -351,12 +347,12 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_listen_close_message(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_listen_close_message(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway listen with close message"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
gateway.running = True
@ -383,36 +379,36 @@ class TestReverseGateway:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_shutdown(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_shutdown(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway shutdown"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_dispatcher_instance = AsyncMock()
mock_dispatcher.return_value = mock_dispatcher_instance
gateway = ReverseGateway()
gateway.running = True
# Mock disconnect
gateway.disconnect = AsyncMock()
await gateway.shutdown()
assert gateway.running is False
mock_dispatcher_instance.shutdown.assert_called_once()
gateway.disconnect.assert_called_once()
mock_client_instance.close.assert_called_once()
mock_backend.close.assert_called_once()
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
def test_reverse_gateway_stop(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
@patch('trustgraph.rev_gateway.service.get_pubsub')
def test_reverse_gateway_stop(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway stop"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
gateway = ReverseGateway()
gateway.running = True
@ -427,12 +423,12 @@ class TestReverseGatewayRun:
@patch('trustgraph.rev_gateway.service.ConfigReceiver')
@patch('trustgraph.rev_gateway.service.MessageDispatcher')
@patch('pulsar.Client')
@patch('trustgraph.rev_gateway.service.get_pubsub')
@pytest.mark.asyncio
async def test_reverse_gateway_run_successful_cycle(self, mock_pulsar_client, mock_dispatcher, mock_config_receiver):
async def test_reverse_gateway_run_successful_cycle(self, mock_get_pubsub, mock_dispatcher, mock_config_receiver):
"""Test ReverseGateway run method with successful connect/listen cycle"""
mock_client_instance = MagicMock()
mock_pulsar_client.return_value = mock_client_instance
mock_backend = MagicMock()
mock_get_pubsub.return_value = mock_backend
mock_config_receiver_instance = AsyncMock()
mock_config_receiver.return_value = mock_config_receiver_instance

2
trustgraph-base/trustgraph/base/__init__.py
View file

@ -1,5 +1,5 @@
from . pubsub import PulsarClient
from . pubsub import PulsarClient, get_pubsub
from . async_processor import AsyncProcessor
from . consumer import Consumer
from . producer import Producer

4
trustgraph-base/trustgraph/messaging/translators/diagnosis.py
View file

@ -57,7 +57,9 @@ class StructuredDataDiagnosisResponseTranslator(MessageTranslator):
result["descriptor"] = obj.descriptor
if obj.metadata:
result["metadata"] = obj.metadata
if obj.schema_matches is not None:
# For schema-selection, always include schema_matches (even if empty)
# For other operations, only include if non-empty
if obj.operation == "schema-selection" or obj.schema_matches:
result["schema-matches"] = obj.schema_matches
return result