Cognitive_Agent/tests/unit/test_firmware_workbench.py

from __future__ import annotations

import hashlib
import json
import threading
import time
import zipfile
from pathlib import Path

import pytest

from cognitive_agent.application.firmware_workbench import (
    FINAL_RELEASE_MESSAGE,
    FirmwareWorkbenchError,
    FirmwareWorkbenchService,
)
from cognitive_agent.infrastructure.can.gateway import CanGatewayError

ROOT = Path(__file__).resolve().parents[2]


def wait_for_terminal(service: FirmwareWorkbenchService, task_id: str) -> dict[str, object]:
    deadline = time.monotonic() + 5
    while time.monotonic() < deadline:
        task = service.task(task_id)
        if task["status"] not in {"waiting", "running", "pending_confirmation"}:
            return task
        time.sleep(0.02)
    raise AssertionError("firmware pipeline did not reach a terminal state")


def make_image(tmp_path: Path) -> Path:
    image = tmp_path / "Seat_Controller_demo.hex"
    image.write_bytes(b":020000040000FA\n" + b":100000000102030405060708090A0B0C0D0E0F1068\n" * 80)
    return image


def test_pipeline_publishes_a_downloadable_ota_package(
    tmp_path: Path, monkeypatch
) -> None:
    monkeypatch.setenv(
        "FIRMWARE_WORKBENCH_OTA_PUBLIC_BASE_URL",
        "http://192.168.43.130:8000/api/firmware-workbench/releases",
    )
    image = make_image(tmp_path)

    def build_runner(
        _task_id: str, log: object, _cancel: threading.Event
    ) -> Path:
        log("info", "IAR build: 0 errors, 0 warnings")
        return image

    service = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    instruction = "增加支持座椅位置参数控制的能力，增加座椅通风功能，增加座椅加热功能"

    first = service.start_task(instruction)
    task = wait_for_terminal(service, str(first["task"]["id"]))
    assert task["status"] == "success"
    assert task["message"] == FINAL_RELEASE_MESSAGE
    assert [stage["status"] for stage in task["stages"]] == ["success"] * 8
    assert len(task["test_results"]) == 7

    snapshot = service.snapshot()
    assert snapshot["baselines"] == [
        {
            "id": "time_only",
            "name": "时间控制基线",
            "capabilities": ["时间控制"],
        }
    ]
    assert len(snapshot["artifacts"]) == 2
    assert len(snapshot["releases"]) == 1
    artifact = next(item for item in snapshot["artifacts"] if item["task_id"] == task["id"])
    baseline = next(item for item in snapshot["artifacts"] if item.get("is_baseline"))
    release = snapshot["releases"][0]
    assert baseline["capabilities"] == ["时间控制"]
    assert baseline["protected"] is True
    assert artifact["capabilities"] == ["时间控制", "位置控制", "座椅通风", "座椅加热"]
    assert artifact["status"] == "published"
    assert release["download_url"] == (
        f"http://192.168.43.130:8000/api/firmware-workbench/releases/"
        f"{release['id']}/download"
    )
    assert service.latest_release()["download_url"] == release["download_url"]
    latest_manifest = json.loads((tmp_path / "ota" / "latest.json").read_text("utf-8"))
    assert latest_manifest["download_url"] == release["download_url"]
    package, filename = service.resolve_release_download(str(release["id"]))
    assert filename == artifact["firmware_filename"]
    assert hashlib.sha256(package.read_bytes()).hexdigest() == artifact["sha256"]
    with zipfile.ZipFile(package) as archive:
        assert {
            "Seat_Controller_demo.hex",
            "manifest.json",
            "requirements.json",
            "validation.json",
            "feature_profile.json",
        } <= set(archive.namelist())
    assert (tmp_path / "ota" / "latest.json").is_file()
    assert service.publish_artifact(str(artifact["id"]))["id"] == release["id"]
    service.close()

    monkeypatch.setenv(
        "FIRMWARE_WORKBENCH_OTA_PUBLIC_BASE_URL",
        "http://192.168.43.131:8000/api/firmware-workbench/releases",
    )
    migrated = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    migrated_release = migrated.latest_release()
    assert migrated_release["download_url"].startswith("http://192.168.43.131:8000/")
    migrated_latest = json.loads((tmp_path / "ota" / "latest.json").read_text("utf-8"))
    assert migrated_latest["download_url"] == migrated_release["download_url"]
    migrated.close()


