CalejoControl/tests/integration/test_protocol_server_integr...

245 lines
9.3 KiB
Python
Raw Permalink Normal View History

"""
Integration tests for Protocol Server integration with ConfigurationManager
"""
import pytest
import asyncio
from unittest.mock import Mock, AsyncMock
from src.dashboard.configuration_manager import (
ConfigurationManager,
ProtocolMapping,
ProtocolType
)
from src.database.flexible_client import FlexibleDatabaseClient
class TestProtocolServerIntegration:
"""Test integration between ConfigurationManager and Protocol Servers"""
@pytest.fixture
async def sqlite_db_client(self):
"""Create SQLite database client for testing"""
db_client = FlexibleDatabaseClient('sqlite:///test_protocol_integration.db')
await db_client.connect()
db_client.create_tables()
yield db_client
await db_client.disconnect()
@pytest.fixture
def mock_setpoint_manager(self):
"""Create mock setpoint manager"""
mock = Mock()
mock.get_current_setpoint = Mock(return_value=50.0)
return mock
@pytest.fixture
def mock_security_manager(self):
"""Create mock security manager"""
mock = Mock()
mock.validate_access = Mock(return_value=True)
return mock
@pytest.fixture
def mock_audit_logger(self):
"""Create mock audit logger"""
mock = Mock()
mock.log_event = Mock()
return mock
@pytest.mark.asyncio
async def test_modbus_server_integration(self, sqlite_db_client, mock_setpoint_manager, mock_security_manager, mock_audit_logger):
"""Test Modbus server integration with ConfigurationManager"""
# Import here to avoid circular imports
from src.protocols.modbus_server import ModbusServer
# Create ConfigurationManager with database
config_manager = ConfigurationManager(db_client=sqlite_db_client)
# Add Modbus mappings
modbus_mappings = [
ProtocolMapping(
id="modbus_setpoint_001",
station_id="station_001",
pump_id="pump_001",
protocol_type=ProtocolType.MODBUS_TCP,
protocol_address="100",
data_type="setpoint",
db_source="frequency_hz"
),
ProtocolMapping(
id="modbus_setpoint_002",
station_id="station_001",
pump_id="pump_002",
protocol_type=ProtocolType.MODBUS_TCP,
protocol_address="101",
data_type="setpoint",
db_source="frequency_hz"
)
]
for mapping in modbus_mappings:
config_manager.add_protocol_mapping(mapping)
# Create Modbus server with ConfigurationManager
modbus_server = ModbusServer(
configuration_manager=config_manager,
setpoint_manager=mock_setpoint_manager,
security_manager=mock_security_manager,
audit_logger=mock_audit_logger
)
# Initialize pump mapping
await modbus_server._initialize_pump_mapping()
# Verify that mappings were loaded
assert len(modbus_server.pump_addresses) == 2
assert "station_001/pump_001" in modbus_server.pump_addresses
assert "station_001/pump_002" in modbus_server.pump_addresses
assert modbus_server.pump_addresses["station_001/pump_001"] == 100
assert modbus_server.pump_addresses["station_001/pump_002"] == 101
@pytest.mark.asyncio
async def test_opcua_server_integration(self, sqlite_db_client, mock_setpoint_manager, mock_security_manager, mock_audit_logger):
"""Test OPC UA server integration with ConfigurationManager"""
# Import here to avoid circular imports
from src.protocols.opcua_server import OPCUAServer
# Create ConfigurationManager with database
config_manager = ConfigurationManager(db_client=sqlite_db_client)
# Add OPC UA mappings
opcua_mappings = [
ProtocolMapping(
id="opcua_setpoint_001",
station_id="station_001",
pump_id="pump_001",
protocol_type=ProtocolType.OPC_UA,
protocol_address="ns=2;s=Station_001.Pump_001.Setpoint_Hz",
data_type="setpoint",
db_source="frequency_hz"
),
ProtocolMapping(
id="opcua_setpoint_002",
station_id="station_001",
pump_id="pump_002",
protocol_type=ProtocolType.OPC_UA,
protocol_address="ns=2;s=Station_001.Pump_002.Setpoint_Hz",
data_type="setpoint",
db_source="frequency_hz"
)
]
for mapping in opcua_mappings:
config_manager.add_protocol_mapping(mapping)
# Create OPC UA server with ConfigurationManager
opcua_server = OPCUAServer(
configuration_manager=config_manager,
setpoint_manager=mock_setpoint_manager,
security_manager=mock_security_manager,
audit_logger=mock_audit_logger
)
# Verify that mappings were loaded
opcua_mappings = opcua_server.configuration_manager.get_protocol_mappings(protocol_type=ProtocolType.OPC_UA)
assert len(opcua_mappings) == 2
# Verify specific mappings
mapping_ids = [m.id for m in opcua_mappings]
assert "opcua_setpoint_001" in mapping_ids
assert "opcua_setpoint_002" in mapping_ids
@pytest.mark.asyncio
async def test_mixed_protocol_integration(self, sqlite_db_client, mock_setpoint_manager, mock_security_manager, mock_audit_logger):
"""Test integration with mixed protocol types"""
# Import here to avoid circular imports
from src.protocols.modbus_server import ModbusServer
from src.protocols.opcua_server import OPCUAServer
# Create ConfigurationManager with database
config_manager = ConfigurationManager(db_client=sqlite_db_client)
# Add mixed protocol mappings
mixed_mappings = [
ProtocolMapping(
id="modbus_mixed_001",
station_id="station_001",
pump_id="pump_001",
protocol_type=ProtocolType.MODBUS_TCP,
protocol_address="100",
data_type="setpoint",
db_source="frequency_hz"
),
ProtocolMapping(
id="opcua_mixed_001",
station_id="station_001",
pump_id="pump_002",
protocol_type=ProtocolType.OPC_UA,
protocol_address="ns=2;s=Station_001.Pump_002.Setpoint_Hz",
data_type="setpoint",
db_source="frequency_hz"
),
ProtocolMapping(
id="modbus_rtu_mixed_001",
station_id="station_002",
pump_id="pump_001",
protocol_type=ProtocolType.MODBUS_RTU,
protocol_address="40001",
data_type="setpoint",
db_source="frequency_hz"
),
ProtocolMapping(
id="rest_mixed_001",
station_id="station_002",
pump_id="pump_002",
protocol_type=ProtocolType.REST_API,
protocol_address="https://api.example.com/v1/stations/002/pumps/002/setpoint",
data_type="setpoint",
db_source="frequency_hz"
)
]
for mapping in mixed_mappings:
config_manager.add_protocol_mapping(mapping)
# Create Modbus server
modbus_server = ModbusServer(
configuration_manager=config_manager,
setpoint_manager=mock_setpoint_manager,
security_manager=mock_security_manager,
audit_logger=mock_audit_logger
)
# Create OPC UA server
opcua_server = OPCUAServer(
configuration_manager=config_manager,
setpoint_manager=mock_setpoint_manager,
security_manager=mock_security_manager,
audit_logger=mock_audit_logger
)
# Initialize Modbus pump mapping
await modbus_server._initialize_pump_mapping()
# Verify Modbus mappings
assert len(modbus_server.pump_addresses) == 2 # Only Modbus TCP and RTU
# Verify OPC UA mappings
opcua_mappings = opcua_server.configuration_manager.get_protocol_mappings(protocol_type=ProtocolType.OPC_UA)
assert len(opcua_mappings) == 1
# Verify all mappings in ConfigurationManager
all_mappings = config_manager.get_protocol_mappings()
assert len(all_mappings) == 4
# Verify protocol type distribution
modbus_tcp_mappings = config_manager.get_protocol_mappings(protocol_type=ProtocolType.MODBUS_TCP)
modbus_rtu_mappings = config_manager.get_protocol_mappings(protocol_type=ProtocolType.MODBUS_RTU)
opcua_mappings = config_manager.get_protocol_mappings(protocol_type=ProtocolType.OPC_UA)
rest_mappings = config_manager.get_protocol_mappings(protocol_type=ProtocolType.REST_API)
assert len(modbus_tcp_mappings) == 1
assert len(modbus_rtu_mappings) == 1
assert len(opcua_mappings) == 1
assert len(rest_mappings) == 1