Adding tests to get coverage up to 95 %

Author: niharika2999

tests/basis/test_basis.py

@@ -6,7 +6,7 @@
 import pytest
 from sklearn.exceptions import NotFittedError
 
-from pysensors.basis import SVD, Custom, Identity, RandomProjection
+from pysensors.basis import SVD, Custom, Identity, RandomProjection, _base
 
 
 @pytest.mark.parametrize("basis", [Identity(), SVD(), RandomProjection()])
@@ -197,3 +197,52 @@ def mock_validate_input(self, value):
     custom_instance.matrix_inverse(n_basis_modes=3)
     assert validation_called
     assert test_value == 3
+
+
+def test_invertible_basis_abstract_method():
+    class TestBasis(_base.InvertibleBasis):
+        pass
+
+    with pytest.raises(TypeError, match="Can't instantiate abstract class TestBasis"):
+        TestBasis()
+
+    class ProperTestBasis(_base.InvertibleBasis):
+        def matrix_inverse(self, n_basis_modes=None, **kwargs):
+            return None
+
+    with pytest.raises(
+        NotImplementedError, match="This method has not been implemented"
+    ):
+        _base.InvertibleBasis.matrix_inverse(None)
+
+
+def test_validate_input_too_many_modes_error():
+    basis = SVD()
+    n_available_modes = 5
+    basis.basis_matrix_ = np.random.rand(10, n_available_modes)
+    basis.n_basis_modes = n_available_modes
+    too_many_modes = 8
+
+    expected_error = (
+        f"Requested number of modes {too_many_modes} exceeds"
+        f" number available: {n_available_modes}"
+    )
+
+    with pytest.raises(ValueError, match=expected_error):
+        basis._validate_input(n_basis_modes=too_many_modes)
+
+
+def test_matrix_representation_copy():
+    basis = SVD()
+    n_features = 10
+    n_basis_modes = 5
+    basis.basis_matrix_ = np.random.rand(n_features, n_basis_modes)
+    result_copy = basis.matrix_representation(n_basis_modes=3, copy=True)
+    np.testing.assert_array_equal(result_copy, basis.basis_matrix_[:, :3])
+    original_value = basis.basis_matrix_[0, 0]
+    result_copy[0, 0] = 999
+    assert basis.basis_matrix_[0, 0] == original_value
+    result_view = basis.matrix_representation(n_basis_modes=3, copy=False)
+    np.testing.assert_array_equal(result_view, basis.basis_matrix_[:, :3])
+    result_view[0, 0] = 777
+    assert basis.basis_matrix_[0, 0] == 777

tests/classification/test_sspoc.py

@@ -395,3 +395,50 @@ def test_warning_when_both_n_sensors_and_threshold_provided(sspoc_mock):
         match="Both n_sensors.*and threshold.*were passed so threshold will be ignored",
     ):
         sspoc_mock.update_sensors(n_sensors=2, threshold=0.4)
+
+
+def test_update_sensors_too_many_sensors_error():
+    n_available_sensors = 10
+    model = SSPOC()
+    model.sensor_coef_ = np.random.rand(n_available_sensors)
+    too_many_sensors = n_available_sensors + 5
+
+    expected_error = (
+        f"n_sensors\\({too_many_sensors}\\) cannot exceed number of "
+        f"available sensors \\({n_available_sensors}\\)"
+    )
+
+    with pytest.raises(ValueError, match=expected_error):
+        model.update_sensors(n_sensors=too_many_sensors)
+
+
+def test_uninformative_sensors_warning():
+    n_available_sensors = 10
+    n_sensors_to_select = 6
+    model = SSPOC()
+    sensor_coef = np.zeros(n_available_sensors)
+    sensor_coef[:5] = np.random.rand(5)
+    sensor_coef[:5] = -np.sort(-np.abs(sensor_coef[:5]))
+    model.sensor_coef_ = sensor_coef
+    with pytest.warns(
+        UserWarning,
+        match="Some uninformative sensors were selected. Consider decreasing n_sensors",
+    ):
+        model.update_sensors(n_sensors=n_sensors_to_select)
+
+
+def test_uninformative_sensors_multiclass_warning():
+    n_available_sensors = 10
+    n_classes = 3
+    n_sensors_to_select = 6
+    model = SSPOC()
+    sensor_coef = np.zeros((n_available_sensors, n_classes))
+    sensor_coef[:5, :] = np.random.rand(5, n_classes)
+    for i in range(5):
+        sensor_coef[i, :] = np.abs(sensor_coef[i, :]) + 0.5
+    model.sensor_coef_ = sensor_coef
+    with pytest.warns(
+        UserWarning,
+        match="Some uninformative sensors were selected. Consider decreasing n_sensors",
+    ):
+        model.update_sensors(n_sensors=n_sensors_to_select, method=np.mean)

