Code import - branch 1.4.2

tests/functional/conftest.py

@@ -0,0 +1,47 @@
+# import subprocess
+# from time import sleep
+# from typing import Generator
+# import uuid
+# from kafka import KafkaConsumer
+# import pytest
+# from redis import Redis
+
+
+# @pytest.fixture(scope="session", autouse=True)
+# def docker_compose():
+#     """Sobe os containers antes dos testes e derruba depois."""
+#     print("\n🚀 Subindo Docker Compose...")
+#     subprocess.run(["docker", "compose", "up", "-d"], check=True)
+
+#     print("⏳ Aguardando containers ficarem prontos...")
+#     sleep(15)  # ajuste conforme necessário
+
+#     yield  # os testes rodam aqui
+
+#     print("\n🧹 Derrubando Docker Compose...")
+#     subprocess.run(["docker", "compose", "down"], check=True)
+
+
+# @pytest.fixture()
+# def redis_client():
+#     redis = Redis(host="localhost", port=6379, decode_responses=True)
+#     redis.flushdb()
+
+#     yield redis
+
+#     # Limpa o banco de dados após os testes
+#     redis.flushdb()
+#     redis.close()
+
+
+# def kafka_searcher(topic) -> Generator[KafkaConsumer, None, None]:
+#     consumer = KafkaConsumer(
+#         topic,
+#         bootstrap_servers="localhost:9092",
+#         group_id=f"test-group-{uuid.uuid4()}",
+#         auto_offset_reset="earliest",   # Começa a consumir apenas mensagens novas
+#         enable_auto_commit=True,
+#     )
+
+#     yield consumer
+#     consumer.close()

tests/functional/test_single_node.py

@@ -0,0 +1,118 @@
+# import json
+# import subprocess
+# from time import sleep
+
+# from tests.functional.conftest import kafka_searcher
+
+
+# new_data = {
+#     "slot:opc_tags:1": {
+#         "server1": {
+#             "name": "server1",
+#             "url": "opc.tcp://simulator:4840",
+#             "server_uri": "http://opcua-server.simulator",
+#             "tags": {
+#                 'ns=2;i=2': {
+#                     'tag_name': 'Counter',
+#                     'frequency': 1000,
+#                     'topics': [],
+#                 },
+#                 'ns=2;i=3': {
+#                     'tag_name': 'Rollout',
+#                     'frequency': 1000,
+#                     "topics": [],
+#                 },
+#                 'ns=2;i=4': {
+#                     'tag_name': 'Square',
+#                     'frequency': 1000,
+#                     "topics": [],
+#                 },
+#             }
+#         }
+#     },
+#     "slot:opc_tags:2": {
+#         "server2": {
+#             "name": "server2",
+#             "url": "opc.tcp://simulator:4840",
+#             "server_uri": "http://opcua-server.simulator",
+#             "tags": {
+#                 'ns=2;i=2': {
+#                     'tag_name': 'Counter',
+#                     'frequency': 1000,
+#                     'topics': [],
+#                 },
+#                 'ns=2;i=3': {
+#                     'tag_name': 'Rollout',
+#                     'frequency': 1000,
+#                     "topics": [],
+#                 },
+#                 'ns=2;i=4': {
+#                     'tag_name': 'Square',
+#                     'frequency': 1000,
+#                     "topics": [],
+#                 },
+#             }
+#         }
+#     }
+# }
+
+
+# def test_simple(redis_client):
+#     new_data['slot:opc_tags:1']['server1']['tags']['ns=2;i=2']['topics'] = [
+#         'test_topic_1']
+#     redis_client.set("slot:opc_tags:1",
+#                      json.dumps(new_data['slot:opc_tags:1']))
+
+#     sleep(20)  # Espera o Ingestor processar os dados
+
+#     # Check if lease is in Redis
+#     assert redis_client.get("lease:opc_tags:1") == 'ingestor'
+#     assert redis_client.get("heartbeat:ingestor:ingestor") == '1'
+
+#     # Check if data is in Kafka
+
+#     kafka = next(kafka_searcher('test_topic_1'))
+#     sleep(1)
+#     messages = kafka.poll(timeout_ms=10000)
+
+#     assert messages, "Expected messages in Kafka, but got none."
+
+
+# def test_simple_double_slot(redis_client):
+
+#     new_data['slot:opc_tags:1']['server1']['tags']['ns=2;i=2']['topics'] = [
+#         'test_topic_double_slot1']
+#     redis_client.set("slot:opc_tags:1",
+#                      json.dumps(new_data['slot:opc_tags:1']))
+
+#     sleep(20)  # Espera o Ingestor processar os dados
+
+#     assert redis_client.get("lease:opc_tags:1") == 'ingestor'
+#     assert redis_client.get("heartbeat:ingestor:ingestor") == '1'
+
+#     # Check if data is in Kafka
+#     kafka1 = next(kafka_searcher('test_topic_double_slot1'))
+#     messages = kafka1.poll(timeout_ms=10000)
+
+#     assert messages, "Expected messages in test_topic_double_slot1, but got none."
+
+#     new_data['slot:opc_tags:2']['server2']['tags']['ns=2;i=2']['topics'] = [
+#         'test_topic_double_slot2']
+#     redis_client.set("slot:opc_tags:2",
+#                      json.dumps(new_data['slot:opc_tags:2']))
+
+#     sleep(20)  # Espera o Ingestor processar os dados
+
+#     # Check if lease is in Redis
+#     assert redis_client.get("lease:opc_tags:2") == 'ingestor'
+#     assert redis_client.get("lease:opc_tags:1") == 'ingestor'
+#     assert redis_client.get("heartbeat:ingestor:ingestor") == '1'
+
+#     # Check if data is in Kafka
+#     kafka2 = next(kafka_searcher('test_topic_double_slot2'))
+#     messages = kafka2.poll(timeout_ms=10000)
+
+#     assert messages, "Expected messages in test_topic_double_slot2, but got none."
+
+#     messages = kafka1.poll(timeout_ms=10000)
+#     assert messages, "Expected messages in test_topic_double_slot1, but got none."

tests/unit/managers/test_data_manager.py

@@ -0,0 +1,108 @@
+from unittest.mock import ANY, AsyncMock, MagicMock, patch
+
+from pytest import fixture, mark
+from sientia_do.notifications.models import NotificationLevel
+
+from ingestor.managers.data_manager import DataManager
+
+metadata = {
+    'metadata': {
+        'model_id': 'test_model',
+        'model_name': 'test_model',
+        'workflow_name': 'test_workflow',
+        'schema_name': 'test_schedule',
+        'pod_id': 'localhost',
+    },
+}
+
+
+@fixture
+@patch('ingestor.managers.data_manager.MongoDBRepository')
+def data_manager(mongodb_repository):
+    data_manager = DataManager(
+        mongo_connection_string='mongodb://localhost:27017',
+        mongo_database='sientia',
+        logger=MagicMock(),
+        notification_handler=MagicMock(),
+        metadata=metadata['metadata'],
+        metrics_controller=MagicMock(),
+    )
+
+    data_manager.send_notification = MagicMock()
+    data_manager.send_notification_async = AsyncMock()
+    data_manager.emit_metric = AsyncMock()
+    return data_manager
+
+
+@patch('ingestor.managers.data_manager.MongoDBRepository')
+def test___init___success(mongodb_repository):
+    logger_mock = MagicMock()
+
+    data_manager = DataManager(
+        metadata=metadata['metadata'],
+        mongo_connection_string='mongodb://localhost:27017',
+        mongo_database='sientia',
+        logger=logger_mock,
+        notification_handler=MagicMock(),
+        metrics_controller=MagicMock(),
+    )
+
+    logger_mock.info.assert_any_call(
+        'DataManager initialized with MongoDB servers: mongodb://localhost:27017'
+    )
+    logger_mock.error.assert_not_called()
+    assert data_manager.connection_string == 'mongodb://localhost:27017'
+
+
+def test_shutdown(data_manager):
+    close_mock = MagicMock()
+    data_manager.mongo_repository.close = close_mock
+
+    data_manager.shutdown()
+    close_mock.assert_called_once()
+
+
+def test_shutdown_exception_mongo(data_manager):
+    data_manager.mongo_repository.close = MagicMock(side_effect=Exception('Test error'))
+
+    data_manager.shutdown()
+
+    data_manager.logger.error.assert_called_once_with('Error closing MongoDB client: Test error')
+
+
+def test___del__(data_manager):
+    data_manager.shutdown = MagicMock()
+    data_manager.__del__()
+    data_manager.shutdown.assert_called_once()
+
+
+@mark.asyncio
+async def test_publish(data_manager):
+    topic = 'test_topic'
+    data = {'key': 'value', 'name': 'test_tag'}
+
+    data_manager.mongo_repository.insert = AsyncMock()
+
+    await data_manager.publish(topic, data)
+
+    data_manager.mongo_repository.insert.assert_called_once_with(
+        collection_name=topic,
+        document={**data, 'inserted_at': ANY},
+        metadata=metadata['metadata'],
+    )
+
+
+@mark.asyncio
+async def test_publish_error_mongo(data_manager):
+    data_manager.mongo_repository.insert = AsyncMock(side_effect=Exception('Test error'))
+
+    await data_manager.publish('test_topic', {'key': 'value'})
+
+    data_manager.send_notification_async.assert_called_once_with(
+        notification_id='MONGO_PRODUCER_ERROR_test_topic',
+        message='Error inserting message to MongoDB: Test error',
+        block='mongo_producer',
+        level=NotificationLevel.ERROR,
+        attachment_content=ANY,
+        metadata=metadata['metadata'],
+    )

tests/unit/managers/test_ingestor_manager.py

