mirror of
https://github.com/home-assistant/supervisor.git
synced 2025-06-17 15:36:29 +00:00
2148de45a0
* Allow client to change boot slot via API * Wrap call to rauc in job that checks for OS * Reboot after changing the active boot slot * Add test cases and clean up * BootName to BootSlot * Fix test * Rename boot_name to boot_slot * Fix tests after field change
340 lines
12 KiB
Python
340 lines
12 KiB
Python
"""Test OS API."""
|
|
|
|
from unittest.mock import Mock, PropertyMock, patch
|
|
|
|
from aiohttp.test_utils import TestClient
|
|
from dbus_fast import DBusError, ErrorType
|
|
import pytest
|
|
|
|
from supervisor.coresys import CoreSys
|
|
from supervisor.dbus.agent.boards.interface import BoardProxy
|
|
from supervisor.host.control import SystemControl
|
|
from supervisor.os.manager import OSManager
|
|
from supervisor.resolution.const import ContextType, IssueType, SuggestionType
|
|
from supervisor.resolution.data import Issue, Suggestion
|
|
|
|
from tests.common import mock_dbus_services
|
|
from tests.dbus_service_mocks.agent_boards import Boards as BoardsService
|
|
from tests.dbus_service_mocks.agent_boards_green import Green as GreenService
|
|
from tests.dbus_service_mocks.agent_boards_yellow import Yellow as YellowService
|
|
from tests.dbus_service_mocks.agent_datadisk import DataDisk as DataDiskService
|
|
from tests.dbus_service_mocks.agent_system import System as SystemService
|
|
from tests.dbus_service_mocks.base import DBusServiceMock
|
|
from tests.dbus_service_mocks.rauc import Rauc as RaucService
|
|
|
|
|
|
@pytest.fixture(name="boards_service")
|
|
async def fixture_boards_service(
|
|
os_agent_services: dict[str, DBusServiceMock],
|
|
) -> BoardsService:
|
|
"""Return mock Boards service."""
|
|
yield os_agent_services["agent_boards"]
|
|
|
|
|
|
async def test_api_os_info(api_client: TestClient):
|
|
"""Test os info api."""
|
|
resp = await api_client.get("/os/info")
|
|
result = await resp.json()
|
|
|
|
for attr in (
|
|
"version",
|
|
"version_latest",
|
|
"update_available",
|
|
"board",
|
|
"boot",
|
|
"data_disk",
|
|
"boot_slots",
|
|
):
|
|
assert attr in result["data"]
|
|
|
|
|
|
async def test_api_os_info_with_agent(api_client: TestClient, coresys: CoreSys):
|
|
"""Test os info api for data disk."""
|
|
resp = await api_client.get("/os/info")
|
|
result = await resp.json()
|
|
|
|
assert result["data"]["data_disk"] == "BJTD4R-0x97cde291"
|
|
|
|
|
|
async def test_api_os_info_boot_slots(
|
|
api_client: TestClient, coresys: CoreSys, os_available
|
|
):
|
|
"""Test os info api for boot slots."""
|
|
await coresys.os.load()
|
|
resp = await api_client.get("/os/info")
|
|
result = await resp.json()
|
|
|
|
assert result["data"]["boot_slots"] == {
|
|
"A": {
|
|
"state": "inactive",
|
|
"status": "good",
|
|
"version": "9.0.dev20220818",
|
|
},
|
|
"B": {"state": "booted", "status": "good", "version": "9.0.dev20220824"},
|
|
}
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"new_disk",
|
|
["/dev/sdaaaa", "/dev/mmcblk1", "Generic-Flash-Disk-61BCDDB6"],
|
|
ids=["non-existent", "unavailable drive by path", "unavailable drive by id"],
|
|
)
|
|
async def test_api_os_datadisk_move_fail(
|
|
api_client: TestClient,
|
|
coresys: CoreSys,
|
|
new_disk: str,
|
|
os_available,
|
|
):
|
|
"""Test datadisk move to non-existent or invalid devices."""
|
|
resp = await api_client.post("/os/datadisk/move", json={"device": new_disk})
|
|
result = await resp.json()
|
|
|
|
assert result["message"] == f"'{new_disk}' not a valid data disk target!"
|
|
|
|
|
|
async def test_api_os_datadisk_list(api_client: TestClient, coresys: CoreSys):
|
|
"""Test datadisk list function."""
|
|
resp = await api_client.get("/os/datadisk/list")
|
|
result = await resp.json()
|
|
|
|
assert result["data"]["devices"] == ["SSK-SSK-Storage-DF56419883D56"]
|
|
assert result["data"]["disks"] == [
|
|
{
|
|
"vendor": "SSK",
|
|
"model": "SSK Storage",
|
|
"serial": "DF56419883D56",
|
|
"id": "SSK-SSK-Storage-DF56419883D56",
|
|
"size": 250059350016,
|
|
"dev_path": "/dev/sda",
|
|
"name": "SSK SSK Storage (DF56419883D56)",
|
|
}
|
|
]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"new_disk",
|
|
["SSK-SSK-Storage-DF56419883D56", "/dev/sda"],
|
|
ids=["by drive id", "by device path"],
|
|
)
|
|
async def test_api_os_datadisk_migrate(
|
|
api_client: TestClient,
|
|
coresys: CoreSys,
|
|
os_agent_services: dict[str, DBusServiceMock],
|
|
new_disk: str,
|
|
os_available,
|
|
):
|
|
"""Test migrating datadisk."""
|
|
datadisk_service: DataDiskService = os_agent_services["agent_datadisk"]
|
|
datadisk_service.ChangeDevice.calls.clear()
|
|
|
|
with patch.object(SystemControl, "reboot") as reboot:
|
|
resp = await api_client.post("/os/datadisk/move", json={"device": new_disk})
|
|
assert resp.status == 200
|
|
|
|
assert datadisk_service.ChangeDevice.calls == [("/dev/sda",)]
|
|
reboot.assert_called_once()
|
|
|
|
|
|
async def test_api_os_datadisk_wipe(
|
|
api_client: TestClient,
|
|
os_agent_services: dict[str, DBusServiceMock],
|
|
os_available,
|
|
):
|
|
"""Test datadisk wipe."""
|
|
system_service: SystemService = os_agent_services["agent_system"]
|
|
system_service.ScheduleWipeDevice.calls.clear()
|
|
|
|
with patch.object(SystemControl, "reboot") as reboot:
|
|
resp = await api_client.post("/os/datadisk/wipe")
|
|
assert resp.status == 200
|
|
|
|
assert system_service.ScheduleWipeDevice.calls == [()]
|
|
reboot.assert_called_once()
|
|
|
|
|
|
async def test_api_set_boot_slot(
|
|
api_client: TestClient,
|
|
all_dbus_services: dict[str, DBusServiceMock],
|
|
coresys: CoreSys,
|
|
os_available,
|
|
):
|
|
"""Test changing the boot slot via API."""
|
|
rauc_service: RaucService = all_dbus_services["rauc"]
|
|
await coresys.os.load()
|
|
|
|
with patch.object(SystemControl, "reboot") as reboot:
|
|
resp = await api_client.post("/os/boot-slot", json={"boot_slot": "A"})
|
|
assert resp.status == 200
|
|
|
|
reboot.assert_called_once()
|
|
assert rauc_service.Mark.calls == [("active", "kernel.0")]
|
|
|
|
|
|
async def test_api_set_boot_slot_invalid(api_client: TestClient):
|
|
"""Test invalid calls to set boot slot."""
|
|
resp = await api_client.post("/os/boot-slot", json={"boot_slot": "C"})
|
|
assert resp.status == 400
|
|
result = await resp.json()
|
|
assert "expected BootSlot or one of 'A', 'B'" in result["message"]
|
|
|
|
resp = await api_client.post("/os/boot-slot", json={"boot_slot": "A"})
|
|
assert resp.status == 400
|
|
result = await resp.json()
|
|
assert "no Home Assistant OS available" in result["message"]
|
|
|
|
|
|
async def test_api_set_boot_slot_error(
|
|
api_client: TestClient,
|
|
all_dbus_services: dict[str, DBusServiceMock],
|
|
coresys: CoreSys,
|
|
capture_exception: Mock,
|
|
os_available,
|
|
):
|
|
"""Test changing the boot slot via API."""
|
|
rauc_service: RaucService = all_dbus_services["rauc"]
|
|
rauc_service.response_mark = DBusError(ErrorType.FAILED, "fail")
|
|
await coresys.os.load()
|
|
|
|
resp = await api_client.post("/os/boot-slot", json={"boot_slot": "A"})
|
|
assert resp.status == 400
|
|
result = await resp.json()
|
|
assert result["message"] == "Can't mark A as active!"
|
|
capture_exception.assert_called_once()
|
|
|
|
|
|
async def test_api_board_yellow_info(api_client: TestClient, coresys: CoreSys):
|
|
"""Test yellow board info."""
|
|
resp = await api_client.get("/os/boards/yellow")
|
|
assert resp.status == 200
|
|
|
|
result = await resp.json()
|
|
assert result["data"]["disk_led"] is True
|
|
assert result["data"]["heartbeat_led"] is True
|
|
assert result["data"]["power_led"] is True
|
|
|
|
assert (await api_client.get("/os/boards/green")).status == 400
|
|
assert (await api_client.get("/os/boards/supervised")).status == 400
|
|
assert (await api_client.get("/os/boards/not-real")).status == 400
|
|
|
|
|
|
async def test_api_board_yellow_options(
|
|
api_client: TestClient,
|
|
coresys: CoreSys,
|
|
os_agent_services: dict[str, DBusServiceMock | dict[str, DBusServiceMock]],
|
|
):
|
|
"""Test yellow board options."""
|
|
yellow_service: YellowService = os_agent_services["agent_boards_yellow"]
|
|
|
|
assert coresys.dbus.agent.board.yellow.disk_led is True
|
|
assert coresys.dbus.agent.board.yellow.heartbeat_led is True
|
|
assert coresys.dbus.agent.board.yellow.power_led is True
|
|
assert len(coresys.resolution.issues) == 0
|
|
with patch.object(BoardProxy, "save_data") as save_data:
|
|
resp = await api_client.post(
|
|
"/os/boards/yellow",
|
|
json={"disk_led": False, "heartbeat_led": False, "power_led": False},
|
|
)
|
|
assert resp.status == 200
|
|
save_data.assert_called_once()
|
|
|
|
await yellow_service.ping()
|
|
assert coresys.dbus.agent.board.yellow.disk_led is False
|
|
assert coresys.dbus.agent.board.yellow.heartbeat_led is False
|
|
assert coresys.dbus.agent.board.yellow.power_led is False
|
|
|
|
assert (
|
|
Issue(IssueType.REBOOT_REQUIRED, ContextType.SYSTEM)
|
|
in coresys.resolution.issues
|
|
)
|
|
assert (
|
|
Suggestion(SuggestionType.EXECUTE_REBOOT, ContextType.SYSTEM)
|
|
in coresys.resolution.suggestions
|
|
)
|
|
|
|
|
|
async def test_api_board_green_info(
|
|
api_client: TestClient, coresys: CoreSys, boards_service: BoardsService
|
|
):
|
|
"""Test green board info."""
|
|
await mock_dbus_services({"agent_boards_green": None}, coresys.dbus.bus)
|
|
boards_service.board = "Green"
|
|
await coresys.dbus.agent.board.connect(coresys.dbus.bus)
|
|
|
|
resp = await api_client.get("/os/boards/green")
|
|
assert resp.status == 200
|
|
|
|
result = await resp.json()
|
|
assert result["data"]["activity_led"] is True
|
|
assert result["data"]["power_led"] is True
|
|
assert result["data"]["system_health_led"] is True
|
|
|
|
assert (await api_client.get("/os/boards/yellow")).status == 400
|
|
assert (await api_client.get("/os/boards/supervised")).status == 400
|
|
assert (await api_client.get("/os/boards/not-real")).status == 400
|
|
|
|
|
|
async def test_api_board_green_options(
|
|
api_client: TestClient,
|
|
coresys: CoreSys,
|
|
boards_service: BoardsService,
|
|
):
|
|
"""Test yellow board options."""
|
|
green_service: GreenService = (
|
|
await mock_dbus_services({"agent_boards_green": None}, coresys.dbus.bus)
|
|
)["agent_boards_green"]
|
|
boards_service.board = "Green"
|
|
await coresys.dbus.agent.board.connect(coresys.dbus.bus)
|
|
|
|
assert coresys.dbus.agent.board.green.activity_led is True
|
|
assert coresys.dbus.agent.board.green.power_led is True
|
|
assert coresys.dbus.agent.board.green.user_led is True
|
|
assert len(coresys.resolution.issues) == 0
|
|
with patch.object(BoardProxy, "save_data") as save_data:
|
|
resp = await api_client.post(
|
|
"/os/boards/green",
|
|
json={
|
|
"activity_led": False,
|
|
"power_led": False,
|
|
"system_health_led": False,
|
|
},
|
|
)
|
|
assert resp.status == 200
|
|
save_data.assert_called_once()
|
|
|
|
await green_service.ping()
|
|
assert coresys.dbus.agent.board.green.activity_led is False
|
|
assert coresys.dbus.agent.board.green.power_led is False
|
|
assert coresys.dbus.agent.board.green.user_led is False
|
|
assert len(coresys.resolution.issues) == 0
|
|
|
|
|
|
async def test_api_board_supervised_info(
|
|
api_client: TestClient, coresys: CoreSys, boards_service: BoardsService
|
|
):
|
|
"""Test supervised board info."""
|
|
await mock_dbus_services({"agent_boards_supervised": None}, coresys.dbus.bus)
|
|
boards_service.board = "Supervised"
|
|
await coresys.dbus.agent.board.connect(coresys.dbus.bus)
|
|
|
|
with patch("supervisor.os.manager.CPE.get_product", return_value=["not-hassos"]):
|
|
await coresys.os.load()
|
|
|
|
assert (await api_client.get("/os/boards/supervised")).status == 200
|
|
assert (await api_client.post("/os/boards/supervised", json={})).status == 405
|
|
assert (await api_client.get("/os/boards/yellow")).status == 400
|
|
assert (await api_client.get("/os/boards/not-real")).status == 400
|
|
|
|
|
|
async def test_api_board_other_info(
|
|
api_client: TestClient, coresys: CoreSys, boards_service: BoardsService
|
|
):
|
|
"""Test info for other board without dbus object."""
|
|
boards_service.board = "not-real"
|
|
await coresys.dbus.agent.board.connect(coresys.dbus.bus)
|
|
|
|
with patch.object(OSManager, "board", new=PropertyMock(return_value="not-real")):
|
|
assert (await api_client.get("/os/boards/not-real")).status == 200
|
|
assert (await api_client.post("/os/boards/not-real", json={})).status == 405
|
|
assert (await api_client.get("/os/boards/yellow")).status == 400
|
|
assert (await api_client.get("/os/boards/supervised")).status == 400
|