testing

.github/workflows/push_to_hf_space.yml

@@ -60,6 +60,12 @@ jobs:
         run: |
           echo "No tests implemented yet — placeholder step."
           echo "This will later run pytest."
+
+    # this is the completed test step
+    # - name: Run unit tests
+    #   run: |
+    #     pip install pytest
+    #     pytest A4/ -v --tb=short
       
       # -------------------------
       # 6. Push to HuggingFace

A4/conftest.py

@@ -0,0 +1,82 @@
+# Provides reusable model paths sample data and loaded model fixtures for testing regression and classification models that we have so far.
+
+import pytest
+import os
+import pickle
+import pandas as pd
+
+# path fixtures
+
+@pytest.fixture
+def repo_root():
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+
+@pytest.fixture
+def models_dir(repo_root):
+    return os.path.join(repo_root, "A3", "models")
+
+
+@pytest.fixture
+def regression_model_path(models_dir):
+    return os.path.join(models_dir, "champion_model_final_2.pkl")
+
+
+@pytest.fixture
+def classification_model_path(models_dir):
+    return os.path.join(models_dir, "final_champion_model_A3.pkl")
+
+
+@pytest.fixture
+def datasets_dir(repo_root):
+    return os.path.join(repo_root, "Datasets_all")
+
+
+# Model Fixtures
+
+@pytest.fixture
+def regression_artifact(regression_model_path):
+    
+    # return the regression model dict
+    if not os.path.exists(regression_model_path):
+        pytest.skip(f"Model not found: {regression_model_path}")
+    
+    with open(regression_model_path, "rb") as f:
+        return pickle.load(f)
+
+
+@pytest.fixture
+def classification_artifact(classification_model_path):
+    
+    # return the classification model dict
+    if not os.path.exists(classification_model_path):
+        pytest.skip(f"Model not found: {classification_model_path}")
+    
+    with open(classification_model_path, "rb") as f:
+        return pickle.load(f)
+
+
+# sample data
+
+@pytest.fixture
+def sample_regression_features(regression_artifact):
+    
+    # sample feature and data for testing
+    feature_columns = regression_artifact["feature_columns"]
+    
+    sample_data = {col: [0.5] for col in feature_columns}
+    return pd.DataFrame(sample_data)
+
+
+@pytest.fixture
+def sample_classification_features(classification_artifact):
+
+    feature_columns = classification_artifact["feature_columns"]
+    
+    sample_data = {col: [0.5] for col in feature_columns}
+    return pd.DataFrame(sample_data)
+
+# expected values
+@pytest.fixture
+def expected_classification_classes():
+    return ["Lower Body", "Upper Body"]

A4/test_models.py

