Add fixture for fake measurements

Author: Scienfitz

tests/conftest.py

@@ -77,7 +77,11 @@
 )
 from baybe.utils.basic import hilberts_factory
 from baybe.utils.boolean import strtobool
-from baybe.utils.dataframe import add_fake_measurements, add_parameter_noise
+from baybe.utils.dataframe import (
+    add_fake_measurements,
+    add_parameter_noise,
+    create_fake_input,
+)
 from baybe.utils.random import temporary_seed
 
 # Hypothesis settings
@@ -164,6 +168,18 @@ def fixture_batch_size(request):
     return request.param
 
 
+@pytest.fixture(name="n_fake_measurements")
+def fixture_n_fake_measurements(batch_size):
+    """Number of rows for :func:`baybe.utils.dataframe.create_fake_input`."""
+    return batch_size
+
+
+@pytest.fixture(name="fake_measurements")
+def fixture_fake_measurements(parameters, targets, batch_size):
+    """Artificially created valid measurements."""
+    return create_fake_input(parameters, targets, batch_size)
+
+
 @pytest.fixture(
     params=[5, pytest.param(8, marks=pytest.mark.slow)],
     name="n_grid_points",

tests/test_input_output.py

@@ -8,7 +8,7 @@
 from baybe.recommenders import BotorchRecommender
 from baybe.searchspace import SearchSpace
 from baybe.targets import NumericalTarget
-from baybe.utils.dataframe import add_fake_measurements, create_fake_input
+from baybe.utils.dataframe import add_fake_measurements
 
 
 @pytest.mark.parametrize(
@@ -43,14 +43,12 @@
     ],
 )
 @pytest.mark.parametrize("n_grid_points", [5], ids=["g5"])
-def test_bad_parameter_input_value(campaign, bad_val, batch_size):
+def test_bad_parameter_input_value(campaign, bad_val, fake_measurements):
     """Test attempting to read in an invalid parameter value."""
-    rec = create_fake_input(campaign.parameters, campaign.targets, batch_size)
-
     # Add an invalid value
-    rec[campaign.parameters[0].name].iloc[0] = bad_val
+    fake_measurements[campaign.parameters[0].name].iloc[0] = bad_val
     with pytest.raises((ValueError, TypeError)):
-        campaign.add_measurements(rec)
+        campaign.add_measurements(fake_measurements)
 
 
 @pytest.mark.parametrize(

tests/test_pending_experiments.py

@@ -21,7 +21,6 @@
 from baybe.utils.basic import get_subclasses
 from baybe.utils.dataframe import (
     add_parameter_noise,
-    create_fake_input,
 )
 from baybe.utils.random import temporary_seed
 
@@ -115,13 +114,12 @@
     ],
 )
 @pytest.mark.parametrize("n_grid_points", [8], ids=["grid8"])
-def test_pending_points(campaign, batch_size):
+def test_pending_points(campaign, batch_size, fake_measurements):
     """Test there is no recommendation overlap if pending experiments are specified."""
     warnings.filterwarnings("ignore", category=UnusedObjectWarning)
 
     # Add some initial measurements
-    rec = create_fake_input(campaign.parameters, campaign.targets, batch_size)
-    campaign.add_measurements(rec)
+    campaign.add_measurements(fake_measurements)
 
     # Get recommendations and set them as pending experiments while getting another set
     # Fix the random seed for each recommend call to limit influence of randomness in
@@ -156,24 +154,23 @@ def test_pending_points(campaign, batch_size):
 )
 @pytest.mark.parametrize("n_grid_points", [5], ids=["g5"])
 @pytest.mark.parametrize("batch_size", [3], ids=["b3"])
-def test_invalid_acqf(searchspace, recommender, objective, batch_size, acqf):
+def test_invalid_acqf(searchspace, objective, batch_size, acqf, fake_measurements):
     """Test exception raised for acqfs that don't support pending experiments."""
     recommender = TwoPhaseMetaRecommender(
         recommender=BotorchRecommender(acquisition_function=acqf)
     )
 
     # Create fake measurements and pending experiments
-    rec1 = create_fake_input(searchspace.parameters, objective.targets, batch_size)
-    rec2 = rec1.copy()
-    add_parameter_noise(rec2, searchspace.parameters)
+    fake_pending_experiments = fake_measurements.copy()
+    add_parameter_noise(fake_pending_experiments, searchspace.parameters)
 
     with pytest.raises(IncompatibleAcquisitionFunctionError):
         recommender.recommend(
             batch_size,
             searchspace,
             objective,
-            measurements=rec1,
-            pending_experiments=rec2,
+            measurements=fake_measurements,
+            pending_experiments=fake_pending_experiments,
         )
 
 
@@ -215,18 +212,18 @@ def test_invalid_input(
     batch_size,
     invalid_pending_value,
     parameter_names,
+    fake_measurements,
 ):
     """Test exception raised for invalid pending experiments input."""
     # Create fake measurements and pending experiments
-    rec1 = create_fake_input(searchspace.parameters, objective.targets, batch_size)
-    rec2 = rec1.copy()
-    rec2[parameter_names[0]] = invalid_pending_value
+    fake_pending_experiments = fake_measurements.copy()
+    fake_pending_experiments[parameter_names[0]] = invalid_pending_value
 
     with pytest.raises((ValueError, TypeError), match="parameter"):
         recommender.recommend(
             batch_size,
             searchspace,
             objective,
-            measurements=rec1,
-            pending_experiments=rec2,
+            measurements=fake_measurements,
+            pending_experiments=fake_pending_experiments,
         )

tests/test_surrogate.py

@@ -2,25 +2,21 @@
 
 from unittest.mock import patch
 
-from baybe.recommenders.pure.nonpredictive.sampling import RandomRecommender
 from baybe.surrogates.gaussian_process.core import GaussianProcessSurrogate
-from baybe.utils.dataframe import add_fake_measurements
 
 
 @patch.object(GaussianProcessSurrogate, "_fit")
-def test_caching(patched, searchspace, objective):
+def test_caching(patched, searchspace, objective, fake_measurements):
     """A second fit call with the same context does not trigger retraining."""
     # Prepare the setting
-    measurements = RandomRecommender().recommend(3, searchspace, objective)
-    add_fake_measurements(measurements, objective.targets)
     surrogate = GaussianProcessSurrogate()
 
     # First call
-    surrogate.fit(searchspace, objective, measurements)
+    surrogate.fit(searchspace, objective, fake_measurements)
     patched.assert_called()
 
     patched.reset_mock()
 
     # Second call
-    surrogate.fit(searchspace, objective, measurements)
+    surrogate.fit(searchspace, objective, fake_measurements)
     patched.assert_not_called()