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

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",