SIENTIAPDE-1030

Add unit tests for connectors configuration, logger, workflows, and predictions batch

- Implement tests for MLflow, OPC, and Postgres configuration builders to validate environment variable handling and default values.
- Create tests for the logger to ensure default settings and handler configurations are correct.
- Add comprehensive tests for the FormatAndExportPrediction and PredictionProcess workflows, covering various scenarios including path flags and activity execution.
- Introduce tests for the PredictionsBatch workflow to verify the execution of local activities and child workflows.
- Include a values.yaml file for Kubernetes deployment configuration, specifying image details, service account settings, environment variables, and resource limits.

tests/laborious/utils/filters/test_conditional_filters.py

@@ -0,0 +1,30 @@
+from pandas import DataFrame
+
+from laborious.utils.filters.conditional_filters import (
+    filter_specific_variables_null_values,
+    filter_empty_data
+)
+
+
+def test_filter_specific_variables_null_values():
+    assert filter_specific_variables_null_values(
+        DataFrame(
+            {'variable': ['variable1', 'variable2'], 'value': [1, 2]}),
+        config={'VARIABLES': ['variable2']}) is False
+
+
+def test_filter_specific_variables_null_values_with_null_values():
+    assert filter_specific_variables_null_values(
+        DataFrame(
+            {'variable': ['variable1', 'variable2'], 'value': [1, None]}),
+        config={'VARIABLES': ['variable2']}) is True
+
+
+def test_filter_empty_data():
+    assert filter_empty_data(DataFrame(), {}) is True
+
+
+def test_filter_empty_data_with_data():
+    assert filter_empty_data(
+        DataFrame({'variable': ['variable1', 'variable2'], 'value': [1, 2]}),
+        {}) is False

tests/laborious/utils/filters/test_mlflow_filters.py

@@ -0,0 +1,22 @@
+from pandas import DataFrame
+from laborious.utils.filters.mlflow_filters import api_error_filter, nan_values_filter
+
+
+def test_api_error_filter_invalid_response():
+    assert api_error_filter(None, {}) == True  # NOSONAR
+
+
+def test_api_error_filter_valid_response_fail():
+    assert api_error_filter({'success': False}, {}) == True
+
+
+def test_api_error_filter_valid_response_success():
+    assert api_error_filter({'success': True}, {}) == False
+
+
+def test_nan_values_filter_all_nan_values():
+    assert nan_values_filter(DataFrame({'variable': [None, None]}), {}) == True
+
+
+def test_nan_values_filter_no_nan_values():
+    assert nan_values_filter(DataFrame({'variable': [1, 2]}), {}) == False

tests/laborious/utils/repository/test_model_repository.py

