513 lines
18 KiB
Python
513 lines
18 KiB
Python
"""Test Home Assistant yaml loader."""
|
|
import importlib
|
|
import io
|
|
import os
|
|
import pathlib
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
import yaml as pyyaml
|
|
|
|
from homeassistant.config import YAML_CONFIG_FILE, load_yaml_config_file
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
import homeassistant.util.yaml as yaml
|
|
from homeassistant.util.yaml import loader as yaml_loader
|
|
|
|
from tests.common import get_test_config_dir, patch_yaml_files
|
|
|
|
|
|
@pytest.fixture(params=["enable_c_loader", "disable_c_loader"])
|
|
def try_both_loaders(request):
|
|
"""Disable the yaml c loader."""
|
|
if request.param != "disable_c_loader":
|
|
yield
|
|
return
|
|
try:
|
|
cloader = pyyaml.CSafeLoader
|
|
except ImportError:
|
|
return
|
|
del pyyaml.CSafeLoader
|
|
importlib.reload(yaml_loader)
|
|
yield
|
|
pyyaml.CSafeLoader = cloader
|
|
importlib.reload(yaml_loader)
|
|
|
|
|
|
@pytest.fixture(params=["enable_c_dumper", "disable_c_dumper"])
|
|
def try_both_dumpers(request):
|
|
"""Disable the yaml c dumper."""
|
|
if request.param != "disable_c_dumper":
|
|
yield
|
|
return
|
|
try:
|
|
cdumper = pyyaml.CSafeDumper
|
|
except ImportError:
|
|
return
|
|
del pyyaml.CSafeDumper
|
|
importlib.reload(yaml_loader)
|
|
yield
|
|
pyyaml.CSafeDumper = cdumper
|
|
importlib.reload(yaml_loader)
|
|
|
|
|
|
def test_simple_list(try_both_loaders):
|
|
"""Test simple list."""
|
|
conf = "config:\n - simple\n - list"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["config"] == ["simple", "list"]
|
|
|
|
|
|
def test_simple_dict(try_both_loaders):
|
|
"""Test simple dict."""
|
|
conf = "key: value"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == "value"
|
|
|
|
|
|
def test_unhashable_key() -> None:
|
|
"""Test an unhashable key."""
|
|
files = {YAML_CONFIG_FILE: "message:\n {{ states.state }}"}
|
|
with pytest.raises(HomeAssistantError), patch_yaml_files(files):
|
|
load_yaml_config_file(YAML_CONFIG_FILE)
|
|
|
|
|
|
def test_no_key(try_both_loaders):
|
|
"""Test item without a key."""
|
|
files = {YAML_CONFIG_FILE: "a: a\nnokeyhere"}
|
|
with pytest.raises(HomeAssistantError), patch_yaml_files(files):
|
|
yaml.load_yaml(YAML_CONFIG_FILE)
|
|
|
|
|
|
def test_environment_variable(try_both_loaders):
|
|
"""Test config file with environment variable."""
|
|
os.environ["PASSWORD"] = "secret_password"
|
|
conf = "password: !env_var PASSWORD"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["password"] == "secret_password"
|
|
del os.environ["PASSWORD"]
|
|
|
|
|
|
def test_environment_variable_default(try_both_loaders):
|
|
"""Test config file with default value for environment variable."""
|
|
conf = "password: !env_var PASSWORD secret_password"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["password"] == "secret_password"
|
|
|
|
|
|
def test_invalid_environment_variable(try_both_loaders):
|
|
"""Test config file with no environment variable sat."""
|
|
conf = "password: !env_var PASSWORD"
|
|
with pytest.raises(HomeAssistantError), io.StringIO(conf) as file:
|
|
yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
|
|
|
|
def test_include_yaml(try_both_loaders):
|
|
"""Test include yaml."""
|
|
with patch_yaml_files({"test.yaml": "value"}):
|
|
conf = "key: !include test.yaml"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == "value"
|
|
|
|
with patch_yaml_files({"test.yaml": None}):
|
|
conf = "key: !include test.yaml"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == {}
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_list(mock_walk, try_both_loaders):
|
|
"""Test include dir list yaml."""
|
|
mock_walk.return_value = [["/test", [], ["two.yaml", "one.yaml"]]]
|
|
|
|
with patch_yaml_files({"/test/one.yaml": "one", "/test/two.yaml": "two"}):
|
|
conf = "key: !include_dir_list /test"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == sorted(["one", "two"])
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_list_recursive(mock_walk, try_both_loaders):
|
|
"""Test include dir recursive list yaml."""
|
|
mock_walk.return_value = [
|
|
["/test", ["tmp2", ".ignore", "ignore"], ["zero.yaml"]],
|
|
["/test/tmp2", [], ["one.yaml", "two.yaml"]],
|
|
["/test/ignore", [], [".ignore.yaml"]],
|
|
]
|
|
|
|
with patch_yaml_files(
|
|
{
|
|
"/test/zero.yaml": "zero",
|
|
"/test/tmp2/one.yaml": "one",
|
|
"/test/tmp2/two.yaml": "two",
|
|
}
|
|
):
|
|
conf = "key: !include_dir_list /test"
|
|
with io.StringIO(conf) as file:
|
|
assert (
|
|
".ignore" in mock_walk.return_value[0][1]
|
|
), "Expecting .ignore in here"
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert "tmp2" in mock_walk.return_value[0][1]
|
|
assert ".ignore" not in mock_walk.return_value[0][1]
|
|
assert sorted(doc["key"]) == sorted(["zero", "one", "two"])
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_named(mock_walk, try_both_loaders):
|
|
"""Test include dir named yaml."""
|
|
mock_walk.return_value = [
|
|
["/test", [], ["first.yaml", "second.yaml", "secrets.yaml"]]
|
|
]
|
|
|
|
with patch_yaml_files({"/test/first.yaml": "one", "/test/second.yaml": "two"}):
|
|
conf = "key: !include_dir_named /test"
|
|
correct = {"first": "one", "second": "two"}
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == correct
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_named_recursive(mock_walk, try_both_loaders):
|
|
"""Test include dir named yaml."""
|
|
mock_walk.return_value = [
|
|
["/test", ["tmp2", ".ignore", "ignore"], ["first.yaml"]],
|
|
["/test/tmp2", [], ["second.yaml", "third.yaml"]],
|
|
["/test/ignore", [], [".ignore.yaml"]],
|
|
]
|
|
|
|
with patch_yaml_files(
|
|
{
|
|
"/test/first.yaml": "one",
|
|
"/test/tmp2/second.yaml": "two",
|
|
"/test/tmp2/third.yaml": "three",
|
|
}
|
|
):
|
|
conf = "key: !include_dir_named /test"
|
|
correct = {"first": "one", "second": "two", "third": "three"}
|
|
with io.StringIO(conf) as file:
|
|
assert (
|
|
".ignore" in mock_walk.return_value[0][1]
|
|
), "Expecting .ignore in here"
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert "tmp2" in mock_walk.return_value[0][1]
|
|
assert ".ignore" not in mock_walk.return_value[0][1]
|
|
assert doc["key"] == correct
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_merge_list(mock_walk, try_both_loaders):
|
|
"""Test include dir merge list yaml."""
|
|
mock_walk.return_value = [["/test", [], ["first.yaml", "second.yaml"]]]
|
|
|
|
with patch_yaml_files(
|
|
{"/test/first.yaml": "- one", "/test/second.yaml": "- two\n- three"}
|
|
):
|
|
conf = "key: !include_dir_merge_list /test"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert sorted(doc["key"]) == sorted(["one", "two", "three"])
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_merge_list_recursive(mock_walk, try_both_loaders):
|
|
"""Test include dir merge list yaml."""
|
|
mock_walk.return_value = [
|
|
["/test", ["tmp2", ".ignore", "ignore"], ["first.yaml"]],
|
|
["/test/tmp2", [], ["second.yaml", "third.yaml"]],
|
|
["/test/ignore", [], [".ignore.yaml"]],
|
|
]
|
|
|
|
with patch_yaml_files(
|
|
{
|
|
"/test/first.yaml": "- one",
|
|
"/test/tmp2/second.yaml": "- two",
|
|
"/test/tmp2/third.yaml": "- three\n- four",
|
|
}
|
|
):
|
|
conf = "key: !include_dir_merge_list /test"
|
|
with io.StringIO(conf) as file:
|
|
assert (
|
|
".ignore" in mock_walk.return_value[0][1]
|
|
), "Expecting .ignore in here"
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert "tmp2" in mock_walk.return_value[0][1]
|
|
assert ".ignore" not in mock_walk.return_value[0][1]
|
|
assert sorted(doc["key"]) == sorted(["one", "two", "three", "four"])
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_merge_named(mock_walk, try_both_loaders):
|
|
"""Test include dir merge named yaml."""
|
|
mock_walk.return_value = [["/test", [], ["first.yaml", "second.yaml"]]]
|
|
|
|
files = {
|
|
"/test/first.yaml": "key1: one",
|
|
"/test/second.yaml": "key2: two\nkey3: three",
|
|
}
|
|
|
|
with patch_yaml_files(files):
|
|
conf = "key: !include_dir_merge_named /test"
|
|
with io.StringIO(conf) as file:
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert doc["key"] == {"key1": "one", "key2": "two", "key3": "three"}
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.os.walk")
|
|
def test_include_dir_merge_named_recursive(mock_walk, try_both_loaders):
|
|
"""Test include dir merge named yaml."""
|
|
mock_walk.return_value = [
|
|
["/test", ["tmp2", ".ignore", "ignore"], ["first.yaml"]],
|
|
["/test/tmp2", [], ["second.yaml", "third.yaml"]],
|
|
["/test/ignore", [], [".ignore.yaml"]],
|
|
]
|
|
|
|
with patch_yaml_files(
|
|
{
|
|
"/test/first.yaml": "key1: one",
|
|
"/test/tmp2/second.yaml": "key2: two",
|
|
"/test/tmp2/third.yaml": "key3: three\nkey4: four",
|
|
}
|
|
):
|
|
conf = "key: !include_dir_merge_named /test"
|
|
with io.StringIO(conf) as file:
|
|
assert (
|
|
".ignore" in mock_walk.return_value[0][1]
|
|
), "Expecting .ignore in here"
|
|
doc = yaml_loader.yaml.load(file, Loader=yaml_loader.SafeLineLoader)
|
|
assert "tmp2" in mock_walk.return_value[0][1]
|
|
assert ".ignore" not in mock_walk.return_value[0][1]
|
|
assert doc["key"] == {
|
|
"key1": "one",
|
|
"key2": "two",
|
|
"key3": "three",
|
|
"key4": "four",
|
|
}
|
|
|
|
|
|
@patch("homeassistant.util.yaml.loader.open", create=True)
|
|
def test_load_yaml_encoding_error(mock_open, try_both_loaders):
|
|
"""Test raising a UnicodeDecodeError."""
|
|
mock_open.side_effect = UnicodeDecodeError("", b"", 1, 0, "")
|
|
with pytest.raises(HomeAssistantError):
|
|
yaml_loader.load_yaml("test")
|
|
|
|
|
|
def test_dump(try_both_dumpers):
|
|
"""The that the dump method returns empty None values."""
|
|
assert yaml.dump({"a": None, "b": "b"}) == "a:\nb: b\n"
|
|
|
|
|
|
def test_dump_unicode(try_both_dumpers):
|
|
"""The that the dump method returns empty None values."""
|
|
assert yaml.dump({"a": None, "b": "привет"}) == "a:\nb: привет\n"
|
|
|
|
|
|
FILES = {}
|
|
|
|
|
|
def load_yaml(fname, string, secrets=None):
|
|
"""Write a string to file and return the parsed yaml."""
|
|
FILES[fname] = string
|
|
with patch_yaml_files(FILES):
|
|
return load_yaml_config_file(fname, secrets)
|
|
|
|
|
|
class TestSecrets(unittest.TestCase):
|
|
"""Test the secrets parameter in the yaml utility."""
|
|
|
|
# pylint: disable=invalid-name
|
|
|
|
def setUp(self):
|
|
"""Create & load secrets file."""
|
|
config_dir = get_test_config_dir()
|
|
self._yaml_path = os.path.join(config_dir, YAML_CONFIG_FILE)
|
|
self._secret_path = os.path.join(config_dir, yaml.SECRET_YAML)
|
|
self._sub_folder_path = os.path.join(config_dir, "subFolder")
|
|
self._unrelated_path = os.path.join(config_dir, "unrelated")
|
|
|
|
load_yaml(
|
|
self._secret_path,
|
|
(
|
|
"http_pw: pwhttp\n"
|
|
"comp1_un: un1\n"
|
|
"comp1_pw: pw1\n"
|
|
"stale_pw: not_used\n"
|
|
"logger: debug\n"
|
|
),
|
|
)
|
|
self._yaml = load_yaml(
|
|
self._yaml_path,
|
|
(
|
|
"http:\n"
|
|
" api_password: !secret http_pw\n"
|
|
"component:\n"
|
|
" username: !secret comp1_un\n"
|
|
" password: !secret comp1_pw\n"
|
|
""
|
|
),
|
|
yaml_loader.Secrets(config_dir),
|
|
)
|
|
|
|
def tearDown(self):
|
|
"""Clean up secrets."""
|
|
FILES.clear()
|
|
|
|
def test_secrets_from_yaml(self):
|
|
"""Did secrets load ok."""
|
|
expected = {"api_password": "pwhttp"}
|
|
assert expected == self._yaml["http"]
|
|
|
|
expected = {"username": "un1", "password": "pw1"}
|
|
assert expected == self._yaml["component"]
|
|
|
|
def test_secrets_from_parent_folder(self):
|
|
"""Test loading secrets from parent folder."""
|
|
expected = {"api_password": "pwhttp"}
|
|
self._yaml = load_yaml(
|
|
os.path.join(self._sub_folder_path, "sub.yaml"),
|
|
(
|
|
"http:\n"
|
|
" api_password: !secret http_pw\n"
|
|
"component:\n"
|
|
" username: !secret comp1_un\n"
|
|
" password: !secret comp1_pw\n"
|
|
""
|
|
),
|
|
yaml_loader.Secrets(get_test_config_dir()),
|
|
)
|
|
|
|
assert expected == self._yaml["http"]
|
|
|
|
def test_secret_overrides_parent(self):
|
|
"""Test loading current directory secret overrides the parent."""
|
|
expected = {"api_password": "override"}
|
|
load_yaml(
|
|
os.path.join(self._sub_folder_path, yaml.SECRET_YAML), "http_pw: override"
|
|
)
|
|
self._yaml = load_yaml(
|
|
os.path.join(self._sub_folder_path, "sub.yaml"),
|
|
(
|
|
"http:\n"
|
|
" api_password: !secret http_pw\n"
|
|
"component:\n"
|
|
" username: !secret comp1_un\n"
|
|
" password: !secret comp1_pw\n"
|
|
""
|
|
),
|
|
yaml_loader.Secrets(get_test_config_dir()),
|
|
)
|
|
|
|
assert expected == self._yaml["http"]
|
|
|
|
def test_secrets_from_unrelated_fails(self):
|
|
"""Test loading secrets from unrelated folder fails."""
|
|
load_yaml(os.path.join(self._unrelated_path, yaml.SECRET_YAML), "test: failure")
|
|
with pytest.raises(HomeAssistantError):
|
|
load_yaml(
|
|
os.path.join(self._sub_folder_path, "sub.yaml"),
|
|
"http:\n api_password: !secret test",
|
|
)
|
|
|
|
def test_secrets_logger_removed(self):
|
|
"""Ensure logger: debug was removed."""
|
|
with pytest.raises(HomeAssistantError):
|
|
load_yaml(self._yaml_path, "api_password: !secret logger")
|
|
|
|
@patch("homeassistant.util.yaml.loader._LOGGER.error")
|
|
def test_bad_logger_value(self, mock_error):
|
|
"""Ensure logger: debug was removed."""
|
|
load_yaml(self._secret_path, "logger: info\npw: abc")
|
|
load_yaml(
|
|
self._yaml_path,
|
|
"api_password: !secret pw",
|
|
yaml_loader.Secrets(get_test_config_dir()),
|
|
)
|
|
assert mock_error.call_count == 1, "Expected an error about logger: value"
|
|
|
|
def test_secrets_are_not_dict(self):
|
|
"""Did secrets handle non-dict file."""
|
|
FILES[
|
|
self._secret_path
|
|
] = "- http_pw: pwhttp\n comp1_un: un1\n comp1_pw: pw1\n"
|
|
with pytest.raises(HomeAssistantError):
|
|
load_yaml(
|
|
self._yaml_path,
|
|
(
|
|
"http:\n"
|
|
" api_password: !secret http_pw\n"
|
|
"component:\n"
|
|
" username: !secret comp1_un\n"
|
|
" password: !secret comp1_pw\n"
|
|
""
|
|
),
|
|
)
|
|
|
|
|
|
def test_representing_yaml_loaded_data(try_both_dumpers):
|
|
"""Test we can represent YAML loaded data."""
|
|
files = {YAML_CONFIG_FILE: 'key: [1, "2", 3]'}
|
|
with patch_yaml_files(files):
|
|
data = load_yaml_config_file(YAML_CONFIG_FILE)
|
|
assert yaml.dump(data) == "key:\n- 1\n- '2'\n- 3\n"
|
|
|
|
|
|
def test_duplicate_key(caplog, try_both_loaders):
|
|
"""Test duplicate dict keys."""
|
|
files = {YAML_CONFIG_FILE: "key: thing1\nkey: thing2"}
|
|
with patch_yaml_files(files):
|
|
load_yaml_config_file(YAML_CONFIG_FILE)
|
|
assert "contains duplicate key" in caplog.text
|
|
|
|
|
|
def test_no_recursive_secrets(caplog, try_both_loaders):
|
|
"""Test that loading of secrets from the secrets file fails correctly."""
|
|
files = {YAML_CONFIG_FILE: "key: !secret a", yaml.SECRET_YAML: "a: 1\nb: !secret a"}
|
|
with patch_yaml_files(files), pytest.raises(HomeAssistantError) as e:
|
|
load_yaml_config_file(YAML_CONFIG_FILE)
|
|
|
|
assert e.value.args == ("Secrets not supported in this YAML file",)
|
|
|
|
|
|
def test_input_class() -> None:
|
|
"""Test input class."""
|
|
input = yaml_loader.Input("hello")
|
|
input2 = yaml_loader.Input("hello")
|
|
|
|
assert input.name == "hello"
|
|
assert input == input2
|
|
|
|
assert len({input, input2}) == 1
|
|
|
|
|
|
def test_input(try_both_loaders, try_both_dumpers):
|
|
"""Test loading inputs."""
|
|
data = {"hello": yaml.Input("test_name")}
|
|
assert yaml.parse_yaml(yaml.dump(data)) == data
|
|
|
|
|
|
@pytest.mark.skipif(
|
|
not os.environ.get("HASS_CI"),
|
|
reason="This test validates that the CI has the C loader available",
|
|
)
|
|
def test_c_loader_is_available_in_ci() -> None:
|
|
"""Verify we are testing the C loader in the CI."""
|
|
assert yaml.loader.HAS_C_LOADER is True
|
|
|
|
|
|
async def test_loading_actual_file_with_syntax(hass, try_both_loaders):
|
|
"""Test loading a real file with syntax errors."""
|
|
with pytest.raises(HomeAssistantError):
|
|
fixture_path = pathlib.Path(__file__).parent.joinpath(
|
|
"fixtures", "bad.yaml.txt"
|
|
)
|
|
await hass.async_add_executor_job(load_yaml_config_file, fixture_path)
|