@@ -0,0 +1,648 @@
+from unittest.mock import AsyncMock, MagicMock, call, patch
+
+from pytest import fixture, mark
+from sientia_do.notifications.models import NotificationLevel
+
+from ingestor.managers.ingestor_manager import IngestorManager
+
+metadata = {
+    'metadata': {
+        'model_id': 'test_model',
+        'model_name': 'test_model',
+        'workflow_name': 'test_workflow',
+        'schema_name': 'test_schedule',
+    },
+}
+
+
+@fixture
+@patch('ingestor.managers.ingestor_manager.DataManager')
+@patch('ingestor.managers.ingestor_manager.ResourceManager')
+def ingestor_manager(data_manager_mock, resource_manager_mock):
+    ingestor = IngestorManager(
+        redis_data={'host': 'localhost', 'port': 6379},
+        lease_ttl=60,
+        heartbeat_ttl=60,
+        poll_interval=5,
+        mongo_connection_string='mongodb://localhost:27017',
+        mongo_database='sientia',
+        logger=MagicMock(),
+        notification_handler=MagicMock(),
+        metadata=metadata['metadata'],
+        metrics_controller=MagicMock(),
+    )
+
+    ingestor.send_notification = MagicMock()
+    ingestor.send_notification_async = AsyncMock()
+    ingestor.emit_metric = AsyncMock()
+
+    return ingestor
+
+
+@patch('ingestor.managers.ingestor_manager.OpcManager')
+@patch('ingestor.managers.ingestor_manager.DataManager')
+@patch('ingestor.managers.ingestor_manager.ResourceManager')
+@patch('ingestor.managers.ingestor_manager.NotificationHandler')
+def test___init__(
+    notification_handler_mock, resource_manager_mock, data_manager_mock, opc_manager_mock
+):
+    ingestor = IngestorManager(
+        redis_data={'host': 'localhost', 'port': 6379},
+        lease_ttl=60,
+        heartbeat_ttl=60,
+        poll_interval=5,
+        mongo_connection_string='mongodb://localhost:27017',
+        mongo_database='sientia',
+        logger=MagicMock(),
+        notification_handler=MagicMock(),
+        metadata=metadata['metadata'],
+        metrics_controller=MagicMock(),
+    )
+
+    opc_manager_mock.assert_not_called()
+    data_manager_mock.assert_called_once_with(
+        mongo_connection_string='mongodb://localhost:27017',
+        mongo_database='sientia',
+        metadata=metadata['metadata'],
+        logger=ingestor.logger,
+        notification_handler=ingestor.notification_handler,
+        metrics_controller=ingestor.metrics_controller,
+    )
+    resource_manager_mock.assert_called_once_with(
+        host='localhost',
+        port=6379,
+        lease_ttl=60,
+        heartbeat_ttl=60,
+        metadata=metadata['metadata'],
+        logger=ingestor.logger,
+        notification_handler=ingestor.notification_handler,
+        username=None,
+        password=None,
+        metrics_controller=ingestor.metrics_controller,
+    )
+    assert ingestor.poll_interval == 5
+    assert ingestor.managed_tags == {}
+    assert ingestor.opc_servers == {}
+    assert ingestor.opc_managers == {}
+    assert ingestor.data_manager == data_manager_mock.return_value
+    assert ingestor.resource_manager == resource_manager_mock.return_value
+
+
+@mark.asyncio
+@patch('ingestor.managers.ingestor_manager.OpcManager')
+async def test_initialize_opc_from_config(opc_manager, ingestor_manager):
+    server_config = {
+        'name': 'server1',
+        'url': 'opc.tcp://localhost:4840',
+        'subscription_period_ms': 1000,
+        'server_uri': 'http://opcua-server.simulator',
+        'cert_path': '/path/to/cert',
+        'private_key_path': '/path/to/private_key',
+        'server_cert_path': '/path/to/server_cert',
+        'pod_id': 'test_pod',
+    }
+
+    opc_manager.return_value = MagicMock(connect=AsyncMock())
+    result = await ingestor_manager.initialize_opc_from_config(server_config)
+
+    opc_manager.assert_called_once_with(
+        name=server_config['name'],
+        url=server_config['url'],
+        data_manager=ingestor_manager.data_manager,
+        logger=ingestor_manager.logger,
+        subscription_period_ms=server_config['subscription_period_ms'],
+        server_uri=server_config['server_uri'],
+        notification_handler=ingestor_manager.notification_handler,
+        cert_path=server_config['cert_path'],
+        private_key_path=server_config['private_key_path'],
+        server_cert_path=server_config['server_cert_path'],
+        metadata=metadata['metadata'],
+        metrics_controller=ingestor_manager.metrics_controller,
+    )
+
+    assert result == opc_manager.return_value
+    result.connect.assert_called_once()
+
+
+@mark.asyncio
+@patch('ingestor.managers.ingestor_manager.OpcManager')
+@patch('ingestor.managers.ingestor_manager.traceback')
+async def test_initialize_opc_from_config_exception(traceback_mock, opc_manager, ingestor_manager):
+    server_config = {
+        'name': 'server1',
+        'url': 'opc.tcp://localhost:4840',
+        'subscription_period_ms': 1000,
+        'server_uri': 'http://opcua-server.simulator',
+        'cert_path': '/path/to/cert',
+        'private_key_path': '/path/to/private_key',
+        'server_cert_path': '/path/to/server_cert',
+    }
+
+    ingestor_manager.logger.error = MagicMock()
+    opc_manager.side_effect = Exception('Initialization error')
+
+    result = await ingestor_manager.initialize_opc_from_config(server_config)
+
+    assert result is None
+
+    traceback_mock.format_exc.assert_called_once()
+    ingestor_manager.send_notification.assert_called_once_with(
+        metadata=metadata['metadata'],
+        notification_id=f'OPC_CONNECTION_ERROR_{server_config["name"]}',
+        message='Error initializing OPC manager: Initialization error',
+        block='opc_manager',
+        level=NotificationLevel.ERROR,
+        attachment_content=traceback_mock.format_exc.return_value,
+    )
+
+
+@mark.asyncio
+async def test_shutdown(ingestor_manager):
+    ingestor_manager.opc_managers = {'server1': AsyncMock(), 'server2': AsyncMock()}
+
+    ingestor_manager.data_manager.shutdown = MagicMock()
+
+    await ingestor_manager.shutdown()
+
+    ingestor_manager.opc_managers['server1'].shutdown.assert_called_once()
+    ingestor_manager.opc_managers['server2'].shutdown.assert_called_once()
+
+    ingestor_manager.data_manager.shutdown.assert_called_once()
+
+
+@patch('ingestor.managers.ingestor_manager.asyncio')
+def test___del__(asyncio_mock, ingestor_manager):
+    ingestor_manager.shutdown = MagicMock()
+    ingestor_manager.__del__()
+    asyncio_mock.run.assert_called_once_with(ingestor_manager.shutdown.return_value)
+
+
+@mark.asyncio
+async def test_remove_server(ingestor_manager):
+    server1 = AsyncMock()
+    server2 = AsyncMock()
+    ingestor_manager.opc_managers = {'server1': server1, 'server2': server2}
+    ingestor_manager.managed_tags = {
+        'slot1': {'server1': {'config': 'config1'}, 'server2': {'config': 'config2'}}
+    }
+    await ingestor_manager.remove_server('server1')
+    server1.shutdown.assert_called_once()
+    server2.shutdown.assert_not_called()
+    assert 'server1' not in ingestor_manager.opc_managers
+    assert 'server2' in ingestor_manager.opc_managers
+    assert ingestor_manager.managed_tags == {'slot1': {'server2': {'config': 'config2'}}}
+
+
+@mark.asyncio
+async def test_remove_server_not_found(ingestor_manager):
+    server1 = AsyncMock()
+    server2 = AsyncMock()
+    ingestor_manager.opc_managers = {'server1': server1, 'server2': server2}
+    ingestor_manager.managed_tags = {
+        'slot1': {'server1': {'config': 'config1'}, 'server2': {'config': 'config2'}}
+    }
+    await ingestor_manager.remove_server('server3')
+    server1.shutdown.assert_not_called()
+    server2.shutdown.assert_not_called()
+    assert 'server1' in ingestor_manager.opc_managers
+    assert 'server2' in ingestor_manager.opc_managers
+    assert ingestor_manager.managed_tags == {
+        'slot1': {'server1': {'config': 'config1'}, 'server2': {'config': 'config2'}}
+    }
+
+
+@mark.asyncio
+@patch('ingestor.managers.ingestor_manager.OpcManager')
+@patch('ingestor.managers.ingestor_manager.metrics')
+async def test_update_opc_servers(metrics, opc_manager, ingestor_manager):
+    manager1 = MagicMock(config={'config': 'config1'})
+    manager2 = MagicMock(config={'config': 'config2'})
+    manager3 = MagicMock(config={'config': 'config3'})
+
+    async def mock_initialize_from_config(config):
+        if config == {'config': 'config1'}:
+            return manager1
+        elif config == {'config': 'config2'}:
+            return manager2
+        elif config == {'config': 'config3'}:
+            return manager3
+        else:
+            return None
+
+    ingestor_manager.initialize_opc_from_config = AsyncMock(side_effect=mock_initialize_from_config)
+    ingestor_manager.remove_server = AsyncMock()
+
+    ingestor_manager.managed_tags = {
+        'slot1': {
+            'server1': {'config': 'config1'},
+            'server2': {'config': 'config2'},
+            'server5': {'config': 'config5'},
+        },
+        'slot2': {
+            'server3': {'config': 'config3'},
+            'server1': {'config': 'config1'},
+        },
+    }
+
+    mock = AsyncMock(config={'config': 'old_config2'})
+    ingestor_manager.opc_managers['server3'] = AsyncMock(config={'config': 'config3'})
+    ingestor_manager.opc_managers['server2'] = mock
+    ingestor_manager.opc_managers['server4'] = AsyncMock()
+
+    await ingestor_manager.update_opc_servers()
+
+    ingestor_manager.initialize_opc_from_config.assert_any_call({'config': 'config1'})
+    ingestor_manager.initialize_opc_from_config.assert_any_call({'config': 'config2'})
+    ingestor_manager.initialize_opc_from_config.assert_any_call({'config': 'config5'})
+
+    assert ingestor_manager.initialize_opc_from_config.call_count == 3
+
+    assert ingestor_manager.opc_managers['server1'].config == {'config': 'config1'}
+    assert ingestor_manager.opc_managers['server2'].config == {'config': 'config2'}
+    assert ingestor_manager.opc_managers['server3'].config == {'config': 'config3'}
+
+    ingestor_manager.remove_server.assert_any_call('server4')
+    ingestor_manager.remove_server.assert_any_call('server5')
+    assert ingestor_manager.remove_server.call_count == 2
+
+    assert ingestor_manager.opc_managers['server2'] != mock
+
+    ingestor_manager.emit_metric.assert_called_once_with(
+        metric_object=metrics.OPC_MANAGERS_ACTIVE,
+        method='set',
+        value=len(ingestor_manager.opc_managers),
+        tags={'pod_id': ingestor_manager.pod_id},
+    )
+
+
+@mark.asyncio
+@patch('ingestor.managers.ingestor_manager.metrics')
+async def test_check_opc_servers_integrity_all_healthy(metrics, ingestor_manager):
+    # Setup mock OPC managers
+    opc_manager1 = MagicMock()
+    opc_manager1.check_cycles = AsyncMock(return_value=None)
+    opc_manager1.check_opc_listenning = AsyncMock(return_value=False)
+    opc_manager1.config = {'config': 'config1'}
+
+    opc_manager2 = MagicMock()
+    opc_manager2.check_cycles = AsyncMock(return_value=None)
+    opc_manager2.check_opc_listenning = AsyncMock(return_value=False)
+    opc_manager2.config = {'config': 'config2'}
+
+    ingestor_manager.opc_managers = {'server1': opc_manager1, 'server2': opc_manager2}
+
+    # Mock the initialize_opc_from_config method
+    ingestor_manager.initialize_opc_from_config = MagicMock()
+
+    # Call the method
+    await ingestor_manager.check_opc_servers_integrity()
+
+    # Verify that check_cycles and check_opc_listenning were called for each server
+    opc_manager1.check_cycles.assert_called_once()
+    opc_manager1.check_opc_listenning.assert_called_once()
+    opc_manager2.check_cycles.assert_called_once()
+    opc_manager2.check_opc_listenning.assert_called_once()
+
+    # Verify that no reinitialization was needed
+    ingestor_manager.initialize_opc_from_config.assert_not_called()
+
+    ingestor_manager.emit_metric.assert_called_once_with(
+        metric_object=metrics.OPC_MANAGERS_ACTIVE,
+        method='set',
+        value=len(ingestor_manager.opc_managers),
+        tags={'pod_id': ingestor_manager.pod_id},
+    )
+
+
+@mark.asyncio
+async def test_check_opc_servers_integrity_server_lost(ingestor_manager):
+    # Setup mock OPC manager that will be lost
+    opc_manager = AsyncMock()
+    opc_manager.check_cycles.return_value = None
+    opc_manager.check_opc_listenning.return_value = True  # Server is lost
+    opc_manager.config = {'config': 'config1'}
+
+    ingestor_manager.opc_managers = {'server1': opc_manager}
+    ingestor_manager.managed_tags = {'slot1': MagicMock()}
+
+    # Call the method
+    await ingestor_manager.check_opc_servers_integrity()
+
+    assert 'server1' not in ingestor_manager.opc_managers
+    ingestor_manager.managed_tags['slot1'].pop.assert_called_once_with('server1', None)
+
+
+def test_check_opc_servers_integrity_server_lost_with_tags(ingestor_manager):
+    # Setup mock OPC manager that will be lost
+    opc_manager = MagicMock()
+    opc_manager.check_cycles.return_value = None
+    opc_manager.check_opc_listenning.return_value = True  # Server is lost
+    opc_manager.config = {'config': 'config1'}
+
+    ingestor_manager.opc_managers = {'server1': opc_manager}
+
+    # Setup managed tags
+    ingestor_manager.managed_tags = {
+        'slot1': {'server1': {'config': 'config1', 'tags': {'tag1': 'value1'}}}
+    }
+
+    # Mock the initialize_opc_from_config method to return a new manager
+    new_manager = MagicMock()
+    ingestor_manager.initialize_opc_from_config = MagicMock(return_value=new_manager)
+
+    # Call the method
+    ingestor_manager.check_opc_servers_integrity()
+
+
+@mark.asyncio
+async def test_declare_active(ingestor_manager):
+    ingestor_manager.resource_manager.ingestor_heartbeat = AsyncMock()
+    await ingestor_manager.declare_active()
+    ingestor_manager.resource_manager.ingestor_heartbeat.assert_called_once()
+
+
+@mark.asyncio
+async def test_get_active_ingestors(ingestor_manager):
+    ingestor_manager.resource_manager.get_all_ingestors = AsyncMock()
+    await ingestor_manager.get_active_ingestors()
+    ingestor_manager.resource_manager.get_all_ingestors.assert_called_once()
+
+
+@mark.asyncio
+async def test_get_active_ingestors_empty(ingestor_manager):
+    ingestor_manager.resource_manager.get_all_ingestors = AsyncMock(return_value=None)
+    result = await ingestor_manager.get_active_ingestors()
+    assert result == []
+    ingestor_manager.resource_manager.get_all_ingestors.assert_called_once()
+
+
+@patch('ingestor.managers.ingestor_manager.metrics')
+@mark.asyncio
+async def test_get_number_of_leases_success(metrics, ingestor_manager):
+    ingestor_manager.resource_manager.get_all_leases = AsyncMock(return_value=['lease1', 'lease2'])
+    result = await ingestor_manager.get_number_of_leases()
+    assert result == 2
+
+    ingestor_manager.emit_metric.assert_called_once_with(
+        metric_object=metrics.LEASES_TOTAL,
+        method='set',
+        value=2,
+        tags={'pod_id': ingestor_manager.pod_id},
+    )
+    ingestor_manager.resource_manager.get_all_leases.assert_called_once()
+
+
+@patch('ingestor.managers.ingestor_manager.metrics')
+@mark.asyncio
+async def test_get_number_of_slots_success(metrics, ingestor_manager):
+    ingestor_manager.resource_manager.get_all_slots = AsyncMock(return_value=['slot1', 'slot2'])
+    result = await ingestor_manager.get_number_of_slots()
+    assert result == 2
+    ingestor_manager.resource_manager.get_all_slots.assert_called_once()
+    ingestor_manager.emit_metric.assert_called_once_with(
+        metric_object=metrics.SLOTS_TOTAL,
+        method='set',
+        value=2,
+        tags={'pod_id': ingestor_manager.pod_id},
+    )
+
+
+@patch('ingestor.managers.ingestor_manager.metrics')
+@mark.asyncio
+async def test_get_number_of_slots_empty(metrics, ingestor_manager):
+    ingestor_manager.resource_manager.get_all_slots = AsyncMock(return_value=None)
+    result = await ingestor_manager.get_number_of_slots()
+    assert result == 0
+    ingestor_manager.resource_manager.get_all_slots.assert_called_once()
+    ingestor_manager.emit_metric.assert_called_once_with(
+        metric_object=metrics.SLOTS_TOTAL,
+        method='set',
+        value=0,
+        tags={'pod_id': ingestor_manager.pod_id},
+    )
+
+
+@mark.asyncio
+async def test_get_slot_leases_1_success(ingestor_manager):
+    ingestor_manager.resource_manager.lease_tag = AsyncMock(return_value=True)
+    ingestor_manager.resource_manager.get_tag_slot = AsyncMock(return_value={'tags': ['tag1']})
+
+    ingestor_manager.number_of_slots = 1
+    result = await ingestor_manager.get_slot_leases()
+
+    assert result == {'1': {'tags': ['tag1']}}
+
+
+@mark.asyncio
+async def test_get_slot_leases_2_success(ingestor_manager):
+    ingestor_manager.resource_manager.lease_tag = AsyncMock(side_effect=[True, True])
+    ingestor_manager.resource_manager.get_tag_slot = AsyncMock(
+        side_effect=[{'tags': ['tag1']}, {'tags': ['tag2']}]
+    )
+
+    ingestor_manager.number_of_slots = 2
+    result = await ingestor_manager.get_slot_leases(max_slots=2)
+
+    assert result == {'1': {'tags': ['tag1']}, '2': {'tags': ['tag2']}}
+
+
+@mark.asyncio
+async def test_get_slot_leases_2_1_none(ingestor_manager):
+    ingestor_manager.resource_manager.lease_tag = AsyncMock(side_effect=[True, True])
+    ingestor_manager.resource_manager.get_tag_slot = AsyncMock(
+        side_effect=[None, {'tags': ['tag1']}]
+    )
+
+    ingestor_manager.number_of_slots = 1
+    result = await ingestor_manager.get_slot_leases(max_slots=1)
+
+    assert result == {}
+
+
+@mark.asyncio
+async def test_get_slot_leases_1_failure(ingestor_manager):
+    ingestor_manager.resource_manager.lease_tag = AsyncMock(return_value=False)
+    ingestor_manager.resource_manager.get_tag_slot = AsyncMock(return_value={'tags': ['tag1']})
+
+    result = await ingestor_manager.get_slot_leases()
+    ingestor_manager.resource_manager.get_tag_slot.assert_not_called()
+
+    assert result == {}
+
+
+@mark.asyncio
+async def test_unsubscribe_slot(ingestor_manager):
+    ingestor_manager.managed_tags = {
+        'slot1': {'server1': {'tags': 'config1'}, 'server2': {'tags': 'config2'}},
+        'slot2': {'server3': {'tags': 'config3'}, 'server1': {'tags': 'config1'}},
+    }
+    ingestor_manager.opc_managers = {
+        'server1': AsyncMock(),
+        'server2': AsyncMock(),
+        'server3': AsyncMock(),
+    }
+    await ingestor_manager.unsubscribe_slot('slot1')
+
+    ingestor_manager.opc_managers['server1'].unsubscribe.assert_called_once_with('slot1')
+    ingestor_manager.opc_managers['server2'].unsubscribe.assert_called_once_with('slot1')
+    ingestor_manager.opc_managers['server3'].unsubscribe.assert_not_called()
+
+
+@mark.asyncio
+async def test_update_slot_config(ingestor_manager):
+    ingestor_manager.managed_tags = {
+        'slot1': {'config': 'old_config'},
+        'slot2': {'config': 'new_config'},
+        'slot3': {'config': 'old_config'},
+    }
+
+    ingestor_manager.resource_manager.get_tag_slot = AsyncMock(
+        side_effect=[{'config': 'updated_config'}, {'config': 'new_config'}, None]
+    )
+    ingestor_manager.resource_manager.renew_tag_lease = AsyncMock()
+
+    await ingestor_manager.update_slot_config()
+
+    assert ingestor_manager.managed_tags['slot1'] == {'config': 'updated_config'}
+    assert ingestor_manager.managed_tags['slot2'] == {'config': 'new_config'}
+    assert 'slot3' not in ingestor_manager.managed_tags
+
+    ingestor_manager.resource_manager.renew_tag_lease.assert_any_call('slot1')
+    ingestor_manager.resource_manager.renew_tag_lease.assert_any_call('slot3')
+    ingestor_manager.resource_manager.renew_tag_lease.assert_any_call('slot2')
+    assert ingestor_manager.resource_manager.renew_tag_lease.call_count == 3
+
+
+@patch('ingestor.managers.ingestor_manager.metrics')
+@mark.asyncio
+async def test_drop_slot_leases(metrics, ingestor_manager):
+    ingestor_manager.resource_manager.drop_tag_lease = AsyncMock()
+    await ingestor_manager.drop_slot_leases(['1', '2'])
+
+    ingestor_manager.resource_manager.drop_tag_lease.assert_any_call('1')
+    ingestor_manager.resource_manager.drop_tag_lease.assert_any_call('2')
+
+    ingestor_manager.emit_metric.assert_has_calls(
+        [
+            call(
+                metric_object=metrics.SLOTS_RELEASED,
+                method='inc',
+                value=1,
+                tags={'pod_id': ingestor_manager.pod_id},
+            ),
+            call(
+                metric_object=metrics.SLOTS_RELEASED,
+                method='inc',
+                value=1,
+                tags={'pod_id': ingestor_manager.pod_id},
+            ),
+        ]
+    )
+
+
+@mark.asyncio
+async def test_manage_server_no_server(ingestor_manager):
+    ingestor_manager.opc_managers = {'server1': MagicMock(), 'server2': MagicMock()}
+    server_config = {'tags': 'config1'}
+
+    result = await ingestor_manager.manage_server('slot1', 'server3', server_config, server_config)
+
+    assert result == 1
+    ingestor_manager.opc_managers['server1'].create_subscription.assert_not_called()
+    ingestor_manager.opc_managers['server1'].subscribe.assert_not_called()
+
+
+@mark.asyncio
+async def test_manage_server_create_subscription_failure(ingestor_manager):
+    ingestor_manager.opc_managers = {'server1': MagicMock(), 'server2': MagicMock()}
+    ingestor_manager.subscriptions = {'server1': MagicMock()}
+    server_config = {'tags': 'config1'}
+
+    ingestor_manager.opc_managers['server1'].create_subscription.side_effect = Exception(
+        'Subscription error'
+    )
+
+    result = await ingestor_manager.manage_server('slot1', 'server1', server_config, server_config)
+
+    assert result == 2
+    ingestor_manager.opc_managers['server1'].create_subscription.assert_called_once_with('slot1')
+    ingestor_manager.opc_managers['server1'].subscribe.assert_not_called()
+
+
+@mark.asyncio
+async def test_manage_server(ingestor_manager):
+    ingestor_manager.opc_managers = {'server1': AsyncMock(), 'server2': AsyncMock()}
+    ingestor_manager.subscriptions = {'server1': AsyncMock()}
+    server_config = {'tags': 'config1'}
+
+    result = await ingestor_manager.manage_server('slot1', 'server1', server_config, server_config)
+
+    assert result == 0
+    ingestor_manager.opc_managers['server1'].create_subscription.assert_called_once_with('slot1')
+    ingestor_manager.opc_managers['server1'].subscribe.assert_called_once_with(
+        'slot1', 'config1', ingestor_manager.poll_interval
+    )
+
+
+@patch('ingestor.managers.ingestor_manager.traceback')
+@mark.asyncio
+async def test_manage_server_subscribe_failure(traceback_mock, ingestor_manager):
+    ingestor_manager.opc_managers = {'server1': AsyncMock(), 'server2': AsyncMock()}
+    ingestor_manager.subscriptions = {'server1': AsyncMock()}
+    server_config = {'tags': 'config1'}
+
+    ingestor_manager.opc_managers['server1'].subscribe.side_effect = Exception('Subscription error')
+
+    result = await ingestor_manager.manage_server('slot1', 'server1', server_config, server_config)
+
+    assert result == 2
+    ingestor_manager.opc_managers['server1'].create_subscription.assert_called_once_with('slot1')
+    ingestor_manager.opc_managers['server1'].subscribe.assert_called_once_with(
+        'slot1', 'config1', ingestor_manager.poll_interval
+    )
+    ingestor_manager.opc_managers['server1'].unsubscribe.assert_called_once_with('slot1')
+
+    traceback_mock.format_exc.assert_called_once()
+
+    ingestor_manager.send_notification_async.assert_called_once_with(
+        metadata=metadata['metadata'],
+        notification_id='OPC_SUBSCRIPTION_ERROR_slot1:server1',
+        message="Failed to subscribe to tags from slot1:server1\n{'tags': 'config1'}: Subscription error",
+        block='opc_manager',
+        level=NotificationLevel.ERROR,
+        attachment_content=traceback_mock.format_exc.return_value,
+    )
+
+    ingestor_manager.logger.warning.assert_any_call(
+        'Removing subscription from server server1 for slot slot1'
+    )
+
+
+@mark.asyncio
+async def test_subscribe_to_tags(ingestor_manager):
+    ingestor_manager.manage_server = AsyncMock(side_effect=[0, 1, 2])
+    ingestor_manager.managed_tags = {'slot1': MagicMock(), 'slot2': MagicMock()}
+
+    ingestor_manager.opc_managers = {
+        'server1': AsyncMock(),
+        'server2': AsyncMock(),
+        'server3': AsyncMock(),
+    }
+    ingestor_manager.subscriptions = {'server1': AsyncMock()}
+    tags = {
+        'slot1': {
+            'server1': {'tags': 'config1'},
+            'server2': {'tags': 'config2'},
+            'server3': {'tags': 'config3'},
+        }
+    }
+
+    await ingestor_manager.subscribe_to_tags(tags)
+
+    ingestor_manager.manage_server.assert_any_call('slot1', 'server1', {'tags': 'config1'}, tags)
+    ingestor_manager.manage_server.assert_any_call('slot1', 'server2', {'tags': 'config2'}, tags)
+    ingestor_manager.manage_server.assert_any_call('slot1', 'server3', {'tags': 'config3'}, tags)
+
+    assert ingestor_manager.manage_server.call_count == 3
+
+    ingestor_manager.managed_tags['slot1'].pop.assert_called_once_with('server3', None)

