cleanup tests

Author: PicoCentauri

.github/copilot-instructions.md

@@ -24,6 +24,8 @@ Example: `FPS` (Farthest Point Sampling) exists as both `feature_selection.FPS`
 
 ## Development Workflows
 
+Use 88 character line length limit for code and docstrings.
+
 ### Testing
 ```bash
 # Run all tests with coverage
@@ -39,11 +41,27 @@ tox -e tests-dev
 Tests use pytest-style assertions and fixtures. Common patterns:
 - Use `@pytest.fixture` for test data setup
 - Use `assert` statements instead of `self.assertEqual()`
-- Use `pytest.raises()` for exception testing
+- Use `pytest.raises()` for exception testing with `match=` parameter
 - Use `pytest.warns()` for warning testing
 - Use `pytest.mark.parametrize` for parameterized tests
 - Tests often load datasets via `skmatter.datasets.load_*()`
 
+**Exception Testing Style:**
+- Keep `with pytest.raises(...)` statement on one line (88 char limit)
+- For long match strings, define a `match` variable before the with statement:
+  ```python
+  match = "Long error message that would exceed line length limit"
+  with pytest.raises(ValueError, match=match):
+      some_function()
+  ```
+- Use `re.escape()` when matching messages with special regex characters:
+  ```python
+  import re
+  match = f"Found array with shape={X.shape} ..."
+  with pytest.raises(ValueError, match=re.escape(match)):
+      selector.fit(X)
+  ```
+
 ### Linting & Formatting
 ```bash
 # Check only (CI mode)

tests/test_datasets.py

@@ -97,9 +97,8 @@ def test_load_csd_1000r_access_descr(csd):
 def test_load_dataset_without_pandas():
     """Check if the correct exception occurs when pandas isn't present."""
     with mock.patch.dict("sys.modules", {"pandas": None}):
-        with pytest.raises(ImportError) as cm:
-            _ = load_who_dataset()
-        assert str(cm.value) == "load_who_dataset requires pandas."
+        with pytest.raises(ImportError, match="load_who_dataset requires pandas."):
+            load_who_dataset()
 
 
 def test_dataset_size_and_shape(who_data):

tests/test_dch.py

@@ -109,11 +109,11 @@ def test_residual_features_ndim(test_data):
 
     selector = DirectionalConvexHull()
     selector.fit(T, y)
-    with pytest.raises(ValueError) as cm:
-        selector.score_feature_matrix(X)
-    assert str(cm.value) == (
+    match = (
         "X has 10 features, but DirectionalConvexHull is expecting 4 features as input."
     )
+    with pytest.raises(ValueError, match=match):
+        selector.score_feature_matrix(X)
 
 
 def test_negative_score(test_data):

tests/test_feature_pcov_fps.py

@@ -29,9 +29,6 @@ def test_no_mixing_1(X_y_idx):
     """Check that the model throws an error when mixing = 1.0."""
     X, y, _ = X_y_idx
     selector = PCovFPS(n_to_select=1, mixing=1.0)
-    with pytest.raises(ValueError) as cm:
+    match = "Mixing = 1.0 corresponds to traditional FPS. Please use the FPS class."
+    with pytest.raises(ValueError, match=match):
         selector.fit(X, y=y)
-    assert (
-        str(cm.value)
-        == "Mixing = 1.0 corresponds to traditional FPS. Please use the FPS class."
-    )

tests/test_feature_simple_cur.py

@@ -15,7 +15,7 @@ def X():
 def test_bad_transform(X):
     selector = CUR(n_to_select=2)
     with pytest.raises(exceptions.NotFittedError):
-        _ = selector.transform(X)
+        selector.transform(X)
 
 
 def test_restart(X):

tests/test_feature_simple_fps.py

@@ -50,22 +50,21 @@ def test_initialize(X_and_idx):
     for i in range(4):
         assert selector.selected_idx_[i] == idx[i]
 
+    match = "Invalid value of the initialize parameter"
+
     initialize = np.array([1, 5, 3, 0.25])
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match=match):
         selector = FPS(n_to_select=len(idx) - 1, initialize=initialize)
         selector.fit(X)
