def test_config_updated(self):
conf = Config()
conf.update(prepare({"config": {"param": {"value": 0}}}, source_name="lib"))
conf.update(prepare({"config": {"param2": {"value": 0}}}, source_name="lib2"))
assert conf["config"][0].name == "param"
assert conf["config"][1].name == "param2"
def test_raises_when_trying_to_add_duplicate_config_setting(self):
conf = Config(
prepare({"config": {
"param": {
"value": 0
}
}}, source_name="lib"))
with pytest.raises(ValueError, match="lib.param already defined"):
conf.update(
prepare({"config": {
"param": {
"value": 0
}
}}, source_name="lib"))
def test_target_overrides_only_collected_for_valid_targets(self):
lib = {
"name": "lib",
"target_overrides": {
"*": {
"target.macros": ["j"]
},
"VALID_TARGET": {
"target.device_has": ["k"]
},
"FILTER_TARGET": {
"network-default-interface-type": "ETHERNET"
},
},
}
expected_macro_override = Override(namespace="target",
name="macros",
value={"j"},
modifier=None)
expected_device_has_override = Override(namespace="target",
name="device_has",
value={"k"},
modifier=None)
conf = source.prepare(lib, target_filters=["VALID_TARGET"])
macro_override, device_has_override, *others = conf["overrides"]
assert macro_override == expected_macro_override
assert device_has_override == expected_device_has_override
assert others == []
def test_override_fields_from_target_are_namespaced(self):
target = {"overrides": {"network-default-interface-type": "ETHERNET"}}
conf = source.prepare(target, "target")
network_override, *_ = conf["overrides"]
assert network_override.namespace == "target" and network_override.name == "network-default-interface-type"
def test_cumulative_fields_parsed(self):
lib = {
"name": "lib",
"target_overrides": {
"*": {
"macros_add": ["MAC"],
"target.device_has_add": ["k"],
"target.device_has_remove": ["j"]
}
},
}
expected_device_has_add = Override(namespace="target",
name="device_has",
modifier="add",
value={"k"})
expected_device_has_remove = Override(namespace="target",
name="device_has",
modifier="remove",
value={"j"})
expected_macros_add = Override(namespace="lib",
name="macros",
modifier="add",
value={"MAC"})
conf = source.prepare(lib)
macros_add_override, device_has_add_override, device_has_remove_override = conf[
"overrides"]
assert device_has_add_override == expected_device_has_add
assert device_has_remove_override == expected_device_has_remove
assert macros_add_override == expected_macros_add
def test_warns_and_skips_override_for_undefined_config_parameter(
self, caplog):
conf = Config()
override_name = "this-does-not-exist"
conf.update(prepare({"target_overrides": {"*": {override_name: ""}}}))
assert override_name in caplog.text
assert not conf
def _assemble_config_from_sources(
target_attributes: dict,
mbed_lib_files: List[Path],
mbed_app_file: Optional[Path] = None) -> Config:
config = Config(source.prepare(target_attributes, source_name="target"))
previous_filter_data = None
app_data = None
if mbed_app_file:
# We need to obtain the file filter data from mbed_app.json so we can select the correct set of mbed_lib.json
# files to include in the config. We don't want to update the config object with all of the app settings yet
# as we won't be able to apply overrides correctly until all relevant mbed_lib.json files have been parsed.
app_data = source.from_file(
mbed_app_file,
default_name="app",
target_filters=FileFilterData.from_config(config).labels)
_get_app_filter_labels(app_data, config)
current_filter_data = FileFilterData.from_config(config)
while previous_filter_data != current_filter_data:
filtered_files = _filter_files(mbed_lib_files, current_filter_data)
for config_file in filtered_files:
config.update(
source.from_file(config_file,
target_filters=current_filter_data.labels))
# Remove any mbed_lib files we've already visited from the list so we don't parse them multiple times.
mbed_lib_files.remove(config_file)
previous_filter_data = current_filter_data
current_filter_data = FileFilterData.from_config(config)
# Apply mbed_app.json data last so config parameters are overriden in the correct order.
if app_data:
config.update(app_data)
return config
def test_ignores_present_option(self):
source = prepare({
"name": "mbed_component",
"config": {
"present": {
"help": "Mbed Component",
"value": True
}
}
})
config = Config(source)
assert not config["config"]
def test_returns_quoted_content(self, fake_target):
config = Config(prepare(fake_target))
# Add an option whose value contains quotes to the config.
config["config"] = [
ConfigSetting(
name="mqtt-host",
namespace="iotc",
help_text="",
value='{"mqtt.2030.ltsapis.goog", IOTC_MQTT_PORT}',
)
]
result = render_mbed_config_cmake_template(config, TOOLCHAIN_NAME,
"target_name")
assert '"-DMBED_CONF_IOTC_MQTT_HOST={\\"mqtt.2030.ltsapis.goog\\", IOTC_MQTT_PORT}"' in result
def test_override_fields_from_lib_are_namespaced(self):
lib = {
"name": "lib",
"target_overrides": {
"*": {
"network-default-interface-type": "ETHERNET",
"target.device_has": ["k"]
}
},
}
conf = source.prepare(lib)
network_override, device_has_override = conf["overrides"]
assert network_override.namespace == "lib" and network_override.name == "network-default-interface-type"
assert device_has_override.namespace == "target" and device_has_override.name == "device_has"
def test_converts_config_setting_value_lists_to_sets(self):
lib = {
"name": "library",
"config": {
"list-values": {
"value": ["ETHERNET", "WIFI"]
}
},
"sectors": [[0, 2048]],
"header_info": [[0, 2048], ["bobbins"], ["magic"]],
}
conf = source.prepare(lib)
assert conf["config"][0].value == {"ETHERNET", "WIFI"}
assert conf["sectors"] == {0, 2048}
assert conf["header_info"] == {0, 2048, "bobbins", "magic"}
def test_returns_rendered_content(self, fake_target):
config = Config(prepare(fake_target))
result = render_mbed_config_cmake_template(config, TOOLCHAIN_NAME,
"target_name")
for label in fake_target["labels"] + fake_target["extra_labels"]:
assert label in result
for macro in fake_target["features"] + fake_target["components"] + [
TOOLCHAIN_NAME
]:
assert macro in result
for toolchain in fake_target["supported_c_libs"]:
assert toolchain in result
for supported_c_libs in toolchain:
assert supported_c_libs in result
for supported_application_profiles in fake_target[
"supported_application_profiles"]:
assert supported_application_profiles in result
def test_config_fields_from_target_are_namespaced(self):
target = {
"config": {
"network-default-interface-type": {
"help":
"Default network "
"interface type. "
"Typical options: null, "
"ETHERNET, WIFI, "
"CELLULAR, MESH",
"value":
"ETHERNET",
}
}
}
conf = source.prepare(target, "target")
config_setting, *_ = conf["config"]
assert config_setting.namespace == "target"
assert config_setting.name == "network-default-interface-type"
def test_config_fields_from_lib_are_namespaced(self):
lib = {
"name": "library",
"config": {
"network-default-interface-type": {
"help":
"Default network "
"interface type. "
"Typical options: null, "
"ETHERNET, WIFI, "
"CELLULAR, MESH",
"value":
"ETHERNET",
}
},
}
conf = source.prepare(lib)
config_setting, *_ = conf["config"]
assert config_setting.namespace == "library"
assert config_setting.name == "network-default-interface-type"
def test_assembles_config_using_all_relevant_files(self):
target = {
"config": {
"foo": {
"value": None
}
},
"macros": [],
"labels": ["A"],
"extra_labels": [],
"features": ["RED"],
"components": [],
"c_lib": "std",
"printf_lib": "minimal-printf",
}
mbed_lib_files = [
{
"path": Path("subdir", "FEATURE_RED", "mbed_lib.json"),
"json_contents": {
"name": "red",
"config": {
"bool": {
"value": False
}
},
"target_overrides": {
"A": {
"bool": True,
"target.features_add": ["BLUE"],
"target.components_add": ["LEG"]
}
},
"macros": ["RED_MACRO"],
},
},
{
"path": Path("TARGET_A", "mbed_lib.json"),
"json_contents": {
"name": "a",
"config": {
"number": {
"value": 123
}
},
"target_overrides": {
"*": {
"target.features_add": ["RED"]
}
},
},
},
{
"path": Path("COMPONENT_LEG", "mbed_lib.json"),
"json_contents": {
"name": "leg",
"config": {
"number-of-fingers": {
"value": 5
}
},
"macros": ["LEG_MACRO"],
},
},
]
unused_mbed_lib_file = {
"path": Path("subdir", "FEATURE_BROWN", "mbed_lib.json"),
"json_contents": {
"name": "brown",
"target_overrides": {
"*": {
"red.bool": "DON'T USE ME"
}
},
"macros": ["DONT_USE_THIS_MACRO"],
},
}
mbed_app_file = {
"path": Path("mbed_app.json"),
"json_contents": {
"target_overrides": {
"*": {
"target.foo": "bar"
}
}
},
}
with TemporaryDirectory() as directory:
created_mbed_lib_files = create_files(directory, mbed_lib_files)
created_mbed_app_file = create_files(directory, [mbed_app_file])[0]
create_files(directory, [unused_mbed_lib_file])
subject = _assemble_config_from_sources(
target, find_files("mbed_lib.json", Path(directory)),
created_mbed_app_file)
mbed_lib_sources = [
prepare(decode_json_file(Path(directory, file)),
target_filters=["A"])
for file in created_mbed_lib_files
]
mbed_app_source = prepare(decode_json_file(
Path(directory, created_mbed_app_file)),
target_filters=["A"])
expected_config = Config(prepare(target, source_name="target"))
for source in mbed_lib_sources + [mbed_app_source]:
expected_config.update(source)
subject["config"].sort(key=lambda x: x.name)
expected_config["config"].sort(key=lambda x: x.name)
assert subject == expected_config