def test_repeated_instruction_always_creates_and_executes_a_new_task(tmp_path: Path) -> None:
    image = make_image(tmp_path)

    def build_runner(
        _task_id: str, log: object, _cancel: threading.Event
    ) -> Path:
        log("info", "IAR build: 0 errors, 0 warnings")
        return image

    service = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    first = service.start_task("增加座椅加热功能。")
    first_task = wait_for_terminal(service, str(first["task"]["id"]))
    second = service.start_task("增加座椅加热功能。")

    assert first["task"]["id"] != second["task"]["id"]
    assert "duplicate" not in first
    assert "duplicate" not in second
    second_task = wait_for_terminal(service, str(second["task"]["id"]))
    assert first_task["status"] == "success"
    assert second_task["status"] == "success"
    assert first_task["target_capabilities"] == ["时间控制", "座椅加热"]
    assert second_task["target_capabilities"] == ["时间控制", "座椅加热"]
    service.close()


def test_non_baseline_artifact_can_be_deleted_but_baseline_is_protected(tmp_path: Path) -> None:
    image = make_image(tmp_path)

    def build_runner(
        _task_id: str, log: object, _cancel: threading.Event
    ) -> Path:
        log("info", "IAR build: 0 errors, 0 warnings")
        return image

    service = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    started = service.start_task("增加座椅通风功能")
    task = wait_for_terminal(service, str(started["task"]["id"]))
    package_path, _ = service.resolve_artifact_download(str(task["artifact_id"]))
    release_path, _ = service.resolve_release_download(str(task["release_id"]))

    result = service.delete_artifact(str(task["artifact_id"]))
    assert result["deleted"] is True
    assert not package_path.exists()
    assert not release_path.exists()
    snapshot = service.snapshot()
    assert [artifact["id"] for artifact in snapshot["artifacts"]] == [
        "fw-art-time-only-baseline"
    ]
    assert snapshot["releases"] == []

    try:
        service.delete_artifact("fw-art-time-only-baseline")
    except Exception as exc:  # noqa: BLE001 - public error type is asserted below
        assert getattr(exc, "code", None) == "baseline_protected"
    else:
        raise AssertionError("time-only baseline must not be deletable")
    service.close()


def test_position_instruction_merges_with_time_only_baseline(tmp_path: Path) -> None:
    image = make_image(tmp_path)

    def build_runner(
        _task_id: str, log: object, _cancel: threading.Event
    ) -> Path:
        log("info", "IAR build: profile position=1 ventilation=0 heating=0")
        return image

    service = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    started = service.start_task("增加支持座椅位置参数控制的能力。", "time_only")
    task = wait_for_terminal(service, str(started["task"]["id"]))

    assert task["status"] == "success"
    assert task["baseline_capabilities"] == ["时间控制"]
    assert task["requested_capabilities"] == ["位置控制"]
    assert task["target_capabilities"] == ["时间控制", "位置控制"]
    artifact = service.snapshot()["artifacts"][0]
    assert artifact["capabilities"] == ["时间控制", "位置控制"]
    assert artifact["capability_diff"]["added"] == ["位置控制"]
    assert "vent" not in artifact["firmware_filename"]
    assert "heat" not in artifact["firmware_filename"]
    profile_path = tmp_path / "workbench" / "tasks" / task["id"] / "feature_profile.json"
    assert json.loads(profile_path.read_text("utf-8"))["rocking_horse"] is False
    service.close()