-    assert str(cm.value) == "Invalid value of the initialize parameter"
 
     initialize = np.array([[1, 5, 3], [2, 4, 6]])
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match=match):
         selector = FPS(n_to_select=len(idx) - 1, initialize=initialize)
         selector.fit(X)
-    assert str(cm.value) == "Invalid value of the initialize parameter"
 
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match=match):
         selector = FPS(n_to_select=1, initialize="bad")
         selector.fit(X)
-    assert str(cm.value) == "Invalid value of the initialize parameter"
 
 
 def test_get_distances(X_and_idx):
@@ -80,7 +79,7 @@ def test_get_distances(X_and_idx):
 
     with pytest.raises(NotFittedError):
         selector = FPS(n_to_select=7)
-        _ = selector.get_select_distance()
+        selector.get_select_distance()
 
 
 def test_unique_selected_idx_zero_score():

tests/test_greedy_selector.py

@@ -1,3 +1,5 @@
+import re
+
 import numpy as np
 import pytest
 from sklearn.datasets import load_diabetes as get_dataset
@@ -30,10 +32,9 @@ def X():
 
 
 def test_bad_type(X):
-    with pytest.raises(
-        ValueError, match="Only feature and sample selection supported."
-    ):
-        _ = GreedyTester(selection_type="bad").fit(X)
+    match = "Only feature and sample selection supported."
+    with pytest.raises(ValueError, match=match):
+        GreedyTester(selection_type="bad").fit(X)
 
 
 def test_score_threshold(X):
@@ -46,28 +47,21 @@ def test_score_threshold(X):
 
 
 def test_score_threshold_and_full(X):
-    with pytest.raises(ValueError) as cm:
-        _ = GreedyTester(score_threshold=20, full=True, n_to_select=12).fit(X)
-    assert str(cm.value) == "You cannot specify both `score_threshold` and `full=True`."
+    match = "You cannot specify both `score_threshold` and `full=True`."
+    with pytest.raises(ValueError, match=match):
+        GreedyTester(score_threshold=20, full=True, n_to_select=12).fit(X)
 
 
 def test_bad_score_threshold_type(X):
-    with pytest.raises(ValueError) as cm:
-        _ = GreedyTester(score_threshold_type="bad").fit(X)
-    assert (
-        str(cm.value)
-        == "invalid score_threshold_type, expected one of 'relative' or 'absolute'"
-    )
+    match = "invalid score_threshold_type, expected one of 'relative' or 'absolute'"
+    with pytest.raises(ValueError, match=match):
+        GreedyTester(score_threshold_type="bad").fit(X)
 
 
 def test_bad_warm_start(X):
     selector = GreedyTester()
-    with pytest.raises(
-        ValueError,
-        match=(
-            "Cannot fit with warm_start=True without having been previously initialized"
-        ),
-    ):
+    match = "Cannot fit with warm_start=True without having been previously initialized"
+    with pytest.raises(ValueError, match=match):
         selector.fit(X, warm_start=True)
 
 
@@ -82,12 +76,9 @@ def test_bad_y(X):
 def test_bad_transform(X):
     selector = GreedyTester(n_to_select=2)
     selector.fit(X)
-    with pytest.raises(ValueError) as cm:
-        _ = selector.transform(X[:, :3])
-    assert (
-        str(cm.value)
-        == "X has 3 features, but GreedyTester is expecting 10 features as input."
-    )
+    match = "X has 3 features, but GreedyTester is expecting 10 features as input."
+    with pytest.raises(ValueError, match=match):
+        selector.transform(X[:, :3])
 
 
 def test_no_nfeatures(X):
@@ -105,27 +96,26 @@ def test_decimal_nfeatures(X):
 @pytest.mark.parametrize("nf", [1.2, "1", 20])
 def test_bad_nfeatures(X, nf):
     selector = GreedyTester(n_to_select=nf)
