Raise error when loading param via response api

src/ert/storage/local_ensemble.py

@@ -215,6 +215,8 @@ def load_parameters(
     def load_responses(
         self, key: str, realizations: npt.NDArray[np.int_]
     ) -> xr.Dataset:
+        if key not in self.experiment.response_configuration:
+            raise ValueError(f"{key} is not a response")
         loaded = []
         for realization in realizations:
             input_path = self.mount_point / f"realization-{realization}" / f"{key}.nc"

tests/performance_tests/test_memory_usage.py

@@ -73,13 +73,14 @@ def fill_storage_with_data(poly_template: Path, ert_config: ErtConfig) -> None:
         ens_config = ert_config.ensemble_config
         experiment_id = storage.create_experiment(
             parameters=ens_config.parameter_configuration,
+            responses=ens_config.response_configuration,
             observations=ert_config.observations,
         )
         source = storage.create_ensemble(experiment_id, name="prior", ensemble_size=100)
 
         summary_obs_keys = ens_config.getKeylistFromImplType(SummaryConfig)
         realizations = list(range(ert_config.model_config.num_realizations))
-        for _obs_key, obs in ert_config.observations.items():
+        for _, obs in ert_config.observations.items():
             data_key = obs.attrs["response"]
             for real in realizations:
                 if data_key != "summary":

tests/unit_tests/storage/migration/test_block_fs_snake_oil.py

@@ -10,6 +10,7 @@
 import ert.storage.migration._block_fs_native as bfn
 import ert.storage.migration.block_fs as bf
 from ert.config import ErtConfig, GenKwConfig
+from ert.config.summary_config import SummaryConfig
 from ert.storage import open_storage
 from ert.storage.local_storage import local_storage_set_ert_config
 
@@ -88,31 +89,51 @@ def test_migrate_gen_kw(data, parameter, ens_config, tmp_path):
             assert (expect_array == actual).all(), param
 
 
-def test_migrate_summary(data, ensemble, forecast, time_map):
+def test_migrate_summary(data, forecast, time_map, tmp_path):
     group = "/REAL_0/SUMMARY"
-    bf._migrate_summary(ensemble, forecast, time_map)
+    with open_storage(tmp_path / "storage", mode="w") as storage:
+        experiment = storage.create_experiment(
+            responses=[
+                SummaryConfig(name="summary", input_file="some_file", keys=["some_key"])
+            ]
+        )
+        ensemble = experiment.create_ensemble(name="default_0", ensemble_size=5)
 
-    expected_keys = set(data[group].variables) - set(data[group].dimensions)
-    assert set(ensemble.get_summary_keyset()) == expected_keys
+        bf._migrate_summary(ensemble, forecast, time_map)
 
-    for key in ensemble.get_summary_keyset():
-        expect = np.array(data[group][key])[1:]  # Skip first report_step
-        actual = (
-            ensemble.load_responses("summary", (0,))
-            .sel(name=key)["values"]
-            .data.flatten()
-        )
-        assert list(expect) == list(actual), key
+        expected_keys = set(data[group].variables) - set(data[group].dimensions)
+        assert set(ensemble.get_summary_keyset()) == expected_keys
+
+        for key in ensemble.get_summary_keyset():
+            expect = np.array(data[group][key])[1:]  # Skip first report_step
+            actual = (
+                ensemble.load_responses("summary", (0,))
+                .sel(name=key)["values"]
+                .data.flatten()
+            )
+            assert list(expect) == list(actual), key
 
 
-def test_migrate_gen_data(data, ensemble, forecast):
+def test_migrate_gen_data(data, forecast, tmp_path):
     group = "/REAL_0/GEN_DATA"
-    bf._migrate_gen_data(ensemble, forecast)
+    with open_storage(tmp_path / "storage", mode="w") as storage:
+        experiment = storage.create_experiment(
+            responses=[
+                SummaryConfig(name=name, input_file="some_file", keys=["some_key"])
+                for name in (
+                    "SNAKE_OIL_WPR_DIFF",
+                    "SNAKE_OIL_OPR_DIFF",
+                    "SNAKE_OIL_GPR_DIFF",
+                )
+            ]
+        )
+        ensemble = experiment.create_ensemble(name="default_0", ensemble_size=5)
+        bf._migrate_gen_data(ensemble, forecast)
 
-    for key in set(data[group].variables) - set(data[group].dimensions):
-        expect = np.array(data[group][key]).flatten()
-        actual = ensemble.load_responses(key, (0,))["values"].data.flatten()
-        assert list(expect) == list(actual), key
+        for key in set(data[group].variables) - set(data[group].dimensions):
+            expect = np.array(data[group][key]).flatten()
+            actual = ensemble.load_responses(key, (0,))["values"].data.flatten()
+            assert list(expect) == list(actual), key
 
 
 @pytest.mark.parametrize("name,iter", [("default_3", 3), ("foobar", 0)])

tests/unit_tests/storage/test_local_ensemble.py

@@ -4,6 +4,7 @@
 import xtgeo
 from resdata.grid import GridGenerator
 
+from ert.config import GenKwConfig
 from ert.config.field import Field
 from ert.field_utils import FieldFileFormat
 from ert.storage import open_storage
@@ -105,7 +106,9 @@ def test_that_load_responses_throws_exception(tmp_path):
         experiment = storage.create_experiment()
         ensemble = storage.create_ensemble(experiment, name="foo", ensemble_size=1)
 
-        with pytest.raises(expected_exception=KeyError):
+        with pytest.raises(
+            expected_exception=ValueError, match="I_DONT_EXIST is not a response"
+        ):
             ensemble.load_responses("I_DONT_EXIST", (1,))
 
 
@@ -118,27 +121,37 @@ def test_that_load_parameters_throws_exception(tmp_path):
             ensemble.load_parameters("I_DONT_EXIST", 1)
 
 
-def test_that_only_registered_parameters_can_be_saved(tmp_path):
+def test_that_loading_parameter_via_response_api_fails(tmp_path):
+    uniform_parameter = GenKwConfig(
+        name="PARAMETER",
+        forward_init=False,
+        template_file="",
+        transfer_function_definitions=[
+            "KEY1 UNIFORM 0 1",
+        ],
+        output_file="kw.txt",
+    )
     with open_storage(tmp_path, mode="w") as storage:
-        experiment = storage.create_experiment()
+        experiment = storage.create_experiment(
+            parameters=[uniform_parameter],
+        )
         prior = storage.create_ensemble(
             experiment,
             ensemble_size=1,
             iteration=0,
             name="prior",
         )
 
-        with pytest.raises(
-            ValueError, match="PARAMETER is not registered to the experiment."
-        ):
-            prior.save_parameters(
-                "PARAMETER",
-                0,
-                xr.Dataset(
-                    {
-                        "values": ("names", [1.0]),
-                        "transformed_values": ("names", [1.0]),
-                        "names": ["KEY_1"],
-                    }
-                ),
-            )
+        prior.save_parameters(
+            "PARAMETER",
+            0,
+            xr.Dataset(
+                {
+                    "values": ("names", [1.0]),
+                    "transformed_values": ("names", [1.0]),
+                    "names": ["KEY_1"],
+                }
+            ),
+        )
+        with pytest.raises(ValueError, match="PARAMETER is not a response"):
+            prior.load_responses("PARAMETER", (0,))

tests/unit_tests/test_libres_facade.py

@@ -363,7 +363,7 @@ def test_gen_data_collector(
     snake_oil_case_storage, snapshot, snake_oil_default_storage
 ):
     facade = LibresFacade(snake_oil_case_storage)
-    with pytest.raises(KeyError):
+    with pytest.raises(ValueError, match="RFT_XX is not a response"):
         _ = facade.load_gen_data(snake_oil_default_storage, "RFT_XX", 199)
 
     with pytest.raises(KeyError):