tests: cover build_config helpers and builds config endpoint

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: shiv-tyagi

tests/build_config/test_build_config.py

@@ -0,0 +1,101 @@
+"""Tests for shared build_config packaging helpers."""
+import tarfile
+from pathlib import Path
+
+import pytest
+import yaml
+
+from build_config import (
+    CONFIG_FILENAME,
+    CONFIG_VERSION,
+    build_config_dict,
+    config_dict_from_build_info,
+    dump_config_yaml,
+    validate_config_dict,
+    write_config_yaml,
+)
+from build_manager import BuildInfo
+from metadata_manager import RemoteInfo
+
+
+def _valid_config(**overrides):
+    base = build_config_dict(
+        vehicle_id="copter",
+        vehicle_name="Copter",
+        version_id="ardupilot-Copter-4.5.0-abc",
+        version_name="4.5.0",
+        version_type="stable",
+        remote_name="ardupilot",
+        board_id="CubeOrange",
+        board_name="CubeOrange",
+        selected_features={"HAL_LOGGING_ENABLED"},
+    )
+    base.update(overrides)
+    return base
+
+
+def test_validate_accepts_schema_compliant_config():
+    validate_config_dict(_valid_config())
+
+
+def test_validate_rejects_missing_required_field():
+    bad = _valid_config()
+    del bad["board"]
+    with pytest.raises(Exception):
+        validate_config_dict(bad)
+
+
+def test_dump_and_write_roundtrip(tmp_path: Path):
+    config = _valid_config()
+    text = dump_config_yaml(config)
+    parsed = yaml.safe_load(text)
+    assert parsed["config_version"] == CONFIG_VERSION
+    assert parsed["vehicle"]["id"] == "copter"
+
+    out = tmp_path / CONFIG_FILENAME
+    write_config_yaml(out, config)
+    assert out.is_file()
+    assert yaml.safe_load(out.read_text())["board"]["id"] == "CubeOrange"
+
+
+def test_config_dict_from_build_info_uses_labels_and_names():
+    info = BuildInfo(
+        vehicle_id="copter",
+        version_id="ver-1",
+        remote_info=RemoteInfo(
+            name="ardupilot",
+            url="https://github.com/ArduPilot/ardupilot.git",
+        ),
+        git_hash="abc123",
+        board="MatekH743",
+        selected_features={"HAL_LOGGING_ENABLED"},
+        vehicle_name="Copter",
+        board_name="MatekH743",
+        version_name="4.5.0",
+        version_type="stable",
+    )
+    config = config_dict_from_build_info(info)
+    validate_config_dict(config)
+    assert config["selected_features"] == ["HAL_LOGGING_ENABLED"]
+    assert config["version"]["name"] == "4.5.0"
+    assert config["version"]["remote_name"] == "ardupilot"
+
+
+def test_packaged_yaml_inside_tar(tmp_path: Path):
+    """Simulate Builder archive membership for custombuild.yaml."""
+    config = _valid_config()
+    config_path = tmp_path / CONFIG_FILENAME
+    write_config_yaml(config_path, config)
+
+    archive = tmp_path / "copter-MatekH743-build1.tar.gz"
+    folder_name = archive.name.removesuffix(".tar.gz")
+    with tarfile.open(archive, "w:gz") as tar:
+        tar.add(config_path, arcname=f"{folder_name}/{CONFIG_FILENAME}")
+
+    with tarfile.open(archive, "r:gz") as tar:
+        names = [m.name for m in tar.getmembers()]
+        assert f"{folder_name}/{CONFIG_FILENAME}" in names
+        extracted = tar.extractfile(f"{folder_name}/{CONFIG_FILENAME}")
+        assert extracted is not None
+        loaded = yaml.safe_load(extracted.read())
+        assert loaded["vehicle"]["id"] == "copter"

tests/web/test_builds_api.py