@@ -0,0 +1,278 @@
+from unittest.mock import ANY, MagicMock, patch
+import numpy as np
+from pandas import DataFrame
+import pytest
+from laborious.utils.repository.model_repository import MLFlowRepository
+
+
+@pytest.fixture
+def mlflow_repository():
+    with patch('laborious.utils.repository.model_repository.ModelServing', autospec=True) as MockModelServing:
+        mock_instance = MockModelServing.return_value
+        mock_instance.get_transformed_data = MagicMock()
+
+        repo = MLFlowRepository(
+            host='http://localhost:5000',
+            username='admin',
+            password='admin'
+        )
+        return repo
+
+
+def test_get_current_data_df(mlflow_repository):
+    current_data = {
+        'prediction': [1, 3],
+        'target': [1, 1],
+    }
+    mlflow_repository.model_serving.get_transformed_data.return_value = {
+        'var1': [1, 2],
+        'var2': [2, np.nan],
+    }
+    expected = DataFrame({
+        'var1': [1],
+        'var2': [2],
+        'prediction': [1],
+        'target': [1],
+    })
+    output = mlflow_repository.get_current_data_df(current_data,
+                                                   'model', 'target')
+
+    mlflow_repository.model_serving.get_transformed_data.assert_called_once_with(
+        'model', current_data, by='model')
+
+    diff = output.compare(expected)
+    assert diff.empty
+
+
+def test_get_artifact(mlflow_repository):
+    mlflow_repository.get_artifact(
+        'destination', 'search_by', 'run_id', 'model', 'artifact'
+    )
+    mlflow_repository.model_serving.get_artifact.assert_called_once_with(
+        destination='destination',
+        search_by='search_by',
+        run_id='run_id',
+        model_name='model',
+        artifact_name='artifact'
+    )
+
+
+def test_calculate_model_metrics(mlflow_repository):
+    mlflow_repository.model_serving.get_model_metrics.return_value = 'data'
+    real_data = 'real_data'
+    predictions = 'predictions'
+    flag = 'flag'
+    output = mlflow_repository.calculate_model_metrics(
+        real_data, predictions, flag
+    )
+    mlflow_repository.model_serving.get_model_metrics.assert_called_once_with(
+        reference_data=None,
+        real_data=real_data,
+        predictions=predictions,
+        type_flag=flag
+    )
+    assert output == 'data'
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_get_experiment_by_run_id(mlflow, mlflow_repository):
+    mlflow.get_run.return_value = MagicMock(
+        info=MagicMock(
+            experiment_id='0',
+        )
+    )
+    mlflow.get_experiment.return_value = MagicMock()
+    mlflow.get_experiment.return_value.name = 'test'
+
+    output = mlflow_repository.get_experiment_by_run_id('0')
+    assert output == 'test'
+    mlflow.get_run.assert_called_once_with('0')
+    mlflow.get_experiment.assert_called_once_with('0')
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_get_next_run_name(mlflow, mlflow_repository):
+    mlflow.search_runs.return_value = [1, 2, 3]
+    output = mlflow_repository.get_next_run_name('run')
+    assert output == 'run-4'
+    mlflow.search_runs.assert_called_once_with(
+        experiment_names=['run'],
+        order_by=['start_time desc'],
+    )
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_get_experiment_success(mlflow, mlflow_repository):
+    mlflow.get_experiment_by_name.return_value = MagicMock(
+        experiment_id='0')
+
+    output = mlflow_repository.get_experiment('test')
+
+    assert output == 0
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_get_experiment_error(mlflow, mlflow_repository):
+    mlflow.get_experiment_by_name.return_value = None
+
+    try:
+        mlflow_repository.get_experiment('test')
+    except ValueError as e:
+        assert str(e) == 'Experiment test not found'
+    else:
+        assert False
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_get_experiment_last_run(mlflow, mlflow_repository):
+    mlflow.search_runs.return_value = DataFrame({
+        'params.retrain': ['True', 'False', 'True', 'False'],
+        'end_time': ['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04'],
+        'run_id': ['0', '1', '2', '3'],
+    })
+
+    output = mlflow_repository.get_experiment_last_run(0)
+
+    mlflow.search_runs.assert_called_once_with(
+        experiment_ids=[0],
+        filter_string="",
+        output_format="pandas",
+    )
+
+    assert output == '2'
+
+
+@patch('laborious.utils.repository.model_repository.mlflow')
+def test_update_production_model_by_run_id(mlflow, mlflow_repository):
+    client_mock = MagicMock()
+    mlflow.tracking.MlflowClient.return_value = client_mock
+
+    client_mock.get_registered_model.return_value = MagicMock(
+        latest_versions=[
+            MagicMock(version='1'),
+            MagicMock(version='2'),
+            MagicMock(version='3'),
+        ]
+    )
+    output = mlflow_repository.update_production_model_by_run_id('0', 'test')
+
+    mlflow.register_model.assert_called_once_with(
+        "runs:/0/prediction_model",
+        'test',
+    )
+
+    mlflow.tracking.MlflowClient.assert_called_once()
+    client_mock.get_registered_model.assert_called_once_with('test')
+    client_mock.transition_model_version_stage.assert_called_once_with(
+        name='test',
+        version='3',
+        stage='Production',
+        archive_existing_versions=True,
+    )
+
+    assert output == {
+        'model_name': 'test',
+        'version': '3',
+        'mlflow_run_id': '0',
+    }
+
+
+def test_update_production_model(mlflow_repository):
+    connector = mlflow_repository
+
+    with patch.object(connector, 'get_experiment',
+                      return_value='0') as get_experiment:
+        with patch.object(connector, 'get_experiment_last_run',
+                          return_value='2') as get_experiment_last_run:
+            with patch.object(connector, 'update_production_model_by_run_id',
+                              return_value={'model_name': 'test', 'version': '3',
+                                            'mlflow_run_id': '0'}) as update_production_model_by_run_id:
+
+                output = connector.update_production_model('0', 'test')
+
+                get_experiment.assert_called_once_with('0')
+                get_experiment_last_run.assert_called_once_with('0')
+                update_production_model_by_run_id.assert_called_once_with(
+                    '2', 'test')
+
+                assert output == {
+                    'model_name': 'test',
+                    'version': '3',
+                    'mlflow_run_id': '0',
+                    'mlflow_experiment_id': '0',
+                }
+
+
+def test_transform_success(mlflow_repository):
+    data = 'data'
+    model_name = 'model'
+
+    output = mlflow_repository.transform(model_name, data, 1)
+
+    mlflow_repository.model_serving.get_cached_transform.assert_called_once_with(
+        model_name, data, 1)
+
+    assert output == {
+        'success': True,
+        'content': mlflow_repository.model_serving.get_cached_transform.return_value.to_dict.return_value
+    }
+
+
+def test_transform_error(mlflow_repository):
+    data = 'data'
+    model_name = 'model'
+
+    mlflow_repository.model_serving.get_cached_transform.side_effect = Exception(
+        'error')
+
+    output = mlflow_repository.transform(model_name, data, 1)
+
+    mlflow_repository.model_serving.get_cached_transform.assert_called_once_with(
+        model_name, data, 1)
+
+    assert output == {
+        'success': False,
+        'content': {
+            'message': 'error',
+            'traceback': ANY
+        }
+    }
+
+
+def test_predict_success(mlflow_repository):
+    data = 'data'
+    model_name = 'model'
+    mlflow_repository.model_serving.get_cached_predict.return_value = np.array(
+        [2, 3]
+    )
+
+    output = mlflow_repository.predict(model_name, data, 1)
+
+    mlflow_repository.model_serving.get_cached_predict.assert_called_once_with(
+        model_name, data, 1)
+
+    assert output['success'] is True
+    assert output['content'] == {'prediction': {
+        0: 3}, 'response_time': ANY}
+
+
+def test_predict_error(mlflow_repository):
+    data = 'data'
+    model_name = 'model'
+
+    mlflow_repository.model_serving.get_cached_predict = MagicMock(
+        side_effect=Exception('error')
+    )
+
+    output = mlflow_repository.predict(model_name, data, 1)
+
+    mlflow_repository.model_serving.get_cached_predict.assert_called_once_with(
+        model_name, data, 1)
+
+    assert output == {
+        'success': False,
+        'content': {
+            'message': 'error',
+            'traceback': ANY
+        }
+    }

