mirror of
https://github.com/trustgraph-ai/trustgraph.git
synced 2026-04-25 08:26:21 +02:00
c23e28aa66
The Metadata dataclass dropped its `metadata: list[Triple]` field
and EntityEmbeddings/ChunkEmbeddings settled on a singular
`vector: list[float]` field, but several call sites kept passing
`Metadata(metadata=...)` and `EntityEmbeddings(vectors=...)`. The
bugs were latent until a websocket client first hit
`/api/v1/flow/default/import/entity-contexts`, at which point the
dispatcher TypeError'd on construction.
Production fixes (5 call sites on the same migration tail):
* trustgraph-flow gateway dispatchers entity_contexts_import.py
and graph_embeddings_import.py — drop the stale
Metadata(metadata=...) kwarg; switch graph_embeddings_import
to the singular `vector` wire key.
* trustgraph-base messaging translators knowledge.py and
document_loading.py — fix decode side to read the singular
`"vector"` key, matching what their own encode sides have
always written.
* trustgraph-flow tables/knowledge.py — fix Cassandra row
deserialiser to construct EntityEmbeddings(vector=...)
instead of vectors=.
* trustgraph-flow gateway core_import/core_export — switch the
kg-core msgpack wire format to the singular `"v"`/`"vector"`
key and drop the dead `m["m"]` envelope field that referenced
the removed Metadata.metadata triples list (it was a
guaranteed KeyError on the export side).
Defense-in-depth regression coverage (32 new tests across 7 files):
* tests/contract/test_schema_field_contracts.py — pin the field
set of Metadata, EntityEmbeddings, ChunkEmbeddings,
EntityContext so any future schema rename fails CI loudly
with a clear diff.
* tests/unit/test_translators/test_knowledge_translator_roundtrip.py
and test_document_embeddings_translator_roundtrip.py -
encode→decode round-trip the affected translators end to end,
locking in the singular `"vector"` wire key.
* tests/unit/test_gateway/test_entity_contexts_import_dispatcher.py
and test_graph_embeddings_import_dispatcher.py — exercise the
websocket dispatchers' receive() path with realistic
payloads, the direct regression test for the original
production crash.
* tests/unit/test_gateway/test_core_import_export_roundtrip.py
— pack/unpack the kg-core msgpack format through the real
dispatcher classes (with KnowledgeRequestor mocked),
including a full export→import round-trip.
* tests/unit/test_tables/test_knowledge_table_store.py —
exercise the Cassandra row → schema conversion via __new__ to
bypass the live cluster connection.
Also fixes an unrelated leaked-coroutine RuntimeWarning in
test_gateway/test_service.py::test_run_method_calls_web_run_app: the
mocked aiohttp.web.run_app now closes the coroutine that Api.run() hands
it, mirroring what the real run_app would do, instead of leaving it for
the GC to complain about.
355 lines
No EOL
15 KiB
Python
355 lines
No EOL
15 KiB
Python
"""
|
|
Tests for Gateway Service API
|
|
"""
|
|
|
|
import pytest
|
|
import asyncio
|
|
from unittest.mock import Mock, patch, MagicMock, AsyncMock
|
|
from aiohttp import web
|
|
import pulsar
|
|
|
|
from trustgraph.gateway.service import Api, run, default_pulsar_host, default_prometheus_url, default_timeout, default_port, default_api_token
|
|
|
|
# Tests for Gateway Service API
|
|
|
|
|
|
class TestApi:
|
|
"""Test cases for Api class"""
|
|
|
|
|
|
def test_api_initialization_with_defaults(self):
|
|
"""Test Api initialization with default values"""
|
|
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 get_pubsub was called
|
|
mock_get_pubsub.assert_called_once()
|
|
|
|
def test_api_initialization_with_custom_config(self):
|
|
"""Test Api initialization with custom configuration"""
|
|
config = {
|
|
"port": 9000,
|
|
"timeout": 300,
|
|
"pulsar_host": "pulsar://custom-host:6650",
|
|
"pulsar_api_key": "test-api-key",
|
|
"pulsar_listener": "custom-listener",
|
|
"prometheus_url": "http://custom-prometheus:9090",
|
|
"api_token": "secret-token"
|
|
}
|
|
|
|
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"
|
|
assert api.pulsar_api_key == "test-api-key"
|
|
assert api.prometheus_url == "http://custom-prometheus:9090/"
|
|
assert api.auth.token == "secret-token"
|
|
assert api.auth.allow_all is False
|
|
|
|
# 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('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
|
|
mock_get_pubsub.return_value = Mock()
|
|
|
|
api = Api(pulsar_api_key="test-key")
|
|
|
|
# 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('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")
|
|
assert api.prometheus_url == "http://prometheus:9090/"
|
|
|
|
# Test URL with trailing slash
|
|
api = Api(prometheus_url="http://prometheus:9090/")
|
|
assert api.prometheus_url == "http://prometheus:9090/"
|
|
|
|
def test_api_initialization_empty_api_token_means_no_auth(self):
|
|
"""Test that empty API token results in allow_all authentication"""
|
|
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('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
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_app_factory_creates_application(self):
|
|
"""Test that app_factory creates aiohttp application"""
|
|
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
|
|
mock_get_pubsub.return_value = Mock()
|
|
|
|
api = Api()
|
|
|
|
# Mock the dependencies
|
|
api.config_receiver = Mock()
|
|
api.config_receiver.start = AsyncMock()
|
|
api.endpoint_manager = Mock()
|
|
api.endpoint_manager.add_routes = Mock()
|
|
api.endpoint_manager.start = AsyncMock()
|
|
|
|
app = await api.app_factory()
|
|
|
|
assert isinstance(app, web.Application)
|
|
assert app._client_max_size == 256 * 1024 * 1024
|
|
|
|
# Verify that config receiver was started
|
|
api.config_receiver.start.assert_called_once()
|
|
|
|
# Verify that endpoint manager was configured
|
|
api.endpoint_manager.add_routes.assert_called_once_with(app)
|
|
api.endpoint_manager.start.assert_called_once()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_app_factory_with_custom_endpoints(self):
|
|
"""Test app_factory with custom endpoints"""
|
|
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub:
|
|
mock_get_pubsub.return_value = Mock()
|
|
|
|
api = Api()
|
|
|
|
# Mock custom endpoints
|
|
mock_endpoint1 = Mock()
|
|
mock_endpoint1.add_routes = Mock()
|
|
mock_endpoint1.start = AsyncMock()
|
|
|
|
mock_endpoint2 = Mock()
|
|
mock_endpoint2.add_routes = Mock()
|
|
mock_endpoint2.start = AsyncMock()
|
|
|
|
api.endpoints = [mock_endpoint1, mock_endpoint2]
|
|
|
|
# Mock the dependencies
|
|
api.config_receiver = Mock()
|
|
api.config_receiver.start = AsyncMock()
|
|
api.endpoint_manager = Mock()
|
|
api.endpoint_manager.add_routes = Mock()
|
|
api.endpoint_manager.start = AsyncMock()
|
|
|
|
app = await api.app_factory()
|
|
|
|
# Verify custom endpoints were configured
|
|
mock_endpoint1.add_routes.assert_called_once_with(app)
|
|
mock_endpoint1.start.assert_called_once()
|
|
mock_endpoint2.add_routes.assert_called_once_with(app)
|
|
mock_endpoint2.start.assert_called_once()
|
|
|
|
def test_run_method_calls_web_run_app(self):
|
|
"""Test that run method calls web.run_app"""
|
|
with patch('trustgraph.gateway.service.get_pubsub') as mock_get_pubsub, \
|
|
patch('aiohttp.web.run_app') as mock_run_app:
|
|
mock_get_pubsub.return_value = Mock()
|
|
|
|
# Api.run() passes self.app_factory() — a coroutine — to
|
|
# web.run_app, which would normally consume it inside its own
|
|
# event loop. Since we mock run_app, close the coroutine here
|
|
# so it doesn't leak as an "unawaited coroutine" RuntimeWarning.
|
|
def _consume_coro(coro, **kwargs):
|
|
coro.close()
|
|
mock_run_app.side_effect = _consume_coro
|
|
|
|
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
|
|
assert len(args) == 1 # Should have one positional arg (the coroutine)
|
|
assert kwargs == {'port': 8080} # Should have port keyword arg
|
|
|
|
def test_api_components_initialization(self):
|
|
"""Test that all API components are properly initialized"""
|
|
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.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
|
|
|
|
|
|
class TestRunFunction:
|
|
"""Test cases for the run() function"""
|
|
|
|
def test_run_function_with_metrics_enabled(self):
|
|
"""Test run function with metrics enabled"""
|
|
import warnings
|
|
# Suppress the specific async warning with a broader pattern
|
|
warnings.filterwarnings("ignore", message=".*Api.app_factory.*was never awaited", category=RuntimeWarning)
|
|
|
|
with patch('argparse.ArgumentParser.parse_args') as mock_parse_args, \
|
|
patch('trustgraph.gateway.service.start_http_server') as mock_start_http_server:
|
|
|
|
# Mock command line arguments
|
|
mock_args = Mock()
|
|
mock_args.metrics = True
|
|
mock_args.metrics_port = 8000
|
|
mock_parse_args.return_value = mock_args
|
|
|
|
# Create a simple mock instance without any async methods
|
|
mock_api_instance = Mock()
|
|
mock_api_instance.run = Mock()
|
|
|
|
# Create a mock Api class without importing the real one
|
|
mock_api = Mock(return_value=mock_api_instance)
|
|
|
|
# Patch using context manager to avoid importing the real Api class
|
|
with patch('trustgraph.gateway.service.Api', mock_api):
|
|
# Mock vars() to return a dict
|
|
with patch('builtins.vars') as mock_vars:
|
|
mock_vars.return_value = {
|
|
'metrics': True,
|
|
'metrics_port': 8000,
|
|
'pulsar_host': default_pulsar_host,
|
|
'timeout': default_timeout
|
|
}
|
|
|
|
run()
|
|
|
|
# Verify metrics server was started
|
|
mock_start_http_server.assert_called_once_with(8000)
|
|
|
|
# Verify Api was created and run was called
|
|
mock_api.assert_called_once()
|
|
mock_api_instance.run.assert_called_once()
|
|
|
|
@patch('trustgraph.gateway.service.start_http_server')
|
|
@patch('argparse.ArgumentParser.parse_args')
|
|
def test_run_function_with_metrics_disabled(self, mock_parse_args, mock_start_http_server):
|
|
"""Test run function with metrics disabled"""
|
|
# Mock command line arguments
|
|
mock_args = Mock()
|
|
mock_args.metrics = False
|
|
mock_parse_args.return_value = mock_args
|
|
|
|
# Create a simple mock instance without any async methods
|
|
mock_api_instance = Mock()
|
|
mock_api_instance.run = Mock()
|
|
|
|
# Patch the Api class inside the test without using decorators
|
|
with patch('trustgraph.gateway.service.Api') as mock_api:
|
|
mock_api.return_value = mock_api_instance
|
|
|
|
# Mock vars() to return a dict
|
|
with patch('builtins.vars') as mock_vars:
|
|
mock_vars.return_value = {
|
|
'metrics': False,
|
|
'metrics_port': 8000,
|
|
'pulsar_host': default_pulsar_host,
|
|
'timeout': default_timeout
|
|
}
|
|
|
|
run()
|
|
|
|
# Verify metrics server was NOT started
|
|
mock_start_http_server.assert_not_called()
|
|
|
|
# Verify Api was created and run was called
|
|
mock_api.assert_called_once()
|
|
mock_api_instance.run.assert_called_once()
|
|
|
|
@patch('argparse.ArgumentParser.parse_args')
|
|
def test_run_function_argument_parsing(self, mock_parse_args):
|
|
"""Test that run function properly parses command line arguments"""
|
|
# Mock command line arguments
|
|
mock_args = Mock()
|
|
mock_args.metrics = False
|
|
mock_parse_args.return_value = mock_args
|
|
|
|
# Create a simple mock instance without any async methods
|
|
mock_api_instance = Mock()
|
|
mock_api_instance.run = Mock()
|
|
|
|
# Mock vars() to return a dict with all expected arguments
|
|
expected_args = {
|
|
'pulsar_host': 'pulsar://test:6650',
|
|
'pulsar_api_key': 'test-key',
|
|
'pulsar_listener': 'test-listener',
|
|
'prometheus_url': 'http://test-prometheus:9090',
|
|
'port': 9000,
|
|
'timeout': 300,
|
|
'api_token': 'secret',
|
|
'log_level': 'INFO',
|
|
'metrics': False,
|
|
'metrics_port': 8001
|
|
}
|
|
|
|
# Patch the Api class inside the test without using decorators
|
|
with patch('trustgraph.gateway.service.Api') as mock_api:
|
|
mock_api.return_value = mock_api_instance
|
|
|
|
with patch('builtins.vars') as mock_vars:
|
|
mock_vars.return_value = expected_args
|
|
|
|
run()
|
|
|
|
# Verify Api was created with the parsed arguments
|
|
mock_api.assert_called_once_with(**expected_args)
|
|
mock_api_instance.run.assert_called_once()
|
|
|
|
def test_run_function_creates_argument_parser(self):
|
|
"""Test that run function creates argument parser with correct arguments"""
|
|
with patch('argparse.ArgumentParser') as mock_parser_class:
|
|
mock_parser = Mock()
|
|
mock_parser_class.return_value = mock_parser
|
|
mock_parser.parse_args.return_value = Mock(metrics=False)
|
|
|
|
with patch('trustgraph.gateway.service.Api') as mock_api, \
|
|
patch('builtins.vars') as mock_vars:
|
|
mock_vars.return_value = {'metrics': False}
|
|
mock_api.return_value = Mock()
|
|
|
|
run()
|
|
|
|
# Verify ArgumentParser was created
|
|
mock_parser_class.assert_called_once()
|
|
|
|
# Verify add_argument was called for each expected argument
|
|
expected_arguments = [
|
|
'pulsar-host', 'pulsar-api-key', 'pulsar-listener',
|
|
'prometheus-url', 'port', 'timeout', 'api-token',
|
|
'log-level', 'metrics', 'metrics-port'
|
|
]
|
|
|
|
# Check that add_argument was called multiple times (once for each arg)
|
|
assert mock_parser.add_argument.call_count >= len(expected_arguments) |