bambuddy/backend/tests/unit/test_spoolman_inventory_helpers.py

"""Unit tests for _safe_int, _safe_float, and _map_spoolman_spool helpers."""

import math

import pytest

from backend.app.api.routes._spoolman_helpers import (
    _map_spoolman_spool,
    _safe_float,
    _safe_int,
)

# ---------------------------------------------------------------------------
# _safe_int
# ---------------------------------------------------------------------------


class TestSafeInt:
    def test_normal_int(self):
        assert _safe_int(1000, 0) == 1000

    def test_float_rounds_down(self):
        assert _safe_int(750.9, 0) == 750

    def test_none_returns_fallback(self):
        assert _safe_int(None, 999) == 999

    def test_nan_returns_fallback(self):
        assert _safe_int(math.nan, 999) == 999

    def test_inf_returns_fallback(self):
        assert _safe_int(math.inf, 999) == 999

    def test_neg_inf_returns_fallback(self):
        assert _safe_int(-math.inf, 999) == 999

    def test_string_numeric(self):
        assert _safe_int("500", 0) == 500

    def test_string_non_numeric_returns_fallback(self):
        assert _safe_int("abc", 42) == 42

    def test_zero(self):
        assert _safe_int(0, 999) == 0


# ---------------------------------------------------------------------------
# _safe_float
# ---------------------------------------------------------------------------


class TestSafeFloat:
    def test_normal_float(self):
        assert _safe_float(123.45, 0.0) == pytest.approx(123.45)

    def test_none_returns_fallback(self):
        assert _safe_float(None, -1.0) == -1.0

    def test_nan_returns_fallback(self):
        assert _safe_float(math.nan, -1.0) == -1.0

    def test_inf_returns_fallback(self):
        assert _safe_float(math.inf, -1.0) == -1.0

    def test_neg_inf_returns_fallback(self):
        assert _safe_float(-math.inf, -1.0) == -1.0

    def test_string_numeric(self):
        assert _safe_float("3.14", 0.0) == pytest.approx(3.14)

    def test_string_non_numeric_returns_fallback(self):
        assert _safe_float("bad", 0.0) == 0.0

    def test_zero(self):
        assert _safe_float(0.0, 99.0) == 0.0


# ---------------------------------------------------------------------------
# _map_spoolman_spool
# ---------------------------------------------------------------------------


MINIMAL_SPOOL = {
    "id": 1,
    "filament": {
        "material": "PLA",
        "name": "PLA Basic",
        "color_hex": "FF0000",
        "weight": 1000.0,
        "vendor": {"name": "Bambu Lab"},
    },
    "used_weight": 250.0,
    "archived": False,
    "registered": "2024-01-01T00:00:00Z",
}


