SIENTIAPDE-1241: Added remaining trainig_repository tests and some model_repository tests

tests/utils/repository/test_training_repository.py

@@ -30,8 +30,6 @@ def sample_params():
     return TrainModelParams(
         experiment_run_id=1,
         experiment_name='test_experiment',
-        username='test_user',
-        model_type='Linear Regression',
         target_variable='target',
         variable_columns=['var1', 'var2', 'var3'],
         lag_train=0,
@@ -105,8 +103,6 @@ class TestExtractModelEquation:
         params = TrainModelParams(
             experiment_run_id=1,
             experiment_name='test',
-            username='test_user',
-            model_type='Linear Regression',
             target_variable='y',
             variable_columns=['x'],
             lag_train=0,
@@ -224,6 +220,78 @@ class TestInitDataPreprocessor:
             assert preprocessor.lag_transform[col] == 3
 
 
+class TestInitScalerDict:
+    """Tests for _init_scaler_dict method."""
+
+    def test_init_scaler_dict_without_scaler(self, training_repo, sample_params):
+        """Test scaler dict initialization when scaler is not used."""
+        from model_manager.sientia.models import DataPreprocessor
+
+        sample_params.use_scaler = False
+        process_data = MagicMock(spec=DataPreprocessor)
+
+        result = training_repo._init_scaler_dict(process_data, sample_params)
+
+        assert result == {}
+
+    def test_init_scaler_dict_with_minmax_scaler(self, training_repo, sample_params):
+        """Test scaler dict initialization with MinMaxScaler."""
+        from model_manager.sientia.models import DataPreprocessor
+        from sientia_do.operations.normalization import MinMaxScaler
+
+        sample_params.use_scaler = True
+
+        # Create mock MinMaxScaler
+        mock_scaler = MagicMock(spec=MinMaxScaler)
+        mock_scaler.x_min = np.array([0.0, 1.0, 2.0])
+        mock_scaler.x_max = np.array([10.0, 11.0, 12.0])
+        mock_scaler.y_min = 0.5
+        mock_scaler.y_max = 100.5
+
+        # Create mock preprocessor that returns the scaler
+        process_data = MagicMock(spec=DataPreprocessor)
+        process_data.get_scaler.return_value = mock_scaler
+
+        result = training_repo._init_scaler_dict(process_data, sample_params)
+
+        # Check feature scalers
+        assert 'var1' in result
+        assert 'var2' in result
+        assert 'var3' in result
+        assert result['var1'] == {'min': 0.0, 'max': 10.0}
+        assert result['var2'] == {'min': 1.0, 'max': 11.0}
+        assert result['var3'] == {'min': 2.0, 'max': 12.0}
+
+        # Check target scaler
+        assert 'target' in result
+        assert result['target'] == {'min': 0.5, 'max': 100.5}
+
+    def test_init_scaler_dict_with_z_scaler(self, training_repo, sample_params):
+        """Test scaler dict initialization with Z_Scaler."""
+        from model_manager.sientia.models import DataPreprocessor
+        from sientia_do.operations.normalization import Z_Scaler
+
+        sample_params.use_scaler = True
+
+        # Create mock Z_Scaler
+        mock_scaler = MagicMock(spec=Z_Scaler)
+        expected_dict = {
+            'var1': {'mean': 5.0, 'std': 1.5},
+            'var2': {'mean': 10.0, 'std': 2.0},
+            'target': {'mean': 50.0, 'std': 10.0},
+        }
+        mock_scaler.create_dict.return_value = expected_dict
+
+        # Create mock preprocessor
+        process_data = MagicMock(spec=DataPreprocessor)
+        process_data.get_scaler.return_value = mock_scaler
+
+        result = training_repo._init_scaler_dict(process_data, sample_params)
+
+        assert result == expected_dict
+        mock_scaler.create_dict.assert_called_once()
+
+
 class TestAfterTrainCalculation:
     """Tests for after_train_calculation method."""
 
@@ -307,3 +375,93 @@ class TestAfterTrainCalculation:
             for call in mock_logger.info.call_args_list
         )
 
+    def test_after_train_with_custom_scaler_denormalization(
+        self, training_repo, sample_params, sample_linear_model
+    ):
+        """Test denormalization with custom scaler that has denormalize methods."""
+        sample_params.use_scaler = True
+
+        # Create mock data
+        x_train = pd.DataFrame(
+            {'var1': [1, 2, 3], 'var2': [4, 5, 6], 'var3': [7, 8, 9]}, index=[0, 1, 2]
+        )
+        x_test = pd.DataFrame({'var1': [10], 'var2': [11], 'var3': [12]}, index=[3])
+        y_train = pd.Series([100, 200, 300], index=[0, 1, 2], name='target')
+        y_test = pd.Series([400], index=[3], name='target')
+
+        # Mock predict
+        sample_linear_model.predict = MagicMock(return_value=np.array([450.0]))
+
+        # Create mock scaler with denormalize methods
+        mock_scaler = MagicMock()
+        mock_scaler.denormalize_single_input = MagicMock(side_effect=lambda x, col: x * 2)
+        mock_scaler.denormalize_predictions = MagicMock(return_value=np.array([900.0]))
+
+        # Create mock preprocessor
+        mock_process_data = MagicMock()
+        mock_process_data.get_scaler.return_value = mock_scaler
+
+        train_result = TrainModelResult(
+            params=sample_params,
+            process_data=mock_process_data,
+            x_train=x_train,
+            x_test=x_test,
+            y_train=y_train,
+            y_test=y_test,
+            regr=sample_linear_model,
+            scaler_dict={},
+        )
+
+        result = training_repo.after_train_calculation(sample_params, train_result)
+
+        # Verify denormalize methods were called
+        assert mock_scaler.denormalize_single_input.called
+        assert mock_scaler.denormalize_predictions.called
+        assert result.y_pred is not None
+
+    def test_after_train_with_sklearn_scaler(
+        self, training_repo, sample_params, sample_linear_model
+    ):
+        """Test denormalization with sklearn StandardScaler."""
+        sample_params.use_scaler = True
+
+        # Create mock data
+        x_train = pd.DataFrame(
+            {'var1': [1, 2, 3], 'var2': [4, 5, 6], 'var3': [7, 8, 9]}, index=[0, 1, 2]
+        )
+        x_test = pd.DataFrame({'var1': [10], 'var2': [11], 'var3': [12]}, index=[3])
+        y_train = pd.Series([100, 200, 300], index=[0, 1, 2], name='target')
+        y_test = pd.Series([400], index=[3], name='target')
+
+        # Mock predict
+        sample_linear_model.predict = MagicMock(return_value=np.array([450.0]))
+
+        # Create mock sklearn scaler (without denormalize methods)
+        mock_scaler = MagicMock()
+        # Remove denormalize methods to trigger sklearn path
+        if hasattr(mock_scaler, 'denormalize_single_input'):
+            delattr(mock_scaler, 'denormalize_single_input')
+        mock_scaler.inverse_transform = MagicMock(side_effect=lambda x: x * 2)
+
+        # Create mock preprocessor with feature_names_order
+        mock_process_data = MagicMock()
+        mock_process_data.get_scaler.return_value = mock_scaler
+        mock_process_data.feature_names_order = ['var1', 'var2', 'var3']
+
+        train_result = TrainModelResult(
+            params=sample_params,
+            process_data=mock_process_data,
+            x_train=x_train,
+            x_test=x_test,
+            y_train=y_train,
+            y_test=y_test,
+            regr=sample_linear_model,
+            scaler_dict={},
+        )
+
+        result = training_repo.after_train_calculation(sample_params, train_result)
+
+        # Verify inverse_transform was called
+        assert mock_scaler.inverse_transform.called
+        assert result.y_pred is not None
+