tests/laborious/utils/repository/test_opc_repository.py

@@ -0,0 +1,259 @@
+from unittest.mock import Mock, patch, MagicMock, ANY, call
+from asyncua.crypto.security_policies import SecurityPolicyBasic256
+from pytest import fixture
+from laborious.utils.repository.opc_repository import OpcRepository
+from sientia_do.notifications.models import NotificationLevel
+from datetime import datetime
+
+
+@fixture
+def mock_logger():
+    return Mock()
+
+
+@fixture
+def opc_repository(mock_logger):
+    return OpcRepository(
+        name="test_repo",
+        url="opc.tcp://localhost:4840",
+        logger=mock_logger,
+        notification_handler=Mock(),
+        reconnection_interval=60,
+        server_uri="urn:test:server",
+        cert_path="/path/to/cert.pem",
+        private_key_path="/path/to/key.pem",
+        server_cert_path="/path/to/server_cert.pem"
+    )
+
+
+@fixture
+def mock_client():
+    with patch('laborious.utils.repository.opc_repository.Client') as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+        yield client_instance
+
+
+def test_init(opc_repository):
+    assert opc_repository.name == "test_repo"
+    assert opc_repository.url == "opc.tcp://localhost:4840"
+    assert opc_repository.server_uri == "urn:test:server"
+    assert opc_repository.cert_path == "/path/to/cert.pem"
+    assert opc_repository.private_key_path == "/path/to/key.pem"
+    assert opc_repository.server_cert_path == "/path/to/server_cert.pem"
+    assert opc_repository.reconnection_interval == 60
+    assert opc_repository.client is None
+    assert opc_repository.last_reconnection_time is None
+    assert opc_repository.error_count == 0
+
+
+def test_set_security(opc_repository, mock_client):
+    opc_repository.client = mock_client
+    opc_repository.set_security()
+
+    mock_client.application_uri = "urn:test:server"
+    mock_client.set_security.assert_called_once_with(
+        SecurityPolicyBasic256,
+        certificate="/path/to/cert.pem",
+        private_key="/path/to/key.pem",
+        server_certificate="/path/to/server_cert.pem"
+    )
+    assert mock_client.secure_channel_timeout == 10000000
+    assert mock_client.session_timeout == 10000000
+
+
+def test_set_security_missing_certificates(opc_repository):
+    opc_repository.cert_path = None
+    opc_repository.private_key_path = None
+
+    try:
+        opc_repository.set_security()
+    except ValueError as e:
+        assert str(
+            e) == "Certificate and private key paths must be provided for secure connection."
+
+
+def test_connect_with_security(opc_repository, mock_client):
+    opc_repository.try_connect = MagicMock()
+    opc_repository.connect()
+
+    opc_repository.try_connect.assert_called_once()
+    assert opc_repository.client == mock_client
+
+
+def test_connect_without_security(opc_repository, mock_client):
+    opc_repository.cert_path = None
+    opc_repository.try_connect = MagicMock()
+    opc_repository.set_security = MagicMock()
+    opc_repository.connect()
+
+    opc_repository.try_connect.assert_called_once()
+    opc_repository.set_security.assert_not_called()
+    assert opc_repository.client == mock_client
+
+
+def test_try_connect_sucess(opc_repository):
+    opc_repository.last_reconnection_time = None
+    opc_repository.client = MagicMock()
+    opc_repository.try_connect()
+    opc_repository.client.connect.assert_called_once()
+    assert opc_repository.last_reconnection_time is not None
+
+
+def test_try_connect_fail(opc_repository):
+    opc_repository.last_reconnection_time = None
+    opc_repository.client = MagicMock()
+    opc_repository.client.connect.side_effect = Exception("Test error")
+
+    opc_repository.try_connect()
+
+    opc_repository.client.connect.assert_called_once()
+    assert opc_repository.last_reconnection_time is not None
+    opc_repository.notification_handler.build_and_send_notification.assert_called_once_with(
+        notification_id=f"OPC_CONNECTION_ERROR_{opc_repository.name}",
+        message="Failed to connect to OPC server: Test error",
+        block="opc_repository",
+        level=NotificationLevel.ERROR,
+        attachment_content=ANY
+    )
+
+
+def test_disconnect(opc_repository, mock_client):
+    opc_repository.client = mock_client
+    opc_repository.disconnect()
+
+    mock_client.disconnect.assert_called_once()
+    assert opc_repository.client is None
+
+
+def test_validate_connection_none_client(opc_repository):
+    opc_repository.client = None
+    opc_repository.connect = MagicMock()
+    response = opc_repository.validate_connection()
+    assert response
+    opc_repository.connect.assert_called_once()
+
+
+def test_validate_connection_error_count_disconnect_error(opc_repository):
+    opc_repository.error_count = 6
+    opc_repository.client = MagicMock()
+    opc_repository.disconnect = MagicMock(side_effect=Exception("Test error"))
+    opc_repository.connect = MagicMock()
+
+    response = opc_repository.validate_connection()
+    assert response == opc_repository.connect.return_value
+    opc_repository.disconnect.assert_called_once()
+    opc_repository.connect.assert_called_once()
+    opc_repository.logger.error.assert_has_calls(
+        [
+            call("Failed to disconnect from OPC server: Test error"),
+        ]
+    )
+
+
+@patch('laborious.utils.repository.opc_repository.hasattr', return_value=True)
+@patch('laborious.utils.repository.opc_repository.datetime',
+       MagicMock(now=MagicMock(return_value=datetime(2025, 1, 1, 0, 0, 0))))
+def test_validate_connection_lost_not_time_to_reconect(_mock_datetime, opc_repository):
+    opc_repository.error_count = 0
+    opc_repository.client = MagicMock()
+    opc_repository.client.aio_obj.uaclient.protocol = None
+    opc_repository.last_reconnection_time = datetime(2025, 1, 1, 0, 0, 0)
+    opc_repository.try_connect = MagicMock()
+
+    response = opc_repository.validate_connection()
+    opc_repository.try_connect.assert_not_called()
+    assert response is False
+
+
+@patch('laborious.utils.repository.opc_repository.hasattr', return_value=True)
+@patch('laborious.utils.repository.opc_repository.datetime',
+       MagicMock(now=MagicMock(return_value=datetime(2025, 1, 1, 1, 0, 0))))
+def test_validate_connection_lost_time_to_reconect(_mock_datetime, opc_repository):
+    opc_repository.error_count = 0
+    opc_repository.client = MagicMock()
+    opc_repository.client.aio_obj.uaclient.protocol = None
+    opc_repository.last_reconnection_time = datetime(2025, 1, 1, 0, 0, 0)
+    opc_repository.try_connect = MagicMock()
+
+    response = opc_repository.validate_connection()
+    opc_repository.try_connect.assert_called_once()
+    assert response == opc_repository.try_connect.return_value
+
+
+def test_validate_connection_failed(opc_repository):
+    opc_repository.client = MagicMock()
+    opc_repository.error_count = 0
+
+    output = opc_repository.validate_connection()
+    assert output is True
+
+
+def test_write_data_validate_connection_do_nothing(opc_repository):
+    opc_repository.validate_connection = MagicMock(return_value=True)
+    opc_repository.client = MagicMock()
+    opc_repository.write_data("ns=2;s=TestNode", 42.0, "float")
+    opc_repository.validate_connection.assert_called_once()
+    opc_repository.client.get_node.assert_called_once_with("ns=2;s=TestNode")
+
+
+def test_write_data_validate_connection_failed(opc_repository):
+    opc_repository.validate_connection = MagicMock(return_value=False)
+    opc_repository.client = MagicMock()
+    opc_repository.error_count = 0
+    opc_repository.write_data("ns=2;s=TestNode", 42.0, "float")
+    opc_repository.validate_connection.assert_called_once()
+    opc_repository.client.get_node.assert_not_called()
+
+
+def test_write_data_get_node_failed(opc_repository):
+    opc_repository.validate_connection = MagicMock(return_value=True)
+    opc_repository.client = MagicMock()
+    opc_repository.error_count = 0
+    opc_repository.client.get_node.side_effect = Exception("Test error")
+    opc_repository.write_data("ns=2;s=TestNode", 42.0, "float")
+    opc_repository.validate_connection.assert_called_once()
+    opc_repository.client.get_node.assert_called_once_with("ns=2;s=TestNode")
+    opc_repository.notification_handler.build_and_send_notification.assert_called_once_with(
+        notification_id=f"OPC_WRITE_GET_NODE_ERROR_{opc_repository.name}",
+        message="Failed to get node from OPC server: Test error",
+        block="opc_repository",
+        level=NotificationLevel.ERROR,
+        attachment_content=ANY
+    )
+    assert opc_repository.error_count == 1
+
+
+def test_write_data(opc_repository, mock_client):
+    opc_repository.validate_connection = MagicMock(return_value=True)
+    opc_repository.client = mock_client
+    mock_node = MagicMock()
+    mock_client.get_node.return_value = mock_node
+
+    opc_repository.write_data("ns=2;s=TestNode", 42.0, "float")
+
+    mock_client.get_node.assert_called_once_with("ns=2;s=TestNode")
+    mock_node.write_value.assert_called_once()
+    opc_repository.logger.info.assert_called_once_with(
+        "Writing 42.0 - <class 'float'> to " + str(mock_node))
+
+
+def test_write_data_write_value_failed(opc_repository, mock_client):
+    opc_repository.validate_connection = MagicMock(return_value=True)
+    opc_repository.client = mock_client
+    mock_node = MagicMock()
+    opc_repository.error_count = 0
+    mock_client.get_node.return_value = mock_node
+    mock_node.write_value.side_effect = Exception("Test error")
+    opc_repository.write_data("ns=2;s=TestNode", 42.0, "float")
+    opc_repository.validate_connection.assert_called_once()
+    mock_client.get_node.assert_called_once_with("ns=2;s=TestNode")
+    mock_node.write_value.assert_called_once()
+    opc_repository.notification_handler.build_and_send_notification.assert_called_once_with(
+        notification_id=f"OPC_WRITE_DATA_ERROR_{opc_repository.name}",
+        message="Failed to write data to OPC server: Test error",
+        block="opc_repository",
+        level=NotificationLevel.ERROR,
+        attachment_content=ANY
+    )
+    assert opc_repository.error_count == 1