@@ -444,3 +444,34 @@ def test_get_artifact_method_not_allowed(self, client):
         for method in [client.post, client.put, client.patch, client.delete]:
             response = method("/api/v1/builds/build-abc123/artifact")
             assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    def test_get_config_returns_200_when_available(self, client):
+        """Returns YAML when the service provides packaged config."""
+        mock_service = Mock()
+        mock_service.get_build_config_yaml.return_value = (
+            "config_version: \"0.0.1\"\nvehicle:\n  id: copter\n  name: Copter\n",
+            "custombuild-copter-MatekH743-build-abc123.yaml",
+        )
+        with self.override_builds_service(client, mock_service):
+            response = client.get("/api/v1/builds/build-abc123/config")
+
+        assert response.status_code == status.HTTP_200_OK
+        assert "copter" in response.text
+        assert "attachment" in response.headers.get("content-disposition", "")
+
+    def test_get_config_returns_404_when_not_available(self, client):
+        mock_service = Mock()
+        mock_service.get_build_config_yaml.return_value = None
+        with self.override_builds_service(client, mock_service):
+            response = client.get("/api/v1/builds/some-build-id/config")
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert "some-build-id" in response.json()["detail"]
+
+    def test_get_config_service_called_with_correct_build_id(self, client):
+        mock_service = Mock()
+        mock_service.get_build_config_yaml.return_value = None
+        with self.override_builds_service(client, mock_service):
+            client.get("/api/v1/builds/target-build/config")
+
+        mock_service.get_build_config_yaml.assert_called_once_with("target-build")

tests/web/test_builds_service.py

@@ -70,6 +70,10 @@ def make_build_info(
     git_hash="abc123def456",
     board="MatekH743",
     selected_features=None,
+    vehicle_name=None,
+    board_name=None,
+    version_name="4.5.0",
+    version_type="stable",
     state=bm.BuildState.PENDING,
     percent=0,
 ):
@@ -80,6 +84,10 @@ def make_build_info(
         git_hash=git_hash,
         board=board,
         selected_features=set(selected_features) if selected_features is not None else set(),
+        vehicle_name=vehicle_name or vehicle_id.capitalize(),
+        board_name=board_name or board,
+        version_name=version_name,
+        version_type=version_type,
     )
     info.progress = bm.BuildProgress(state=state, percent=percent)
     return info
@@ -161,6 +169,21 @@ def test_create_build_raises_value_error_for_missing_vehicle_id(self, service):
         with pytest.raises(ValueError, match="vehicle_id is required"):
             service.create_build(request)
 
+    def test_create_build_raises_value_error_for_invalid_vehicle(
+        self, service, mock_vehicles_manager
+    ):
+        """ValueError is raised when vehicle_id is not a known vehicle."""
+        mock_vehicles_manager.get_vehicle_by_id.return_value = None
+        request = BuildRequest(
+            vehicle_id="unknown-vehicle",
+            board_id="MatekH743",
+            version_id="copter-4.5.0-stable",
+            selected_features=[],
+        )
+
+        with pytest.raises(ValueError, match="Invalid vehicle_id"):
+            service.create_build(request)
+
     def test_create_build_raises_value_error_for_missing_board_id(
         self, service
     ):
