300 lines
10 KiB
Python
300 lines
10 KiB
Python
"""Unit tests for TrainModelParams class."""
|
|
|
|
import pytest
|
|
|
|
from model_manager.utils.models.train_model_params import TrainModelParams
|
|
|
|
|
|
@pytest.fixture
|
|
def valid_params_dict():
|
|
"""Create valid parameters dictionary for testing."""
|
|
return {
|
|
'variable_columns': ['var1', 'var2', 'var3'],
|
|
'lag_train': 5,
|
|
'lag_val': 3,
|
|
'target_variable': 'target',
|
|
'rem_static_win': True,
|
|
'low_lim': {'var1': 0.0, 'var2': 0.0, 'var3': 0.0},
|
|
'upp_lim': {'var1': 100.0, 'var2': 100.0, 'var3': 100.0},
|
|
'window': 10,
|
|
'use_scaler': True,
|
|
'include_ar': False,
|
|
'bucket_name': 'test-bucket',
|
|
'file_name': 'test-file.csv',
|
|
'line_separator': '\n',
|
|
'decimal_separator': '.',
|
|
'train_size': 80,
|
|
'shuffle': True,
|
|
'experiment_run_id': 123,
|
|
'experiment_name': 'Test experiment name',
|
|
'removed_intervals': [],
|
|
}
|
|
|
|
|
|
def test_train_model_params_creation_with_valid_params(valid_params_dict):
|
|
"""Test creating TrainModelParams with all valid parameters."""
|
|
params = TrainModelParams(**valid_params_dict)
|
|
|
|
assert params.variable_columns == ['var1', 'var2', 'var3']
|
|
assert params.lag_train == 5
|
|
assert params.lag_val == 3
|
|
assert params.target_variable == 'target'
|
|
assert params.rem_static_win is True
|
|
assert params.low_lim == {'var1': 0.0, 'var2': 0.0, 'var3': 0.0}
|
|
assert params.upp_lim == {'var1': 100.0, 'var2': 100.0, 'var3': 100.0}
|
|
assert params.window == 10
|
|
assert params.use_scaler is True
|
|
assert params.include_ar is False
|
|
assert params.bucket_name == 'test-bucket'
|
|
assert params.file_name == 'test-file.csv'
|
|
assert params.line_separator == '\n'
|
|
assert params.decimal_separator == '.'
|
|
assert params.train_size == 80
|
|
assert params.shuffle is True
|
|
assert params.experiment_run_id == 123
|
|
assert params.experiment_name == 'Test experiment name'
|
|
assert params.removed_intervals == []
|
|
|
|
|
|
def test_train_model_params_from_dict_creation(valid_params_dict):
|
|
"""Test creating TrainModelParams using from_dict method."""
|
|
params = TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
assert params.variable_columns == ['var1', 'var2', 'var3']
|
|
assert params.lag_train == 5
|
|
assert params.experiment_run_id == 123
|
|
|
|
|
|
def test_train_model_params_variable_columns_none_raises_error(valid_params_dict):
|
|
"""Test that None variable_columns raises ValueError."""
|
|
valid_params_dict['variable_columns'] = None
|
|
|
|
with pytest.raises(ValueError, match='variable_columns is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_variable_columns_wrong_type_raises_error(valid_params_dict):
|
|
"""Test that wrong type for variable_columns raises TypeError."""
|
|
valid_params_dict['variable_columns'] = 'not a list'
|
|
|
|
with pytest.raises(TypeError, match='variable_columns must be of type list'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_lag_train_none_raises_error(valid_params_dict):
|
|
"""Test that None lag_train raises ValueError."""
|
|
valid_params_dict['lag_train'] = None
|
|
|
|
with pytest.raises(ValueError, match='lag_train is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_lag_train_wrong_type_raises_error(valid_params_dict):
|
|
"""Test that wrong type for lag_train raises TypeError."""
|
|
valid_params_dict['lag_train'] = '5'
|
|
|
|
with pytest.raises(TypeError, match='lag_train must be of type int'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_target_variable_none_raises_error(valid_params_dict):
|
|
"""Test that None target_variable raises ValueError."""
|
|
valid_params_dict['target_variable'] = None
|
|
|
|
with pytest.raises(ValueError, match='target_variable is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_target_variable_wrong_type_raises_error(valid_params_dict):
|
|
"""Test that wrong type for target_variable raises TypeError."""
|
|
valid_params_dict['target_variable'] = 123
|
|
|
|
with pytest.raises(TypeError, match='target_variable must be of type str'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_boolean_fields(valid_params_dict):
|
|
"""Test boolean fields validation."""
|
|
# Test rem_static_win
|
|
valid_params_dict['rem_static_win'] = None
|
|
with pytest.raises(ValueError, match='rem_static_win is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
valid_params_dict['rem_static_win'] = 'true'
|
|
with pytest.raises(TypeError, match='rem_static_win must be of type bool'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_dict_fields(valid_params_dict):
|
|
"""Test dict fields validation."""
|
|
# Test low_lim
|
|
valid_params_dict['low_lim'] = None
|
|
with pytest.raises(ValueError, match='low_lim is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
valid_params_dict['low_lim'] = {'var1': 0.0}
|
|
valid_params_dict['upp_lim'] = 'not a dict'
|
|
with pytest.raises(TypeError, match='upp_lim must be of type dict'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_bucket_name_none_raises_error(valid_params_dict):
|
|
"""Test that None bucket_name raises ValueError."""
|
|
valid_params_dict['bucket_name'] = None
|
|
|
|
with pytest.raises(ValueError, match='bucket_name is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_file_name_none_raises_error(valid_params_dict):
|
|
"""Test that None file_name raises ValueError."""
|
|
valid_params_dict['file_name'] = None
|
|
|
|
with pytest.raises(ValueError, match='file_name is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_experiment_run_id_none_raises_error(valid_params_dict):
|
|
"""Test that None experiment_run_id raises ValueError."""
|
|
valid_params_dict['experiment_run_id'] = None
|
|
|
|
with pytest.raises(ValueError, match='experiment_run_id is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_experiment_name_none_raises_error(valid_params_dict):
|
|
"""Test that None experiment_name raises ValueError."""
|
|
valid_params_dict['experiment_name'] = None
|
|
|
|
with pytest.raises(ValueError, match='experiment_name is required and cannot be None'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_removed_intervals_can_be_none(valid_params_dict):
|
|
"""Test that removed_intervals can be None (uses _check_type not _check_none)."""
|
|
valid_params_dict['removed_intervals'] = None
|
|
|
|
params = TrainModelParams.from_dict(valid_params_dict)
|
|
assert params.removed_intervals is None
|
|
|
|
|
|
def test_train_model_params_removed_intervals_wrong_type_raises_error(valid_params_dict):
|
|
"""Test that wrong type for removed_intervals raises TypeError."""
|
|
valid_params_dict['removed_intervals'] = 'not a list'
|
|
|
|
with pytest.raises(TypeError, match='removed_intervals must be of type list'):
|
|
TrainModelParams.from_dict(valid_params_dict)
|
|
|
|
|
|
def test_train_model_params_removed_intervals_with_values(valid_params_dict):
|
|
"""Test removed_intervals with actual interval values."""
|
|
valid_params_dict['removed_intervals'] = [
|
|
('2023-01-01', '2023-01-10'),
|
|
('2023-02-01', '2023-02-05'),
|
|
]
|
|
|
|
params = TrainModelParams.from_dict(valid_params_dict)
|
|
assert len(params.removed_intervals) == 2
|
|
assert params.removed_intervals[0] == ('2023-01-01', '2023-01-10')
|
|
|
|
|
|
def test_train_model_params_all_fields_count():
|
|
"""Test that TrainModelParams has exactly 19 required fields."""
|
|
import inspect
|
|
|
|
sig = inspect.signature(TrainModelParams.__init__)
|
|
# Subtract 1 for 'self'
|
|
param_count = len(sig.parameters) - 1
|
|
assert param_count == 19
|
|
|
|
|
|
def test_train_model_params_with_minimal_valid_data():
|
|
"""Test creating params with minimal valid data."""
|
|
params = TrainModelParams(
|
|
variable_columns=['x'],
|
|
lag_train=1,
|
|
lag_val=1,
|
|
target_variable='y',
|
|
rem_static_win=False,
|
|
low_lim={},
|
|
upp_lim={},
|
|
window=1,
|
|
use_scaler=False,
|
|
include_ar=False,
|
|
bucket_name='bucket',
|
|
file_name='file.csv',
|
|
line_separator='\n',
|
|
decimal_separator='.',
|
|
train_size=50,
|
|
shuffle=False,
|
|
experiment_run_id=1,
|
|
experiment_name='name',
|
|
removed_intervals=[],
|
|
)
|
|
|
|
assert params.variable_columns == ['x']
|
|
assert params.lag_train == 1
|
|
assert params.experiment_run_id == 1
|
|
|
|
|
|
def test_train_model_params_check_none_method():
|
|
"""Test _check_none method behavior."""
|
|
params_dict = {
|
|
'variable_columns': ['var1'],
|
|
'lag_train': 5,
|
|
'lag_val': 3,
|
|
'target_variable': 'target',
|
|
'rem_static_win': True,
|
|
'low_lim': {},
|
|
'upp_lim': {},
|
|
'window': 10,
|
|
'use_scaler': True,
|
|
'include_ar': False,
|
|
'bucket_name': 'bucket',
|
|
'file_name': 'file.csv',
|
|
'line_separator': '\n',
|
|
'decimal_separator': '.',
|
|
'train_size': 80,
|
|
'shuffle': True,
|
|
'experiment_run_id': 123,
|
|
'experiment_name': 'exp',
|
|
'removed_intervals': [],
|
|
}
|
|
|
|
params = TrainModelParams(**params_dict)
|
|
|
|
# Test that _check_none is a private method
|
|
assert hasattr(params, '_check_none')
|
|
assert callable(params._check_none)
|
|
|
|
|
|
def test_train_model_params_check_type_method():
|
|
"""Test _check_type method behavior."""
|
|
params_dict = {
|
|
'variable_columns': ['var1'],
|
|
'lag_train': 5,
|
|
'lag_val': 3,
|
|
'target_variable': 'target',
|
|
'rem_static_win': True,
|
|
'low_lim': {},
|
|
'upp_lim': {},
|
|
'window': 10,
|
|
'use_scaler': True,
|
|
'include_ar': False,
|
|
'bucket_name': 'bucket',
|
|
'file_name': 'file.csv',
|
|
'line_separator': '\n',
|
|
'decimal_separator': '.',
|
|
'train_size': 80,
|
|
'shuffle': True,
|
|
'experiment_run_id': 123,
|
|
'experiment_name': 'exp',
|
|
'removed_intervals': [],
|
|
}
|
|
|
|
params = TrainModelParams(**params_dict)
|
|
|
|
# Test that _check_type is a private method
|
|
assert hasattr(params, '_check_type')
|
|
assert callable(params._check_type)
|