tests/laborious/utils/test_connectors_config.py

@@ -0,0 +1,133 @@
+from os import environ
+from laborious.utils.connectors_config import (build_mlflow_config,
+                                               build_opc_config,
+                                               build_postgres_config)
+
+
+def test_build_mlflow_config_with_env_vars():
+    # Arrange
+    environ['MLFLOW_HOST'] = 'http://test-host'
+    environ['MLFLOW_PORT'] = '8080'
+    environ['MLFLOW_USERNAME'] = 'test-user'
+    environ['MLFLOW_PASSWORD'] = 'test-pass'
+
+    # Act
+    config = build_mlflow_config()
+
+    # Assert
+    assert config['host'] == 'http://test-host'
+    assert config['port'] == 8080
+    assert config['username'] == 'test-user'
+    assert config['password'] == 'test-pass'
+
+
+def test_build_mlflow_config_with_defaults():
+    # Arrange
+    # Clear any existing env vars
+    environ.pop('MLFLOW_HOST', None)
+    environ.pop('MLFLOW_PORT', None)
+    environ.pop('MLFLOW_USERNAME', None)
+    environ.pop('MLFLOW_PASSWORD', None)
+
+    # Act
+    config = build_mlflow_config()
+
+    # Assert
+    assert config['host'] == 'http://localhost'
+    assert config['port'] == 5080
+    assert config['username'] == 'aignosi'
+    assert config['password'] == 'aignosi'
+
+
+def test_build_opc_config_with_env_vars():
+    # Arrange
+    environ['OPC_CONFIG'] = '{"opc": {"name": "test-opc", "url": "opc.tcp://test:4840"}}'
+
+    # Act
+    config = build_opc_config()
+
+    # Assert
+    assert config['opc']['name'] == 'test-opc'
+    assert config['opc']['url'] == 'opc.tcp://test:4840'
+
+
+def test_build_opc_config_with_individual_env_vars():
+    # Arrange
+    environ.pop('OPC_CONFIG', None)
+    environ['OPC_NAME'] = 'test-name'
+    environ['OPC_URL'] = 'opc.tcp://test:4840'
+    environ['OPC_SERVER_URI'] = 'opc.tcp://test:4840'
+    environ['OPC_RECONNECTION_INTERVAL'] = '300'
+
+    # Act
+    config = build_opc_config()
+
+    # Assert
+    assert config['opc']['name'] == 'test-name'
+    assert config['opc']['url'] == 'opc.tcp://test:4840'
+    assert config['opc']['server_uri'] == 'opc.tcp://test:4840'
+    assert config['opc']['reconnection_interval'] == 300
+
+
+def test_build_opc_config_with_defaults():
+    # Arrange
+    environ.pop('OPC_CONFIG', None)
+    environ.pop('OPC_NAME', None)
+    environ.pop('OPC_URL', None)
+    environ.pop('OPC_SERVER_URI', None)
+    environ.pop('OPC_RECONNECTION_INTERVAL', None)
+
+    # Act
+    config = build_opc_config()
+
+    # Assert
+    assert config['opc']['name'] == 'opc'
+    assert config['opc']['url'] == 'opc.tcp://localhost:4840'
+    assert config['opc']['server_uri'] == 'opc.tcp://localhost:4840'
+    assert config['opc']['reconnection_interval'] == 120
+
+
+def test_build_postgres_config_with_env_vars():
+    # Arrange
+    environ['POSTGRES_HOST'] = 'test-host'
+    environ['POSTGRES_PORT'] = '5433'
+    environ['POSTGRES_USER'] = 'test-user'
+    environ['POSTGRES_PASSWORD'] = 'test-pass'
+    environ['POSTGRES_DBNAME'] = 'test-db'
+    environ['POSTGRES_MIN_CONNECTIONS'] = '10'
+    environ['POSTGRES_MAX_CONNECTIONS'] = '30'
+
+    # Act
+    config = build_postgres_config()
+
+    # Assert
+    assert config['host'] == 'test-host'
+    assert config['port'] == 5433
+    assert config['user'] == 'test-user'
+    assert config['password'] == 'test-pass'
+    assert config['dbname'] == 'test-db'
+    assert config['min_connections'] == 10
+    assert config['max_connections'] == 30
+
+
+def test_build_postgres_config_with_defaults():
+    # Arrange
+    environ.pop('POSTGRES_HOST', None)
+    environ.pop('POSTGRES_PORT', None)
+    environ.pop('POSTGRES_USER', None)
+    environ.pop('POSTGRES_PASSWORD', None)
+    environ.pop('POSTGRES_DBNAME', None)
+    environ.pop('POSTGRES_MIN_CONNECTIONS', None)
+    environ.pop('POSTGRES_MAX_CONNECTIONS', None)
+
+    # Act
+    config = build_postgres_config()
+
+    # Assert
+    assert config['host'] == 'localhost'
+    assert config['port'] == 5432
+    assert config['user'] == 'sientia'
+    assert config['password'] == 'sientia'
+    assert config['dbname'] == 'sientia'
+    assert config['min_connections'] == 5
+    assert config['max_connections'] == 20

tests/laborious/utils/test_logger.py

@@ -0,0 +1,37 @@
+import os
+from unittest.mock import patch
+import logging
+import pytest
+from laborious.utils.logger import get_logger
+
+
+@pytest.fixture
+def mock_env_vars():
+    with patch.dict(os.environ, {}, clear=True):
+        yield
+
+
+@pytest.mark.usefixtures("mock_env_vars")
+@patch('laborious.utils.logger.logging.Formatter')
+@patch('laborious.utils.logger.logging.StreamHandler')
+def test_get_logger_defaults(mock_stream_handler, mock_formatter):
+    """Test logger creation with default settings"""
+    # Mock the StreamHandler and Formatter
+
+    logger = get_logger('test_logger')
+
+    # Verify logger settings
+    assert logger.name == 'test_logger'
+    assert logger.level == logging.INFO
+
+    # Verify handler configuration
+    mock_stream_handler.return_value.setLevel.assert_called_once_with('INFO')
+    mock_stream_handler.return_value.setFormatter.assert_called_once()
+
+    # Verify formatter configuration
+    mock_formatter.assert_called_once_with(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    # Verify handler was added to logger
+    assert len(logger.handlers) == 1