@@ -0,0 +1,152 @@
+import pytest
+import os
+import pickle
+import numpy as np
+
+# regression model tests
+class TestRegressionModelLoading:
+
+    def test_regression_model_file_exists(self, regression_model_path):
+        assert os.path.exists(regression_model_path)
+
+    def test_regression_artifact_is_dict(self, regression_artifact):
+        assert isinstance(regression_artifact, dict)
+
+    def test_regression_artifact_has_model_key(self, regression_artifact):
+        assert "model" in regression_artifact
+
+    def test_regression_artifact_has_feature_columns(self, regression_artifact):
+        assert "feature_columns" in regression_artifact
+
+    def test_regression_feature_columns_not_empty(self, regression_artifact):
+        assert len(regression_artifact["feature_columns"]) > 0
+
+    def test_regression_model_has_predict_method(self, regression_artifact):
+        model = regression_artifact["model"]
+        assert hasattr(model, "predict")
+
+
+class TestRegressionModelPrediction:
+
+    def test_regression_prediction_returns_array(
+        self, regression_artifact, sample_regression_features
+    ):
+        # regression model should return numpy
+        model = regression_artifact["model"]
+        prediction = model.predict(sample_regression_features)
+        assert isinstance(prediction, np.ndarray)
+
+    def test_regression_prediction_shape(
+        self, regression_artifact, sample_regression_features
+    ):
+        # one value for sample
+        model = regression_artifact["model"]
+        prediction = model.predict(sample_regression_features)
+        assert prediction.shape[0] == len(sample_regression_features)
+
+    def test_regression_prediction_is_numeric(
+        self, regression_artifact, sample_regression_features
+    ):
+        # should be a number
+        model = regression_artifact["model"]
+        prediction = model.predict(sample_regression_features)
+        assert np.issubdtype(prediction.dtype, np.number)
+
+    def test_regression_prediction_in_reasonable_range(
+        self, regression_artifact, sample_regression_features
+    ):
+        model = regression_artifact["model"]
+        prediction = model.predict(sample_regression_features)[0]
+        # Allow some tolerance outside 0-1 for edge cases
+        assert -0.5 <= prediction <= 1.5
+
+
+class TestClassificationModelLoading:
+
+    def test_classification_model_file_exists(self, classification_model_path):
+        assert os.path.exists(classification_model_path)
+
+    def test_classification_artifact_is_dict(self, classification_artifact):
+        assert isinstance(classification_artifact, dict)
+
+    def test_classification_artifact_has_model_key(self, classification_artifact):
+        assert "model" in classification_artifact
+
+    def test_classification_artifact_has_feature_columns(self, classification_artifact):
+        assert "feature_columns" in classification_artifact
+
+    def test_classification_artifact_has_classes(self, classification_artifact):
+        assert "classes" in classification_artifact
+
+    def test_classification_model_has_predict_method(self, classification_artifact):
+        model = classification_artifact["model"]
+        assert hasattr(model, "predict")
+
+    def test_classification_classes_match_expected(
+        self, classification_artifact, expected_classification_classes
+    ):
+        classes = list(classification_artifact["classes"])
+        assert sorted(classes) == sorted(expected_classification_classes)
+
+
+class TestClassificationModelPrediction:
+
+    def test_classification_prediction_returns_array(
+        self, classification_artifact, sample_classification_features
+    ):
+        model = classification_artifact["model"]
+        prediction = model.predict(sample_classification_features)
+        assert isinstance(prediction, np.ndarray)
+
+    def test_classification_prediction_shape(
+        self, classification_artifact, sample_classification_features
+    ):
+        # one class per sample
+        model = classification_artifact["model"]
+        prediction = model.predict(sample_classification_features)
+        assert prediction.shape[0] == len(sample_classification_features)
+
+    def test_classification_prediction_is_valid_class(
+        self, classification_artifact, sample_classification_features,
+        expected_classification_classes
+    ):
+        # should be a valid class
+        model = classification_artifact["model"]
+        prediction = model.predict(sample_classification_features)[0]
+        assert prediction in expected_classification_classes
+
+
+class TestModelArtifactStructure:
+
+    def test_regression_artifact_has_metrics(self, regression_artifact):
+        assert "test_metrics" in regression_artifact
+
+    def test_classification_artifact_has_metrics(self, classification_artifact):
+        assert "test_metrics" in classification_artifact
+
+    def test_regression_metrics_has_r2(self, regression_artifact):
+        metrics = regression_artifact.get("test_metrics", {})
+        assert "r2" in metrics
+
+    def test_regression_r2_is_positive(self, regression_artifact):
+        metrics = regression_artifact.get("test_metrics", {})
+        r2 = metrics.get("r2", 0)
+        assert r2 > 0
+
+class TestErrorHandling:
+
+    def test_load_nonexistent_model_raises_error(self, repo_root):
+        fake_path = os.path.join(repo_root, "nonexistent_model.pkl")
+        with pytest.raises(FileNotFoundError):
+            with open(fake_path, "rb") as f:
+                pickle.load(f)
+
+    def test_regression_model_with_wrong_features_raises(
+        self, regression_artifact
+    ):
+        import pandas as pd
+        model = regression_artifact["model"]
+        wrong_features = pd.DataFrame({"wrong_feature": [0.5]})
+        
+        with pytest.raises((ValueError, KeyError)):
+            model.predict(wrong_features)

pytest.ini

@@ -0,0 +1,13 @@
+[pytest]
+testpaths = A4
+
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# output options ??
+addopts = -v --tb=short
+
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning

requirements.txt

@@ -1,7 +1,10 @@
-gradio>=4.0.0
-pandas>=2.0.0
-numpy>=1.24.0
+gradio==4.44.0
+pandas==2.2.3
+numpy==1.26.4
 scikit-learn==1.7.2
-statsmodels>=0.14.0
-matplotlib>=3.7.0
-gdown>=4.7.0
+statsmodels==0.14.4
+matplotlib==3.9.2
+gdown==5.2.0
+
+pytest==8.3.4
+pytest-cov==6.0.0