tests/unit/managers/test_opc_manager.py

@@ -0,0 +1,627 @@
+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,
+                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,
+                tags={
+                    'pod_id': opc_manager.pod_id,
+                    'server_name': opc_manager.name,
+                },
+            ),
+        ]
+    )

tests/unit/managers/test_resource_manager.py

@@ -0,0 +1,178 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from pytest import fixture, mark, raises
+
+from ingestor.managers.resource_manager import ResourceManager
+
+metadata = {
+    'metadata': {
+        'model_id': 'test_model',
+        'model_name': 'test_model',
+        'workflow_name': 'test_workflow',
+        'schema_name': 'test_schedule',
+    },
+}
+
+
+@patch('ingestor.managers.resource_manager.RedisRepository')
+def test___init__(redis_repository):
+    logger = MagicMock()
+    notification_handler = MagicMock()
+    metrics_controller = MagicMock()
+    resource_manager = ResourceManager(
+        host='localhost',
+        port=6379,
+        lease_ttl=10,
+        heartbeat_ttl=10,
+        metadata=metadata['metadata'],
+        logger=logger,
+        notification_handler=notification_handler,
+        metrics_controller=metrics_controller,
+    )
+    assert resource_manager.redis_repository == redis_repository.return_value
+    redis_repository.assert_called_once_with(
+        host='localhost',
+        port=6379,
+        username=None,
+        password=None,
+        logger=logger,
+        notification_handler=notification_handler,
+        metrics_controller=metrics_controller,
+    )
+    redis_repository.return_value.redis_client.ping.assert_called_once()
+
+
+@patch('ingestor.managers.resource_manager.RedisRepository')
+def test___init__connection_failure(redis_repository):
+    redis_repository.return_value.redis_client.ping.side_effect = Exception('Connection failed')
+    with raises(Exception, match='Connection failed'):
+        ResourceManager(
+            host='localhost',
+            port=6379,
+            lease_ttl=10,
+            heartbeat_ttl=10,
+            metadata=metadata['metadata'],
+            logger=MagicMock(),
+            notification_handler=MagicMock(),
+            metrics_controller=MagicMock(),
+        )
+        redis_repository.return_value.redis_client.ping.assert_called_once()
+        redis_repository.logger.error.assert_called_once_with(
+            'Failed to connect to Redis: Connection failed'
+        )
+        redis_repository.return_value.redis_client.ping.assert_called_once()
+
+
+@fixture
+@patch('ingestor.managers.resource_manager.RedisRepository')
+def resource_manager(redis_repository):
+    resource_manager = ResourceManager(
+        host='localhost',
+        port=6379,
+        lease_ttl=10,
+        heartbeat_ttl=10,
+        metadata=metadata['metadata'],
+        logger=MagicMock(),
+        notification_handler=MagicMock(),
+        metrics_controller=MagicMock(),
+    )
+
+    resource_manager.send_notification = MagicMock()
+    resource_manager.send_notification_async = AsyncMock()
+    resource_manager.emit_metric = AsyncMock()
+
+    resource_manager.redis_repository = AsyncMock()
+
+    return resource_manager
+
+
+@mark.asyncio
+async def test_get_tag_slot(resource_manager):
+    result = await resource_manager.get_tag_slot('id')
+    assert result == resource_manager.redis_repository.get.return_value
+
+    resource_manager.redis_repository.get.assert_called_once_with(
+        'slot:opc_tags:id', metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_ingestor_heartbeat(resource_manager):
+    await resource_manager.ingestor_heartbeat()
+    resource_manager.redis_repository.set.assert_called_once_with(
+        'heartbeat:ingestor:localhost', 1, ttl=10, metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_lease_tag(resource_manager):
+    output = await resource_manager.lease_tag('tag_id')
+    assert output is resource_manager.redis_repository.set.return_value
+    resource_manager.redis_repository.set.assert_called_once_with(
+        'lease:opc_tags:tag_id', 'localhost', ttl=10, nx=True, metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_renew_tag_lease_success(resource_manager):
+    resource_manager.redis_repository.get.return_value = 'localhost'
+    resource_manager.redis_repository.expire.return_value = True
+    result = await resource_manager.renew_tag_lease('tag_id')
+    assert result is resource_manager.redis_repository.expire.return_value
+    resource_manager.redis_repository.get.assert_called_once_with(
+        'lease:opc_tags:tag_id', metadata=metadata['metadata']
+    )
+    resource_manager.redis_repository.expire.assert_called_once_with(
+        'lease:opc_tags:tag_id', 10, metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_renew_tag_lease_failure(resource_manager):
+    resource_manager.redis_repository.get.return_value = 'other_pod_id'
+
+    result = await resource_manager.renew_tag_lease('tag_id')
+    assert result is False
+
+    resource_manager.redis_repository.get.assert_called_once_with(
+        'lease:opc_tags:tag_id', metadata=metadata['metadata']
+    )
+    resource_manager.redis_repository.expire.assert_not_called()
+
+
+@mark.asyncio
+async def test_drop_tag_lease(resource_manager):
+    await resource_manager.drop_tag_lease('tag_id')
+    resource_manager.redis_repository.delete.assert_called_once_with(
+        'lease:opc_tags:tag_id', metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_get_all_ingestors(resource_manager):
+    resource_manager.redis_repository.keys.return_value = ['ingestor1', 'ingestor2']
+    result = await resource_manager.get_all_ingestors()
+    assert result == ['ingestor1', 'ingestor2']
+    resource_manager.redis_repository.keys.assert_called_once_with(
+        'heartbeat:ingestor:*', metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_get_all_slots(resource_manager):
+    resource_manager.redis_repository.keys.return_value = ['slot1', 'slot2']
+    result = await resource_manager.get_all_slots()
+    assert result == ['slot1', 'slot2']
+    resource_manager.redis_repository.keys.assert_called_once_with(
+        'slot:opc_tags:*', metadata=metadata['metadata']
+    )
+
+
+@mark.asyncio
+async def test_get_all_leases(resource_manager):
+    resource_manager.redis_repository.keys.return_value = ['lease1', 'lease2']
+    result = await resource_manager.get_all_leases()
+    assert result == ['lease1', 'lease2']
+    resource_manager.redis_repository.keys.assert_called_once_with(
+        'lease:opc_tags:*', metadata=metadata['metadata']
+    )

tests/unit/test_app.py

@@ -0,0 +1,319 @@
+import asyncio
+import signal as signal_module  # To avoid conflict with mock names
+from threading import Event
+from unittest.mock import AsyncMock, MagicMock, call
+
+import pytest
+
+# Import the 'app' module to be tested
+from ingestor import app
+
+
+# Custom exception to catch os._exit calls
+class OsExitCalledError(Exception):
+    def __init__(self, code):
+        super().__init__(f'os._exit({code}) called')
+        self.code = code
+
+
+# Helper function for the os_exit mock's side_effect
+def raise_os_exit_with_code(exit_code):
+    raise OsExitCalledError(exit_code)
+
+
+@pytest.fixture
+def mock_app_env(monkeypatch):
+    """Fixture to mock dependencies of app.main and app.signal_handler."""
+    mocks = {
+        'start_http_server': MagicMock(),
+        'Ingestor': MagicMock(),
+        'metrics_APP_UP_labels_set': MagicMock(),
+        'metrics_APP_LOOP_COUNT_labels_inc': MagicMock(),
+        'metrics_APP_LOOP_DURATION_labels_observe': MagicMock(),
+        'metrics_APP_ERRORS_TOTAL_labels_inc': MagicMock(),
+        'os_exit': MagicMock(side_effect=raise_os_exit_with_code),
+        'time_time': MagicMock(),
+        'asyncio_sleep': AsyncMock(),
+        'signal_signal': MagicMock(),
+        'traceback_print_exc': MagicMock(),
+        'mock_exit_signal': MagicMock(spec=Event),
+    }
+
+    monkeypatch.setattr(app, 'start_http_server', mocks['start_http_server'])
+    monkeypatch.setattr(app, 'Ingestor', mocks['Ingestor'])
+    monkeypatch.setattr(asyncio, 'sleep', mocks['asyncio_sleep'])
+
+    monkeypatch.setattr(
+        app.metrics.APP_UP,
+        'labels',
+        MagicMock(return_value=MagicMock(set=mocks['metrics_APP_UP_labels_set'])),
+    )
+    monkeypatch.setattr(
+        app.metrics.APP_LOOP_COUNT,
+        'labels',
+        MagicMock(return_value=MagicMock(inc=mocks['metrics_APP_LOOP_COUNT_labels_inc'])),
+    )
+    monkeypatch.setattr(
+        app.metrics.APP_LOOP_DURATION,
+        'labels',
+        MagicMock(
+            return_value=MagicMock(observe=mocks['metrics_APP_LOOP_DURATION_labels_observe'])
+        ),
+    )
+    monkeypatch.setattr(
+        app.metrics.APP_ERRORS_TOTAL,
+        'labels',
+        MagicMock(return_value=MagicMock(inc=mocks['metrics_APP_ERRORS_TOTAL_labels_inc'])),
+    )
+
+    monkeypatch.setattr(app.os, '_exit', mocks['os_exit'])
+    monkeypatch.setattr(app, 'time', mocks['time_time'])
+    monkeypatch.setattr(app.signal, 'signal', mocks['signal_signal'])
+    monkeypatch.setattr(app.traceback, 'print_exc', mocks['traceback_print_exc'])
+
+    monkeypatch.setattr(app, 'exit_signal', mocks['mock_exit_signal'])
+    monkeypatch.setattr(app, 'POD_ID', 'test_pod')
+
+    mock_ingestor_instance = mocks['Ingestor'].return_value
+    mock_ingestor_instance.poll_interval = 0.01
+    mock_ingestor_instance.logger = MagicMock()
+
+    # Make async methods async mocks
+    mock_ingestor_instance.prepare_ingestor = AsyncMock()
+    mock_ingestor_instance.loop = AsyncMock()
+    mock_ingestor_instance.shutdown = AsyncMock()
+
+    return mocks
+
+
+@pytest.mark.asyncio
+async def test_main_successful_run_one_loop(mock_app_env, capsys):
+    """Test a successful run where the loop executes once and then exits gracefully."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_exit_signal.is_set.side_effect = [False, True]
+    mock_app_env['time_time'].side_effect = [10.0, 11.5]
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    mock_app_env['start_http_server'].assert_called_once_with(9090)
+    app.metrics.APP_UP.labels.assert_any_call(pod_id='test_pod')
+    set_calls = mock_app_env['metrics_APP_UP_labels_set'].call_args_list
+    assert call(1) in set_calls
+    assert call(0) in set_calls
+    assert set_calls.index(call(1)) < set_calls.index(call(0))
+
+    mock_app_env['Ingestor'].assert_called_once_with()
+    mock_ingestor_instance.prepare_ingestor.assert_called_once()
+    mock_ingestor_instance.logger.info.assert_any_call('Ingestor prepared. Starting main loop.')
+
+    mock_ingestor_instance.loop.assert_called_once()
+    app.metrics.APP_LOOP_COUNT.labels.assert_called_with(pod_id='test_pod')
+    mock_app_env['metrics_APP_LOOP_COUNT_labels_inc'].assert_called_once()
+
+    mock_app_env['asyncio_sleep'].assert_has_calls(
+        [call(mock_ingestor_instance.poll_interval), call(5)]
+    )
+
+    app.metrics.APP_LOOP_DURATION.labels.assert_called_with(pod_id='test_pod')
+    mock_app_env['metrics_APP_LOOP_DURATION_labels_observe'].assert_called_once_with(1.5)
+
+    mock_ingestor_instance.shutdown.assert_called_once()
+    mock_ingestor_instance.logger.info.assert_any_call('Main loop exit_signaled.')
+
+    captured = capsys.readouterr()
+    assert 'Prometheus server started on port 9090.' in captured.out
+
+
+@pytest.mark.asyncio
+async def test_main_prometheus_server_fails_to_start(mock_app_env, capsys):
+    """Test the scenario where starting the Prometheus server fails."""
+    mock_app_env['start_http_server'].side_effect = OSError('Port already in use')
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 1
+
+    # Check that .set(1) was not called. .set(0) definitely not called.
+    called_with_1 = False
+    for call_args in mock_app_env['metrics_APP_UP_labels_set'].call_args_list:
+        if call_args == call(1):
+            called_with_1 = True
+            break
+    assert not called_with_1, 'APP_UP.set(1) should not have been called if server start failed'
+
+    mock_app_env['Ingestor'].assert_not_called()
+    captured = capsys.readouterr()
+    assert 'Failed to start Prometheus server: Port already in use' in captured.out
+
+
+@pytest.mark.asyncio
+async def test_main_loop_exception_handling(mock_app_env, capsys):
+    """Test that an exception in ingestor.loop() is handled gracefully."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_exit_signal.is_set.side_effect = [False, True]
+    mock_ingestor_instance.loop.side_effect = Exception('Test loop exception')
+    mock_app_env['time_time'].side_effect = [10.0, 10.1]
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    mock_ingestor_instance.loop.assert_called_once()
+    mock_app_env['traceback_print_exc'].assert_called_once()
+
+    app.metrics.APP_ERRORS_TOTAL.labels.assert_called_with(pod_id='test_pod')
+    mock_app_env['metrics_APP_ERRORS_TOTAL_labels_inc'].assert_called_once()
+
+    mock_exit_signal.set.assert_called_once()
+
+    mock_app_env['metrics_APP_LOOP_COUNT_labels_inc'].assert_not_called()
+
+    app.metrics.APP_LOOP_DURATION.labels.assert_called_with(pod_id='test_pod')
+    mock_app_env['metrics_APP_LOOP_DURATION_labels_observe'].assert_called_once_with(
+        pytest.approx(0.1)
+    )
+
+    mock_ingestor_instance.shutdown.assert_called_once()
+    captured = capsys.readouterr()
+    assert 'Exception in main loop. Setting exit_signal flag.' in captured.out
+
+
+@pytest.mark.asyncio
+async def test_main_keyboard_interrupt_handling(mock_app_env, capsys):
+    """Test that KeyboardInterrupt in ingestor.loop() is handled."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_exit_signal.is_set.side_effect = [False, True]
+    mock_ingestor_instance.loop.side_effect = KeyboardInterrupt()
+    mock_app_env['time_time'].side_effect = [10.0, 10.1]
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    mock_ingestor_instance.loop.assert_called_once()
+    mock_exit_signal.set.assert_called_once()
+    mock_ingestor_instance.shutdown.assert_called_once()
+    captured = capsys.readouterr()
+    assert 'KeyboardInterrupt received. Setting exit_signal flag.' in captured.out
+    mock_app_env['metrics_APP_ERRORS_TOTAL_labels_inc'].assert_not_called()
+
+
+def test_signal_handler_sets_exit_signal(mock_app_env):
+    """Test that the signal_handler function calls exit_signal.set()."""
+    mock_exit_signal_set = mock_app_env['mock_exit_signal'].set
+
+    app.signal_handler(signal_module.SIGINT, None)
+    mock_exit_signal_set.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_main_multiple_loop_iterations(mock_app_env):
+    """Test the main loop runs for a few iterations."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_exit_signal.is_set.side_effect = [False, False, False, True]
+    mock_app_env['time_time'].side_effect = [10.0, 10.1, 10.2, 10.3, 10.4, 10.5]
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    assert mock_ingestor_instance.loop.call_count == 3
+
+    assert app.metrics.APP_LOOP_COUNT.labels.call_count == 3
+    app.metrics.APP_LOOP_COUNT.labels.assert_called_with(
+        pod_id='test_pod'
+    )  # Checks last call or any call
+    assert mock_app_env['metrics_APP_LOOP_COUNT_labels_inc'].call_count == 3
+
+    assert mock_app_env['asyncio_sleep'].call_count == 4
+
+    assert app.metrics.APP_LOOP_DURATION.labels.call_count == 3
+    app.metrics.APP_LOOP_DURATION.labels.assert_called_with(pod_id='test_pod')
+    duration_calls = mock_app_env['metrics_APP_LOOP_DURATION_labels_observe'].call_args_list
+    assert duration_calls[0] == call(pytest.approx(0.1, abs=1e-9))
+    assert duration_calls[1] == call(pytest.approx(0.1, abs=1e-9))
+    assert duration_calls[2] == call(pytest.approx(0.1, abs=1e-9))
+
+    mock_ingestor_instance.shutdown.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_main_pod_id_used_in_metrics(mock_app_env):
+    """Test that the POD_ID from app module is used in metric labels."""
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+    mock_exit_signal.is_set.side_effect = [False, True]
+    mock_app_env['time_time'].side_effect = [10.0, 11.0]
+
+    with pytest.raises(OsExitCalledError):
+        await app.main()
+
+    app.metrics.APP_UP.labels.assert_any_call(pod_id='test_pod')
+    app.metrics.APP_LOOP_COUNT.labels.assert_any_call(pod_id='test_pod')
+    app.metrics.APP_LOOP_DURATION.labels.assert_any_call(pod_id='test_pod')
+    # APP_ERRORS_TOTAL would be checked similarly if it were called in this flow.
+
+    # Check the .set() / .inc() calls on the mocks returned by .labels()
+    mock_app_env['metrics_APP_UP_labels_set'].assert_any_call(1)
+    mock_app_env['metrics_APP_UP_labels_set'].assert_any_call(0)
+    mock_app_env['metrics_APP_LOOP_COUNT_labels_inc'].assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_run_async_main(mock_app_env, capsys):
+    """Test the run_async_main function that sets up the event loop."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_exit_signal.is_set.side_effect = [False, True]
+    mock_app_env['time_time'].side_effect = [10.0, 11.0]
+
+    # Instead of calling run_async_main() which creates a new event loop,
+    # we test the main() function directly since that's what run_async_main() would call
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    # Verify the main function was called through the event loop
+    mock_app_env['start_http_server'].assert_called_once_with(9090)
+    mock_ingestor_instance.prepare_ingestor.assert_called_once()
+    mock_ingestor_instance.loop.assert_called_once()
+    mock_ingestor_instance.shutdown.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_main_prepare_ingestor_failure(mock_app_env, capsys):
+    """Test that prepare_ingestor failure is handled correctly."""
+    mock_ingestor_instance = mock_app_env['Ingestor'].return_value
+    mock_exit_signal = mock_app_env['mock_exit_signal']
+
+    mock_ingestor_instance.prepare_ingestor.side_effect = Exception('Preparation failed')
+    mock_exit_signal.is_set.side_effect = [False, True]
+
+    with pytest.raises(OsExitCalledError) as excinfo:
+        await app.main()
+    assert excinfo.value.code == 0
+
+    # Verify error metrics were incremented
+    app.metrics.APP_ERRORS_TOTAL.labels.assert_called_with(pod_id='test_pod')
+    mock_app_env['metrics_APP_ERRORS_TOTAL_labels_inc'].assert_called_once()
+
+    # Verify exit signal was set
+    mock_exit_signal.set.assert_called_once()
+
+    # Verify shutdown was called
+    mock_ingestor_instance.shutdown.assert_called_once()
+
+    # Verify error was logged
+    mock_ingestor_instance.logger.error.assert_called_once_with(
+        'Failed to prepare ingestor: Preparation failed'
+    )

tests/unit/test_ingestor.py

@@ -0,0 +1,334 @@
+from unittest.mock import ANY, AsyncMock, MagicMock, call, patch
+
+from pytest import fixture, mark
+
+from ingestor.ingestor import Ingestor
+
+
+@patch('ingestor.ingestor.getenv')
+@patch('ingestor.ingestor.NotificationHandler')
+def test___init__(notification_handler, getenv):
+    getenv.side_effect = [
+        'localhost',  # REDIS_HOST
+        '63790',  # REDIS_PORT
+        'user',  # REDIS_USERNAME
+        'password',  # REDIS_PASSWORD
+        '100',  # LEASE_TTL
+        '200',  # HEARTBEAT_TTL
+        'localhost',  # HOSTNAME
+        '50',  # POLL_INTERVAL
+        'localhost:27017',  # MONGODB_URL
+        'sientia',  # MONGODB_USERNAME
+        'sientia',  # MONGODB_PASSWORD
+        'sientia',  # MONGODB_DATABASE
+    ]
+
+    ingestor = Ingestor()
+
+    getenv.assert_any_call('REDIS_HOST', 'localhost')
+    getenv.assert_any_call('REDIS_PORT', '6379')
+    getenv.assert_any_call('REDIS_USERNAME', None)
+    getenv.assert_any_call('REDIS_PASSWORD', None)
+    getenv.assert_any_call('LEASE_TTL', '10')
+    getenv.assert_any_call('HEARTBEAT_TTL', '20')
+    getenv.assert_any_call('HOSTNAME', 'localhost')
+    getenv.assert_any_call('POLL_INTERVAL', '5')
+
+    assert ingestor.redis_host == 'localhost'
+    assert ingestor.redis_port == 63790
+    assert ingestor.redis_username == 'user'
+    assert ingestor.redis_password == 'password'
+    assert ingestor.lease_ttl == 100
+    assert ingestor.heartbeat_ttl == 200
+    assert ingestor.pod_id == 'localhost'
+    assert ingestor.poll_interval == 50
+    assert ingestor.metadata == {
+        'model_id': '-',
+        'model_name': '-',
+        'workflow_name': 'opc_ingestor',
+        'schema_name': 'opc_ingestor',
+        'pod_id': 'localhost',
+    }
+
+    notification_handler.assert_called_once_with(
+        connection_string='mongodb://sientia:sientia@localhost:27017',
+        database='sientia',
+        logger=ingestor.logger,
+        project_name='opc_ingestor',
+    )
+
+
+@fixture
+@patch('ingestor.ingestor.getenv')
+@patch('ingestor.ingestor.NotificationHandler')
+def ingestor(_notification_handler, _getenv):
+    ing = Ingestor()
+    ing.logger = MagicMock()
+
+    return ing
+
+
+@fixture
+def ingestor_manager_started(ingestor):
+    ingestor.ingestor_manager = AsyncMock(
+        initialize_opc_from_config=AsyncMock(),
+        shutdown=AsyncMock(),
+        update_opc_servers=AsyncMock(),
+        subscribe_to_tags=AsyncMock(),
+        unsubscribe_slot=AsyncMock(),
+    )
+    return ingestor
+
+
+@mark.asyncio
+async def test_shutdown(ingestor_manager_started):
+    await ingestor_manager_started.shutdown()
+
+    ingestor_manager_started.ingestor_manager.shutdown.assert_called_once()
+
+
+@mark.asyncio
+async def test_handle_acquired_tags_not_acquired(ingestor_manager_started):
+    await ingestor_manager_started.handle_acquired_tags([])
+
+    ingestor_manager_started.logger.warning.assert_called_once_with('No slots available')
+    ingestor_manager_started.ingestor_manager.update_opc_servers.assert_not_called()
+    ingestor_manager_started.ingestor_manager.subscribe_to_tags.assert_not_called()
+
+
+@mark.asyncio
+async def test_handle_acquired_tags_success(ingestor_manager_started):
+    await ingestor_manager_started.handle_acquired_tags(['tag1', 'tag2'])
+
+    ingestor_manager_started.logger.warning.assert_not_called()
+    ingestor_manager_started.ingestor_manager.update_opc_servers.assert_called_once()
+    ingestor_manager_started.ingestor_manager.subscribe_to_tags.assert_called_once_with(
+        ['tag1', 'tag2']
+    )
+
+
+@patch('ingestor.ingestor.IngestorManager')
+@mark.asyncio
+async def test_prepare_ingestor(ingestor_manager_mock, ingestor):
+    ingestor_manager = ingestor_manager_mock.return_value
+    ingestor_manager.get_slot_leases.return_value = True
+
+    ingestor_manager.declare_active = AsyncMock()
+    ingestor_manager.get_slot_leases = AsyncMock()
+    ingestor.handle_acquired_tags = AsyncMock()
+
+    await ingestor.prepare_ingestor()
+
+    ingestor_manager_mock.assert_called_once_with(
+        redis_data={
+            'host': ingestor.redis_host,
+            'port': ingestor.redis_port,
+            'username': ingestor.redis_username,
+            'password': ingestor.redis_password,
+        },
+        lease_ttl=ingestor.lease_ttl,
+        heartbeat_ttl=ingestor.heartbeat_ttl,
+        poll_interval=ingestor.poll_interval,
+        mongo_connection_string=ingestor.mongo_connection_string,
+        mongo_database=ingestor.mongo_database,
+        metadata=ingestor.metadata,
+        logger=ingestor.logger,
+        notification_handler=ingestor.notification_handler,
+        metrics_controller=ingestor.metrics_controller,
+    )
+    ingestor_manager.declare_active.assert_called_once()
+    ingestor_manager.get_slot_leases.assert_called_once()
+
+    ingestor.handle_acquired_tags.assert_called_once_with(
+        ingestor_manager.get_slot_leases.return_value
+    )
+
+
+def test_manage_slots_has_slots(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = True
+
+    ingestor_manager_started.manage_no_slots(5)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_not_called()
+    ingestor_manager_started.ingestor_manager.handle_acquired_tags.assert_not_called()
+
+
+def test_manage_no_slots_has_slots_none_available(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = True
+
+    ingestor_manager_started.manage_no_slots(0)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_not_called()
+    ingestor_manager_started.ingestor_manager.handle_acquired_tags.assert_not_called()
+
+
+def test_manage_slots_none_available(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = False
+
+    ingestor_manager_started.manage_no_slots(0)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_not_called()
+    ingestor_manager_started.ingestor_manager.handle_acquired_tags.assert_not_called()
+
+
+@mark.asyncio
+async def test_manage_slots_none_available_none_available(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = False
+
+    await ingestor_manager_started.manage_no_slots(2)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_called_once_with(1)
+
+
+@mark.asyncio
+async def test_manage_leases_no_ingestor_manager(ingestor_manager_started):
+    ingestor_manager_started.ingestor_manager = None
+
+    assert await ingestor_manager_started.manage_leases(2, 2, 5) is None
+
+
+@mark.asyncio
+async def test_manage_leases_no_available_slots_no_extra_slots(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+
+    await ingestor_manager_started.manage_leases(0, 0, 0)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_not_called()
+    ingestor_manager_started.ingestor_manager.handle_acquired_tags.assert_not_called()
+    ingestor_manager_started.ingestor_manager.drop_slot_leases.assert_not_called()
+
+
+@mark.asyncio
+async def test_manage_leases_available_slots_innactive_ingestors(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+
+    await ingestor_manager_started.manage_leases(2, 2, 5)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_called_once_with(2)
+
+    ingestor_manager_started.ingestor_manager.drop_slot_leases.assert_not_called()
+
+
+@mark.asyncio
+async def test_manage_leases_no_available_slots_extra_sltos(ingestor_manager_started):
+    ingestor_manager_started.handle_acquired_tags = MagicMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = {
+        'tag1': 'server1',
+        'tag2': 'server2',
+        'tag3': 'server3',
+    }
+
+    await ingestor_manager_started.manage_leases(0, 0, 2)
+
+    ingestor_manager_started.ingestor_manager.get_slot_leases.assert_not_called()
+    ingestor_manager_started.handle_acquired_tags.assert_not_called()
+    ingestor_manager_started.ingestor_manager.drop_slot_leases.assert_called_once_with(
+        ['tag2', 'tag3']
+    )
+
+
+@mark.asyncio
+async def test_loop(ingestor_manager_started):
+    ingestor_manager_started.manage_no_slots = AsyncMock()
+    ingestor_manager_started.manage_leases = AsyncMock()
+    ingestor_manager_started.update_ingestor_manager = AsyncMock()
+    ingestor_manager_started.ingestor_manager.check_opc_servers_integrity = AsyncMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = {
+        'slot1': 'server1',
+        'slot2': 'server2',
+        'slot3': 'server3',
+    }
+    ingestor_manager_started.ingestor_manager.get_active_ingestors = AsyncMock(
+        return_value=['ingestor1', 'ingestor2']
+    )
+    ingestor_manager_started.ingestor_manager.get_number_of_slots = AsyncMock(return_value=5)
+    ingestor_manager_started.ingestor_manager.get_number_of_leases = AsyncMock(return_value=1)
+
+    await ingestor_manager_started.loop()
+
+    ingestor_manager_started.ingestor_manager.declare_active.assert_called_once()
+    ingestor_manager_started.ingestor_manager.get_active_ingestors.assert_called_once()
+    ingestor_manager_started.ingestor_manager.get_number_of_slots.assert_called_once()
+
+    ingestor_manager_started.manage_no_slots.assert_called_once_with(
+        ingestor_manager_started.ingestor_manager.get_number_of_slots.return_value
+    )
+    # Explanation: 5 - 2 = 3, 3 - 1 = 2
+    ingestor_manager_started.manage_leases.assert_called_once_with(4, 3, 2)
+    ingestor_manager_started.ingestor_manager.update_slot_config.assert_called_once()
+
+    ingestor_manager_started.ingestor_manager.check_opc_servers_integrity.assert_called_once()
+    ingestor_manager_started.update_ingestor_manager.assert_called_once()
+
+
+@mark.asyncio
+async def test_loop_no_managed(ingestor_manager_started):
+    ingestor_manager_started.manage_no_slots = AsyncMock()
+    ingestor_manager_started.manage_leases = AsyncMock()
+    ingestor_manager_started.update_ingestor_manager = AsyncMock()
+    ingestor_manager_started.ingestor_manager.check_opc_servers_integrity = AsyncMock()
+    ingestor_manager_started.ingestor_manager.managed_tags = {}
+    ingestor_manager_started.ingestor_manager.get_active_ingestors = AsyncMock(
+        return_value=['ingestor1', 'ingestor2']
+    )
+    ingestor_manager_started.ingestor_manager.get_number_of_slots = AsyncMock(return_value=5)
+
+    await ingestor_manager_started.loop()
+
+    ingestor_manager_started.ingestor_manager.declare_active.assert_called_once()
+    ingestor_manager_started.ingestor_manager.get_active_ingestors.assert_called_once()
+    ingestor_manager_started.ingestor_manager.get_number_of_slots.assert_called_once()
+
+    ingestor_manager_started.manage_no_slots.assert_called_once_with(
+        ingestor_manager_started.ingestor_manager.get_number_of_slots.return_value
+    )
+    # Explanation: 5 - 2 = 3, 3 - 1 = 2
+    ingestor_manager_started.manage_leases.assert_called_once_with(ANY, 3, -1)
+    ingestor_manager_started.ingestor_manager.update_slot_config.assert_called_once()
+    ingestor_manager_started.logger.info.assert_any_call('No slots acquired in this loop')
+
+    ingestor_manager_started.ingestor_manager.check_opc_servers_integrity.assert_called_once()
+    ingestor_manager_started.update_ingestor_manager.assert_called_once()
+
+
+@mark.asyncio
+async def test_loop_no_ingestor_manager(ingestor_manager_started):
+    ingestor_manager_started.ingestor_manager = None
+
+    assert await ingestor_manager_started.loop() is None
+
+
+@mark.asyncio
+async def test_update_ingestor_manager(ingestor_manager_started):
+    ingestor_manager_started.ingestor_manager.managed_tags = {
+        'slot_to_create': 'new_config',
+        'slot_to_update': 'new_config',
+        'slot_to_do_nothing': 'old_config',
+    }
+
+    old_managed_tags = {
+        'slot_to_update': 'old_config',
+        'slot_to_delete': 'old_config',
+        'slot_to_do_nothing': 'old_config',
+    }
+
+    await ingestor_manager_started.update_ingestor_manager(old_managed_tags)
+
+    ingestor_manager_started.ingestor_manager.update_opc_servers.assert_called_once()
+    ingestor_manager_started.ingestor_manager.subscribe_to_tags.assert_has_calls(
+        [call({'slot_to_create': 'new_config'}), call({'slot_to_update': 'new_config'})]
+    )
+    ingestor_manager_started.ingestor_manager.unsubscribe_slot.assert_has_calls(
+        [call('slot_to_update'), call('slot_to_delete')]
+    )
+
+
+@mark.asyncio
+async def test_update_ingestor_manager_no_ingestor_manager(ingestor_manager_started):
+    ingestor_manager_started.ingestor_manager = None
+
+    await ingestor_manager_started.update_ingestor_manager({})

tests/unit/test_metrics.py

@@ -0,0 +1,191 @@
+# tests/unit/test_metrics.py
+
+from prometheus_client import Counter, Gauge, Histogram
+
+import ingestor.metrics as metrics
+
+# --- Test Functions for Each Metric (Corrected for v0.22.0 _name behavior) ---
+
+
+def test_ingestor_tag_written_count():
+    """Verify the definition of INGESTOR_TAG_WRITTEN_COUNT."""
+    assert metrics.TAG_WRITTEN_COUNT is not None
+    assert isinstance(metrics.TAG_WRITTEN_COUNT, Counter)
+    assert metrics.TAG_WRITTEN_COUNT._name == 'ingestor_tag_written_count'
+    assert set(metrics.TAG_WRITTEN_COUNT._labelnames) == {'pod_id', 'tag_name', 'collection_name'}
+
+
+def test_app_loop_count():
+    """Verify the definition of APP_LOOP_COUNT."""
+    assert metrics.APP_LOOP_COUNT is not None
+    assert isinstance(metrics.APP_LOOP_COUNT, Counter)
+    assert metrics.APP_LOOP_COUNT._name == 'app_main_loop'  # REMOVED _total
+    assert set(metrics.APP_LOOP_COUNT._labelnames) == {'pod_id'}
+
+
+def test_app_loop_duration():
+    """Verify the definition of APP_LOOP_DURATION."""
+    assert metrics.APP_LOOP_DURATION is not None
+    assert isinstance(metrics.APP_LOOP_DURATION, Histogram)
+    assert (
+        metrics.APP_LOOP_DURATION._name == 'app_main_loop_duration_seconds'
+    )  # Histograms don't have _total
+    assert set(metrics.APP_LOOP_DURATION._labelnames) == {'pod_id'}
+
+
+def test_app_errors_total():
+    """Verify the definition of APP_ERRORS_TOTAL."""
+    assert metrics.APP_ERRORS_TOTAL is not None
+    assert isinstance(metrics.APP_ERRORS_TOTAL, Counter)
+    assert metrics.APP_ERRORS_TOTAL._name == 'app_errors'  # REMOVED _total
+    assert set(metrics.APP_ERRORS_TOTAL._labelnames) == {'pod_id'}
+
+
+def test_app_up():
+    """Verify the definition of APP_UP."""
+    assert metrics.APP_UP is not None
+    assert isinstance(metrics.APP_UP, Gauge)
+    assert metrics.APP_UP._name == 'app_up'  # Gauges don't have _total
+    assert set(metrics.APP_UP._labelnames) == {'pod_id'}
+
+
+def test_active_ingestors():
+    """Verify the definition of ACTIVE_INGESTORS."""
+    assert metrics.ACTIVE_INGESTORS is not None
+    assert isinstance(metrics.ACTIVE_INGESTORS, Gauge)
+    assert metrics.ACTIVE_INGESTORS._name == 'ingestor_active_total'
+    assert set(metrics.ACTIVE_INGESTORS._labelnames) == {'pod_id'}
+
+
+def test_slots_total():
+    """Verify the definition of SLOTS_TOTAL."""
+    assert metrics.SLOTS_TOTAL is not None
+    assert isinstance(metrics.SLOTS_TOTAL, Gauge)
+    assert metrics.SLOTS_TOTAL._name == 'ingestor_slots_total'
+    assert set(metrics.SLOTS_TOTAL._labelnames) == {'pod_id'}
+
+
+def test_leases_total():
+    """Verify the definition of LEASES_TOTAL."""
+    assert metrics.LEASES_TOTAL is not None
+    assert isinstance(metrics.LEASES_TOTAL, Gauge)
+    assert metrics.LEASES_TOTAL._name == 'ingestor_leases_total'
+    assert set(metrics.LEASES_TOTAL._labelnames) == {'pod_id'}
+
+
+def test_slots_managed():
+    """Verify the definition of SLOTS_MANAGED."""
+    assert metrics.SLOTS_MANAGED is not None
+    assert isinstance(metrics.SLOTS_MANAGED, Gauge)
+    assert metrics.SLOTS_MANAGED._name == 'ingestor_slots_managed_current'
+    assert set(metrics.SLOTS_MANAGED._labelnames) == {'pod_id'}
+
+
+def test_slots_acquired():
+    """Verify the definition of SLOTS_ACQUIRED."""
+    assert metrics.SLOTS_ACQUIRED is not None
+    assert isinstance(metrics.SLOTS_ACQUIRED, Counter)
+    assert metrics.SLOTS_ACQUIRED._name == 'ingestor_slots_acquired'  # REMOVED _total
+    assert set(metrics.SLOTS_ACQUIRED._labelnames) == {'pod_id'}
+
+
+def test_slots_released():
+    """Verify the definition of SLOTS_RELEASED."""
+    assert metrics.SLOTS_RELEASED is not None
+    assert isinstance(metrics.SLOTS_RELEASED, Counter)
+    assert metrics.SLOTS_RELEASED._name == 'ingestor_slots_released'  # REMOVED _total
+    assert set(metrics.SLOTS_RELEASED._labelnames) == {'pod_id'}
+
+
+def test_opc_managers_active():
+    """Verify the definition of OPC_MANAGERS_ACTIVE."""
+    assert metrics.OPC_MANAGERS_ACTIVE is not None
+    assert isinstance(metrics.OPC_MANAGERS_ACTIVE, Gauge)
+    assert metrics.OPC_MANAGERS_ACTIVE._name == 'ingestor_opc_managers_active'
+    assert set(metrics.OPC_MANAGERS_ACTIVE._labelnames) == {'pod_id'}
+
+
+def test_opc_subscription_errors():
+    """Verify the definition of OPC_SUBSCRIPTION_ERRORS."""
+    assert metrics.OPC_SUBSCRIPTION_ERRORS is not None
+    assert isinstance(metrics.OPC_SUBSCRIPTION_ERRORS, Counter)
+    assert (
+        metrics.OPC_SUBSCRIPTION_ERRORS._name == 'ingestor_opc_subscription_errors'
+    )  # REMOVED _total
+    assert set(metrics.OPC_SUBSCRIPTION_ERRORS._labelnames) == {
+        'pod_id',
+        'server',
+        'slot',
+    }
+
+
+def test_opc_connections_total():
+    """Verify the definition of OPC_CONNECTIONS_TOTAL."""
+    assert metrics.OPC_CONNECTIONS_TOTAL is not None
+    assert isinstance(metrics.OPC_CONNECTIONS_TOTAL, Counter)
+    assert metrics.OPC_CONNECTIONS_TOTAL._name == 'opc_connections_initiated'  # REMOVED _total
+    assert set(metrics.OPC_CONNECTIONS_TOTAL._labelnames) == {'pod_id', 'server_name'}
+
+
+def test_opc_connections_failed():
+    """Verify the definition of OPC_CONNECTIONS_FAILED."""
+    assert metrics.OPC_CONNECTIONS_FAILED is not None
+    assert isinstance(metrics.OPC_CONNECTIONS_FAILED, Counter)
+    assert metrics.OPC_CONNECTIONS_FAILED._name == 'opc_connections_failed'  # REMOVED _total
+    assert set(metrics.OPC_CONNECTIONS_FAILED._labelnames) == {'pod_id', 'server_name'}
+
+
+def test_opc_connection_status():
+    """Verify the definition of OPC_CONNECTION_STATUS."""
+    assert metrics.OPC_CONNECTION_STATUS is not None
+    assert isinstance(metrics.OPC_CONNECTION_STATUS, Gauge)
+    assert metrics.OPC_CONNECTION_STATUS._name == 'opc_connection_status'
+    assert set(metrics.OPC_CONNECTION_STATUS._labelnames) == {
+        'pod_id',
+        'server_name',
+        'server_url',
+    }
+
+
+def test_opc_subscriptions_created():
+    """Verify the definition of OPC_SUBSCRIPTIONS_CREATED."""
+    assert metrics.OPC_SUBSCRIPTIONS_CREATED is not None
+    assert isinstance(metrics.OPC_SUBSCRIPTIONS_CREATED, Counter)
+    assert metrics.OPC_SUBSCRIPTIONS_CREATED._name == 'opc_subscriptions_created'  # REMOVED _total
+    assert set(metrics.OPC_SUBSCRIPTIONS_CREATED._labelnames) == {
+        'pod_id',
+        'server_name',
+        'slot_name',
+    }
+
+
+def test_opc_tags_subscribed():
+    """Verify the definition of OPC_TAGS_SUBSCRIBED."""
+    assert metrics.OPC_TAGS_SUBSCRIBED is not None
+    assert isinstance(metrics.OPC_TAGS_SUBSCRIBED, Gauge)
+    assert metrics.OPC_TAGS_SUBSCRIBED._name == 'opc_tags_subscribed_current'
+    assert set(metrics.OPC_TAGS_SUBSCRIBED._labelnames) == {'pod_id', 'server_name'}
+
+
+def test_opc_cycles_without_data():
+    """Verify the definition of OPC_CYCLES_WITHOUT_DATA."""
+    assert metrics.OPC_CYCLES_WITHOUT_DATA is not None
+    assert isinstance(metrics.OPC_CYCLES_WITHOUT_DATA, Gauge)
+    assert metrics.OPC_CYCLES_WITHOUT_DATA._name == 'opc_cycles_without_data'
+    assert set(metrics.OPC_CYCLES_WITHOUT_DATA._labelnames) == {'pod_id', 'server_name'}
+
+
+def test_opc_reconnections_total():
+    """Verify the definition of OPC_RECONNECTIONS_TOTAL."""
+    assert metrics.OPC_RECONNECTIONS_TOTAL is not None
+    assert isinstance(metrics.OPC_RECONNECTIONS_TOTAL, Counter)
+    assert metrics.OPC_RECONNECTIONS_TOTAL._name == 'opc_reconnections_tried'  # REMOVED _total
+    assert set(metrics.OPC_RECONNECTIONS_TOTAL._labelnames) == {'pod_id', 'server_name'}
+
+
+def test_notifications_sent():
+    """Verify the definition of NOTIFICATIONS_SENT."""
+    assert metrics.NOTIFICATIONS_SENT is not None
+    assert isinstance(metrics.NOTIFICATIONS_SENT, Counter)
+    assert metrics.NOTIFICATIONS_SENT._name == 'notifications_sent'  # REMOVED _total
+    assert set(metrics.NOTIFICATIONS_SENT._labelnames) == {'pod_id', 'level', 'block'}