Migrate error type in error.json file

RealizationStorageState IntEnum to StrEnum

(cherry picked from commit 72a6ffb)

Author: Yngve S. Kristiansen

src/ert/storage/local_storage.py

@@ -30,7 +30,7 @@
 
 logger = logging.getLogger(__name__)
 
-_LOCAL_STORAGE_VERSION = 16
+_LOCAL_STORAGE_VERSION = 17
 
 
 class _Migrations(BaseModel):
@@ -498,6 +498,7 @@ def _migrate(self, version: int) -> None:
             to14,
             to15,
             to16,
+            to17,
         )
 
         try:
@@ -543,6 +544,7 @@ def _migrate(self, version: int) -> None:
                     13: to14,
                     14: to15,
                     15: to16,
+                    16: to17,
                 }
                 for from_version in range(version, _LOCAL_STORAGE_VERSION):
                     migrations[from_version].migrate(self.path)

src/ert/storage/migration/to17.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+from typing import Any
+
+info = "Migrate realization error type from IntEnum to StrEnum"
+
+
+def migrate_realization_errors_json_content(
+    error_json: dict[str, Any],
+) -> dict[str, Any]:
+    int_to_str = {
+        1: "undefined",
+        2: "parameters_loaded",
+        4: "responses_loaded",
+        8: "failure_in_current",
+        16: "failure_in_parent",
+    }
+    return error_json | {"type": int_to_str[error_json["type"]]}
+
+
+def migrate_realization_errors(path: Path) -> None:
+    for realization_error in path.glob("ensembles/*/realization-*/error.json"):
+        old_error_json_content = json.loads(
+            realization_error.read_text(encoding="utf-8")
+        )
+        realization_error.write_text(
+            json.dumps(
+                migrate_realization_errors_json_content(old_error_json_content),
+                indent=2,
+            )
+        )
+
+
+def migrate(path: Path) -> None:
+    migrate_realization_errors(path)

tests/ert/unit_tests/storage/migration/test_to17.py

@@ -0,0 +1,132 @@
+# test_migrate.py
+import json
+from datetime import datetime
+from pathlib import Path
+
+from ert.storage.migration.to17 import (
+    migrate,
+    migrate_realization_errors_json_content,
+)
+
+
+def test_add_experiment_status_to_index_json():
+    input_json = {
+        "type": 8,
+        "message": "An error occurred.",
+        "time": datetime.now().isoformat(),
+    }
+
+    expected_output = {
+        "type": "failure_in_current",
+        "message": "An error occurred.",
+        "time": input_json["time"],
+    }
+
+    result = migrate_realization_errors_json_content(input_json)
+    assert migrate_realization_errors_json_content(input_json) == expected_output, (
+        f"Expected {expected_output}, got {result}"
+    )
+
+
+def test_that_realization_storage_state_is_converted_to_strenum_for_all_reals(
+    use_tmpdir,
+):
+    ensembles = ["ensemble_1", "ensemble_2", "ensemble_3"]
+
+    for ensemble in ensembles:
+        ensemble_path = Path(f"ensembles/{ensemble}")
+        ensemble_path.mkdir(parents=True, exist_ok=True)
+
+        for realization, _error_int, _error_str in [
+            (0, 1, "undefined"),
+            (1, 2, "parameters_loaded"),
+            (2, 4, "responses_loaded"),
+            (3, 8, "failure_in_current"),
+            (4, 16, "failure_in_parent"),
+        ]:
+            real_dir = ensemble_path / f"realization-{realization}"
+            real_dir.mkdir()
+            (real_dir / "error.json").write_text(
+                json.dumps(
+                    {
+                        "type": _error_int,
+                        "message": f"Realization {realization} in {ensemble} failed.",
+                        "time": datetime.now().isoformat(),
+                    }
+                ),
+                encoding="utf-8",
+            )
+
+    migrate(Path("."))
+
+    for ensemble in ensembles:
+        ensemble_path = Path(f"ensembles/{ensemble}")
+        for realization, _error_int, _error_str in [
+            (0, 1, "undefined"),
+            (1, 2, "parameters_loaded"),
+            (2, 4, "responses_loaded"),
+            (3, 8, "failure_in_current"),
+            (4, 16, "failure_in_parent"),
+        ]:
+            error_file = ensemble_path / f"realization-{realization}/error.json"
+            contents = json.loads(error_file.read_text(encoding="utf-8"))
+            assert contents["type"] == _error_str
+
+
+def test_realizations_with_missing_error_json(use_tmpdir):
+    ensembles = ["ensemble_1", "ensemble_2", "ensemble_3"]
+
+    missing_files = {
+        "ensemble_1": [1, 3],
+        "ensemble_2": [0, 4],
+        "ensemble_3": [2, 3],
+    }
+
+    for ensemble in ensembles:
+        ensemble_path = Path(f"ensembles/{ensemble}")
+        ensemble_path.mkdir(parents=True, exist_ok=True)
+
+        for realization, _error_int, _error_str in [
+            (0, 1, "undefined"),
+            (1, 2, "parameters_loaded"),
+            (2, 4, "responses_loaded"),
+            (3, 8, "failure_in_current"),
+            (4, 16, "failure_in_parent"),
+        ]:
+            real_dir = ensemble_path / f"realization-{realization}"
+            real_dir.mkdir()
+            error_file = real_dir / "error.json"
+            error_file.write_text(
+                json.dumps(
+                    {
+                        "type": _error_int,
+                        "message": f"Realization {realization} in {ensemble} failed.",
+                        "time": datetime.now().isoformat(),
+                    }
+                ),
+                encoding="utf-8",
+            )
+
+        for missing_real in missing_files[ensemble]:
+            missing_file = ensemble_path / f"realization-{missing_real}/error.json"
+            if missing_file.exists():
+                missing_file.unlink()
+
+    migrate(Path("."))
+
+    for ensemble in ensembles:
+        ensemble_path = Path(f"ensembles/{ensemble}")
+        for realization, _error_int, _error_str in [
+            (0, 1, "undefined"),
+            (1, 2, "parameters_loaded"),
+            (2, 4, "responses_loaded"),
+            (3, 8, "failure_in_current"),
+            (4, 16, "failure_in_parent"),
+        ]:
+            error_file = ensemble_path / f"realization-{realization}/error.json"
+
+            if realization in missing_files[ensemble]:
+                assert not error_file.exists()
+            else:
+                contents = json.loads(error_file.read_text(encoding="utf-8"))
+                assert contents["type"] == _error_str