mirror of
https://github.com/maziggy/bambuddy.git
synced 2026-09-30 19:21:33 +02:00
maziggy
1e08c25a9f
Two stacked causes under-reported multi-plate prints in the project
rollup and the archive card.
Root cause 1 - parser only read plate 1.
ThreeMFParser._parse_slice_info used root.find(".//plate") and pulled
prediction / weight from that one element. Any multi-plate file's
archive-level print_time_seconds / filament_used_grams reflected
plate 1 alone. The /plates endpoint already looped findall and was
correct, which is why the plate carousel showed the right numbers
while the archive card was wrong.
Fix: loop every <plate> and sum prediction + weight. Per-plate
concepts (plate_number, _plate_index, printable_objects) only set
when there's exactly one plate - for multi-plate exports the
archive represents all plates and a single index doesn't apply at
the file level. bed_type keeps the first plate's value as a
best-effort default. Malformed prediction / weight on individual
plates skip cleanly rather than poison the sum.
Root cause 2 - project rollup aggregated PrintArchive, not the
per-run log.
compute_project_stats and list_projects quick-stats summed
PrintArchive.print_time_seconds / filament_used_grams / cost /
energy_* WHERE project_id. A reprint reuses the source archive row
and writes a new PrintLogEntry, so 3 sequential runs collapsed to 1
archive - and that archive's numbers were already plate-1-only from
cause 1. The Archive Print Log path was already correct because it
drove off print_log_entries (archives.py:420 comment).
Fix: both compute_project_stats and the list_projects quick-stats
block inner-join print_log_entries -> print_archives WHERE
archives.project_id. total_archives becomes COUNT(PrintLogEntry.id),
failed_prints counts runs in failed/aborted/cancelled/stopped,
completed_items is SUM(PrintArchive.quantity) for runs where
status='completed', time/filament/cost/energy from PrintLogEntry.
Orphan log rows (archive_id IS NULL post archive deletion) are
excluded by the inner join.
Same-shape fixes carried forward (no follow-ups per project rule):
system.py system-info totals: total_print_time / total_filament
had the same bug shape - summed PrintArchive directly so reprints
collapsed to one row. Now sums PrintLogEntry.duration_seconds /
filament_used_grams. The semantic shift is also a correctness
improvement: the field now reflects time the printer actually spent
printing, not slicer-estimated time.
archives.py time-accuracy metric: estimate / actual per run where
estimate = PrintArchive.print_time_seconds. Post-parser-fix
multi-plate archives have file-level estimate but per-run actual =
one plate, so ratio = N x 100% for an N-plate file. The calc now
clamps each row to the [50%, 200%] plausibility band before
contributing to the printer-level average; single-plate accuracy
(the case the metric is designed for) stays fully included.
Backfill: users with AMS spool tracking - the reporter's case - have
per-run filament_used_grams from the tracked spool delta, so stats
become correct immediately. Users without tracking fall back to the
archive estimate and undercount until they reprint. Archive card
still reads PrintArchive.filament_used_grams directly so old
multi-plate archives keep plate-1-only numbers until reslice -
forward-only as the reporter accepted.
378 lines
15 KiB
Python
378 lines
15 KiB
Python
"""Integration tests for System API endpoints.
|
|
|
|
Tests the full request/response cycle for /api/v1/system/ endpoints.
|
|
"""
|
|
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
from httpx import AsyncClient
|
|
|
|
|
|
class TestSystemAPI:
|
|
"""Integration tests for /api/v1/system/ endpoints."""
|
|
|
|
# ========================================================================
|
|
# System Info Endpoint
|
|
# ========================================================================
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_get_system_info(self, async_client: AsyncClient):
|
|
"""Verify system info endpoint returns expected structure."""
|
|
# Mock psutil to avoid system-specific values
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
assert response.status_code == 200
|
|
result = response.json()
|
|
|
|
# Verify top-level structure
|
|
assert "app" in result
|
|
assert "database" in result
|
|
assert "printers" in result
|
|
assert "storage" in result
|
|
assert "system" in result
|
|
assert "memory" in result
|
|
assert "cpu" in result
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_app_section(self, async_client: AsyncClient):
|
|
"""Verify app section contains version and directory info."""
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
app_info = result["app"]
|
|
|
|
assert "version" in app_info
|
|
assert "base_dir" in app_info
|
|
assert "archive_dir" in app_info
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_database_section(self, async_client: AsyncClient):
|
|
"""Verify database section contains counts and statistics."""
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
db_info = result["database"]
|
|
|
|
assert "archives" in db_info
|
|
assert "archives_completed" in db_info
|
|
assert "archives_failed" in db_info
|
|
assert "printers" in db_info
|
|
assert "filaments" in db_info
|
|
assert "projects" in db_info
|
|
assert "smart_plugs" in db_info
|
|
assert "total_print_time_seconds" in db_info
|
|
assert "total_print_time_formatted" in db_info
|
|
assert "total_filament_grams" in db_info
|
|
assert "total_filament_kg" in db_info
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_storage_section(self, async_client: AsyncClient):
|
|
"""Verify storage section contains disk usage info."""
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
storage_info = result["storage"]
|
|
|
|
assert "archive_size_bytes" in storage_info
|
|
assert "archive_size_formatted" in storage_info
|
|
assert "database_size_bytes" in storage_info
|
|
assert "database_size_formatted" in storage_info
|
|
assert "disk_total_bytes" in storage_info
|
|
assert "disk_total_formatted" in storage_info
|
|
assert "disk_used_bytes" in storage_info
|
|
assert "disk_free_bytes" in storage_info
|
|
assert "disk_percent_used" in storage_info
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_memory_section(self, async_client: AsyncClient):
|
|
"""Verify memory section contains RAM usage info."""
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
memory_info = result["memory"]
|
|
|
|
assert "total_bytes" in memory_info
|
|
assert "total_formatted" in memory_info
|
|
assert "available_bytes" in memory_info
|
|
assert "used_bytes" in memory_info
|
|
assert "percent_used" in memory_info
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_cpu_section(self, async_client: AsyncClient):
|
|
"""Verify CPU section contains processor info."""
|
|
with patch("backend.app.api.routes.system.psutil") as mock_psutil:
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
cpu_info = result["cpu"]
|
|
|
|
assert "count" in cpu_info
|
|
assert "count_logical" in cpu_info
|
|
assert "percent" in cpu_info
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_printers_section(self, async_client: AsyncClient, printer_factory):
|
|
"""Verify printers section contains connected printer info."""
|
|
# Create a test printer
|
|
_printer = await printer_factory(name="Test Printer", model="X1C")
|
|
|
|
with (
|
|
patch("backend.app.api.routes.system.psutil") as mock_psutil,
|
|
patch("backend.app.api.routes.system.printer_manager") as mock_pm,
|
|
):
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
|
|
# Mock no connected printers for simplicity
|
|
mock_pm._clients = {}
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
printers_info = result["printers"]
|
|
|
|
assert "total" in printers_info
|
|
assert "connected" in printers_info
|
|
assert "connected_list" in printers_info
|
|
assert printers_info["total"] >= 1 # At least our test printer
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_system_info_with_archives(self, async_client: AsyncClient, printer_factory, archive_factory):
|
|
"""Verify database stats include archive counts.
|
|
|
|
Post-#1593 `total_print_time_seconds` is summed from
|
|
`PrintLogEntry.duration_seconds` (the *actual* per-run duration),
|
|
not `PrintArchive.print_time_seconds` (the slicer estimate). The
|
|
archive_factory derives the run's duration from
|
|
``completed_at - started_at`` on the archive, so the test sets
|
|
those so each run carries a duration the system route can sum.
|
|
"""
|
|
from datetime import datetime, timezone
|
|
|
|
printer = await printer_factory()
|
|
await archive_factory(
|
|
printer.id,
|
|
status="completed",
|
|
print_time_seconds=3600,
|
|
started_at=datetime(2026, 5, 1, 10, 0, tzinfo=timezone.utc),
|
|
completed_at=datetime(2026, 5, 1, 11, 0, tzinfo=timezone.utc),
|
|
)
|
|
await archive_factory(
|
|
printer.id,
|
|
status="failed",
|
|
print_time_seconds=1800,
|
|
started_at=datetime(2026, 5, 2, 10, 0, tzinfo=timezone.utc),
|
|
completed_at=datetime(2026, 5, 2, 10, 30, tzinfo=timezone.utc),
|
|
)
|
|
|
|
with (
|
|
patch("backend.app.api.routes.system.psutil") as mock_psutil,
|
|
patch("backend.app.api.routes.system.printer_manager") as mock_pm,
|
|
):
|
|
mock_psutil.disk_usage.return_value = MagicMock(
|
|
total=500000000000, used=250000000000, free=250000000000, percent=50.0
|
|
)
|
|
mock_psutil.virtual_memory.return_value = MagicMock(
|
|
total=16000000000, available=8000000000, used=8000000000, percent=50.0
|
|
)
|
|
mock_psutil.boot_time.return_value = 1700000000.0
|
|
mock_psutil.cpu_count.return_value = 4
|
|
mock_psutil.cpu_percent.return_value = 25.0
|
|
mock_pm._clients = {}
|
|
|
|
response = await async_client.get("/api/v1/system/info")
|
|
|
|
result = response.json()
|
|
db_info = result["database"]
|
|
|
|
assert db_info["archives"] >= 2
|
|
assert db_info["archives_completed"] >= 1
|
|
assert db_info["archives_failed"] >= 1
|
|
assert db_info["total_print_time_seconds"] >= 5400
|
|
|
|
|
|
class TestSystemHelperFunctions:
|
|
"""Tests for system info helper functions."""
|
|
|
|
def test_format_bytes_bytes(self):
|
|
"""Verify format_bytes handles bytes correctly."""
|
|
from backend.app.api.routes.system import format_bytes
|
|
|
|
assert format_bytes(500) == "500.0 B"
|
|
|
|
def test_format_bytes_kilobytes(self):
|
|
"""Verify format_bytes handles kilobytes correctly."""
|
|
from backend.app.api.routes.system import format_bytes
|
|
|
|
result = format_bytes(1536)
|
|
assert "KB" in result
|
|
|
|
def test_format_bytes_megabytes(self):
|
|
"""Verify format_bytes handles megabytes correctly."""
|
|
from backend.app.api.routes.system import format_bytes
|
|
|
|
result = format_bytes(1536 * 1024)
|
|
assert "MB" in result
|
|
|
|
def test_format_bytes_gigabytes(self):
|
|
"""Verify format_bytes handles gigabytes correctly."""
|
|
from backend.app.api.routes.system import format_bytes
|
|
|
|
result = format_bytes(1536 * 1024 * 1024)
|
|
assert "GB" in result
|
|
|
|
def test_format_uptime_minutes(self):
|
|
"""Verify format_uptime handles minutes correctly."""
|
|
from backend.app.api.routes.system import format_uptime
|
|
|
|
result = format_uptime(300) # 5 minutes
|
|
assert "5m" in result
|
|
|
|
def test_format_uptime_hours(self):
|
|
"""Verify format_uptime handles hours correctly."""
|
|
from backend.app.api.routes.system import format_uptime
|
|
|
|
result = format_uptime(7200) # 2 hours
|
|
assert "2h" in result
|
|
|
|
def test_format_uptime_days(self):
|
|
"""Verify format_uptime handles days correctly."""
|
|
from backend.app.api.routes.system import format_uptime
|
|
|
|
result = format_uptime(86400 * 2 + 3600 * 5) # 2 days 5 hours
|
|
assert "2d" in result
|
|
assert "5h" in result
|
|
|
|
def test_format_uptime_less_than_minute(self):
|
|
"""Verify format_uptime handles < 1 minute correctly."""
|
|
from backend.app.api.routes.system import format_uptime
|
|
|
|
result = format_uptime(30) # 30 seconds
|
|
assert result == "< 1m"
|
|
|
|
|
|
class TestSystemHealthAPI:
|
|
"""Integration tests for GET /api/v1/system/health (log-health scan)."""
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_health_clean_log(self, async_client: AsyncClient, tmp_path, monkeypatch):
|
|
"""A log with no known issues returns an empty, healthy result."""
|
|
from backend.app.core.config import settings
|
|
|
|
(tmp_path / "bambuddy.log").write_text(
|
|
"2026-05-22 10:00:00,000 INFO [backend.app.main] Application startup complete\n",
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setattr(settings, "log_dir", tmp_path)
|
|
|
|
response = await async_client.get("/api/v1/system/health")
|
|
|
|
assert response.status_code == 200
|
|
result = response.json()
|
|
assert result["log_available"] is True
|
|
assert result["findings"] == []
|
|
assert result["summary"]["total"] == 0
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.integration
|
|
async def test_health_detects_known_issue(self, async_client: AsyncClient, tmp_path, monkeypatch):
|
|
"""A known signature in the log surfaces as a finding."""
|
|
from backend.app.core.config import settings
|
|
|
|
(tmp_path / "bambuddy.log").write_text(
|
|
"2026-05-22 10:00:00,000 WARNING [backend.app.services.bambu_ftp] "
|
|
"FTP connection permission error to 10.0.0.9: 530\n",
|
|
encoding="utf-8",
|
|
)
|
|
monkeypatch.setattr(settings, "log_dir", tmp_path)
|
|
|
|
response = await async_client.get("/api/v1/system/health")
|
|
|
|
assert response.status_code == 200
|
|
result = response.json()
|
|
ids = [f["signature_id"] for f in result["findings"]]
|
|
assert "ftp-auth-rejected" in ids
|
|
assert result["summary"]["layer8"] >= 1
|