-    with pytest.raises(ValueError) as cm:
-        selector.fit(X)
-    assert str(cm.value) == (
-        "n_to_select must be either None, an integer in "
-        "[1, n_features] representing the absolute number "
-        "of features, or a float in (0, 1] representing a "
-        f"percentage of features to select. Got {nf} "
-        f"features and an input with {X.shape[1]} feature."
+    expected_msg = (
+        "n_to_select must be either None, an integer in [1, n_features] representing "
+        "the absolute number of features, or a float in (0, 1] representing a "
+        f"percentage of features to select. Got {nf} features and an input with "
+        f"{X.shape[1]} feature."
     )
+    with pytest.raises(ValueError, match=re.escape(expected_msg)):
+        selector.fit(X)
 
 
 def test_not_fitted():
     with pytest.raises(NotFittedError):
         selector = GreedyTester()
-        _ = selector._get_support_mask()
+        selector._get_support_mask()
 
 
 def test_fitted(X):
     selector = GreedyTester()
     selector.fit(X)
-    _ = selector._get_support_mask()
+    selector._get_support_mask()
 
     Xr = selector.transform(X)
     assert Xr.shape[1] == X.shape[1] // 2
@@ -135,18 +125,17 @@ def test_size_input():
     X = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
     selector_sample = GreedyTester(selection_type="sample")
     selector_feature = GreedyTester(selection_type="feature")
-    with pytest.raises(ValueError) as cm:
-        selector_feature.fit(X)
-    assert str(cm.value) == (
+    expected_msg_feature = (
         f"Found array with 1 feature(s) (shape={X.shape}) while a minimum of 2 is "
         "required by GreedyTester."
     )
+    with pytest.raises(ValueError, match=re.escape(expected_msg_feature)):
+        selector_feature.fit(X)
 
     X = X.reshape(1, -1)
-
-    with pytest.raises(ValueError) as cm:
-        selector_sample.fit(X)
-    assert str(cm.value) == (
+    expected_msg_sample = (
         f"Found array with 1 sample(s) (shape={X.shape}) while a minimum of 2 is "
         "required by GreedyTester."
     )
+    with pytest.raises(ValueError, match=re.escape(expected_msg_sample)):
+        selector_sample.fit(X)

tests/test_kernel_pcovc.py

@@ -110,14 +110,14 @@ def test_reconstruction_errors(kpcovc_model, X, Y, error_tol):
 def test_nonfitted_failure(X):
     kpcovc = KernelPCovC(mixing=0.5, n_components=4, tol=1e-12)
     with pytest.raises(exceptions.NotFittedError):
-        _ = kpcovc.transform(X)
+        kpcovc.transform(X)
 
 
 def test_no_arg_predict(X, Y):
     kpcovc = KernelPCovC(mixing=0.5, n_components=4, tol=1e-12)
     kpcovc.fit(X, Y)
     with pytest.raises(ValueError):
-        _ = kpcovc.predict()
+        kpcovc.predict()
 
 
 def test_T_shape(X, Y):
@@ -145,28 +145,30 @@ def test_Z_shape(kpcovc_model, X, Y):
 def test_decision_function(kpcovc_model, X, Y):
     kpcovc = kpcovc_model(center=True)
     kpcovc.fit(X, Y)
-    with pytest.raises(ValueError) as cm:
-        _ = kpcovc.decision_function()
-    assert str(cm.value) == "Either X or T must be supplied."
-    _ = kpcovc.decision_function(X)
+
+    with pytest.raises(ValueError, match="Either X or T must be supplied."):
+        kpcovc.decision_function()
+
+    kpcovc.decision_function(X)
     T = kpcovc.transform(X)
-    _ = kpcovc.decision_function(T=T)
+    kpcovc.decision_function(T=T)
 
 
 def test_no_centerer(kpcovc_model, X, Y):
     kpcovc = kpcovc_model(center=False)
     kpcovc.fit(X, Y)
     with pytest.raises(AttributeError):
-        _ = kpcovc.centerer_
+        kpcovc.centerer_
 
 
 def test_centerer(kpcovc_model, X, Y):
     kpcovc = kpcovc_model(center=True)
     kpcovc.fit(X, Y)
     assert hasattr(kpcovc, "centerer_")
-    _ = kpcovc.predict(X)
-    _ = kpcovc.transform(X)
-    _ = kpcovc.score(X, Y)
+
+    kpcovc.predict(X)
+    kpcovc.transform(X)
+    kpcovc.score(X, Y)
 
 
 def test_prefit_classifier(X, Y):
@@ -198,14 +200,14 @@ def test_incompatible_classifier(kpcovc_model, X, Y):
     classifier = GaussianNB()
     classifier.fit(X, Y)
     kpcovc = kpcovc_model(mixing=0.5, classifier=classifier)
-    with pytest.raises(ValueError) as cm:
-        kpcovc.fit(X, Y)
-    assert str(cm.value) == (
+    expected_msg = (
         "Classifier must be an instance of "
         "`LogisticRegression`, `LogisticRegressionCV`, `LinearSVC`, "
         "`LinearDiscriminantAnalysis`, `RidgeClassifier`, `RidgeClassifierCV`, "
         "`SGDClassifier`, `Perceptron`, or `precomputed`"
     )
+    with pytest.raises(ValueError, match=expected_msg):
+        kpcovc.fit(X, Y)
 
 
 def test_none_classifier(X, Y):
@@ -221,15 +223,13 @@ def test_incompatible_coef_shape(kpcovc_model, X, Y):
     cl_multi = LinearSVC()
     cl_multi.fit(K, np.random.randint(0, 3, size=X.shape[0]))
     kpcovc_binary = kpcovc_model(mixing=0.5, classifier=cl_multi)
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="For binary classification"):
         kpcovc_binary.fit(X, Y)
-    assert "For binary classification" in str(cm.value)
     cl_binary = LinearSVC()
     cl_binary.fit(K, Y)
     kpcovc_multi = kpcovc_model(mixing=0.5, classifier=cl_binary)
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="For multiclass classification"):
         kpcovc_multi.fit(X, np.random.randint(0, 3, size=X.shape[0]))
-    assert "For multiclass classification" in str(cm.value)
 
 
 def test_precomputed_classification(X, Y, error_tol):
@@ -327,10 +327,9 @@ def test_svd_solvers(kpcovc_model, X, Y):
 
 
 def test_bad_solver(kpcovc_model, X, Y):
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="Unrecognized svd_solver='bad'"):
         kpcovc = kpcovc_model(svd_solver="bad")
         kpcovc.fit(X, Y)
-    assert str(cm.value) == "Unrecognized svd_solver='bad'"
 
 
 def test_good_n_components(kpcovc_model, X, Y):
@@ -344,20 +343,16 @@ def test_good_n_components(kpcovc_model, X, Y):
 
 
 def test_bad_n_components(kpcovc_model, X, Y):
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="n_components="):
         kpcovc = kpcovc_model(n_components=-1, svd_solver="auto")
         kpcovc.fit(X, Y)
-    assert str(cm.value).startswith("n_components=")
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="n_components="):
         kpcovc = kpcovc_model(n_components=0, svd_solver="randomized")
         kpcovc.fit(X, Y)
-    assert str(cm.value).startswith("n_components=")
-    with pytest.raises(ValueError) as cm:
+    with pytest.raises(ValueError, match="n_components="):
         kpcovc = kpcovc_model(n_components=X.shape[0], svd_solver="arpack")
         kpcovc.fit(X, Y)
-    assert str(cm.value).startswith("n_components=")
     for svd_solver in ["auto", "full"]:
-        with pytest.raises(ValueError) as cm:
+        with pytest.raises(ValueError, match="must be of type int"):
             kpcovc = kpcovc_model(n_components=np.pi, svd_solver=svd_solver)
             kpcovc.fit(X, Y)
-        assert "must be of type int" in str(cm.value)