class TestMapSpoolmanSpool:
    def test_basic_mapping(self):
        result = _map_spoolman_spool(MINIMAL_SPOOL)
        assert result["id"] == 1
        assert result["material"] == "PLA"
        assert result["rgba"] == "FF0000FF"
        assert result["label_weight"] == 1000
        assert result["weight_used"] == pytest.approx(250.0)
        assert result["data_origin"] == "spoolman"

    def test_missing_id_raises(self):
        spool = {k: v for k, v in MINIMAL_SPOOL.items() if k != "id"}
        with pytest.raises(ValueError, match="missing required 'id'"):
            _map_spoolman_spool(spool)

    def test_none_id_raises(self):
        with pytest.raises(ValueError):
            _map_spoolman_spool({**MINIMAL_SPOOL, "id": None})

    def test_string_id_raises(self):
        with pytest.raises(ValueError, match="not a valid integer"):
            _map_spoolman_spool({**MINIMAL_SPOOL, "id": "abc"})

    def test_zero_id_raises(self):
        with pytest.raises(ValueError, match="positive integer"):
            _map_spoolman_spool({**MINIMAL_SPOOL, "id": 0})

    def test_negative_id_raises(self):
        with pytest.raises(ValueError, match="positive integer"):
            _map_spoolman_spool({**MINIMAL_SPOOL, "id": -5})

    def test_numeric_string_id_accepted(self):
        result = _map_spoolman_spool({**MINIMAL_SPOOL, "id": "42"})
        assert result["id"] == 42

    def test_zero_price_not_converted_to_none(self):
        spool = {**MINIMAL_SPOOL, "price": 0.0}
        result = _map_spoolman_spool(spool)
        assert result["cost_per_kg"] == 0.0

    def test_nonzero_price_preserved(self):
        spool = {**MINIMAL_SPOOL, "price": 9.99}
        result = _map_spoolman_spool(spool)
        assert result["cost_per_kg"] == pytest.approx(9.99)

    def test_none_price_stays_none(self):
        spool = {**MINIMAL_SPOOL, "price": None}
        result = _map_spoolman_spool(spool)
        assert result["cost_per_kg"] is None

    def test_infinity_weight_falls_back(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "weight": math.inf}}
        result = _map_spoolman_spool(spool)
        assert result["label_weight"] == 1000

    def test_nan_used_weight_falls_back(self):
        spool = {**MINIMAL_SPOOL, "used_weight": math.nan}
        result = _map_spoolman_spool(spool)
        assert result["weight_used"] == 0.0

    def test_invalid_color_hex_falls_back_to_grey(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "color_hex": "ZZZZZZ"}}
        result = _map_spoolman_spool(spool)
        assert result["rgba"] == "808080FF"

    def test_short_color_hex_falls_back(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "color_hex": "FFF"}}
        result = _map_spoolman_spool(spool)
        assert result["rgba"] == "808080FF"

    def test_eight_char_color_hex_falls_back(self):
        # Only 6-char hex is valid from Spoolman; 8-char (RGBA) should fall back
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "color_hex": "FF0000FF"}}
        result = _map_spoolman_spool(spool)
        assert result["rgba"] == "808080FF"

    def test_color_name_uses_explicit_field_when_present(self):
        """When Spoolman's filament has color_name set, that wins over the subtype fallback."""
        spool = {
            **MINIMAL_SPOOL,
            "filament": {**MINIMAL_SPOOL["filament"], "color_name": "Sunrise Orange"},
        }
        result = _map_spoolman_spool(spool)
        assert result["color_name"] == "Sunrise Orange"

    def test_color_name_falls_back_to_subtype_when_field_missing(self):
        """Spoolman doesn't standardise color_name; the LinkSpoolModal would
        otherwise show 'Unknown color' for every Spoolman spool. The mapper
        falls back to the filament's name minus material prefix (which the
        subtype field already carries) so the user can tell spools apart at a
        glance even on installs that don't fill color_name.
        """
        spool = {
            **MINIMAL_SPOOL,
            "filament": {
                **MINIMAL_SPOOL["filament"],
                "name": "PLA Basic Red",
                # No color_name field — the common case for default Spoolman installs.
            },
        }
        result = _map_spoolman_spool(spool)
        # subtype is filament_name minus material prefix → "Basic Red"
        assert result["subtype"] == "Basic Red"
        # color_name falls back to subtype.
        assert result["color_name"] == "Basic Red"

    def test_color_name_none_when_both_fields_empty(self):
        """If neither color_name nor a usable subtype exists, return None — UI
        falls back to its own 'Unknown color' string rather than showing a
        misleading material-only label.
        """
        spool = {
            **MINIMAL_SPOOL,
            "filament": {
                **MINIMAL_SPOOL["filament"],
                "name": "PLA",  # name == material → subtype becomes None
            },
        }
        result = _map_spoolman_spool(spool)
        assert result["subtype"] is None
        assert result["color_name"] is None

    def test_color_hex_with_hash_prefix_stripped(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "color_hex": "#00FF00"}}
        result = _map_spoolman_spool(spool)
        assert result["rgba"] == "00FF00FF"

    def test_color_hex_lowercase_normalised(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "color_hex": "ff0000"}}
        result = _map_spoolman_spool(spool)
        assert result["rgba"] == "FF0000FF"

    def test_none_filament(self):
        spool = {**MINIMAL_SPOOL, "filament": None}
        result = _map_spoolman_spool(spool)
        assert result["material"] == ""
        assert result["rgba"] == "808080FF"
        assert result["label_weight"] == 1000

    def test_archived_spool_has_archived_at(self):
        spool = {**MINIMAL_SPOOL, "archived": True}
        result = _map_spoolman_spool(spool)
        assert result["archived_at"] is not None

    def test_subtype_strips_material_prefix(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "material": "PLA", "name": "PLA Basic"}}
        result = _map_spoolman_spool(spool)
        assert result["subtype"] == "Basic"

    def test_brand_from_vendor(self):
        result = _map_spoolman_spool(MINIMAL_SPOOL)
        assert result["brand"] == "Bambu Lab"

    def test_no_vendor_brand_is_none(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "vendor": None}}
        result = _map_spoolman_spool(spool)
        assert result["brand"] is None

    def test_spoolman_location_mapped_to_storage_location(self):
        spool = {**MINIMAL_SPOOL, "location": "Shelf A"}
        result = _map_spoolman_spool(spool)
        assert result["storage_location"] == "Shelf A"

    def test_no_location_gives_none_storage_location(self):
        result = _map_spoolman_spool(MINIMAL_SPOOL)
        assert result["storage_location"] is None

    def test_empty_location_gives_none_storage_location(self):
        spool = {**MINIMAL_SPOOL, "location": ""}
        result = _map_spoolman_spool(spool)
        assert result["storage_location"] is None

    def test_spoolman_location_key_not_in_result(self):
        spool = {**MINIMAL_SPOOL, "location": "Shelf A"}
        result = _map_spoolman_spool(spool)
        assert "spoolman_location" not in result

    def test_core_weight_from_filament_spool_weight(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 196}}
        result = _map_spoolman_spool(spool)
        assert result["core_weight"] == 196

    def test_core_weight_fallback_when_spool_weight_missing(self):
        result = _map_spoolman_spool(MINIMAL_SPOOL)
        assert result["core_weight"] == 250

    def test_core_weight_fallback_when_spool_weight_none(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": None}}
        result = _map_spoolman_spool(spool)
        assert result["core_weight"] == 250

    def test_core_weight_float_truncated_to_int(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 180.9}}
        result = _map_spoolman_spool(spool)
        assert result["core_weight"] == 180

    def test_spool_level_spool_weight_takes_priority_over_filament(self):
        spool = {**MINIMAL_SPOOL, "spool_weight": 300, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 196}}
        assert _map_spoolman_spool(spool)["core_weight"] == 300

    def test_spool_level_zero_spool_weight_not_treated_as_missing(self):
        spool = {**MINIMAL_SPOOL, "spool_weight": 0, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 196}}
        assert _map_spoolman_spool(spool)["core_weight"] == 0

    def test_spool_level_none_falls_back_to_filament(self):
        spool = {**MINIMAL_SPOOL, "spool_weight": None, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 196}}
        assert _map_spoolman_spool(spool)["core_weight"] == 196

    def test_spool_level_absent_falls_back_to_filament(self):
        spool = {**MINIMAL_SPOOL, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": 196}}
        assert _map_spoolman_spool(spool)["core_weight"] == 196

    def test_both_levels_none_uses_fallback(self):
        spool = {**MINIMAL_SPOOL, "spool_weight": None, "filament": {**MINIMAL_SPOOL["filament"], "spool_weight": None}}
        assert _map_spoolman_spool(spool)["core_weight"] == 250


# ---------------------------------------------------------------------------
# F4: _safe_optional_float unit tests
# ---------------------------------------------------------------------------


class TestSafeOptionalFloat:
    """F4: Direct unit tests for _safe_optional_float (NaN/Inf safety)."""

    def test_normal_value(self):
        import pytest

        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(9.99) == pytest.approx(9.99)

    def test_none_returns_none(self):
        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(None) is None

    def test_nan_returns_none(self):
        import math

        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(math.nan) is None

    def test_inf_returns_none(self):
        import math

        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(math.inf) is None

    def test_neg_inf_returns_none(self):
        import math

        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(-math.inf) is None

    def test_zero_returns_zero(self):
        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float(0.0) == 0.0

    def test_string_numeric(self):
        import pytest

        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float("3.14") == pytest.approx(3.14)

    def test_string_non_numeric_returns_none(self):
        from backend.app.api.routes._spoolman_helpers import _safe_optional_float

        assert _safe_optional_float("bad") is None


class TestMapSpoolmanSpoolSlicerFilament:
    """slicer_filament round-trip via Spoolman extra dict.

    Spoolman has no native slicer_filament field, so we persist BambuStudio
    presets under bambu_slicer_filament[_name] keys in the spool's extra
    dict (JSON-encoded strings, like every Spoolman extra value). The map
    function unwraps those values and exposes them as slicer_filament /
    slicer_filament_name on the InventorySpool shape. Without this round-trip
    the user's selected slicer preset is silently dropped on save (#1114).
    """

    def test_slicer_filament_unwrapped_from_extra(self):
        spool = {
            **MINIMAL_SPOOL,
            "extra": {
                "bambu_slicer_filament": '"PFUSf543b298f8ea66"',
                "bambu_slicer_filament_name": '"Devil Design PLA Basic @Bambu Lab H2D 0.4 nozzle (Custom)"',
            },
        }
        result = _map_spoolman_spool(spool)
        assert result["slicer_filament"] == "PFUSf543b298f8ea66"
        assert result["slicer_filament_name"] == "Devil Design PLA Basic @Bambu Lab H2D 0.4 nozzle (Custom)"

    def test_slicer_filament_falls_back_to_filament_name(self):
        # Spool has no bambu_slicer_filament_name override → use Spoolman's filament.name
        spool = {**MINIMAL_SPOOL, "extra": {}}
        result = _map_spoolman_spool(spool)
        assert result["slicer_filament"] is None
        assert result["slicer_filament_name"] == "PLA Basic"  # from filament.name

    def test_empty_string_extra_treated_as_unset(self):
        # JSON-encoded empty string is how the user clears the field
        spool = {
            **MINIMAL_SPOOL,
            "extra": {
                "bambu_slicer_filament": '""',
                "bambu_slicer_filament_name": '""',
            },
        }
        result = _map_spoolman_spool(spool)
        assert result["slicer_filament"] is None
        # Falls back to filament.name when the override is cleared
        assert result["slicer_filament_name"] == "PLA Basic"

    def test_non_json_extra_value_passed_through(self):
        # Tolerate bare-string values written without JSON encoding
        # (older data, manual writes via Spoolman UI, etc.)
        spool = {
            **MINIMAL_SPOOL,
            "extra": {"bambu_slicer_filament": "GFL05"},
        }
        result = _map_spoolman_spool(spool)
        assert result["slicer_filament"] == "GFL05"


class TestExtractExtraStr:
    """JSON-encoded extra-string unwrapper used by _map_spoolman_spool."""

    def test_unwraps_quoted_string(self):
        from backend.app.api.routes._spoolman_helpers import _extract_extra_str

        assert _extract_extra_str({"k": '"hello"'}, "k") == "hello"

    def test_returns_empty_for_missing_key(self):
        from backend.app.api.routes._spoolman_helpers import _extract_extra_str

        assert _extract_extra_str({}, "k") == ""

    def test_returns_empty_for_non_string_value(self):
        from backend.app.api.routes._spoolman_helpers import _extract_extra_str

        # Spoolman extra values are stringified; numeric values shouldn't sneak in
        # but if they do we treat them as unset rather than crashing
        assert _extract_extra_str({"k": 42}, "k") == ""

    def test_returns_empty_for_json_null(self):
        from backend.app.api.routes._spoolman_helpers import _extract_extra_str

        # null isn't a string after decode → treat as unset
        assert _extract_extra_str({"k": "null"}, "k") == ""

    def test_passes_through_bare_string_on_decode_error(self):
        from backend.app.api.routes._spoolman_helpers import _extract_extra_str

        # Tolerate non-JSON-encoded values
        assert _extract_extra_str({"k": "GFL05"}, "k") == "GFL05"


class TestMapSpoolmanSpoolPrice:
    """F4: NaN/Inf price in _map_spoolman_spool gives None cost_per_kg."""

    def test_nan_price_gives_none_cost_per_kg(self):
        import math

        from backend.app.api.routes._spoolman_helpers import _map_spoolman_spool

        spool = {**MINIMAL_SPOOL, "price": math.nan}
        assert _map_spoolman_spool(spool)["cost_per_kg"] is None

    def test_inf_price_gives_none_cost_per_kg(self):
        import math

        from backend.app.api.routes._spoolman_helpers import _map_spoolman_spool

        spool = {**MINIMAL_SPOOL, "price": math.inf}
        assert _map_spoolman_spool(spool)["cost_per_kg"] is None