def test_running_pipeline_can_be_canceled_and_retried(tmp_path: Path) -> None:
    image = make_image(tmp_path)
    allow_build = threading.Event()

    def build_runner(
        _task_id: str, log: object, cancel: threading.Event
    ) -> Path:
        log("info", "IAR build started")
        while not allow_build.is_set():
            if cancel.wait(0.01):
                raise InterruptedError
        return image

    service = FirmwareWorkbenchService(
        ROOT,
        artifact_root=tmp_path / "workbench",
        ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    started = service.start_task("增加座椅通风功能")
    task_id = str(started["task"]["id"])
    deadline = time.monotonic() + 3
    while service.task(task_id)["current_stage"] != "build" and time.monotonic() < deadline:
        time.sleep(0.01)
    service.cancel_task(task_id)
    canceled = wait_for_terminal(service, task_id)
    assert canceled["status"] == "canceled"
    assert any(stage["status"] == "canceled" for stage in canceled["stages"])

    allow_build.set()
    retried = service.retry_task(task_id)
    assert retried["id"] == task_id
    completed = wait_for_terminal(service, task_id)
    assert completed["status"] == "success"
    service.close()


@pytest.mark.parametrize("instruction", [
    "增加动态木马功能",
    "增加木马功能",
    "Add rocking_horse",
    "Add Rocking Horse",
    "Add rocking-horse",
])
def test_rocking_horse_package_and_notification(tmp_path: Path, instruction: str) -> None:
    image = make_image(tmp_path)
    profile = {
        "position_control": True, "ventilation": False,
        "heating": False, "rocking_horse": True,
    }

    def build_runner(task_id: str, log: object, cancel: threading.Event) -> Path:
        workspace = tmp_path / "workbench" / "tasks" / task_id
        assert json.loads((workspace / "feature_profile.json").read_text("utf-8")) == profile
        return image

    service = FirmwareWorkbenchService(
        ROOT, artifact_root=tmp_path / "workbench", ota_root=tmp_path / "ota",
        build_runner=build_runner,
    )
    try:
        started = service.start_task(instruction)
        task = wait_for_terminal(service, started["task"]["id"])
        assert task["status"] == "success", task.get("failure_reason")
        assert [stage["status"] for stage in task["stages"]] == ["success"] * 8
        assert task["target_capabilities"] == ["时间控制", "位置控制", "动态木马"]
        assert any(item["name"] == "动态木马控制与停止保护" for item in task["test_results"])
        artifact = service.artifact(task["artifact_id"])
        assert artifact["capability_diff"]["added"] == ["位置控制", "动态木马"]
        assert "rocking-horse" in artifact["firmware_filename"]
        package, _ = service.resolve_release_download(task["release_id"])
        with zipfile.ZipFile(package) as archive:
            assert json.loads(archive.read("manifest.json"))["capabilities"] == task["target_capabilities"]
            assert json.loads(archive.read("feature_profile.json")) == profile
            assert json.loads(archive.read("requirements.json"))["feature_profile"] == profile
        frames = []

        def publish(frame):
            frames.append(frame)
            return {"status": "published"}

        result = service.notify_artifact(artifact["id"], publish)
        assert result["published_count"] == 3
        assert [frame["sequence"] for frame in frames] == [1, 2, 3]
        assert len({frame["message_id"] for frame in frames}) == 1
        assert all(frame["firmware"]["artifact_name"] == artifact["firmware_filename"] for frame in frames)
        assert all(frame["firmware"]["sha256"] == artifact["sha256"] for frame in frames)
        assert all(frame["auto_upgrade"] is False for frame in frames)

        def unavailable(frame):
            raise CanGatewayError("broker unavailable")

        with pytest.raises(FirmwareWorkbenchError, match="0/3") as error:
            service.notify_artifact(artifact["id"], unavailable)
        assert error.value.code == "notification_publish_failed"
        assert service.artifact(artifact["id"])["status"] == "published"
    finally:
        service.close()


def test_rocking_horse_build_failure_does_not_publish(tmp_path: Path) -> None:
    def fail_build(task_id: str, log: object, cancel: threading.Event) -> Path:
        raise RuntimeError("IAR build failed")

    service = FirmwareWorkbenchService(
        ROOT, artifact_root=tmp_path / "workbench", ota_root=tmp_path / "ota",
        build_runner=fail_build,
    )
    try:
        started = service.start_task("增加动态木马功能")
        task = wait_for_terminal(service, started["task"]["id"])
        assert task["status"] == "failed"
        assert task["failure_reason"] == "IAR build failed"
        assert service.snapshot()["releases"] == []
        assert all(item.get("is_baseline") for item in service.snapshot()["artifacts"])
    finally:
        service.close()