Add coverage for dashboard ahead of Path conversion (#10669)

tests/dashboard/test_entries.py

@@ -0,0 +1,203 @@
+"""Tests for dashboard entries Path-related functionality."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+from unittest.mock import MagicMock
+
+import pytest
+import pytest_asyncio
+
+from esphome.core import CORE
+from esphome.dashboard.entries import DashboardEntries, DashboardEntry
+
+
+def create_cache_key() -> tuple[int, int, float, int]:
+    """Helper to create a valid DashboardCacheKeyType."""
+    return (0, 0, 0.0, 0)
+
+
+@pytest.fixture(autouse=True)
+def setup_core():
+    """Set up CORE for testing."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        CORE.config_path = str(Path(tmpdir) / "test.yaml")
+        yield
+        CORE.reset()
+
+
+@pytest.fixture
+def mock_settings() -> MagicMock:
+    """Create mock dashboard settings."""
+    settings = MagicMock()
+    settings.config_dir = "/test/config"
+    settings.absolute_config_dir = Path("/test/config")
+    return settings
+
+
+@pytest_asyncio.fixture
+async def dashboard_entries(mock_settings: MagicMock) -> DashboardEntries:
+    """Create a DashboardEntries instance for testing."""
+    return DashboardEntries(mock_settings)
+
+
+def test_dashboard_entry_path_initialization() -> None:
+    """Test DashboardEntry initializes with path correctly."""
+    test_path = "/test/config/device.yaml"
+    cache_key = create_cache_key()
+
+    entry = DashboardEntry(test_path, cache_key)
+
+    assert entry.path == test_path
+    assert entry.cache_key == cache_key
+
+
+def test_dashboard_entry_path_with_absolute_path() -> None:
+    """Test DashboardEntry handles absolute paths."""
+    # Use a truly absolute path for the platform
+    test_path = Path.cwd() / "absolute" / "path" / "to" / "config.yaml"
+    cache_key = create_cache_key()
+
+    entry = DashboardEntry(str(test_path), cache_key)
+
+    assert entry.path == str(test_path)
+    assert Path(entry.path).is_absolute()
+
+
+def test_dashboard_entry_path_with_relative_path() -> None:
+    """Test DashboardEntry handles relative paths."""
+    test_path = "configs/device.yaml"
+    cache_key = create_cache_key()
+
+    entry = DashboardEntry(test_path, cache_key)
+
+    assert entry.path == test_path
+    assert not Path(entry.path).is_absolute()
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_get_by_path(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test getting entry by path."""
+    test_path = "/test/config/device.yaml"
+    entry = DashboardEntry(test_path, create_cache_key())
+
+    dashboard_entries._entries[test_path] = entry
+
+    result = dashboard_entries.get(test_path)
+    assert result == entry
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_get_nonexistent_path(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test getting non-existent entry returns None."""
+    result = dashboard_entries.get("/nonexistent/path.yaml")
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_path_normalization(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test that paths are handled consistently."""
+    path1 = "/test/config/device.yaml"
+
+    entry = DashboardEntry(path1, create_cache_key())
+    dashboard_entries._entries[path1] = entry
+
+    result = dashboard_entries.get(path1)
+    assert result == entry
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_path_with_spaces(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test handling paths with spaces."""
+    test_path = "/test/config/my device.yaml"
+    entry = DashboardEntry(test_path, create_cache_key())
+
+    dashboard_entries._entries[test_path] = entry
+
+    result = dashboard_entries.get(test_path)
+    assert result == entry
+    assert result.path == test_path
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_path_with_special_chars(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test handling paths with special characters."""
+    test_path = "/test/config/device-01_test.yaml"
+    entry = DashboardEntry(test_path, create_cache_key())
+
+    dashboard_entries._entries[test_path] = entry
+
+    result = dashboard_entries.get(test_path)
+    assert result == entry
+
+
+def test_dashboard_entries_windows_path() -> None:
+    """Test handling Windows-style paths."""
+    test_path = r"C:\Users\test\esphome\device.yaml"
+    cache_key = create_cache_key()
+
+    entry = DashboardEntry(test_path, cache_key)
+
+    assert entry.path == test_path
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_path_to_cache_key_mapping(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test internal entries storage with paths and cache keys."""
+    path1 = "/test/config/device1.yaml"
+    path2 = "/test/config/device2.yaml"
+
+    entry1 = DashboardEntry(path1, create_cache_key())
+    entry2 = DashboardEntry(path2, (1, 1, 1.0, 1))
+
+    dashboard_entries._entries[path1] = entry1
+    dashboard_entries._entries[path2] = entry2
+
+    assert path1 in dashboard_entries._entries
+    assert path2 in dashboard_entries._entries
+    assert dashboard_entries._entries[path1].cache_key == create_cache_key()
+    assert dashboard_entries._entries[path2].cache_key == (1, 1, 1.0, 1)
+
+
+def test_dashboard_entry_path_property() -> None:
+    """Test that path property returns expected value."""
+    test_path = "/test/config/device.yaml"
+    entry = DashboardEntry(test_path, create_cache_key())
+
+    assert entry.path == test_path
+    assert isinstance(entry.path, str)
+
+
+@pytest.mark.asyncio
+async def test_dashboard_entries_all_returns_entries_with_paths(
+    dashboard_entries: DashboardEntries,
+) -> None:
+    """Test that all() returns entries with their paths intact."""
+    paths = [
+        "/test/config/device1.yaml",
+        "/test/config/device2.yaml",
+        "/test/config/subfolder/device3.yaml",
+    ]
+
+    for path in paths:
+        entry = DashboardEntry(path, create_cache_key())
+        dashboard_entries._entries[path] = entry
+
+    all_entries = dashboard_entries.async_all()
+
+    assert len(all_entries) == len(paths)
+    retrieved_paths = [entry.path for entry in all_entries]
+    assert set(retrieved_paths) == set(paths)