def test_union_merge_matrix(
lhs: Any,
rhs: Any,
) -> None:
lhs = _ensure_container(lhs)
rhs = _ensure_container(rhs)
lnode = lhs._get_node("foo")
rnode = rhs._get_node("foo")
lvalue = _get_value(lnode)
rvalue = _get_value(rnode)
# lvk = get_value_kind(lnode)
rvk = get_value_kind(rnode)
rmissing = rvk is ValueKind.MANDATORY_MISSING
can_merge = True
if can_merge:
merged = OmegaConf.merge(lhs, rhs)
if rmissing:
assert merged == {"foo": lvalue}
else:
assert merged == {"foo": rvalue}
else:
with raises(ValidationError):
OmegaConf.merge(lhs, rhs)
def test_ensure_container_raises_ValueError() -> None:
"""Some values cannot be converted to a container.
On these inputs, _ensure_container should raise a ValueError."""
with raises(
ValueError,
match=re.escape(
"Invalid input. Supports one of " +
"[dict,list,DictConfig,ListConfig,dataclass,dataclass instance,attr class,attr class instance]"
),
):
_ensure_container("abc")
def test_dict_setitem_invalid_element_type(
dc: DictConfig,
value: Any,
err_msg: str,
ensure_container: bool,
overwrite_preexisting_key: bool,
) -> None:
dc_orig = dc
dc = copy.deepcopy(dc)
if ensure_container:
if isinstance(value, (dict, list)):
value = _ensure_container(value)
else:
return # skip
if overwrite_preexisting_key:
with raises((ValidationError, KeyValidationError), match=err_msg):
dc["key"] = value
assert dc == dc_orig
else:
del dc["key"]
with raises((ValidationError, KeyValidationError), match=err_msg):
dc["key"] = value
assert dc == {}
def test_interpolation(cfg: Any, key: str, expected: Any) -> None:
cfg = _ensure_container(cfg)
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.select(cfg, key)
else:
assert OmegaConf.select(cfg, key) == expected
def test_assignment_optional_behavior(src: Any, keys: List[DictKeyType],
ref_type: Any,
is_optional: bool) -> None:
cfg = _ensure_container(src)
for k in keys:
cfg = cfg._get_node(k)
assert cfg._is_optional() == is_optional
assert cfg._metadata.ref_type == ref_type
def test_select_invalid_interpolation(cfg: Any, node_key: str, expected: Any) -> None:
cfg = _ensure_container(cfg)
resolved = OmegaConf.select(
cfg,
node_key,
throw_on_missing=False,
throw_on_resolution_failure=False,
)
assert resolved == expected
def test_select_default(
cfg: Any,
struct: bool,
key: Any,
default: Any,
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
assert OmegaConf.select(cfg, key, default=default) == default
def test_update_force_add(cfg: Any, key: str, value: Any, expected: Any) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, True)
with raises((ConfigAttributeError, ConfigKeyError)): # type: ignore
OmegaConf.update(cfg, key, value, force_add=False)
OmegaConf.update(cfg, key, value, force_add=True)
assert cfg == expected
def test_update_merge_set(cfg: Any, key: str, value: Any, merge: bool,
expected: Any) -> None:
cfg = _ensure_container(cfg)
if is_primitive_container(expected):
OmegaConf.update(cfg, key, value, merge=merge)
assert cfg == expected
else:
with expected:
OmegaConf.update(cfg, key, value, merge=merge)
def test_select(restore_resolvers: Any, cfg: Any, key: Any,
expected: Any) -> None:
OmegaConf.register_resolver("func", lambda x: f"_{x}_")
cfg = _ensure_container(cfg)
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.select(cfg, key)
else:
assert OmegaConf.select(cfg, key) == expected
def test_select_default_returned(
self,
cfg: Any,
struct: Optional[bool],
key: Any,
default: Any,
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
assert OmegaConf.select(cfg, key, default=default) == default
def test_env_interpolation_error(
self,
cfg: Any,
key: str,
expected: Any,
) -> None:
cfg = _ensure_container(cfg)
with expected:
OmegaConf.select(cfg, key)
def test_nested_select_default_not_used(
self,
cfg: Any,
struct: Optional[bool],
key: Any,
default: Any,
expected: Any,
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
assert OmegaConf.select(cfg.x, key, default=default) == expected
def test_select_default_throw_on_resolution_failure(
self, cfg: Any, key: Any, struct: Optional[bool]) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
# throw on resolution failure still throws if default is provided
with raises(InterpolationKeyError):
OmegaConf.select(cfg,
key,
default=123,
throw_on_resolution_failure=True)
def test_select_default_throw_on_missing(
cfg: Any,
struct: bool,
key: Any,
default: Any,
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
# throw on missing still throws if default is provided
with pytest.raises(MissingMandatoryValue):
OmegaConf.select(cfg, key, default=default, throw_on_missing=True)
def test_select_default_not_used(
self,
cfg: Any,
struct: Optional[bool],
key: Any,
default: Any,
expected: Any,
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
selected = OmegaConf.select(cfg, key, default=default)
assert selected == expected
assert type(selected) is type(expected)
def test_union_merge(inputs: Any, expected: Any, type_hint: Any) -> None:
configs = [_ensure_container(c) for c in inputs]
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.merge(*configs)
else:
merged = OmegaConf.merge(*configs)
assert merged == expected
assert isinstance(merged, DictConfig)
node = merged._get_node("foo")
assert isinstance(node, Node)
assert get_type_hint(node) == type_hint
def test_env_interpolation_error(
self,
# DEPRECATED: remove in 2.2 with the legacy env resolver
recwarn: Any,
env_func: str,
cfg: Any,
key: str,
expected: Any,
) -> None:
cfg["env_func"] = env_func # allows choosing which env resolver to use
cfg = _ensure_container(cfg)
with expected:
OmegaConf.select(cfg, key)
def test_to_container(src: Any, expected: Any,
expected_with_resolve: Any) -> None:
if expected is None:
expected = src
if expected_with_resolve is None:
expected_with_resolve = expected
cfg = _ensure_container(src)
container = OmegaConf.to_container(cfg)
assert container == expected
container = OmegaConf.to_container(
cfg, structured_config_mode=SCMode.INSTANTIATE)
assert container == expected
container = OmegaConf.to_container(cfg, resolve=True)
assert container == expected_with_resolve
def test_select(
self,
restore_resolvers: Any,
cfg: Any,
key: Any,
expected: Any,
struct: Optional[bool],
) -> None:
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.select(cfg, key)
else:
assert OmegaConf.select(cfg, key) == expected
def test_optional_element_type_merge(
inputs: Any, expected: Any, ref_type: Any, is_optional: bool
) -> None:
configs = [_ensure_container(c) for c in inputs]
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.merge(*configs)
else:
cfg = OmegaConf.merge(*configs)
assert cfg == expected
assert isinstance(cfg, DictConfig)
node = cfg._get_node("foo")
assert isinstance(node, Node)
assert node._is_optional() == is_optional
assert node._metadata.ref_type == ref_type
def test_env_interpolation(
monkeypatch: Any,
cfg: Any,
env_name: Optional[str],
env_val: str,
key: str,
expected: Any,
) -> None:
if env_name is not None:
monkeypatch.setenv(env_name, env_val)
cfg = _ensure_container(cfg)
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.select(cfg, key)
else:
assert OmegaConf.select(cfg, key) == expected
def test_append_to_typed(
cfg: ListConfig,
value: Any,
expected: Any,
expected_ref_type: type,
) -> None:
cfg = _ensure_container(cfg)
if isinstance(expected, type):
with raises(expected):
cfg.append(value)
else:
cfg.append(value)
assert cfg == expected
node = cfg._get_node(-1)
assert isinstance(node, Node)
assert node._metadata.ref_type == expected_ref_type
validate_list_keys(cfg)
def test_select_resolver(
self,
restore_resolvers: Any,
cfg: Any,
key: Any,
expected: Any,
register_func: Any,
struct: Optional[bool],
) -> None:
register_func("func", lambda x: f"_{x}_")
cfg = _ensure_container(cfg)
OmegaConf.set_struct(cfg, struct)
if isinstance(expected, RaisesContext):
with expected:
OmegaConf.select(cfg, key)
else:
assert OmegaConf.select(cfg, key) == expected
def test_items(cfg: Any, expected: Any, expected_no_resolve: Any) -> None:
cfg = _ensure_container(cfg)
if isinstance(expected, list):
assert list(cfg.items()) == expected
else:
with expected:
cfg.items()
if isinstance(expected_no_resolve, list):
pairs = list(cfg.items_ex(resolve=False))
assert pairs == expected_no_resolve
for idx in range(len(expected_no_resolve)):
assert type(pairs[idx][0]) == type(expected_no_resolve[idx][0]) # noqa
assert type(pairs[idx][1]) == type(expected_no_resolve[idx][1]) # noqa
else:
with expected_no_resolve:
cfg.items_ex(resolve=False)
def test_list_assign_to_container_typed_element(
cfg: ListConfig,
value: Any,
type_hint: Any,
key_type: Any,
elt_type: Any,
obj_type: Any,
ensure_container: bool,
) -> None:
cfg = copy.deepcopy(cfg)
if ensure_container:
value = _ensure_container(value)
n = len(cfg)
for idx in range(n):
cfg[idx] = value
check_subnode(cfg, idx, value, type_hint, key_type, elt_type, obj_type)
cfg.append(value)
check_subnode(cfg, n, value, type_hint, key_type, elt_type, obj_type)
def test_dict_assign_to_container_typed_element(
cfg: DictConfig,
value: Any,
type_hint: Any,
key_type: Any,
elt_type: Any,
obj_type: Any,
ensure_container: bool,
) -> None:
cfg = copy.deepcopy(cfg)
if ensure_container:
value = _ensure_container(value)
for key in cfg:
cfg[key] = value
check_subnode(cfg, key, value, type_hint, key_type, elt_type, obj_type)
cfg["_new_key"] = value
check_subnode(cfg, "_new_key", value, type_hint, key_type, elt_type,
obj_type)
def test_resolve_key_and_root(cfg: Any, node_key: str, key: str,
expected: Tuple[Node, str]) -> None:
cfg = _ensure_container(cfg)
node: Container = OmegaConf.select(cfg, node_key)
assert node._resolve_key_and_root(key) == expected
def test_type_inherit_type(cfg: Any) -> None:
cfg = _ensure_container(cfg)
assert isinstance(cfg.a, type(cfg.b))
assert type(
cfg.s) == str # check that string interpolations are always strings
def test_update(cfg: Any, key: str, value: Any, expected: Any) -> None:
cfg = _ensure_container(cfg)
OmegaConf.update(cfg, key, value)
assert cfg == expected
