import json from datetime import datetime from unittest.mock import ANY, AsyncMock, MagicMock, call, patch import pytest from asyncua.crypto.security_policies import SecurityPolicyBasic256 from pytest import fixture, mark from sientia_do.notifications.models import NotificationLevel from ingestor.managers.opc_manager import OpcManager tags = { 'ns=3;i=1001': { 'aggregation_function': 'LTS', 'frequency': 1000, 'max_value': 100, 'min_value': 0, 'tag_name': 'Counter', }, 'ns=3;i=1003': { 'aggregation_function': 'AVG', 'frequency': 1000, 'max_value': 100, 'min_value': 0, 'tag_name': 'Random', }, 'ns=3;i=1004': { 'aggregation_function': 'MDN', 'frequency': 1000, 'max_value': 100, 'min_value': 0, 'tag_name': 'Sawtooth', }, } metadata = { 'metadata': { 'model_id': 'test_model', 'model_name': 'test_model', 'workflow_name': 'test_workflow', 'schema_name': 'test_schedule', }, } @fixture @patch('ingestor.managers.opc_manager.metrics') def raw_opc_manager(mock_metrics): opc_manager = OpcManager( name='TestConnector', url='opc.tcp://localhost:4840', data_manager=AsyncMock(), subscription_period_ms=1000, logger=MagicMock(), server_uri='opc.tcp://localhost:4840', notification_handler=MagicMock(), metadata=metadata['metadata'], metrics_controller=AsyncMock(), ) opc_manager.emit_metric = AsyncMock() opc_manager.send_notification_async = AsyncMock() opc_manager.send_notification = MagicMock() return opc_manager @fixture def opc_manager(raw_opc_manager): raw_opc_manager.client = AsyncMock() raw_opc_manager.cert_path = 'cert.pem' raw_opc_manager.private_key_path = 'private_key.pem' raw_opc_manager.server_cert_path = 'server_cert.pem' return raw_opc_manager @fixture def opc_manager_subscribed(opc_manager): opc_manager.subscriptions['sub1'] = AsyncMock() return opc_manager def test___str__(opc_manager): assert ( str(opc_manager) == 'OpcManager(name=TestConnector, url=opc.tcp://localhost:4840, server_uri=opc.tcp://localhost:4840)\nnodes={}, subscriptions={}' ) @mark.asyncio async def test_shutdown_success(opc_manager): opc_manager.disconnect = AsyncMock() await opc_manager.shutdown() opc_manager.disconnect.assert_called_once() @mark.asyncio async def test_shutdown_error(opc_manager): opc_manager.disconnect = AsyncMock(side_effect=Exception('Test error')) await opc_manager.shutdown() opc_manager.logger.error.assert_called_once_with('Error during cleanup: Test error') @mark.asyncio async def test_set_security_success(opc_manager): await opc_manager.set_security() assert opc_manager.client.application_uri == opc_manager.server_uri opc_manager.client.set_security.assert_called_once_with( SecurityPolicyBasic256, certificate=opc_manager.cert_path, private_key=opc_manager.private_key_path, server_certificate=opc_manager.server_cert_path, ) assert opc_manager.client.secure_channel_timeout == 10000000 assert opc_manager.client.session_timeout == 10000000 @mark.asyncio async def test_set_security_no_cert(opc_manager): opc_manager.cert_path = None opc_manager.private_key_path = None try: await opc_manager.set_security() except ValueError as e: assert str(e) == 'Certificate and private key paths must be provided for secure connection.' else: raise AssertionError('ValueError not raised') assert opc_manager.client.set_security.call_count == 0 @mark.asyncio @patch('ingestor.managers.opc_manager.metrics') @patch('ingestor.managers.opc_manager.Client') async def test_connect_no_security(client, mock_metrics, raw_opc_manager): raw_opc_manager.set_security = AsyncMock() client.return_value = AsyncMock() await raw_opc_manager.connect() client.assert_called_once_with(raw_opc_manager.url, timeout=10, watchdog_intervall=3600000) raw_opc_manager.client.connect.assert_called_once() raw_opc_manager.set_security.assert_not_called() raw_opc_manager.emit_metric.assert_has_calls( [ call( metric_object=mock_metrics.OPC_CONNECTIONS_TOTAL, method='inc', value=1, tags={ 'pod_id': raw_opc_manager.pod_id, 'server_name': raw_opc_manager.name, }, ), call( metric_object=mock_metrics.OPC_CONNECTION_STATUS, method='set', value=1, tags={ 'pod_id': raw_opc_manager.pod_id, 'server_name': raw_opc_manager.name, 'server_url': raw_opc_manager.url, }, ), ], any_order=True, ) @mark.asyncio @patch('ingestor.managers.opc_manager.Client') async def test_connect_with_security(client, raw_opc_manager): raw_opc_manager.cert_path = 'cert.pem' raw_opc_manager.private_key_path = 'private_key.pem' raw_opc_manager.server_cert_path = 'server_cert.pem' raw_opc_manager.set_security = AsyncMock() client.return_value = AsyncMock() await raw_opc_manager.connect() client.assert_called_once_with(raw_opc_manager.url, timeout=10, watchdog_intervall=3600000) raw_opc_manager.client.connect.assert_called_once() raw_opc_manager.set_security.assert_called_once() @mark.asyncio @patch('ingestor.managers.opc_manager.Client') @patch('ingestor.managers.opc_manager.metrics') async def test_connect_exception_handling_and_metrics( mock_metrics_module, mock_opc_client_class, raw_opc_manager ): mock_client_instance = mock_opc_client_class.return_value simulated_error_message = 'Erro de conexão simulado' mock_client_instance.connect.side_effect = Exception(simulated_error_message) raw_opc_manager.disconnect = AsyncMock() opc_manager_instance = raw_opc_manager opc_manager_instance.cert_path = None with pytest.raises(Exception, match=simulated_error_message): await opc_manager_instance.connect() opc_manager_instance.disconnect.assert_called_once() @mark.asyncio async def test_create_subscription_no_client(raw_opc_manager): try: await raw_opc_manager.create_subscription('sub1') except ValueError as e: assert str(e) == 'Client not connected. Call connect first.' else: raise AssertionError('ValueError not raised') @mark.asyncio async def test_create_subscription_success_has_period(opc_manager): await opc_manager.create_subscription('sub1') opc_manager.client.create_subscription.assert_called_once_with( opc_manager.subscription_period_ms, opc_manager ) assert opc_manager.subscriptions['sub1'] is not None @mark.asyncio async def test_create_subscription_success_no_period(opc_manager): await opc_manager.create_subscription('sub1') opc_manager.client.create_subscription.assert_called_once_with( opc_manager.subscription_period_ms, opc_manager ) assert opc_manager.subscriptions['sub1'] is not None @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_create_subscription_with_metrics(metrics, opc_manager): await opc_manager.create_subscription('sub1') opc_manager.emit_metric.assert_called_once_with( metric_object=metrics.OPC_SUBSCRIPTIONS_CREATED, method='inc', value=1, tags={ 'pod_id': opc_manager.pod_id, 'server_name': opc_manager.name, 'slot_name': 'sub1', }, ) @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_create_subscription_exception_during_client_call( mock_metrics_module, raw_opc_manager ): opc_manager_instance = raw_opc_manager opc_manager_instance.client = AsyncMock() subscription_name = 'test_sub_client_error' simulated_error_message = 'Falha ao criar subscrição no cliente OPC' opc_manager_instance.client.create_subscription.side_effect = Exception(simulated_error_message) with pytest.raises(Exception, match=simulated_error_message): await opc_manager_instance.create_subscription(subscription_name) opc_manager_instance.client.create_subscription.assert_called_once_with( opc_manager_instance.subscription_period_ms, opc_manager_instance ) opc_manager_instance.logger.error.assert_called_once_with( f'Failed to create subscription {subscription_name} on {opc_manager_instance.name}: {simulated_error_message}' ) mock_metrics_module.OPC_SUBSCRIPTIONS_CREATED.labels.assert_not_called() @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_subscribe_no_subscription(metrics, opc_manager): try: await opc_manager.subscribe('sub1', tags, 1000) except ValueError as e: assert str(e) == 'Subscription not created. Call create_subscription first.' else: raise AssertionError('ValueError not raised') metrics.OPC_TAGS_SUBSCRIBED.labels.assert_not_called() @mark.asyncio async def test_subscribe_success(opc_manager_subscribed): opc_manager_subscribed.client.get_node = MagicMock() opc_manager_subscribed.nodes = {'ns=3;i=1001': 'data'} await opc_manager_subscribed.subscribe('sub1', tags, 1000) assert opc_manager_subscribed.nodes == tags opc_manager_subscribed.subscriptions['sub1'].subscribe_data_change.assert_called_once_with( [opc_manager_subscribed.client.get_node(n) for n in tags] ) @mark.asyncio async def test_unsubscribe_no_subscription(opc_manager): await opc_manager.unsubscribe('sub1') opc_manager.logger.warning.assert_called_once_with( "Subscription 'sub1' not found. Cannot unsubscribe." ) assert opc_manager.subscriptions.get('sub1') is None @mark.asyncio async def test_unsubscribe_success(opc_manager_subscribed): await opc_manager_subscribed.unsubscribe('sub1') assert opc_manager_subscribed.subscriptions.get('sub1') is None @mark.asyncio async def test_disconnection_fallback_success(opc_manager): opc_manager.client = AsyncMock() opc_manager.client.disconnect.return_value = True result = await opc_manager.disconnection_fallback() assert result == [] @mark.asyncio async def test_disconnection_fallback_fail(opc_manager): opc_manager.client = AsyncMock() opc_manager.client.disconnect.side_effect = Exception('Test error') result = await opc_manager.disconnection_fallback() assert result == [ {'attempt': 1, 'error': 'Test error', 'traceback': ANY}, {'attempt': 2, 'error': 'Test error', 'traceback': ANY}, {'attempt': 3, 'error': 'Test error', 'traceback': ANY}, {'attempt': 4, 'error': 'Test error', 'traceback': ANY}, {'attempt': 5, 'error': 'Test error', 'traceback': ANY}, ] assert opc_manager.client.disconnect.call_count == 5 @mark.asyncio async def test_disconnect_success(opc_manager_subscribed): opc_manager_subscribed.client = MagicMock() await opc_manager_subscribed.disconnect() opc_manager_subscribed.subscriptions['sub1'].delete.assert_called_once() assert opc_manager_subscribed.client is None @mark.asyncio async def test_disconnect_no_client(opc_manager_subscribed): opc_manager_subscribed.client = None assert await opc_manager_subscribed.disconnect() is None opc_manager_subscribed.logger.warning.assert_has_calls( [ call('Client already disconnected.'), ] ) @mark.asyncio async def test_disconnect_error_unsubscribe(opc_manager_subscribed): opc_manager_subscribed.client = MagicMock(disconnect=AsyncMock()) opc_manager_subscribed.subscriptions['sub1'] = MagicMock( delete=AsyncMock(side_effect=Exception('Test error')) ) await opc_manager_subscribed.disconnect() opc_manager_subscribed.subscriptions['sub1'].delete.assert_called_once() opc_manager_subscribed.client = None opc_manager_subscribed.logger.error.assert_called_once_with( 'Failed to clean up subscription: Test error' ) @mark.asyncio async def test_disconnect_error(opc_manager_subscribed): opc_manager_subscribed.client = MagicMock() opc_manager_subscribed.client.disconnect = MagicMock(side_effect=Exception('Test error')) await opc_manager_subscribed.disconnect() opc_manager_subscribed.subscriptions['sub1'].delete.assert_called_once() opc_manager_subscribed.client = None @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_disconnect_metrics_on_successful_path(mock_metrics_module, raw_opc_manager): mock_metrics_module.OPC_CONNECTION_STATUS.reset_mock() mock_metrics_module.OPC_TAGS_SUBSCRIBED.reset_mock() raw_opc_manager.client = MagicMock() mock_sub1 = MagicMock() mock_sub2 = MagicMock() raw_opc_manager.subscriptions = {'sub1': mock_sub1, 'sub2': mock_sub2} await raw_opc_manager.disconnect() raw_opc_manager.emit_metric.assert_has_calls( [ call( metric_object=mock_metrics_module.OPC_CONNECTION_STATUS, method='set', value=0, tags={ 'pod_id': raw_opc_manager.pod_id, 'server_name': raw_opc_manager.name, 'server_url': raw_opc_manager.url, }, ), call( metric_object=mock_metrics_module.OPC_TAGS_SUBSCRIBED, method='set', value=0, tags={ 'pod_id': raw_opc_manager.pod_id, 'server_name': raw_opc_manager.name, }, ), ], any_order=True, ) @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_datachange_notification(metrics, opc_manager_subscribed): data = MagicMock( monitored_item=MagicMock( Value=MagicMock( Value=MagicMock(Value=42), SourceTimestamp=datetime.strptime('2021-01-01T00:00:00', '%Y-%m-%dT%H:%M:%S'), ) ) ) opc_manager_subscribed.nodes = { 'ns=3;i=1001': { 'tag_name': 'Counter', 'cycle_rule': {'cycle_increment': 1.0, 'cycle_count': 2}, 'topics': ['topic1', 'topic2'], } } await opc_manager_subscribed.datachange_notification('ns=3;i=1001', None, data) opc_manager_subscribed.data_manager.publish.assert_any_call( 'topic1', { 'tag': 'ns=3;i=1001', 'name': 'Counter', 'timestamp': '2021-01-01 00:00:00-0300', 'value': 42, }, ) opc_manager_subscribed.data_manager.publish.assert_any_call( 'topic2', { 'tag': 'ns=3;i=1001', 'name': 'Counter', 'timestamp': '2021-01-01 00:00:00-0300', 'value': 42, }, ) assert opc_manager_subscribed.nodes['ns=3;i=1001']['cycle_rule']['cycle_count'] == 0 opc_manager_subscribed.emit_metric.assert_called_once_with( metric_object=metrics.OPC_CYCLES_WITHOUT_DATA, method='set', value=0, tags={ 'pod_id': opc_manager_subscribed.pod_id, 'server_name': opc_manager_subscribed.name, }, ) @mark.asyncio async def test_check_cycles_no_notification(opc_manager): # Setup: node with cycle_count just below threshold opc_manager.nodes = { 'ns=3;i=1001': { 'tag_name': 'Counter', 'cycle_rule': {'cycle_increment': 1.0, 'cycle_count': 3.0}, } } await opc_manager.check_cycles() # After one increment, cycle_count = 4.0, still below threshold assert opc_manager.nodes['ns=3;i=1001']['cycle_rule']['cycle_count'] == pytest.approx(4.0) opc_manager.send_notification_async.assert_not_called() @mark.asyncio async def test_check_cycles_triggers_notification(opc_manager): # Setup: node with cycle_count just below threshold, increment will cross threshold opc_manager.nodes = { 'ns=3;i=1001': { 'tag_name': 'Counter', 'cycle_rule': {'cycle_increment': 2.5, 'cycle_count': 3.0}, } } opc_manager.notification_handler.build_and_send_notification = MagicMock() await opc_manager.check_cycles() # After increment, cycle_count = 5.5, should trigger notification assert opc_manager.nodes['ns=3;i=1001']['cycle_rule']['cycle_count'] == pytest.approx(5.5) opc_manager.send_notification_async.assert_called_once_with( notification_id='TAG_ns=3;i=1001:Counter_LISTENNING_STOPPED', message='5.5 cycles without receive from ns=3;i=1001:Counter', block='opc_manager', level=NotificationLevel.WARNING, metadata=metadata['metadata'], ) @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_check_opc_listenning_no_notification(metrics, opc_manager): opc_manager.non_receive_count = 3 result = await opc_manager.check_opc_listenning() assert opc_manager.non_receive_count == 4 opc_manager.send_notification_async.assert_not_called() assert result is False opc_manager.emit_metric.assert_called_once_with( metric_object=metrics.OPC_CYCLES_WITHOUT_DATA, method='set', value=opc_manager.non_receive_count, tags={ 'pod_id': opc_manager.pod_id, 'server_name': opc_manager.name, }, ) @mark.asyncio async def test_check_opc_listenning_warning_notification(opc_manager): opc_manager.non_receive_count = 4 result = await opc_manager.check_opc_listenning() assert opc_manager.non_receive_count == 5 opc_manager.send_notification_async.assert_called_once_with( notification_id=f'OPC_LISTENNING_STOPPED__{opc_manager.name}', message=f'5 cycles without receive from OPC {opc_manager.name}. Tags: {json.dumps(opc_manager.nodes)}', block='opc_manager', level=NotificationLevel.ERROR, metadata=metadata['metadata'], ) assert result is False @patch('ingestor.managers.opc_manager.metrics') @mark.asyncio async def test_check_opc_listenning_error_notification_and_retry(metrics, opc_manager): opc_manager.non_receive_count = 14 result = await opc_manager.check_opc_listenning() assert opc_manager.non_receive_count == 15 # Should be called twice: once for 5, once for 15 assert opc_manager.send_notification_async.call_count == 2 calls = opc_manager.send_notification_async.call_args_list # First call: 5 cycles warning assert calls[0].kwargs == { 'notification_id': f'OPC_LISTENNING_STOPPED__{opc_manager.name}', 'message': f'15 cycles without receive from OPC {opc_manager.name}. Tags: {json.dumps(opc_manager.nodes)}', 'block': 'opc_manager', 'level': NotificationLevel.ERROR, 'metadata': metadata['metadata'], } # Second call: 15 cycles retry assert calls[1].kwargs == { 'notification_id': f'OPC_CONNECTION_RETRY__{opc_manager.name}', 'message': f'Retrying to connect to server {opc_manager.name}', 'block': 'opc_manager', 'level': NotificationLevel.ERROR, 'metadata': metadata['metadata'], } assert result is True opc_manager.emit_metric.assert_has_calls( [ call( metric_object=metrics.OPC_CYCLES_WITHOUT_DATA, method='set', value=opc_manager.non_receive_count, tags={ 'pod_id': opc_manager.pod_id, 'server_name': opc_manager.name, }, ), ] ) opc_manager.emit_metric.assert_has_calls( [ call( metric_object=metrics.OPC_RECONNECTIONS_TOTAL, method='inc', value=1, tags={ 'pod_id': opc_manager.pod_id, 'server_name': opc_manager.name, }, ), ] )