tests/reconstruction/test_sspor.py

@@ -674,3 +674,31 @@ def custom_score_function(y_true, y_pred, **kwargs):
     assert kwargs["beta"] == 2
     assert "sample_weight" in kwargs
     assert np.array_equal(kwargs["sample_weight"], np.ones(10))
+
+
+def test_reconstruction_error_warning():
+    basis_mode_dim = 6
+    n_sensors = 8
+    model = SSPOR(n_sensors=n_sensors)
+    model.basis_matrix_ = np.random.rand(basis_mode_dim, basis_mode_dim)
+    model.ranked_sensors_ = np.arange(basis_mode_dim)
+    sensor_range = np.arange(1, n_sensors + 1)
+    x_test = np.random.rand(5, basis_mode_dim)
+    with pytest.warns(
+        UserWarning,
+        match=f"Performance may be poor when using more than {basis_mode_dim} sensors",
+    ):
+        model.reconstruction_error(x_test, sensor_range=sensor_range)
+
+
+def test_validate_n_sensors_warning():
+    n_sensors = 10
+    n_samples = 5
+    model = SSPOR(optimizer=CCQR(), n_sensors=n_sensors)
+    model.basis_matrix_ = np.random.rand(15, n_samples)
+    with pytest.warns(
+        UserWarning,
+        match="Number of sensors exceeds number of samples, "
+        "which may cause CCQR to select sensors in constrained regions.",
+    ):
+        model._validate_n_sensors()

tests/utils/test_base.py

@@ -1,58 +1,39 @@
-import pytest
 import numpy as np
+import pytest
+
 from pysensors.utils import validate_input  # Adjust import path as needed
 
+
 def test_validate_input_value_errors():
     """Test that validate_input raises appropriate ValueErrors."""
-    not_arrays = [
-        [1, 2, 3],
-        (1, 2, 3),
-        {1, 2, 3},
-        {"a": 1, "b": 2},
-        "123",
-        123,
-        None
-    ]
+    not_arrays = [[1, 2, 3], (1, 2, 3), {1, 2, 3}, {"a": 1, "b": 2}, "123", 123, None]
     for not_array in not_arrays:
         with pytest.raises(ValueError, match="x must be a numpy array"):
             validate_input(not_array)
     x_1d = np.array([1, 2, 3, 4])
-    wrong_sensors_1d = [
-        np.array([0, 1]),
-        np.array([0, 1, 2, 3, 4]),
-        np.array([])
-    ]
+    wrong_sensors_1d = [np.array([0, 1]), np.array([0, 1, 2, 3, 4]), np.array([])]
     for sensors in wrong_sensors_1d:
         with pytest.raises(ValueError, match="x has the wrong number of features"):
             validate_input(x_1d, sensors)
-    x_2d = np.array([
-        [1, 2, 3],
-        [4, 5, 6]
-    ])
-    wrong_sensors_2d = [
-        np.array([0, 1]),
-        np.array([0, 1, 2, 3]),
-        np.array([])
-    ]
+    x_2d = np.array([[1, 2, 3], [4, 5, 6]])
+    wrong_sensors_2d = [np.array([0, 1]), np.array([0, 1, 2, 3]), np.array([])]
     for sensors in wrong_sensors_2d:
         with pytest.raises(ValueError, match="x has the wrong number of features"):
             validate_input(x_2d, sensors)
 
+
 def test_validate_input_valid_cases():
     """Test that validate_input works correctly with valid inputs."""
     x_1d = np.array([1, 2, 3, 4])
     sensors_1d = np.array([0, 1, 2, 3])
     result = validate_input(x_1d, sensors_1d)
     assert np.array_equal(result, x_1d)
-    x_2d = np.array([
-        [1, 2, 3],
-        [4, 5, 6]
-    ])
+    x_2d = np.array([[1, 2, 3], [4, 5, 6]])
     sensors_2d = np.array([0, 1, 2])
     result = validate_input(x_2d, sensors_2d)
     assert np.array_equal(result, x_2d)
     result = validate_input(x_1d, None)
     assert np.array_equal(result, x_1d)
-    
+
     result = validate_input(x_2d, None)
-    assert np.array_equal(result, x_2d)
+    assert np.array_equal(result, x_2d)