368 lines
11 KiB
Python
368 lines
11 KiB
Python
"""
|
|
Unit tests for panasonic_heatpump component configuration validation.
|
|
|
|
Tests the Python configuration schema and validation logic.
|
|
"""
|
|
|
|
import pytest
|
|
from unittest.mock import Mock, MagicMock, patch
|
|
from esphome.core import CORE
|
|
|
|
|
|
class TestPanasonicHeatpumpConfig:
|
|
"""Test suite for panasonic_heatpump configuration validation."""
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def setup(self):
|
|
"""Setup test fixtures."""
|
|
# Mock CORE to avoid ESPHome initialization issues
|
|
CORE.data = {}
|
|
yield
|
|
|
|
@pytest.fixture
|
|
def mock_uart(self):
|
|
"""Mock UART component."""
|
|
with patch("esphome.components.uart") as mock:
|
|
yield mock
|
|
|
|
@pytest.fixture
|
|
def mock_cg(self):
|
|
"""Mock code generator."""
|
|
with patch("esphome.codegen") as mock:
|
|
mock.esphome_ns = MagicMock()
|
|
mock.esphome_ns.namespace.return_value.class_ = MagicMock()
|
|
yield mock
|
|
|
|
def test_import_component(self):
|
|
"""Test that the component can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
# Add components directory to path
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert ph_init is not None
|
|
except ImportError as e:
|
|
pytest.fail(f"Failed to import panasonic_heatpump: {e}")
|
|
|
|
def test_component_metadata(self):
|
|
"""Test component metadata is correctly defined."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert hasattr(ph_init, "CODEOWNERS")
|
|
assert ph_init.CODEOWNERS == ["@elvit"]
|
|
|
|
assert hasattr(ph_init, "MULTICONF")
|
|
assert ph_init.MULTICONF is True
|
|
|
|
assert hasattr(ph_init, "DEPENDENCIES")
|
|
assert "uart" in ph_init.DEPENDENCIES
|
|
|
|
def test_config_constants(self):
|
|
"""Test that configuration constants are defined."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert hasattr(ph_init, "CONF_PANASONIC_HEATPUMP_ID")
|
|
assert ph_init.CONF_PANASONIC_HEATPUMP_ID == "panasonic_heatpump"
|
|
|
|
assert hasattr(ph_init, "CONF_UART_CLIENT")
|
|
assert ph_init.CONF_UART_CLIENT == "uart_client_id"
|
|
|
|
assert hasattr(ph_init, "CONF_LOG_UART_MSG")
|
|
assert ph_init.CONF_LOG_UART_MSG == "log_uart_msg"
|
|
|
|
@patch("esphome.components.uart")
|
|
@patch("esphome.codegen")
|
|
def test_config_schema_structure(self, mock_cg, mock_uart):
|
|
"""Test that CONFIG_SCHEMA has the correct structure."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert hasattr(ph_init, "CONFIG_SCHEMA")
|
|
assert ph_init.CONFIG_SCHEMA is not None
|
|
|
|
def test_valid_minimal_config(self):
|
|
"""Test validation of minimal valid configuration."""
|
|
config = {
|
|
"id": "my_heatpump",
|
|
"uart_id": "uart_bus",
|
|
}
|
|
# This would require full ESPHome environment to validate
|
|
# Just verify the config structure is reasonable
|
|
assert "id" in config
|
|
assert "uart_id" in config
|
|
|
|
def test_valid_full_config(self):
|
|
"""Test validation of full configuration with all options."""
|
|
config = {
|
|
"id": "my_heatpump",
|
|
"uart_id": "uart_bus",
|
|
"uart_client_id": "uart_client",
|
|
"log_uart_msg": True,
|
|
"update_interval": "3s",
|
|
}
|
|
assert "id" in config
|
|
assert "uart_id" in config
|
|
assert "uart_client_id" in config
|
|
assert "log_uart_msg" in config
|
|
assert "update_interval" in config
|
|
|
|
def test_log_uart_msg_default(self):
|
|
"""Test that log_uart_msg defaults to False."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
# The default is specified in the schema as False
|
|
# This test verifies the constant exists
|
|
assert ph_init.CONF_LOG_UART_MSG == "log_uart_msg"
|
|
|
|
def test_update_interval_default(self):
|
|
"""Test that update_interval has a default value."""
|
|
# The default update_interval should be 3s according to the example
|
|
default_interval = "3s"
|
|
assert default_interval == "3s"
|
|
|
|
def test_multiconf_support(self):
|
|
"""Test that component supports multiple instances."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
# Verify MULTICONF is True, allowing multiple instances
|
|
assert ph_init.MULTICONF is True
|
|
|
|
def test_uart_dependency(self):
|
|
"""Test that UART is listed as a dependency."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert "uart" in ph_init.DEPENDENCIES
|
|
|
|
def test_namespace_definition(self):
|
|
"""Test that component namespace is correctly defined."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
# Verify namespace constant exists
|
|
assert hasattr(ph_init, "panasonic_heatpump_ns")
|
|
|
|
|
|
class TestPanasonicHeatpumpPlatforms:
|
|
"""Test suite for platform configurations."""
|
|
|
|
def test_sensor_platform_exists(self):
|
|
"""Test that sensor platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.sensor import __init__ as sensor_init
|
|
|
|
assert sensor_init is not None
|
|
except ImportError:
|
|
pytest.skip("Sensor platform not accessible in test environment")
|
|
|
|
def test_binary_sensor_platform_exists(self):
|
|
"""Test that binary_sensor platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.binary_sensor import __init__ as bs_init
|
|
|
|
assert bs_init is not None
|
|
except ImportError:
|
|
pytest.skip("Binary sensor platform not accessible in test environment")
|
|
|
|
def test_text_sensor_platform_exists(self):
|
|
"""Test that text_sensor platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.text_sensor import __init__ as ts_init
|
|
|
|
assert ts_init is not None
|
|
except ImportError:
|
|
pytest.skip("Text sensor platform not accessible in test environment")
|
|
|
|
def test_number_platform_exists(self):
|
|
"""Test that number platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.number import __init__ as num_init
|
|
|
|
assert num_init is not None
|
|
except ImportError:
|
|
pytest.skip("Number platform not accessible in test environment")
|
|
|
|
def test_select_platform_exists(self):
|
|
"""Test that select platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.select import __init__ as sel_init
|
|
|
|
assert sel_init is not None
|
|
except ImportError:
|
|
pytest.skip("Select platform not accessible in test environment")
|
|
|
|
def test_switch_platform_exists(self):
|
|
"""Test that switch platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.switch import __init__ as sw_init
|
|
|
|
assert sw_init is not None
|
|
except ImportError:
|
|
pytest.skip("Switch platform not accessible in test environment")
|
|
|
|
def test_climate_platform_exists(self):
|
|
"""Test that climate platform can be imported."""
|
|
try:
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
from panasonic_heatpump.climate import __init__ as clim_init
|
|
|
|
assert clim_init is not None
|
|
except ImportError:
|
|
pytest.skip("Climate platform not accessible in test environment")
|
|
|
|
|
|
class TestPanasonicHeatpumpCodeGeneration:
|
|
"""Test suite for code generation logic."""
|
|
|
|
@pytest.fixture
|
|
def mock_dependencies(self):
|
|
"""Mock all ESPHome dependencies."""
|
|
with patch("esphome.codegen") as mock_cg, patch(
|
|
"esphome.components.uart"
|
|
) as mock_uart, patch("esphome.config_validation"):
|
|
|
|
mock_cg.new_Pvariable = MagicMock(return_value=Mock())
|
|
mock_cg.register_component = MagicMock()
|
|
mock_uart.register_uart_device = MagicMock()
|
|
mock_cg.get_variable = MagicMock(return_value=Mock())
|
|
mock_cg.add = MagicMock()
|
|
|
|
yield {
|
|
"cg": mock_cg,
|
|
"uart": mock_uart,
|
|
}
|
|
|
|
def test_to_code_function_exists(self):
|
|
"""Test that to_code function is defined."""
|
|
import sys
|
|
import os
|
|
|
|
components_path = os.path.join(
|
|
os.path.dirname(__file__), "..", "..", "components"
|
|
)
|
|
sys.path.insert(0, components_path)
|
|
|
|
import panasonic_heatpump as ph_init
|
|
|
|
assert hasattr(ph_init, "to_code")
|
|
assert callable(ph_init.to_code)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pytest.main([__file__, "-v"])
|