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