mirror of
https://github.com/basnijholt/adaptive-lighting.git
synced 2026-09-11 22:34:04 +02:00
472796215b* Implement collapsible sections for options flow Replace single-form options flow with collapsible sections: - Basic options always visible (9 fields) - Advanced options in collapsed section (collapsed by default) - Single form, no multi-step navigation needed Changes: - const.py: Add BASIC_OPTIONS set defining which options are basic - config_flow.py: Use section() from data_entry_flow to wrap advanced options - strings.json: Restructure with sections.advanced for section translations - tests: Update to handle nested section input format * Update README.md, strings.json, and services.yaml * Fix: Use vol.Required for section to render properly * Fix section structure: separate basic and advanced fields in strings.json * Remove accidentally added files * Add local directories to gitignore * Update README.md, strings.json, and services.yaml * Preserve options behavior with collapsible sections * Test serialized advanced options section * fix: preserve config metadata when retrying options * fix: keep options form defaults serializable --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
363 lines
12 KiB
Python
363 lines
12 KiB
Python
"""Test Adaptive Lighting config flow."""
|
|
|
|
import json
|
|
|
|
import pytest
|
|
import voluptuous as vol
|
|
|
|
try:
|
|
from probatio import to_field_list
|
|
except ImportError:
|
|
from voluptuous_serialize import convert as to_field_list
|
|
from homeassistant.components.adaptive_lighting.const import (
|
|
BASIC_OPTIONS,
|
|
CONF_INITIAL_TRANSITION,
|
|
CONF_SUNRISE_TIME,
|
|
CONF_SUNSET_TIME,
|
|
DEFAULT_NAME,
|
|
DOMAIN,
|
|
NONE_STR,
|
|
VALIDATION_TUPLES,
|
|
)
|
|
from homeassistant.config_entries import SOURCE_IMPORT
|
|
from homeassistant.const import CONF_NAME
|
|
from homeassistant.data_entry_flow import FlowResultType, section
|
|
from homeassistant.helpers import config_validation as cv
|
|
|
|
from tests.common import MockConfigEntry
|
|
|
|
DEFAULT_DATA = {key: default for key, default, _ in VALIDATION_TUPLES}
|
|
|
|
# Split DEFAULT_DATA into basic and advanced for section-based input
|
|
BASIC_DATA = {key: value for key, value in DEFAULT_DATA.items() if key in BASIC_OPTIONS}
|
|
ADVANCED_DATA = {
|
|
key: value for key, value in DEFAULT_DATA.items() if key not in BASIC_OPTIONS
|
|
}
|
|
|
|
|
|
def _schema_defaults(schema: vol.Schema) -> dict[str, object]:
|
|
"""Return the defaults from a voluptuous schema."""
|
|
return {
|
|
key.schema: key.default() if callable(key.default) else key.default
|
|
for key in schema.schema
|
|
}
|
|
|
|
|
|
def _advanced_section(result) -> section:
|
|
"""Return the advanced options section from a flow result."""
|
|
advanced = result["data_schema"].schema["advanced"]
|
|
assert isinstance(advanced, section)
|
|
return advanced
|
|
|
|
|
|
async def test_flow_manual_configuration(hass):
|
|
"""Test that config flow works."""
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "user"},
|
|
)
|
|
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "user"
|
|
assert result["handler"] == "adaptive_lighting"
|
|
|
|
result = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"],
|
|
user_input={CONF_NAME: "living room"},
|
|
)
|
|
assert result["type"] == FlowResultType.CREATE_ENTRY
|
|
assert result["title"] == "living room"
|
|
|
|
|
|
async def test_import_success(hass):
|
|
"""Test import step is successful."""
|
|
data = DEFAULT_DATA.copy()
|
|
data[CONF_NAME] = DEFAULT_NAME
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "import"},
|
|
data=data,
|
|
)
|
|
|
|
assert result["type"] == FlowResultType.CREATE_ENTRY
|
|
assert result["title"] == DEFAULT_NAME
|
|
for key, value in data.items():
|
|
assert result["data"][key] == value
|
|
|
|
|
|
async def test_options(hass):
|
|
"""Test updating options with collapsible sections."""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title=DEFAULT_NAME,
|
|
data={CONF_NAME: DEFAULT_NAME},
|
|
options={},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
await hass.config_entries.async_setup(entry.entry_id)
|
|
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "init"
|
|
|
|
# Build input with advanced options nested in "advanced" section
|
|
advanced_data = ADVANCED_DATA.copy()
|
|
advanced_data[CONF_INITIAL_TRANSITION] = 23
|
|
advanced_data[CONF_SUNRISE_TIME] = NONE_STR
|
|
advanced_data[CONF_SUNSET_TIME] = NONE_STR
|
|
basic_data = {**BASIC_DATA, "min_brightness": 12}
|
|
user_input = {
|
|
**basic_data,
|
|
"advanced": advanced_data,
|
|
}
|
|
result = await hass.config_entries.options.async_configure(
|
|
result["flow_id"],
|
|
user_input=user_input,
|
|
)
|
|
assert result["type"] == FlowResultType.CREATE_ENTRY
|
|
|
|
# Verify flattened data is saved correctly
|
|
expected_data = {**basic_data, **advanced_data}
|
|
for key, value in expected_data.items():
|
|
assert result["data"][key] == value
|
|
|
|
assert "advanced" not in result["data"]
|
|
|
|
# Starting the flow again must load the saved flat options into both parts
|
|
# of the sectioned form.
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
assert _schema_defaults(result["data_schema"])["min_brightness"] == 12
|
|
assert (
|
|
_schema_defaults(_advanced_section(result).schema)[CONF_INITIAL_TRANSITION]
|
|
== 23
|
|
)
|
|
|
|
|
|
async def test_options_schema_has_each_setting_once(hass):
|
|
"""Test that basic and advanced options partition all settings."""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title=DEFAULT_NAME,
|
|
data={CONF_NAME: DEFAULT_NAME, "interval": 120, "min_brightness": 7},
|
|
options={"min_brightness": 12},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
schema = result["data_schema"].schema
|
|
advanced = _advanced_section(result)
|
|
|
|
assert advanced.options == {"collapsed": True}
|
|
assert {key.schema for key in schema if key.schema != "advanced"} == BASIC_OPTIONS
|
|
assert {key.schema for key in advanced.schema.schema} == set(
|
|
DEFAULT_DATA,
|
|
) - BASIC_OPTIONS
|
|
assert _schema_defaults(result["data_schema"])["interval"] == 120
|
|
assert _schema_defaults(result["data_schema"])["min_brightness"] == 12
|
|
|
|
serialized_schema = to_field_list(
|
|
result["data_schema"],
|
|
custom_serializer=cv.custom_serializer,
|
|
)
|
|
json.dumps(serialized_schema)
|
|
serialized_advanced = next(
|
|
field for field in serialized_schema if field["name"] == "advanced"
|
|
)
|
|
assert serialized_advanced["type"] == "expandable"
|
|
assert serialized_advanced["expanded"] is False
|
|
assert {field["name"] for field in serialized_advanced["schema"]} == set(
|
|
DEFAULT_DATA,
|
|
) - BASIC_OPTIONS
|
|
|
|
|
|
@pytest.mark.parametrize("lights", [[], ["light.missing"]])
|
|
async def test_incorrect_options(hass, lights):
|
|
"""Test updating incorrect options in advanced section."""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title=DEFAULT_NAME,
|
|
data={CONF_NAME: DEFAULT_NAME},
|
|
options={},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
await hass.config_entries.async_setup(entry.entry_id)
|
|
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
|
|
# Build input with invalid advanced options nested in section
|
|
advanced_data = ADVANCED_DATA.copy()
|
|
advanced_data[CONF_SUNRISE_TIME] = "yolo"
|
|
advanced_data[CONF_SUNSET_TIME] = "yolo"
|
|
basic_data = {**BASIC_DATA, "min_brightness": 12, "lights": lights}
|
|
user_input = {
|
|
**basic_data,
|
|
"advanced": advanced_data,
|
|
}
|
|
result = await hass.config_entries.options.async_configure(
|
|
result["flow_id"],
|
|
user_input=user_input,
|
|
)
|
|
# Should show form with errors
|
|
assert result["type"] == FlowResultType.FORM
|
|
expected_errors = {"base": "option_error"}
|
|
if lights:
|
|
expected_errors["lights"] = "entity_missing"
|
|
assert result["errors"] == expected_errors
|
|
assert _schema_defaults(result["data_schema"])["lights"] == lights
|
|
assert _schema_defaults(result["data_schema"])["min_brightness"] == 12
|
|
assert (
|
|
_schema_defaults(_advanced_section(result).schema)[CONF_SUNRISE_TIME] == "yolo"
|
|
)
|
|
|
|
|
|
async def test_import_twice(hass):
|
|
"""Test importing twice."""
|
|
data = DEFAULT_DATA.copy()
|
|
data[CONF_NAME] = DEFAULT_NAME
|
|
for _ in range(2):
|
|
_ = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "import"},
|
|
data=data,
|
|
)
|
|
|
|
|
|
async def test_options_flow_for_yaml_import(hass):
|
|
"""Test that options flow for YAML-imported entries shows empty form.
|
|
|
|
When a config entry is imported from YAML (source=SOURCE_IMPORT),
|
|
the options flow should show an empty form since the user should
|
|
modify the YAML configuration directly, not through the UI.
|
|
"""
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title=DEFAULT_NAME,
|
|
data={CONF_NAME: DEFAULT_NAME},
|
|
source=SOURCE_IMPORT,
|
|
options={},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
# For YAML imports, the switch setup requires the unique_id to be in
|
|
# hass.data[DOMAIN]["__yaml__"], otherwise it deletes the entry.
|
|
# This simulates what async_step_import does.
|
|
hass.data.setdefault(DOMAIN, {}).setdefault("__yaml__", set()).add(entry.unique_id)
|
|
|
|
await hass.config_entries.async_setup(entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
result = await hass.config_entries.options.async_init(entry.entry_id)
|
|
|
|
# For YAML imports, the options flow shows an empty form (data_schema=None)
|
|
# This is intentional - users should modify YAML, not UI
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "init"
|
|
assert result.get("data_schema") is None
|
|
assert result["description_placeholders"] == {
|
|
"docs_url": "https://github.com/basnijholt/adaptive-lighting#readme",
|
|
"webapp_url": "https://basnijholt.github.io/adaptive-lighting",
|
|
}
|
|
|
|
|
|
async def test_menu_shown_when_entries_exist(hass):
|
|
"""Test that menu step is shown when existing entries exist."""
|
|
# Create an existing entry
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title="existing",
|
|
data={CONF_NAME: "existing"},
|
|
options={"min_brightness": 10},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
# Start a new config flow - should show menu
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "user"},
|
|
)
|
|
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "menu"
|
|
|
|
|
|
async def test_menu_create_new_instance(hass):
|
|
"""Test creating a new instance through the menu."""
|
|
# Create an existing entry
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title="existing",
|
|
data={CONF_NAME: "existing"},
|
|
options={"min_brightness": 10},
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
# Start config flow - shows menu
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "user"},
|
|
)
|
|
assert result["step_id"] == "menu"
|
|
|
|
# Choose to create new instance
|
|
result = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"],
|
|
user_input={"action": "new"},
|
|
)
|
|
|
|
# Should show name form
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "user"
|
|
|
|
# Enter name
|
|
result = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"],
|
|
user_input={CONF_NAME: "new instance"},
|
|
)
|
|
|
|
assert result["type"] == FlowResultType.CREATE_ENTRY
|
|
assert result["title"] == "new instance"
|
|
# New instance should have no options (not duplicated)
|
|
assert result["options"] == {}
|
|
|
|
|
|
async def test_menu_duplicate_instance(hass):
|
|
"""Test duplicating an existing instance through the menu."""
|
|
# Create an existing entry with custom options
|
|
source_options = {"min_brightness": 20, "max_brightness": 80}
|
|
entry = MockConfigEntry(
|
|
domain=DOMAIN,
|
|
title="source",
|
|
data={CONF_NAME: "source"},
|
|
options=source_options,
|
|
)
|
|
entry.add_to_hass(hass)
|
|
|
|
# Start config flow - shows menu
|
|
result = await hass.config_entries.flow.async_init(
|
|
DOMAIN,
|
|
context={"source": "user"},
|
|
)
|
|
assert result["step_id"] == "menu"
|
|
|
|
# Choose to duplicate existing entry
|
|
result = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"],
|
|
user_input={"action": entry.entry_id},
|
|
)
|
|
|
|
# Should show name form
|
|
assert result["type"] == FlowResultType.FORM
|
|
assert result["step_id"] == "user"
|
|
|
|
# Enter name for duplicated instance
|
|
result = await hass.config_entries.flow.async_configure(
|
|
result["flow_id"],
|
|
user_input={CONF_NAME: "duplicated"},
|
|
)
|
|
|
|
assert result["type"] == FlowResultType.CREATE_ENTRY
|
|
assert result["title"] == "duplicated"
|
|
# Duplicated instance should have copied options
|
|
assert result["options"] == source_options
|