File size: 8,920 Bytes
e40d9d0 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 |
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}})
# raise if an invalid key is merged into a struct
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)
# raise if an invalid key is merged into a struct
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})
# can assign None to params (type Any):
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)
|