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