@@ -216,9 +239,9 @@ def test_create_build_raises_value_error_when_remote_not_found(
         """ValueError is raised when the remote is not found."""
         mock_versions_manager.get_remote_info.return_value = None
         request = BuildRequest(
-            vehicle_id="some-vehicle",
-            board_id="some-board",
-            version_id="some-version",
+            vehicle_id="copter",
+            board_id="MatekH743",
+            version_id="copter-4.5.0-stable",
             selected_features=[],
         )
 
@@ -725,3 +748,135 @@ def test_get_artifact_path_uses_correct_build_id(
         service.get_artifact_path("my-target-build")
 
         mock_build_manager.build_exists.assert_called_once_with("my-target-build")
+
+    def test_get_build_includes_version_name_and_type(
+        self,
+        service,
+        mock_build_manager,
+        mock_versions_manager,
+    ):
+        """version.name and version.type come from versions_manager."""
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = make_build_info()
+        mock_versions_manager.get_version_info.return_value = make_version_info(
+            release_type="stable",
+            version_number="4.5.0",
+        )
+
+        result = service.get_build("build-abc123")
+
+        assert result.version.name == "4.5.0"
+        assert result.version.type == "stable"
+        mock_versions_manager.get_version_info.assert_called_with(
+            vehicle_id="copter",
+            version_id="copter-4.5.0-stable",
+        )
+
+    def test_get_build_maps_latest_version_name_to_master(
+        self,
+        service,
+        mock_build_manager,
+        mock_versions_manager,
+    ):
+        """latest release_type is exposed as display name 'master'."""
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = make_build_info(
+            version_id="copter-latest",
+        )
+        mock_versions_manager.get_version_info.return_value = make_version_info(
+            release_type="latest",
+            version_number="NA",
+        )
+
+        result = service.get_build("build-abc123")
+
+        assert result.version.name == "master"
+        assert result.version.type == "latest"
+
+    def test_get_build_falls_back_to_stored_version_when_unknown(
+        self,
+        service,
+        mock_build_manager,
+        mock_versions_manager,
+    ):
+        """Missing live version info uses names stored on BuildInfo."""
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = make_build_info(
+            version_name="4.5.0",
+            version_type="stable",
+        )
+        mock_versions_manager.get_version_info.return_value = None
+
+        result = service.get_build("build-abc123")
+
+        assert result.version.name == "4.5.0"
+        assert result.version.type == "stable"
+
+    def test_get_build_falls_back_to_stored_vehicle_name_when_unknown(
+        self,
+        service,
+        mock_build_manager,
+        mock_vehicles_manager,
+    ):
+        """Missing live vehicle uses display name stored on BuildInfo, not id."""
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = make_build_info(
+            vehicle_id="retired-vehicle",
+            vehicle_name="Retired Vehicle",
+        )
+        mock_vehicles_manager.get_vehicle_by_id.side_effect = lambda _vid: None
+
+        result = service.get_build("build-abc123")
+
+        assert result.vehicle.id == "retired-vehicle"
+        assert result.vehicle.name == "Retired Vehicle"
+
+    def test_get_build_config_yaml_generates_from_build_info(
+        self,
+        service,
+        mock_build_manager,
+    ):
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = make_build_info(
+            state=bm.BuildState.SUCCESS,
+            vehicle_id="copter",
+            board="MatekH743",
+            vehicle_name="Copter",
+            selected_features=["HAL_LOGGING_ENABLED"],
+        )
+
+        result = service.get_build_config_yaml("build-abc123")
+
+        assert result is not None
+        yaml_text, filename = result
+        assert "HAL_LOGGING_ENABLED" in yaml_text
+        assert filename.endswith(".yaml")
+
+    def test_get_build_config_yaml_returns_none_when_build_missing(
+        self, service, mock_build_manager
+    ):
+        mock_build_manager.build_exists.return_value = False
+        assert service.get_build_config_yaml("missing") is None
+
+    def test_get_build_config_yaml_returns_none_when_info_missing(
+        self, service, mock_build_manager
+    ):
+        mock_build_manager.build_exists.return_value = True
+        mock_build_manager.get_build_info.return_value = None
+        assert service.get_build_config_yaml("build-abc123") is None
+
+    def test_create_build_stores_display_metadata(
+        self, service, mock_build_manager
+    ):
+        service.create_build(
+            BuildRequest(
+                vehicle_id="copter",
+                board_id="MatekH743",
+                version_id="copter-4.5.0-stable",
+                selected_features=["HAL_LOGGING_ENABLED"],
+            )
+        )
+        submitted: bm.BuildInfo = mock_build_manager.submit_build.call_args[1]["build_info"]
+        assert submitted.selected_features == {"HAL_LOGGING_ENABLED"}
+        assert submitted.vehicle_name == "Copter"
+        assert submitted.version_type == "stable"