mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-10-26 19:01:39 -04:00
298 lines
10 KiB
Python
298 lines
10 KiB
Python
"""
|
|
Unit tests for controller.lib.config module.
|
|
"""
|
|
import copy
|
|
|
|
import pytest
|
|
import yaml
|
|
|
|
from controller.lib.config import (
|
|
get_config,
|
|
get_config_value,
|
|
is_docker_mode,
|
|
is_primary_drive_mounted,
|
|
reload_config_from_drive,
|
|
save_config,
|
|
update_config,
|
|
_deep_merge,
|
|
_get_config_diff,
|
|
)
|
|
|
|
|
|
class TestGetConfig:
|
|
"""Tests for get_config function."""
|
|
|
|
def test_get_config_returns_dict(self, reset_runtime_config):
|
|
"""get_config should return a dictionary."""
|
|
config = get_config()
|
|
assert isinstance(config, dict)
|
|
|
|
def test_get_config_has_default_keys(self, reset_runtime_config):
|
|
"""get_config should have all default keys."""
|
|
config = get_config()
|
|
assert "port" in config
|
|
assert "media_directory" in config
|
|
assert "drives" in config
|
|
assert "managed_services" in config
|
|
assert "hotspot" in config
|
|
assert "throttle" in config
|
|
|
|
def test_get_config_default_port(self, reset_runtime_config):
|
|
"""Default port should be 8087."""
|
|
config = get_config()
|
|
assert config["port"] == 8087
|
|
|
|
|
|
class TestGetConfigValue:
|
|
"""Tests for get_config_value function."""
|
|
|
|
@pytest.mark.parametrize("key,expected", [
|
|
("port", 8087),
|
|
("media_directory", "/media/wrolpi"),
|
|
("drives.auto_mount", True),
|
|
("hotspot.ssid", "WROLPi"),
|
|
("throttle.default_governor", "ondemand"),
|
|
])
|
|
def test_get_value(self, reset_runtime_config, key, expected):
|
|
"""Should get values using dot notation for nested keys."""
|
|
assert get_config_value(key) == expected
|
|
|
|
@pytest.mark.parametrize("key,default,expected", [
|
|
("nonexistent", None, None),
|
|
("nonexistent", "fallback", "fallback"),
|
|
("drives.nonexistent", 42, 42),
|
|
("a.b.c.d.e", "default", "default"),
|
|
])
|
|
def test_get_missing_value_returns_default(self, reset_runtime_config, key, default, expected):
|
|
"""Should return default for missing keys."""
|
|
assert get_config_value(key, default) == expected
|
|
|
|
|
|
class TestIsDockerMode:
|
|
"""Tests for is_docker_mode function."""
|
|
|
|
def test_docker_mode_false_when_not_set(self, mock_docker_mode):
|
|
"""Docker mode should be False when env var not set."""
|
|
assert is_docker_mode() is False
|
|
|
|
def test_docker_mode_true_when_set(self, mock_docker_mode_enabled):
|
|
"""Docker mode should be True when DOCKERIZED=true."""
|
|
assert is_docker_mode() is True
|
|
|
|
|
|
class TestIsPrimaryDriveMounted:
|
|
"""Tests for is_primary_drive_mounted function."""
|
|
|
|
def test_drive_mounted_when_config_dir_exists(self, test_config_directory):
|
|
"""Should return True when /media/wrolpi/config exists."""
|
|
# We need to mock the path check to use our test directory
|
|
from unittest import mock
|
|
|
|
with mock.patch(
|
|
"controller.lib.config.Path"
|
|
) as mock_path:
|
|
mock_path.return_value.exists.return_value = True
|
|
# Re-import to get fresh function
|
|
# Actually test with real path
|
|
|
|
# The real test - check that the function works correctly
|
|
assert test_config_directory.exists()
|
|
|
|
def test_drive_not_mounted_when_config_dir_missing(self, test_directory):
|
|
"""Should return False when config dir doesn't exist."""
|
|
from unittest import mock
|
|
|
|
with mock.patch(
|
|
"controller.lib.config.Path"
|
|
) as mock_path:
|
|
mock_instance = mock.MagicMock()
|
|
mock_instance.exists.return_value = False
|
|
mock_path.return_value = mock_instance
|
|
assert is_primary_drive_mounted() is False
|
|
|
|
|
|
class TestReloadConfigFromDrive:
|
|
"""Tests for reload_config_from_drive function."""
|
|
|
|
def test_reload_returns_false_when_no_config_file(
|
|
self, reset_runtime_config, mock_config_path
|
|
):
|
|
"""Should return False when controller.yaml doesn't exist."""
|
|
result = reload_config_from_drive()
|
|
assert result is False
|
|
|
|
def test_reload_returns_true_when_config_exists(
|
|
self, reset_runtime_config, mock_config_path
|
|
):
|
|
"""Should return True and load config when file exists."""
|
|
# Write a test config
|
|
mock_config_path.write_text(yaml.dump({"port": 9999}))
|
|
|
|
result = reload_config_from_drive()
|
|
assert result is True
|
|
assert get_config_value("port") == 9999
|
|
|
|
def test_reload_merges_with_defaults(
|
|
self, reset_runtime_config, mock_config_path
|
|
):
|
|
"""Config from file should be merged with defaults."""
|
|
# Write partial config - only override port
|
|
mock_config_path.write_text(yaml.dump({"port": 8888}))
|
|
|
|
reload_config_from_drive()
|
|
|
|
# Port should be overridden
|
|
assert get_config_value("port") == 8888
|
|
# Other defaults should still exist
|
|
assert get_config_value("media_directory") == "/media/wrolpi"
|
|
assert get_config_value("drives.auto_mount") is True
|
|
|
|
def test_reload_handles_invalid_yaml(
|
|
self, reset_runtime_config, mock_config_path
|
|
):
|
|
"""Should return False and keep defaults for invalid YAML."""
|
|
mock_config_path.write_text("invalid: yaml: content: [}")
|
|
|
|
result = reload_config_from_drive()
|
|
assert result is False
|
|
# Should still have defaults
|
|
assert get_config_value("port") == 8087
|
|
|
|
def test_reload_handles_empty_file(
|
|
self, reset_runtime_config, mock_config_path
|
|
):
|
|
"""Should handle empty config file gracefully."""
|
|
mock_config_path.write_text("")
|
|
|
|
result = reload_config_from_drive()
|
|
# Empty file is valid YAML (returns None), merged with defaults
|
|
# File exists and was processed, so returns True
|
|
assert result is True
|
|
# Config should still have all defaults
|
|
assert get_config_value("port") == 8087
|
|
|
|
|
|
class TestSaveConfig:
|
|
"""Tests for save_config function."""
|
|
|
|
def test_save_config_raises_when_drive_not_mounted(
|
|
self, reset_runtime_config, mock_drive_not_mounted
|
|
):
|
|
"""Should raise RuntimeError when drive not mounted."""
|
|
with pytest.raises(RuntimeError, match="primary drive not mounted"):
|
|
save_config()
|
|
|
|
def test_save_config_creates_file(
|
|
self, reset_runtime_config, mock_config_path, mock_drive_mounted
|
|
):
|
|
"""Should create config file when saving."""
|
|
update_config("port", 9999)
|
|
save_config()
|
|
|
|
assert mock_config_path.exists()
|
|
saved = yaml.safe_load(mock_config_path.read_text())
|
|
assert saved["port"] == 9999
|
|
|
|
def test_save_config_only_saves_diff(
|
|
self, reset_runtime_config, mock_config_path, mock_drive_mounted
|
|
):
|
|
"""Should only save values that differ from defaults."""
|
|
# Only change port
|
|
update_config("port", 9999)
|
|
save_config()
|
|
|
|
saved = yaml.safe_load(mock_config_path.read_text())
|
|
# Only port should be in the file
|
|
assert saved == {"port": 9999}
|
|
|
|
def test_save_config_removes_file_when_matches_defaults(
|
|
self, reset_runtime_config, mock_config_path, mock_drive_mounted
|
|
):
|
|
"""Should remove config file when config matches defaults."""
|
|
# First create a config file with non-default value
|
|
update_config("port", 9999)
|
|
save_config()
|
|
assert mock_config_path.exists()
|
|
|
|
# Reset to default value
|
|
update_config("port", 8087) # Default port
|
|
save_config()
|
|
|
|
# File should be removed since config matches defaults
|
|
assert not mock_config_path.exists()
|
|
|
|
def test_save_config_removes_stale_file(
|
|
self, reset_runtime_config, mock_config_path, mock_drive_mounted
|
|
):
|
|
"""Should remove existing config file when config is reset to defaults."""
|
|
# Simulate an existing stale config file
|
|
mock_config_path.write_text("drives:\n mounts:\n - device: UUID=1234\n")
|
|
assert mock_config_path.exists()
|
|
|
|
# Runtime config matches defaults (no changes made)
|
|
save_config()
|
|
|
|
# File should be removed
|
|
assert not mock_config_path.exists()
|
|
|
|
|
|
class TestUpdateConfig:
|
|
"""Tests for update_config function."""
|
|
|
|
def test_update_simple_value(self, reset_runtime_config):
|
|
"""Should update simple top-level values."""
|
|
update_config("port", 9999)
|
|
assert get_config_value("port") == 9999
|
|
|
|
def test_update_nested_value(self, reset_runtime_config):
|
|
"""Should update nested values using dot notation."""
|
|
update_config("hotspot.ssid", "MyNetwork")
|
|
assert get_config_value("hotspot.ssid") == "MyNetwork"
|
|
|
|
def test_update_creates_nested_structure(self, reset_runtime_config):
|
|
"""Should create nested structure if it doesn't exist."""
|
|
update_config("new.nested.key", "value")
|
|
assert get_config_value("new.nested.key") == "value"
|
|
|
|
|
|
class TestDeepMerge:
|
|
"""Tests for _deep_merge helper function."""
|
|
|
|
@pytest.mark.parametrize("base,override,expected", [
|
|
# Flat dict merge
|
|
({"a": 1, "b": 2}, {"b": 3, "c": 4}, {"a": 1, "b": 3, "c": 4}),
|
|
# Nested dict merge
|
|
({"a": {"x": 1, "y": 2}}, {"a": {"y": 3, "z": 4}}, {"a": {"x": 1, "y": 3, "z": 4}}),
|
|
# Override replaces non-dict
|
|
({"a": {"x": 1}}, {"a": "string"}, {"a": "string"}),
|
|
])
|
|
def test_merge_dicts(self, base, override, expected):
|
|
"""Should merge dictionaries correctly."""
|
|
result = _deep_merge(base, override)
|
|
assert result == expected
|
|
|
|
def test_merge_does_not_modify_original(self):
|
|
"""Should not modify original dictionaries."""
|
|
base = {"a": 1}
|
|
override = {"b": 2}
|
|
original_base = copy.deepcopy(base)
|
|
_deep_merge(base, override)
|
|
assert base == original_base
|
|
|
|
|
|
class TestGetConfigDiff:
|
|
"""Tests for _get_config_diff helper function."""
|
|
|
|
@pytest.mark.parametrize("config,default,expected", [
|
|
# Equal configs return empty
|
|
({"a": 1, "b": 2}, {"a": 1, "b": 2}, {}),
|
|
# Changed values only
|
|
({"a": 1, "b": 3}, {"a": 1, "b": 2}, {"b": 3}),
|
|
# New keys
|
|
({"a": 1, "b": 2, "c": 3}, {"a": 1, "b": 2}, {"c": 3}),
|
|
# Nested changes
|
|
({"a": {"x": 1, "y": 3}}, {"a": {"x": 1, "y": 2}}, {"a": {"y": 3}}),
|
|
])
|
|
def test_get_config_diff(self, config, default, expected):
|
|
"""Should return only values that differ from defaults."""
|
|
assert _get_config_diff(config, default) == expected
|