| import re |
| from importlib import import_module |
| from typing import Any, Optional |
|
|
| import pytest |
|
|
| from omegaconf import OmegaConf, ValidationError, _utils |
| from omegaconf.errors import ConfigKeyError |
|
|
|
|
| @pytest.mark.parametrize( |
| "class_type", |
| [ |
| "tests.structured_conf.data.dataclasses", |
| "tests.structured_conf.data.attr_classes", |
| ], |
| ) |
| class TestStructured: |
| class TestBasic: |
| def test_error_on_non_structured_config_class(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| with pytest.raises(ValidationError, match="structured config"): |
| OmegaConf.structured(module.NotStructuredConfig) |
|
|
| def test_error_on_non_structured_nested_config_class( |
| self, class_type: str |
| ) -> None: |
| module: Any = import_module(class_type) |
| with pytest.raises( |
| ValidationError, |
| match=re.escape("Unexpected object type : NotStructuredConfig"), |
| ): |
| OmegaConf.structured(module.StructuredWithInvalidField) |
|
|
| def test_assignment_of_subclass(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create({"plugin": module.Plugin}) |
| cfg.plugin = OmegaConf.structured(module.ConcretePlugin) |
| assert OmegaConf.get_type(cfg.plugin) == module.ConcretePlugin |
| assert ( |
| OmegaConf.get_type(cfg.plugin.params) |
| == module.ConcretePlugin.FoobarParams |
| ) |
|
|
| def test_assignment_of_non_subclass_1(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create({"plugin": module.Plugin}) |
| with pytest.raises(ValidationError): |
| cfg.plugin = OmegaConf.structured(module.FaultyPlugin) |
|
|
| def test_merge(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg1 = OmegaConf.create({"plugin": module.Plugin}) |
| cfg2 = OmegaConf.create({"plugin": module.ConcretePlugin}) |
| assert cfg2.plugin == module.ConcretePlugin |
| res: Any = OmegaConf.merge(cfg1, cfg2) |
| assert OmegaConf.get_type(res.plugin) == module.ConcretePlugin |
| assert ( |
| OmegaConf.get_type(res.plugin.params) |
| == module.ConcretePlugin.FoobarParams |
| ) |
|
|
| def test_merge_of_non_subclass_1(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg1 = OmegaConf.create({"plugin": module.Plugin}) |
| cfg2 = OmegaConf.create({"plugin": module.FaultyPlugin}) |
| with pytest.raises(ValidationError): |
| OmegaConf.merge(cfg1, cfg2) |
|
|
| def test_merge_error_new_attribute(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.structured(module.ConcretePlugin) |
| cfg2 = OmegaConf.create({"params": {"bar": 10}}) |
| |
| with pytest.raises(ConfigKeyError): |
| OmegaConf.merge(cfg, cfg2) |
|
|
| def test_merge_error_override_bad_type(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.structured(module.ConcretePlugin) |
|
|
| |
| with pytest.raises(ValidationError): |
| OmegaConf.merge(cfg, {"params": {"foo": "zonk"}}) |
|
|
| def test_error_message(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.structured(module.StructuredOptional) |
| msg = re.escape("child 'not_optional' is not Optional") |
| with pytest.raises(ValidationError, match=msg): |
| cfg.not_optional = None |
|
|
| def test_none_assignment(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create({"plugin": module.Plugin}) |
| |
| cfg.plugin.params = None |
| assert cfg.plugin.params is None |
|
|
| cfg2 = OmegaConf.create({"plugin": module.ConcretePlugin}) |
| with pytest.raises(ValidationError): |
| cfg2.plugin.params = None |
|
|
| @pytest.mark.parametrize("rhs", [1, "foo"]) |
| class TestFailedAssignmentOrMerges: |
| def test_assignment_of_non_subclass_2(self, class_type: str, rhs: Any) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create({"plugin": module.Plugin}) |
| with pytest.raises(ValidationError): |
| cfg.plugin = rhs |
|
|
| def test_merge_of_non_subclass_2(self, class_type: str, rhs: Any) -> None: |
| module: Any = import_module(class_type) |
| cfg1 = OmegaConf.create({"plugin": module.Plugin}) |
| cfg2 = OmegaConf.create({"plugin": rhs}) |
| with pytest.raises(ValidationError): |
| OmegaConf.merge(cfg1, cfg2) |
|
|
| def test_get_type(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg1 = OmegaConf.create(module.LinkedList) |
| assert OmegaConf.get_type(cfg1) == module.LinkedList |
| assert _utils.get_ref_type(cfg1, "next") == Optional[module.LinkedList] |
| assert OmegaConf.get_type(cfg1, "next") is None |
|
|
| assert cfg1.next is None |
| assert OmegaConf.is_missing(cfg1, "value") |
|
|
| cfg2 = OmegaConf.create(module.MissingTest.Missing1) |
| assert OmegaConf.is_missing(cfg2, "head") |
| assert _utils.get_ref_type(cfg2, "head") == module.LinkedList |
| assert OmegaConf.get_type(cfg2, "head") is None |
|
|
| class TestMissing: |
| def test_missing1(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create(module.MissingTest.Missing1) |
| assert OmegaConf.is_missing(cfg, "head") |
|
|
| assert OmegaConf.get_type(cfg, "head") is None |
|
|
| with pytest.raises(ValidationError): |
| cfg.head = 10 |
|
|
| def test_missing2(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create(module.MissingTest.Missing2) |
| assert cfg == {"head": {"next": "???", "value": 1}} |
| assert OmegaConf.is_missing(cfg.head, "next") |
|
|
| cfg.head.next = module.LinkedList(value=2) |
| assert cfg == {"head": {"next": {"next": None, "value": 2}, "value": 1}} |
|
|
| def test_plugin_holder(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| cfg = OmegaConf.create(module.PluginHolder) |
|
|
| assert OmegaConf.is_optional(cfg, "none") |
| assert _utils.get_ref_type(cfg, "none") == Optional[module.Plugin] |
| assert OmegaConf.get_type(cfg, "none") is None |
|
|
| assert not OmegaConf.is_optional(cfg, "missing") |
| assert _utils.get_ref_type(cfg, "missing") == module.Plugin |
| assert OmegaConf.get_type(cfg, "missing") is None |
|
|
| assert not OmegaConf.is_optional(cfg, "plugin") |
| assert _utils.get_ref_type(cfg, "plugin") == module.Plugin |
| assert OmegaConf.get_type(cfg, "plugin") == module.Plugin |
|
|
| cfg.plugin = module.ConcretePlugin() |
| assert not OmegaConf.is_optional(cfg, "plugin") |
| assert _utils.get_ref_type(cfg, "plugin") == module.Plugin |
| assert OmegaConf.get_type(cfg, "plugin") == module.ConcretePlugin |
|
|
| assert not OmegaConf.is_optional(cfg, "plugin2") |
| assert _utils.get_ref_type(cfg, "plugin2") == module.Plugin |
| assert OmegaConf.get_type(cfg, "plugin2") == module.ConcretePlugin |
|
|
| def test_plugin_merge(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| plugin = OmegaConf.structured(module.Plugin) |
| concrete = OmegaConf.structured(module.ConcretePlugin) |
| ret = OmegaConf.merge(plugin, concrete) |
| assert ret == concrete |
| assert OmegaConf.get_type(ret) == module.ConcretePlugin |
|
|
| more_fields = OmegaConf.structured(module.PluginWithAdditionalField) |
| ret = OmegaConf.merge(plugin, more_fields) |
| assert ret == more_fields |
| assert OmegaConf.get_type(ret) == module.PluginWithAdditionalField |
|
|
| def test_native_missing(self, class_type: str) -> None: |
| module: Any = import_module(class_type) |
| with pytest.raises( |
| ValueError, |
| match=re.escape( |
| "Missing default value for WithNativeMISSING.num," |
| " to indicate default must be populated later use OmegaConf.MISSING" |
| ), |
| ): |
| OmegaConf.create(module.WithNativeMISSING) |
|
|
