Merge pull request #51 from UBC-MDS/feature/more_test

looks good, merged

Author: lukeni777

src/ridge_remake/ridge_remake.py

@@ -62,3 +62,34 @@ def test_pandas_compatibility():
     y_pred = get_reg_line(X, y)
     assert isinstance(y_pred, np.ndarray)
     assert len(y_pred) == 3
+
+def test_mismatched_dimensions():
+    """
+    Verify that providing X and y with a different number of samples 
+    raises a ValueError during matrix multiplication.
+    """
+    # X has 3 samples, but y only has 2 samples
+    X = np.array([[1], [2], [3]])
+    y = np.array([1, 2])
+    
+    # NumPy's matrix multiplication (@) will raise ValueError due to dimension mismatch
+    with pytest.raises(ValueError):
+        get_reg_line(X, y)
+
+def test_multi_target_regression():
+    """
+    Verify that the function can handle multiple targets (y) simultaneously.
+    If y is (n_samples, n_targets), y_pred should also be (n_samples, n_targets).
+    """
+    X = np.array([[1], [2], [3]])
+    # Target 1: y = 2x, Target 2: y = 10x
+    y = np.array([[2, 10], 
+                  [4, 20], 
+                  [6, 30]])
+    
+    y_pred = get_reg_line(X, y)
+    
+    # Check if the output shape matches the multi-target input shape
+    assert y_pred.shape == (3, 2)
+    # Check if the predictions are accurate for both targets
+    np.testing.assert_allclose(y_pred, y, rtol=1e-5)

tests/unit/test_get_line.py

@@ -111,4 +111,35 @@ def test_r2_constant_target_perfect():
     """Verify that a constant target with perfect prediction returns 1.0."""
     y_true = [5, 5, 5]
     y_pred = [5, 5, 5]
-    assert ridge_get_r2(y_true, y_pred) == 1.0
+    assert ridge_get_r2(y_true, y_pred) == 1.0
+
+def test_r2_negative_score():
+    """
+    Conceptual Case: Worse Than Mean
+    Verify that the function correctly returns a negative value when the 
+    predictions are worse than simply predicting the mean of y_true.
+    """
+    y_true = np.array([1, 2, 3])  # Mean is 2.0, SS_tot is 2.0
+    # Predictions that are very far from the true values
+    y_pred = np.array([10, 20, 30]) 
+    
+    result = ridge_get_r2(y_true, y_pred)
+    
+    # R2 = 1 - (SS_res / SS_tot). If SS_res > SS_tot, R2 must be negative.
+    assert result < 0.0
+    assert isinstance(result, float)
+
+def test_r2_2d_column_vectors():
+    """
+    Structural Case: 2D Column Vectors (n_samples, 1)
+    In many ML workflows, y is often reshaped as a 2D column vector.
+    Verify that the function handles (n, 1) shapes correctly via numpy broadcasting.
+    """
+    y_true = np.array([[1.0], [2.0], [3.0]])
+    y_pred = np.array([[1.1], [1.9], [3.1]])
+    
+    result = ridge_get_r2(y_true, y_pred)
+    
+    # The result should be a single float value, even for 2D inputs
+    assert np.isscalar(result)
+    assert 0.0 < result < 1.0

tests/unit/test_ridge_r2.py

@@ -17,6 +17,7 @@
 
 matplotlib.use("Agg") 
 import matplotlib.pyplot as plt
+import numpy as np
 import pytest
 from matplotlib.collections import PathCollection
 
@@ -53,3 +54,38 @@ def test_ridge_scatter():
 
     with pytest.raises(TypeError, match="ax"):
         ridge_scatter(None, [1, 2], [3, 4], scatter_kwargs=None)
+
+def test_ridge_scatter_input_types():
+    """
+    Verify that the function handles various array-like inputs (lists, numpy arrays)
+    and flattens them correctly using .ravel().
+    """
+    fig, ax = plt.subplots()
+    
+    # Nested lists or 2D arrays should be flattened without error
+    x_input = [[1], [2], [3]]
+    y_input = np.array([[10], [20], [30]])
+    
+    _, points = ridge_scatter(ax, x_input, y_input)
+    
+    # Resulting offsets should have shape (3, 2) representing (x, y) coordinates
+    assert points.get_offsets().shape == (3, 2)
+    
+    plt.close(fig)
+
+def test_ridge_scatter_visual_properties():
+    """
+    Verify that styling arguments in scatter_kwargs are correctly applied
+    to the resulting PathCollection.
+    """
+    fig, ax = plt.subplots()
+    
+    # Test specific visual styling: size (s) and transparency (alpha)
+    style = {"s": 50, "alpha": 0.5, "edgecolors": "red"}
+    _, points = ridge_scatter(ax, [1], [1], scatter_kwargs=style)
+    
+    # PathCollection stores sizes as an array of squares of the diameters
+    assert points.get_sizes()[0] == 50
+    assert points.get_alpha() == 0.5
+    
+    plt.close(fig)

tests/unit/test_ridge_scatter.py

@@ -99,3 +99,47 @@ def test_bad_line_kwargs_typeerror():
         ridge_scatter_line(ax, [1, 2], [3, 4], line_kwargs=[("lw", 2)])
 
     plt.close(fig)
+
+def test_label_and_styling_application():
+    """
+    Verify that label and line_kwargs are correctly applied to the Matplotlib line.
+    """
+    fig, ax = plt.subplots()
+    x = [1, 2, 3]
+    y_line = [2, 4, 6]
+    custom_kwargs = {"color": "red", "linewidth": 5, "linestyle": "--"}
+    custom_label = "Regression Model"
+
+    _, line = ridge_scatter_line(
+        ax, x, y_line, 
+        line_kwargs=custom_kwargs, 
+        label=custom_label
+    )
+
+    # Check if the label was applied
+    assert line.get_label() == custom_label
+    # Check if kwargs were passed correctly
+    assert line.get_color() == "red"
+    assert line.get_linewidth() == 5
+    assert line.get_linestyle() == "--"
+
+    plt.close(fig)
+
+def test_return_values_consistency():
+    """
+    Verify that the function returns the original Axes object and the created Line2D artist.
+    """
+    fig, ax = plt.subplots()
+    x = [0, 1]
+    y_line = [0, 1]
+
+    returned_ax, returned_line = ridge_scatter_line(ax, x, y_line)
+
+    # The returned ax should be the same object passed in
+    assert returned_ax is ax
+    # The returned line should be a Matplotlib Line2D object
+    assert isinstance(returned_line, matplotlib.lines.Line2D)
+    # The returned line should be the same one present in the axes
+    assert returned_line in ax.lines
+
+    plt.close(fig)