Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/gateway/test_disk_status.py

@@ -0,0 +1,118 @@
+"""Tests for gateway.disk_status — the /api/status disk rollup (NS-656)."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import pytest
+
+from gateway import disk_status
+from gateway.disk_status import classify_disk_pressure, collect_disk_status
+
+_GB = 1024  # MB per GB, for readable fixtures
+
+
+class TestClassifyDiskPressure:
+    def test_plentiful_disk_is_ok(self) -> None:
+        # 40 GB free of 100 GB.
+        assert classify_disk_pressure(40 * _GB, 100 * _GB) == "ok"
+
+    def test_absolute_floor_is_critical_on_any_volume(self) -> None:
+        # 200 MB free — below the 256 MB floor even on a huge, low-percent
+        # volume would be impossible, so use a big volume mostly full.
+        assert classify_disk_pressure(200, 500 * _GB) == "critical"
+
+    def test_high_percent_with_low_headroom_is_critical(self) -> None:
+        # 96% used, 800 MB free (< 1 GB headroom) on a 20 GB volume.
+        assert classify_disk_pressure(800, 20 * _GB) == "critical"
+
+    def test_high_percent_with_ample_headroom_is_not_critical(self) -> None:
+        # 96% used but 20 GB free on a 500 GB volume — percent alone must
+        # not trigger critical when absolute headroom is comfortable.
+        assert classify_disk_pressure(20 * _GB, 500 * _GB) == "ok"
+
+    def test_low_free_is_elevated(self) -> None:
+        # 400 MB free of 4 GB (~90% used): below the 512 MB elevated floor,
+        # above the 256 MB critical floor, and under the 95% critical
+        # percent gate.
+        assert classify_disk_pressure(400, 4 * _GB) == "elevated"
+
+    def test_elevated_percent_band(self) -> None:
+        # 88% used, 2.4 GB free of 20 GB — elevated percent gate with
+        # headroom under 4 GB.
+        assert classify_disk_pressure(2400, 20 * _GB) == "elevated"
+
+    def test_elevated_percent_with_ample_headroom_is_ok(self) -> None:
+        # 90% used but 50 GB free of 500 GB.
+        assert classify_disk_pressure(50 * _GB, 500 * _GB) == "ok"
+
+    def test_missing_sample_is_unknown(self) -> None:
+        assert classify_disk_pressure(None, None) == "unknown"
+
+    def test_malformed_sample_is_unknown(self) -> None:
+        assert classify_disk_pressure("lots", 100) == "unknown"
+        assert classify_disk_pressure(True, 100) == "unknown"
+        assert classify_disk_pressure(-5, 100) == "unknown"
+        assert classify_disk_pressure(100, 0) == "unknown"
+
+
+class TestCollectDiskStatus:
+    def test_reports_real_usage(self, tmp_path: Path) -> None:
+        status = collect_disk_status(tmp_path)
+        assert status["pressure"] in {"ok", "elevated", "critical"}
+        assert isinstance(status["total_mb"], int) and status["total_mb"] > 0
+        assert isinstance(status["free_mb"], int) and status["free_mb"] >= 0
+        assert isinstance(status["used_percent"], float)
+        assert 0.0 <= status["used_percent"] <= 100.0
+
+    def test_unreadable_filesystem_degrades_to_unknown(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        def _boom(_path):  # noqa: ANN001, ANN202
+            raise OSError("statvfs failed")
+
+        monkeypatch.setattr(shutil, "disk_usage", _boom)
+        status = collect_disk_status(tmp_path)
+        assert status == {
+            "pressure": "unknown",
+            "total_mb": None,
+            "free_mb": None,
+            "used_percent": None,
+        }
+
+    def test_zero_total_degrades_to_unknown(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        fake = shutil._ntuple_diskusage(total=0, used=0, free=0)  # type: ignore[attr-defined]
+        monkeypatch.setattr(shutil, "disk_usage", lambda _p: fake)
+        status = collect_disk_status(tmp_path)
+        assert status["pressure"] == "unknown"
+        assert status["total_mb"] is None
+
+    def test_synthetic_full_volume_is_critical(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # 10 GB volume with 100 MB free — the OOF-2/OOF-107 state.
+        total = 10 * 1024**3
+        free = 100 * 1024**2
+        fake = shutil._ntuple_diskusage(  # type: ignore[attr-defined]
+            total=total, used=total - free, free=free
+        )
+        monkeypatch.setattr(shutil, "disk_usage", lambda _p: fake)
+        status = collect_disk_status(tmp_path)
+        assert status["pressure"] == "critical"
+        assert status["total_mb"] == 10 * 1024
+        assert status["free_mb"] == 100
+        assert status["used_percent"] == 99.0
+
+    def test_never_raises_even_without_home(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # Default-home resolution failing must degrade, not raise.
+        monkeypatch.setattr(
+            disk_status.shutil,
+            "disk_usage",
+            lambda _p: (_ for _ in ()).throw(PermissionError("nope")),
+        )
+        assert collect_disk_status(None)["pressure"] == "unknown"