Add more tests of error messages

src/ert/config/_read_summary.py

@@ -6,7 +6,7 @@
 from datetime import datetime, timedelta
 from enum import Enum, auto
 from fnmatch import fnmatch
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, TypeVar, Union
 
 import numpy as np
 import numpy.typing as npt
@@ -61,7 +61,7 @@ def from_keyword(cls, summary_keyword: str) -> _SummaryType:
  "W": cls.WELL,
  }
  if summary_keyword == "":
- raise ValueError("Got empty summary_keyword")
+ raise ValueError("Got empty summary keyword")
  if any(special in summary_keyword for special in SPECIAL_KEYWORDS):
  return cls.OTHER
  if summary_keyword[0] in KEYWORD_TYPE_MAPPING:
@@ -93,9 +93,12 @@ def _cell_index(
  return array_index + 1, j + 1, k + 1
 
 
+T = TypeVar("T")
+
+
 def _check_if_missing(
- keyword_name: str, missing_key: str, *test_vars: Optional[int]
-) -> List[int]:
+ keyword_name: str, missing_key: str, *test_vars: Optional[T]
+) -> List[T]:
  if any(v is None for v in test_vars):
  raise ValueError(
  f"Found {keyword_name} keyword in summary "
@@ -149,13 +152,17 @@ def make_summary_key(
  r2 = ((number - r1) // 32768) - 10
  return f"{keyword}:{r1}-{r2}"
  if sum_type == _SummaryType.LOCAL_WELL:
+ (name,) = _check_if_missing("local well", "WGNAMES", name)
+ (lgr_name,) = _check_if_missing("local well", "LGRS", lgr_name)
  return f"{keyword}:{lgr_name}:{name}"
  if sum_type == _SummaryType.LOCAL_BLOCK:
+ li, lj, lk = _check_if_missing("local block", "NUMLX", li, lj, lk)
+ (lgr_name,) = _check_if_missing("local block", "LGRS", lgr_name)
  return f"{keyword}:{lgr_name}:{li},{lj},{lk}"
  if sum_type == _SummaryType.LOCAL_COMPLETION:
- nx, ny = _check_if_missing("local completion", "dimens", nx, ny)
- (number,) = _check_if_missing("local completion", "nums", number)
- i, j, k = _cell_index(number - 1, nx, ny)
+ li, lj, lk = _check_if_missing("local completion", "NUMLX", li, lj, lk)
+ (name,) = _check_if_missing("local completion", "WGNAMES", name)
+ (lgr_name,) = _check_if_missing("local completion", "LGRS", lgr_name)
  return f"{keyword}:{lgr_name}:{name}:{li},{lj},{lk}"
  if sum_type == _SummaryType.NETWORK:
  # This is consistent with resinsight but
@@ -200,7 +207,7 @@ def _find_file_matching(
  raise ValueError(f"Could not find any {kind} matching case path {case}")
  if len(candidates) > 1:
  raise ValueError(
- f"Ambigous reference to {kind} in {case}, could be any of {candidates}"
+ f"Ambiguous reference to {kind} in {case}, could be any of {candidates}"
  )
  return os.path.join(dir, candidates[0])
 
@@ -215,10 +222,13 @@ def read_summary(
  filepath: str, fetch_keys: Sequence[str]
 ) -> Tuple[List[str], Sequence[datetime], Any]:
  summary, spec = _get_summary_filenames(filepath)
- date_index, start_date, date_units, keys, indices = _read_spec(spec, fetch_keys)
- fetched, time_map = _read_summary(
- summary, start_date, date_units, indices, date_index
- )
+ try:
+ date_index, start_date, date_units, keys, indices = _read_spec(spec, fetch_keys)
+ fetched, time_map = _read_summary(
+ summary, start_date, date_units, indices, date_index
+ )
+ except resfo.ResfoParsingError as err:
+ raise ValueError(f"Failed to read summary file {filepath}: {err}") from err
  return (keys, time_map, fetched)
 
 
@@ -228,6 +238,14 @@ def _key2str(key: Union[bytes, str]) -> str:
  return ret.strip()
 
 
+def _check_vals(
+ kw: str, spec: str, vals: Union[npt.NDArray[Any], resfo.MESS]
+) -> npt.NDArray[Any]:
+ if vals is resfo.MESS or isinstance(vals, resfo.MESS):
+ raise ValueError(f"{kw.strip()} in {spec} has incorrect type MESS")
+ return vals
+
+
 def _read_spec(
  spec: str, fetch_keys: Sequence[str]
 ) -> Tuple[int, datetime, DateUnit, List[str], npt.NDArray[np.int32]]:
@@ -245,7 +263,7 @@ def _read_spec(
  "NUMLX ",
  "NUMLY ",
  "NUMLZ ",
- "LGRNAMES",
+ "LGRS ",
  "UNITS ",
  ]
  }
@@ -274,50 +292,48 @@ def _read_spec(
  break
  kw = entry.read_keyword()
  if kw in arrays:
- vals = entry.read_array()
- if vals is resfo.MESS or isinstance(vals, resfo.MESS):
- raise ValueError(f"{kw} in {spec} was MESS")
- arrays[kw] = vals
+ arrays[kw] = _check_vals(kw, spec, entry.read_array())
  if kw == "DIMENS ":
- vals = entry.read_array()
- if vals is resfo.MESS or isinstance(vals, resfo.MESS):
- raise ValueError(f"DIMENS in {spec} was MESS")
+ vals = _check_vals(kw, spec, entry.read_array())
  size = len(vals)
  n = vals[0] if size > 0 else None
  nx = vals[1] if size > 1 else None
  ny = vals[2] if size > 2 else None
  if kw == "STARTDAT":
- vals = entry.read_array()
- if vals is resfo.MESS or isinstance(vals, resfo.MESS):
- raise ValueError(f"Startdate in {spec} was MESS")
+ vals = _check_vals(kw, spec, entry.read_array())
  size = len(vals)
  day = vals[0] if size > 0 else 0
  month = vals[1] if size > 1 else 0
  year = vals[2] if size > 2 else 0
  hour = vals[3] if size > 3 else 0
  minute = vals[4] if size > 4 else 0
  microsecond = vals[5] if size > 5 else 0
- date = datetime(
- day=day,
- month=month,
- year=year,
- hour=hour,
- minute=minute,
- second=microsecond // 10**6,
- microsecond=microsecond % 10**6,
- )
+ try:
+ date = datetime(
+ day=day,
+ month=month,
+ year=year,
+ hour=hour,
+ minute=minute,
+ second=microsecond // 10**6,
+ microsecond=microsecond % 10**6,
+ )
+ except Exception as err:
+ raise ValueError(
+ f"SMSPEC {spec} contains invalid STARTDAT: {err}"
+ ) from err
  keywords = arrays["KEYWORDS"]
  wgnames = arrays["WGNAMES "]
  nums = arrays["NUMS "]
  numlx = arrays["NUMLX "]
  numly = arrays["NUMLY "]
  numlz = arrays["NUMLZ "]
- lgr_names = arrays["LGRNAMES"]
+ lgr_names = arrays["LGRS "]
 
  if date is None:
- raise ValueError(f"keyword startdat missing in {spec}")
+ raise ValueError(f"Keyword startdat missing in {spec}")
  if keywords is None:
- raise ValueError(f"keywords missing in {spec}")
+ raise ValueError(f"Keywords missing in {spec}")
  if n is None:
  n = len(keywords)
 
@@ -367,16 +383,22 @@ def optional_get(arr: Optional[npt.NDArray[Any]], idx: int) -> Any:
 
  units = arrays["UNITS "]
  if units is None:
- raise ValueError(f"keyword units missing in {spec}")
+ raise ValueError(f"Keyword units missing in {spec}")
  if date_index is None:
  raise ValueError(f"KEYWORDS did not contain TIME in {spec}")
  if date_index >= len(units):
  raise ValueError(f"Unit missing for TIME in {spec}")
 
+ unit_key = _key2str(units[date_index])
+ try:
+ date_unit = DateUnit[unit_key]
+ except KeyError:
+ raise ValueError(f"Unknown date unit in {spec}: {unit_key}") from None
+
  return (
  date_index,
  date,
- DateUnit[_key2str(units[date_index])],
+ date_unit,
  list(keys_array),
  indices_array,
  )
@@ -403,9 +425,7 @@ def _read_summary(
  def read_params() -> None:
  nonlocal last_params, values
  if last_params is not None:
- vals = last_params.read_array()
- if vals is resfo.MESS or isinstance(vals, resfo.MESS):
- raise ValueError(f"PARAMS in {summary} was MESS")
+ vals = _check_vals("PARAMS", summary, last_params.read_array())
  values.append(vals[indices])
  dates.append(start_date + unit.make_delta(float(vals[date_index])))
  last_params = None

tests/unit_tests/config/config_dict_generator.py

@@ -394,6 +394,7 @@ def ert_config_values(draw, use_eclbase=booleans):
  smspecs(
  sum_keys=st.just(sum_keys),
  start_date=st.just(Date.from_datetime(first_date)),
+ use_days=st.just(True),
  )
  )
  std_cutoff = draw(small_floats)

tests/unit_tests/config/summary_generator.py

@@ -66,8 +66,14 @@ def root_memnonic(draw):
  second_character = draw(st.sampled_from("OWGVLPT"))
  third_character = draw(st.sampled_from("PIF"))
  fourth_character = draw(st.sampled_from("RT"))
- # local = draw(st.sampled_from(["", "L"])) if first_character in "BCW" else ""
- return first_character + second_character + third_character + fourth_character
+ local = draw(st.sampled_from(["", "L"])) if first_character in "BCW" else ""
+ return (
+ local
+ + first_character
+ + second_character
+ + third_character
+ + fourth_character
+ )
 
 
 @st.composite
@@ -228,7 +234,6 @@ class Smspec:
  region_numbers: List[int]
  units: List[str]
  start_date: Date
- lgr_names: Optional[List[str]] = None
  lgrs: Optional[List[str]] = None
  numlx: Optional[List[PositiveInt]] = None
  numly: Optional[List[PositiveInt]] = None
@@ -266,7 +271,6 @@ def to_ecl(self) -> List[Tuple[str, Any]]:
  ("STARTDAT", np.array(self.start_date.to_ecl(), dtype=np.int32)),
  ]
  + ([("LGRS ", self.lgrs)] if self.lgrs is not None else [])
- + ([("LGRNAMES", self.lgr_names)] if self.lgr_names is not None else [])
  + ([("NUMLX ", self.numlx)] if self.numlx is not None else [])
  + ([("NUMLY ", self.numly)] if self.numly is not None else [])
  + ([("NUMLZ ", self.numlz)] if self.numlz is not None else [])
@@ -281,36 +285,40 @@ def to_file(self, filelike, file_format: resfo.Format = resfo.Format.UNFORMATTED
 
 
 @st.composite
-def smspecs(
- draw,
- sum_keys,
- start_date,
-):
+def smspecs(draw, sum_keys, start_date, use_days=None):
  """
  Strategy for smspec that ensures that the TIME parameter, as required by
  ert, is in the parameters list.
  """
+ use_days = st.booleans() if use_days is None else use_days
  use_locals = draw(st.booleans())
  sum_keys = draw(sum_keys)
+ if any(sk.startswith("L") for sk in sum_keys):
+ use_locals = True
  n = len(sum_keys) + 1
  nx = draw(small_ints)
  ny = draw(small_ints)
  nz = draw(small_ints)
  keywords = ["TIME "] + sum_keys
- units = ["DAYS "] + draw(st.lists(unit_names, min_size=n - 1, max_size=n - 1))
+ if draw(use_days):
+ units = ["DAYS "] + draw(
+ st.lists(unit_names, min_size=n - 1, max_size=n - 1)
+ )
+ else:
+ units = ["HOURS "] + draw(
+ st.lists(unit_names, min_size=n - 1, max_size=n - 1)
+ )
  well_names = [":+:+:+:+"] + draw(st.lists(names, min_size=n - 1, max_size=n - 1))
  if use_locals: # use local
  lgrs = draw(st.lists(names, min_size=n, max_size=n))
  numlx = draw(st.lists(small_ints, min_size=n, max_size=n))
  numly = draw(st.lists(small_ints, min_size=n, max_size=n))
  numlz = draw(st.lists(small_ints, min_size=n, max_size=n))
- lgr_names = list(set(lgrs))
  else:
  lgrs = None
  numlx = None
  numly = None
  numlz = None
- lgr_names = None
  region_numbers = [-32676] + draw(
  st.lists(
  from_dtype(np.dtype(np.int32), min_value=1, max_value=nx * ny * nz),
@@ -336,7 +344,6 @@ def smspecs(
  numlx=st.just(numlx),
  numly=st.just(numly),
  numlz=st.just(numlz),
- lgr_names=st.just(lgr_names),
  region_numbers=st.just(region_numbers),
  units=st.just(units),
  start_date=start_date,