public_git/bambuddy
1
0
Fork 0
mirror of https://github.com/maziggy/bambuddy.git synced 2026-10-09 07:25:44 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
c145b3ebc19446fdbea9437cac16882fa7a5433d
bambuddy/backend/tests/unit/services/test_bambu_mqtt.py
T
maziggy 033eff1254 Show Bambu's own HMS descriptions and the real alert level (issue #2728) 
Document HMS levels, Bambu's descriptions and uncounted faults (issue #2728)
2026-09-28 13:57:02 +02:00

8331 lines
347 KiB
Python
Raw Blame History

"""
Tests for the BambuMQTTClient service.
These tests focus on timelapse tracking during prints.
"""
import asyncio
import json
import logging
import time
from unittest.mock import MagicMock
import pytest
class TestTimelapseTracking:
"""Tests for timelapse state tracking during prints."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_timelapse_flag_initializes_to_false(self, mqtt_client):
"""Verify _timelapse_during_print starts as False."""
assert mqtt_client._timelapse_during_print is False
def test_timelapse_flag_set_when_timelapse_active_during_running(self, mqtt_client):
"""Verify timelapse flag is set when timelapse is active while printing."""
# Simulate print running
mqtt_client._was_running = True
mqtt_client.state.timelapse = False
# Simulate xcam data showing timelapse is enabled
xcam_data = {"timelapse": "enable"}
mqtt_client._parse_xcam_data(xcam_data)
assert mqtt_client.state.timelapse is True
assert mqtt_client._timelapse_during_print is True
def test_timelapse_flag_not_set_when_not_running(self, mqtt_client):
"""Verify timelapse flag is NOT set when printer not running."""
# Printer is idle (not running)
mqtt_client._was_running = False
mqtt_client.state.timelapse = False
# Timelapse is enabled but we're not printing
xcam_data = {"timelapse": "enable"}
mqtt_client._parse_xcam_data(xcam_data)
assert mqtt_client.state.timelapse is True
# Flag should NOT be set since we're not printing
assert mqtt_client._timelapse_during_print is False
def test_timelapse_flag_persists_after_timelapse_stops(self, mqtt_client):
"""Verify timelapse flag stays True even after recording stops."""
# Simulate print running with timelapse
mqtt_client._was_running = True
# Enable timelapse during print
xcam_data = {"timelapse": "enable"}
mqtt_client._parse_xcam_data(xcam_data)
assert mqtt_client._timelapse_during_print is True
# Disable timelapse (recording stops at end of print)
xcam_data = {"timelapse": "disable"}
mqtt_client._parse_xcam_data(xcam_data)
# Flag should still be True (persists until reset)
assert mqtt_client.state.timelapse is False
assert mqtt_client._timelapse_during_print is True
def test_timelapse_flag_from_print_data(self, mqtt_client):
"""Verify timelapse flag is set from print data (not just xcam)."""
# Simulate print running
mqtt_client._was_running = True
mqtt_client.state.timelapse = False
mqtt_client._timelapse_during_print = False
# Manually test the timelapse parsing logic from _parse_print_data
# This tests the "timelapse" field in the main print data
data = {"timelapse": True}
mqtt_client.state.timelapse = data["timelapse"] is True
if mqtt_client.state.timelapse and mqtt_client._was_running:
mqtt_client._timelapse_during_print = True
assert mqtt_client._timelapse_during_print is True
class TestPrintCompletionWithTimelapse:
"""Tests for print completion including timelapse flag."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_print_complete_includes_timelapse_flag(self, mqtt_client):
"""Verify print complete callback includes timelapse_was_active."""
# Set up completion callback
callback_data = {}
def on_complete(data):
callback_data.update(data)
mqtt_client.on_print_complete = on_complete
# Simulate a print that had timelapse active
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client._timelapse_during_print = True
mqtt_client._previous_gcode_state = "RUNNING"
mqtt_client._previous_gcode_file = "test.gcode"
mqtt_client.state.subtask_name = "Test Print"
# Simulate print finish
mqtt_client.state.state = "FINISH"
# Manually trigger the completion logic (simplified)
# In real code this happens in _parse_print_data
should_trigger = (
mqtt_client.state.state in ("FINISH", "FAILED")
and not mqtt_client._completion_triggered
and mqtt_client.on_print_complete
and mqtt_client._previous_gcode_state == "RUNNING"
)
if should_trigger:
status = "completed" if mqtt_client.state.state == "FINISH" else "failed"
timelapse_was_active = mqtt_client._timelapse_during_print
mqtt_client._completion_triggered = True
mqtt_client._was_running = False
mqtt_client._timelapse_during_print = False
mqtt_client.on_print_complete(
{
"status": status,
"filename": mqtt_client._previous_gcode_file,
"subtask_name": mqtt_client.state.subtask_name,
"timelapse_was_active": timelapse_was_active,
}
)
assert "timelapse_was_active" in callback_data
assert callback_data["timelapse_was_active"] is True
def test_print_complete_timelapse_flag_false_when_no_timelapse(self, mqtt_client):
"""Verify timelapse_was_active is False when no timelapse during print."""
callback_data = {}
def on_complete(data):
callback_data.update(data)
mqtt_client.on_print_complete = on_complete
# Print without timelapse
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client._timelapse_during_print = False # No timelapse
mqtt_client._previous_gcode_state = "RUNNING"
mqtt_client._previous_gcode_file = "test.gcode"
mqtt_client.state.subtask_name = "Test Print"
mqtt_client.state.state = "FINISH"
# Trigger completion
timelapse_was_active = mqtt_client._timelapse_during_print
mqtt_client.on_print_complete(
{
"status": "completed",
"filename": mqtt_client._previous_gcode_file,
"subtask_name": mqtt_client.state.subtask_name,
"timelapse_was_active": timelapse_was_active,
}
)
assert callback_data["timelapse_was_active"] is False
def test_timelapse_flag_reset_after_completion(self, mqtt_client):
"""Verify _timelapse_during_print is reset after print completion."""
mqtt_client._timelapse_during_print = True
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
# Simulate completion reset
mqtt_client._completion_triggered = True
mqtt_client._was_running = False
mqtt_client._timelapse_during_print = False
assert mqtt_client._timelapse_during_print is False
class TestRealisticMessageFlow:
"""Tests that simulate realistic MQTT message sequences.
These tests process messages through _process_message to test the full flow,
including the order of xcam parsing vs state detection.
"""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_timelapse_detected_at_print_start_in_same_message(self, mqtt_client):
"""Test that timelapse is detected when xcam and state come in same message.
This is the critical race condition test - xcam data is parsed BEFORE
state detection, so the timelapse flag must be set AFTER _was_running is True.
"""
# Callbacks to track events
start_callback_data = {}
def on_start(data):
start_callback_data.update(data)
mqtt_client.on_print_start = on_start
# Initial state - idle
mqtt_client._was_running = False
mqtt_client._timelapse_during_print = False
mqtt_client._previous_gcode_state = None
# Simulate first message when print starts - contains both xcam and gcode_state
# This is the realistic scenario from the printer
# NOTE: Real MQTT messages wrap print data inside a "print" key
payload = {
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
"xcam": {
"timelapse": "enable", # Timelapse is enabled in this print
"printing_monitor": True,
},
"mc_percent": 0,
"mc_remaining_time": 3600,
}
}
# Process the message (this is what happens in real MQTT flow)
mqtt_client._process_message(payload)
# Verify timelapse was detected even though xcam is parsed before state
assert mqtt_client._was_running is True, "_was_running should be True after RUNNING state"
assert mqtt_client.state.timelapse is True, "state.timelapse should be True"
assert mqtt_client._timelapse_during_print is True, (
"timelapse_during_print should be True when timelapse is in the same message as RUNNING state"
)
def test_timelapse_not_detected_when_disabled(self, mqtt_client):
"""Test that timelapse is NOT detected when disabled in xcam data."""
mqtt_client.on_print_start = lambda data: None
# Initial state - idle
mqtt_client._was_running = False
mqtt_client._timelapse_during_print = False
mqtt_client._previous_gcode_state = None
# Print starts without timelapse
payload = {
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
"xcam": {
"timelapse": "disable", # Timelapse is disabled
"printing_monitor": True,
},
}
}
mqtt_client._process_message(payload)
assert mqtt_client._was_running is True
assert mqtt_client.state.timelapse is False
assert mqtt_client._timelapse_during_print is False
def test_timelapse_detected_when_enabled_after_print_start(self, mqtt_client):
"""Test timelapse detected when enabled in a message after print starts."""
mqtt_client.on_print_start = lambda data: None
# First message - print starts without timelapse info
payload_start = {
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
}
}
mqtt_client._process_message(payload_start)
assert mqtt_client._was_running is True
assert mqtt_client._timelapse_during_print is False # Not detected yet
# Second message - xcam data arrives with timelapse enabled
payload_xcam = {
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
"xcam": {
"timelapse": "enable",
},
}
}
mqtt_client._process_message(payload_xcam)
# Now timelapse should be detected because _was_running is already True
assert mqtt_client._timelapse_during_print is True
def test_print_complete_includes_timelapse_flag_full_flow(self, mqtt_client):
"""Test full print lifecycle with timelapse - from start to completion."""
start_data = {}
complete_data = {}
def on_start(data):
start_data.update(data)
def on_complete(data):
complete_data.update(data)
mqtt_client.on_print_start = on_start
mqtt_client.on_print_complete = on_complete
# Seed a prior state so the first RUNNING push is treated as a real
# state transition rather than a Bambuddy-restart catch-up (#1304).
mqtt_client._previous_gcode_state = "IDLE"
# 1. Print starts with timelapse
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
"xcam": {"timelapse": "enable"},
}
}
)
assert mqtt_client._timelapse_during_print is True
assert "subtask_name" in start_data
# 2. Print continues (multiple messages)
for _ in range(3):
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
"mc_percent": 50,
}
}
)
# Timelapse flag should still be True
assert mqtt_client._timelapse_during_print is True
# 3. Print completes
mqtt_client._process_message(
{
"print": {
"gcode_state": "FINISH",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
# Verify completion callback received timelapse flag
assert "timelapse_was_active" in complete_data
assert complete_data["timelapse_was_active"] is True
assert complete_data["status"] == "completed"
# Flags should be reset after completion
assert mqtt_client._timelapse_during_print is False
assert mqtt_client._was_running is False
def test_print_failed_includes_timelapse_flag(self, mqtt_client):
"""Test that failed print also includes timelapse flag."""
complete_data = {}
def on_complete(data):
complete_data.update(data)
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = on_complete
# Start with timelapse
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
"xcam": {"timelapse": "enable"},
}
}
)
# Print fails
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
assert complete_data["timelapse_was_active"] is True
assert complete_data["status"] == "failed"
class TestPrePrintFailureCompletion:
"""Tests for completion detection when the print errors before reaching RUNNING (#1111).
Common trigger: a file sliced for the wrong nozzle diameter is dispatched. The
printer transitions IDLE -> PREPARE -> FAILED without ever entering RUNNING, so
the legacy completion detection (which required _previous_gcode_state == 'RUNNING'
or _was_running == True) left the queue item stuck at 'printing' forever.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def test_prepare_to_failed_triggers_completion(self, mqtt_client):
"""PREPARE -> FAILED must fire on_print_complete (wrong nozzle size etc.)."""
complete_data = {}
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = lambda data: complete_data.update(data)
mqtt_client._previous_gcode_state = "PREPARE"
mqtt_client._was_running = False
mqtt_client._completion_triggered = False
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"gcode_file": "/data/Metadata/plate_1.gcode",
"subtask_name": "WrongNozzle",
}
}
)
assert complete_data.get("status") == "failed"
def test_slicing_to_failed_triggers_completion(self, mqtt_client):
"""SLICING -> FAILED also treated as a pre-print failure."""
complete_data = {}
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = lambda data: complete_data.update(data)
mqtt_client._previous_gcode_state = "SLICING"
mqtt_client._was_running = False
mqtt_client._completion_triggered = False
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"gcode_file": "/data/Metadata/plate_1.gcode",
"subtask_name": "WrongNozzle",
}
}
)
assert complete_data.get("status") == "failed"
def test_initial_failed_does_not_trigger_completion(self, mqtt_client):
"""First message arriving with FAILED (no prior state) must NOT fire completion.
Protects against a stale FAILED on reconnect being mistaken for a fresh failure
and marking an unrelated queue item as failed.
"""
calls = []
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = lambda data: calls.append(data)
assert mqtt_client._previous_gcode_state is None
assert mqtt_client._was_running is False
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"gcode_file": "/data/Metadata/plate_1.gcode",
"subtask_name": "Stale",
}
}
)
assert calls == []
def test_idle_to_failed_does_not_trigger_completion(self, mqtt_client):
"""IDLE -> FAILED (no print ever dispatched) must NOT fire completion."""
calls = []
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = lambda data: calls.append(data)
mqtt_client._previous_gcode_state = "IDLE"
mqtt_client._was_running = False
mqtt_client._completion_triggered = False
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"subtask_name": "Stale",
}
}
)
assert calls == []
def test_prepare_to_failed_includes_hms_errors_in_callback(self, mqtt_client):
"""Pre-print FAILED callback should carry the current HMS error list so the
queue handler can populate a meaningful error_message."""
complete_data = {}
mqtt_client.on_print_start = lambda data: None
mqtt_client.on_print_complete = lambda data: complete_data.update(data)
mqtt_client._previous_gcode_state = "PREPARE"
mqtt_client._was_running = False
# Message carries HMS data for a nozzle-size mismatch (0500_4038) and the
# PREPARE -> FAILED gcode_state transition in a single update.
mqtt_client._process_message(
{
"print": {
"gcode_state": "FAILED",
"gcode_file": "/data/Metadata/plate_1.gcode",
"hms": [{"attr": 0x05000000, "code": 0x4038}],
}
}
)
assert complete_data.get("status") == "failed"
errs = complete_data.get("hms_errors") or []
assert any(e.get("code") == "0x4038" for e in errs)
class TestAMSDataMerging:
"""Tests for AMS data merging, particularly handling empty slots."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_empty_slot_clears_tray_type(self, mqtt_client):
"""Test that empty slot update clears tray_type (Issue #147).
When a spool is removed from an old AMS, the printer sends empty values.
These must overwrite the previous values to show the slot as empty.
"""
# Initial state: AMS unit with a loaded spool
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{
"id": 0,
"tray_type": "PLA",
"tray_sub_brands": "Bambu PLA Basic",
"tray_color": "FF0000",
"tag_uid": "1234567890ABCDEF",
"remain": 80,
}
],
}
]
}
mqtt_client._handle_ams_data(initial_ams)
# Verify initial state
ams_data = mqtt_client.state.raw_data.get("ams", [])
assert len(ams_data) == 1
tray = ams_data[0]["tray"][0]
assert tray["tray_type"] == "PLA"
assert tray["tray_color"] == "FF0000"
# Now simulate spool removal - printer sends empty values
empty_update = {
"ams": [
{
"id": 0,
"tray": [
{
"id": 0,
"tray_type": "", # Empty = slot is empty
"tray_sub_brands": "",
"tray_color": "",
"tag_uid": "0000000000000000", # Zero UID
"remain": 0,
}
],
}
]
}
mqtt_client._handle_ams_data(empty_update)
# Verify empty values were applied (not ignored by merge logic)
ams_data = mqtt_client.state.raw_data.get("ams", [])
tray = ams_data[0]["tray"][0]
assert tray["tray_type"] == "", "tray_type should be cleared when slot is empty"
assert tray["tray_color"] == "", "tray_color should be cleared when slot is empty"
assert tray["tray_sub_brands"] == "", "tray_sub_brands should be cleared"
assert tray["tag_uid"] == "0000000000000000", "tag_uid should be cleared"
def test_bitmask_only_ht_removal_fires_on_ams_change(self, mqtt_client):
"""#2670: an AMS-HT whose spool is removed can be signalled by
tray_exist_bits alone while the firmware keeps echoing the stale
tray_type/tag_uid/remain in the tray payload. apply_tray_exist_bits
clears the merged slot, but a change-hash built from the RAW payload
never flips (the echoed fields are unchanged), so on_ams_change would
not fire and the spool_assignment row would stay bound to an empty slot.
Hashing the MERGED state fixes it.
"""
from unittest.mock import Mock
mqtt_client.on_ams_change = Mock()
# Loaded HT-A: bit 16 set (0x10000). Fires once as the initial state.
loaded = {
"ams": [{"id": 128, "tray": [{"id": 0, "tray_type": "PLA", "tag_uid": "C7EFC10300000100", "remain": 75}]}],
"tray_exist_bits": "10000",
"power_on_flag": True,
}
mqtt_client._handle_ams_data(loaded)
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["tray_type"] == "PLA"
mqtt_client.on_ams_change.reset_mock()
# Removal signalled ONLY by the bitmask: bit 16 now clear, but the tray
# payload STILL echoes the same PLA/tag/remain — a raw-based hash would
# be byte-identical to the loaded push above and never fire.
bitmask_only_removal = {
"ams": [{"id": 128, "tray": [{"id": 0, "tray_type": "PLA", "tag_uid": "C7EFC10300000100", "remain": 75}]}],
"tray_exist_bits": "0",
"power_on_flag": True,
}
mqtt_client._handle_ams_data(bitmask_only_removal)
# Merged slot cleared, and the callback fired off the merged-state hash.
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["tray_type"] == ""
mqtt_client.on_ams_change.assert_called_once()
def test_partial_update_preserves_other_fields(self, mqtt_client):
"""Test that partial updates still preserve non-slot-status fields."""
# Initial state with full data
initial_ams = {
"ams": [
{
"id": 0,
"humidity": "3",
"temp": "25.5",
"tray": [
{
"id": 0,
"tray_type": "PLA",
"tray_color": "00FF00",
"remain": 90,
"k": 0.02,
}
],
}
]
}
mqtt_client._handle_ams_data(initial_ams)
# Partial update - only remain changes
partial_update = {
"ams": [
{
"id": 0,
"tray": [
{
"id": 0,
"remain": 85, # Only this changed
}
],
}
]
}
mqtt_client._handle_ams_data(partial_update)
# Verify remain was updated but other fields preserved
ams_data = mqtt_client.state.raw_data.get("ams", [])
tray = ams_data[0]["tray"][0]
assert tray["remain"] == 85, "remain should be updated"
assert tray["tray_type"] == "PLA", "tray_type should be preserved"
assert tray["tray_color"] == "00FF00", "tray_color should be preserved"
assert tray["k"] == 0.02, "k should be preserved"
def test_tray_exist_bits_clears_empty_slots(self, mqtt_client):
"""Test that tray_exist_bits clears slots marked as empty (Issue #147).
New AMS models (AMS 2 Pro) don't send empty tray data when a spool is removed.
Instead, they update tray_exist_bits to indicate which slots have spools.
"""
# Initial state: AMS 0 and AMS 1 with loaded spools
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000", "remain": 80},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00", "remain": 60},
{"id": 2, "tray_type": "ABS", "tray_color": "0000FF", "remain": 40},
{"id": 3, "tray_type": "TPU", "tray_color": "FFFF00", "remain": 20},
],
},
{
"id": 1,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FFFFFF", "remain": 90},
{"id": 1, "tray_type": "PLA", "tray_color": "000000", "remain": 70},
{"id": 2, "tray_type": "PLA", "tray_color": "FF00FF", "remain": 50},
{"id": 3, "tray_type": "PLA", "tray_color": "00FFFF", "remain": 30},
],
},
],
"tray_exist_bits": "ff", # All 8 slots have spools (0xFF = 11111111)
}
mqtt_client._handle_ams_data(initial_ams)
# Verify initial state
ams_data = mqtt_client.state.raw_data.get("ams", [])
assert ams_data[1]["tray"][3]["tray_type"] == "PLA" # AMS 1 slot 3 (B4) has spool
# Now simulate spool removal from AMS 1 slot 3 (B4)
# tray_exist_bits: 0x7f = 01111111 (bit 7 = 0 means AMS 1 slot 3 is empty)
update_ams = {
"ams": [
{"id": 0, "tray": [{"id": 0}, {"id": 1}, {"id": 2}, {"id": 3}]},
{"id": 1, "tray": [{"id": 0}, {"id": 1}, {"id": 2}, {"id": 3}]},
],
"tray_exist_bits": "7f", # Bit 7 = 0 -> AMS 1 slot 3 is empty
}
mqtt_client._handle_ams_data(update_ams)
# Verify AMS 1 slot 3 was cleared
ams_data = mqtt_client.state.raw_data.get("ams", [])
b4_tray = ams_data[1]["tray"][3]
assert b4_tray["tray_type"] == "", "tray_type should be cleared for empty slot"
assert b4_tray["remain"] == 0, "remain should be 0 for empty slot"
# Verify other slots are preserved
assert ams_data[0]["tray"][0]["tray_type"] == "PLA", "A1 should still have PLA"
assert ams_data[1]["tray"][0]["tray_type"] == "PLA", "B1 should still have PLA"
def test_tray_exist_bits_promotes_empty_slot_to_state_9(self, mqtt_client):
"""#1322 follow-up by @RosdasHH: the previous fix only caught the bare
{"id": N} payload firmware sends right after a printer restart. In
steady-state operation firmware sends a populated payload and signals
emptiness via tray_exist_bits — the canonical BambuStudio detection.
The bitmask handler now promotes empty slots to state=9 so the rest
of the app (API serializer, inventory short-circuit, AMS card) sees
one signal instead of guessing from payload shape.
State must be int 9, not "9" — `tray_state in {9, 10}` downstream
uses `==` comparison and would silently miss a string.
"""
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000", "state": 11, "remain": 80},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00", "state": 11, "remain": 60},
],
}
],
"tray_exist_bits": "3", # both slots occupied (0b11)
}
mqtt_client._handle_ams_data(initial_ams)
# Slot 1 goes empty — populated payload, only the bitmask says so.
update_ams = {
"ams": [{"id": 0, "tray": [{"id": 0}, {"id": 1}]}],
"tray_exist_bits": "1", # slot 1 now empty (0b01)
}
mqtt_client._handle_ams_data(update_ams)
slot1 = mqtt_client.state.raw_data["ams"][0]["tray"][1]
assert slot1["state"] == 9, "empty-by-bitmask slot must report state=9"
assert isinstance(slot1["state"], int), "state must be int for downstream == comparison"
# Loaded slot keeps its firmware state unchanged.
slot0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert slot0["state"] == 11, "loaded slot must keep its firmware state"
def test_tray_exist_bits_does_not_change_state_on_loaded_slots(self, mqtt_client):
"""Belt and suspenders for the negative path: the new state=9
promotion must fire ONLY when the bitmask bit is 0. A loaded slot
with state=3 (or any other non-9 firmware value) must pass through
untouched, or we'd corrupt every printer that sends transitional
states like 'unloading'."""
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000", "state": 3, "remain": 80},
],
}
],
"tray_exist_bits": "1", # slot occupied
}
mqtt_client._handle_ams_data(initial_ams)
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["state"] == 3
def test_shutdown_message_preserves_ams_data(self, mqtt_client):
"""Printer shutdown (power_on_flag=False) must not wipe AMS slot data (#765).
When a printer shuts down it sends a final MQTT message with
tray_exist_bits='0' and power_on_flag=False. This all-zero value
previously caused every slot to be cleared, which then triggered
auto-unlink of all spool assignments on reconnect.
"""
# Initial state: two AMS units with loaded spools
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF", "remain": 80},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00FF", "remain": 60},
],
},
{
"id": 1,
"tray": [
{"id": 0, "tray_type": "PETG", "tray_color": "DBDDD9FF", "remain": 90},
{"id": 1, "tray_type": "PETG", "tray_color": "67DB25FF", "remain": 70},
],
},
],
"tray_exist_bits": "33", # Slots 0,1 of each AMS (0b00110011)
"power_on_flag": True,
}
mqtt_client._handle_ams_data(initial_ams)
# Verify initial state
ams_data = mqtt_client.state.raw_data["ams"]
assert ams_data[0]["tray"][0]["tray_type"] == "PLA"
assert ams_data[1]["tray"][0]["tray_type"] == "PETG"
# Simulate printer shutdown — all-zero bits with power_on_flag=False
shutdown_ams = {
"ams_exist_bits": "0",
"tray_exist_bits": "0",
"power_on_flag": False,
"insert_flag": False,
"tray_now": "0",
"version": 0,
}
mqtt_client._handle_ams_data(shutdown_ams)
# AMS slot data MUST be preserved — shutdown should not clear it
ams_data = mqtt_client.state.raw_data["ams"]
assert ams_data[0]["tray"][0]["tray_type"] == "PLA", "Shutdown must not clear AMS 0 slot 0"
assert ams_data[0]["tray"][0]["tray_color"] == "FF0000FF", "Shutdown must not clear AMS 0 slot 0 color"
assert ams_data[0]["tray"][1]["tray_type"] == "PETG", "Shutdown must not clear AMS 0 slot 1"
assert ams_data[1]["tray"][0]["tray_type"] == "PETG", "Shutdown must not clear AMS 1 slot 0"
assert ams_data[1]["tray"][1]["tray_type"] == "PETG", "Shutdown must not clear AMS 1 slot 1"
def test_genuine_removal_still_clears_with_power_on(self, mqtt_client):
"""Genuine spool removal (power_on_flag=True) must still clear slot data.
Ensures the #765 fix doesn't break normal spool removal detection.
"""
# Initial state: AMS with loaded spool
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000", "remain": 80},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00", "remain": 60},
],
},
],
"tray_exist_bits": "3", # Both slots occupied (0b11)
"power_on_flag": True,
}
mqtt_client._handle_ams_data(initial_ams)
# Spool removed from slot 1 while printer is running
removal_ams = {
"ams": [
{
"id": 0,
"tray": [{"id": 0}, {"id": 1}],
},
],
"tray_exist_bits": "1", # Only slot 0 occupied (0b01)
"power_on_flag": True,
}
mqtt_client._handle_ams_data(removal_ams)
# Slot 0 preserved, slot 1 cleared
ams_data = mqtt_client.state.raw_data["ams"]
assert ams_data[0]["tray"][0]["tray_type"] == "PLA", "Slot 0 should be preserved"
assert ams_data[0]["tray"][1]["tray_type"] == "", "Slot 1 should be cleared on removal"
assert ams_data[0]["tray"][1]["tray_color"] == "", "Slot 1 color should be cleared"
def test_power_on_flag_defaults_true_when_absent(self, mqtt_client):
"""When power_on_flag is not in the MQTT data, clearing must proceed normally.
Ensures backwards compatibility with firmware that doesn't send power_on_flag.
"""
# Initial state
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000", "remain": 80},
],
},
],
"tray_exist_bits": "1",
}
mqtt_client._handle_ams_data(initial_ams)
# Update WITHOUT power_on_flag — should still clear when bit=0
update_ams = {
"ams": [{"id": 0, "tray": [{"id": 0}]}],
"tray_exist_bits": "0",
# No power_on_flag key at all
}
mqtt_client._handle_ams_data(update_ams)
ams_data = mqtt_client.state.raw_data["ams"]
assert ams_data[0]["tray"][0]["tray_type"] == "", (
"Without power_on_flag, clearing should proceed (defaults to True)"
)
def test_idle_printer_with_power_off_and_nonzero_bits_clears_removed_slot(self, mqtt_client):
"""Spool removal on an idle X1C must be detected even when power_on_flag=False (#1365).
On some X1C firmware (e.g. 01.08.02.00 reported by an3k) the AMS keeps
publishing push_status with `power_on_flag: False` while the printer
sits idle between prints — but `tray_exist_bits` continues to reflect
the real slot inventory. The original #765 guard skipped clearing
whenever power_on_flag was false, so the bit transition that would
mark a slot empty was discarded and the only way to refresh state
was a manual reconnect (pushall). The guard now skips clearing only
on the exact shutdown pattern (zero bits + power_on_flag=False).
"""
# Initial state: two AMS units, slot 1 of AMS 0 loaded (the one
# we'll later remove).
initial_ams = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF", "remain": 80},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00FF", "remain": 60},
],
},
{
"id": 1,
"tray": [
{"id": 0, "tray_type": "PETG", "tray_color": "DBDDD9FF", "remain": 90},
],
},
],
"tray_exist_bits": "13", # 0b00010011 — AMS0 slots 0+1, AMS1 slot 0
"power_on_flag": True,
}
mqtt_client._handle_ams_data(initial_ams)
assert mqtt_client.state.raw_data["ams"][0]["tray"][1]["tray_type"] == "PETG"
# Spool pulled from AMS 0 slot 1 while the printer is idle.
# tray_exist_bits goes from 0x13 -> 0x11, but firmware still reports
# power_on_flag=False because the printer is between prints. The real
# push_status payloads on the affected X1C still carry the full `ams`
# list (matches the bug-report log) — the slot inventory shrinks via
# the bitfield rather than via per-tray content updates.
removal_ams = {
"ams": [
{"id": 0, "tray": [{"id": 0}, {"id": 1}]},
{"id": 1, "tray": [{"id": 0}]},
],
"tray_exist_bits": "11", # 0b00010001 — slot 1 now empty
"power_on_flag": False,
"insert_flag": True,
}
mqtt_client._handle_ams_data(removal_ams)
ams_data = mqtt_client.state.raw_data["ams"]
assert ams_data[0]["tray"][1]["tray_type"] == "", (
"Removal must be detected even with power_on_flag=False when bits are non-zero (#1365)"
)
assert ams_data[0]["tray"][1]["tray_color"] == "", "Removed slot color must be cleared"
# Other slots untouched.
assert ams_data[0]["tray"][0]["tray_type"] == "PLA", "AMS0 slot 0 preserved"
assert ams_data[1]["tray"][0]["tray_type"] == "PETG", "AMS1 slot 0 preserved"
class TestAMSTrayStateClearning:
"""Tests for AMS tray state-based clearing (#784).
Some printers (e.g. H2D) only send {id, state} in incremental MQTT
updates when a tray is not fully loaded. state=11 means loaded;
other values (9=empty, 10=spool present but filament not in feeder)
should clear stale tray data that was set from an earlier pushall.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_H2D",
access_code="12345678",
)
return client
def _seed_loaded_tray(self, mqtt_client):
"""Seed AMS 0 with a fully loaded tray (state=11) and an empty slot."""
initial = {
"ams": [
{
"id": 0,
"tray": [
{
"id": 0,
"tray_type": "PETG",
"tray_sub_brands": "PETG HF",
"tray_color": "00FF00FF",
"tray_id_name": "A00-G1",
"tray_info_idx": "GFG99",
"tag_uid": "AABBCCDD11223344",
"tray_uuid": "AABBCCDD11223344AABBCCDD11223344",
"remain": 75,
"k": 0.02,
"cali_idx": 5,
"state": 11,
},
{
"id": 1,
"tray_type": "PLA",
"tray_color": "FF0000FF",
"remain": 50,
"state": 11,
},
],
}
],
"power_on_flag": False, # H2D always sends False
}
mqtt_client._handle_ams_data(initial)
ams = mqtt_client.state.raw_data["ams"]
assert ams[0]["tray"][0]["tray_type"] == "PETG"
assert ams[0]["tray"][1]["tray_type"] == "PLA"
def test_state_10_clears_stale_tray_data(self, mqtt_client):
"""Incremental update with state=10 (spool present, not loaded) clears tray."""
self._seed_loaded_tray(mqtt_client)
# H2D sends only {id, state} when filament is retracted
update = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "state": 10},
{"id": 1, "state": 11}, # slot 1 still loaded
],
}
],
"power_on_flag": False,
}
mqtt_client._handle_ams_data(update)
ams = mqtt_client.state.raw_data["ams"]
tray0 = ams[0]["tray"][0]
tray1 = ams[0]["tray"][1]
# Tray 0 should be cleared
assert tray0["tray_type"] == "", "tray_type must be cleared on state=10"
assert tray0["tray_color"] == "", "tray_color must be cleared"
assert tray0["tray_sub_brands"] == "", "tray_sub_brands must be cleared"
assert tray0["tray_id_name"] == "", "tray_id_name must be cleared"
assert tray0["tray_info_idx"] == "", "tray_info_idx must be cleared"
assert tray0["tag_uid"] == "0000000000000000", "tag_uid must be cleared"
assert tray0["tray_uuid"] == "00000000000000000000000000000000", "tray_uuid must be cleared"
assert tray0["remain"] == 0, "remain must be 0"
assert tray0["k"] is None, "k must be cleared"
assert tray0["cali_idx"] is None, "cali_idx must be cleared"
assert tray0["state"] == 10, "state should be preserved"
# Tray 1 should be untouched
assert tray1["tray_type"] == "PLA", "Loaded slot must be preserved"
assert tray1["remain"] == 50
def test_state_9_clears_stale_tray_data(self, mqtt_client):
"""Incremental update with state=9 (empty, no spool) clears tray."""
self._seed_loaded_tray(mqtt_client)
update = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "state": 9},
{"id": 1, "state": 11},
],
}
],
"power_on_flag": False,
}
mqtt_client._handle_ams_data(update)
tray0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert tray0["tray_type"] == "", "state=9 must clear tray_type"
assert tray0["remain"] == 0
def test_state_11_preserves_tray_data(self, mqtt_client):
"""Incremental update with state=11 (loaded) must NOT clear tray."""
self._seed_loaded_tray(mqtt_client)
update = {
"ams": [
{
"id": 0,
"tray": [
{"id": 0, "state": 11},
{"id": 1, "state": 11},
],
}
],
"power_on_flag": False,
}
mqtt_client._handle_ams_data(update)
tray0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert tray0["tray_type"] == "PETG", "state=11 must preserve tray data"
assert tray0["tray_color"] == "00FF00FF"
assert tray0["remain"] == 75
def test_no_clearing_when_tray_type_already_empty(self, mqtt_client):
"""Don't re-clear a tray that's already empty (avoids log spam)."""
self._seed_loaded_tray(mqtt_client)
# First unload clears
update = {
"ams": [{"id": 0, "tray": [{"id": 0, "state": 10}, {"id": 1, "state": 11}]}],
"power_on_flag": False,
}
mqtt_client._handle_ams_data(update)
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["tray_type"] == ""
# Second identical update should not trigger clearing again
# (merged_tray.get("tray_type") is already empty/falsy)
mqtt_client._handle_ams_data(update)
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["tray_type"] == ""
def test_reload_after_unload_restores_data(self, mqtt_client):
"""After clearing via state=10, a full update with state=11 restores data."""
self._seed_loaded_tray(mqtt_client)
# Unload
mqtt_client._handle_ams_data(
{
"ams": [{"id": 0, "tray": [{"id": 0, "state": 10}, {"id": 1, "state": 11}]}],
"power_on_flag": False,
}
)
assert mqtt_client.state.raw_data["ams"][0]["tray"][0]["tray_type"] == ""
# Reload — full tray data arrives again
mqtt_client._handle_ams_data(
{
"ams": [
{
"id": 0,
"tray": [
{
"id": 0,
"tray_type": "PETG",
"tray_sub_brands": "PETG HF",
"tray_color": "00FF00FF",
"remain": 75,
"state": 11,
},
{"id": 1, "state": 11},
],
}
],
"power_on_flag": False,
}
)
tray0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert tray0["tray_type"] == "PETG", "Reload must restore tray data"
assert tray0["tray_color"] == "00FF00FF"
assert tray0["remain"] == 75
def _seed_loaded_ht_tray(self, mqtt_client):
"""Seed an AMS-HT unit (id 128, single tray) whose loaded tray reports
state=9 — the real HT resting state, unlike a 4-slot AMS's state=11."""
initial = {
"ams": [
{
"id": 128,
"tray": [
{
"id": 0,
"tray_type": "PA",
"tray_color": "161616FF",
"tray_info_idx": "GFG99",
"tag_uid": "AABBCCDD11223344",
"tray_uuid": "AABBCCDD11223344AABBCCDD11223344",
"remain": 60,
"state": 9,
}
],
}
],
"power_on_flag": True,
}
mqtt_client._handle_ams_data(initial)
def test_ht_unit_state_9_preserves_tray_data(self, mqtt_client):
"""#2594: an AMS-HT reports its loaded tray as state=9. A partial
{id, state=9} for the HT unit must NOT be read as 'empty' and wipe the
present spool — that made the HT-A spool vanish on every power-on."""
self._seed_loaded_ht_tray(mqtt_client)
# Printer sends a partial {id, state} for the HT tray on power-on.
update = {
"ams": [{"id": 128, "tray": [{"id": 0, "state": 9}]}],
"power_on_flag": True,
}
mqtt_client._handle_ams_data(update)
tray0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert tray0["tray_type"] == "PA", "HT state=9 must NOT clear a present spool (#2594)"
assert tray0["tray_uuid"] == "AABBCCDD11223344AABBCCDD11223344", "HT RFID must survive"
assert tray0["remain"] == 60
def test_ht_unit_explicit_empty_still_clears(self, mqtt_client):
"""A genuine HT spool removal (explicit tray_type='') must still clear —
the #2594 fix only skips the state-heuristic, not the explicit path."""
self._seed_loaded_ht_tray(mqtt_client)
update = {
"ams": [{"id": 128, "tray": [{"id": 0, "tray_type": ""}]}],
"power_on_flag": False,
}
mqtt_client._handle_ams_data(update)
tray0 = mqtt_client.state.raw_data["ams"][0]["tray"][0]
assert tray0["tray_type"] == "", "explicit tray_type='' must still clear an HT tray"
class TestApplyTrayExistBitsHelper:
"""Direct contract pinning for the shared ``apply_tray_exist_bits`` helper.
The same logic is exercised end-to-end via ``_handle_ams_data`` in the
internal-state suite and via ``_on_printer_raw`` in the bridge suite,
but those go through the merge / cache layers — the helper itself
deserves direct coverage so future refactors don't silently change
the contract both callers depend on (#1726).
"""
def test_returns_zero_on_missing_bits(self):
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "tray_type": "PLA"}]}]
assert apply_tray_exist_bits(units, None) == 0
assert apply_tray_exist_bits(units, "") == 0
# Untouched.
assert units[0]["tray"][0]["tray_type"] == "PLA"
def test_returns_zero_on_unparseable_bits(self):
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "tray_type": "PLA"}]}]
assert apply_tray_exist_bits(units, "garbage") == 0
assert units[0]["tray"][0]["tray_type"] == "PLA"
def test_shutdown_guard_zero_bits_with_power_off_skips(self):
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF"}]}]
cleared = apply_tray_exist_bits(units, "0", power_on_flag=False)
assert cleared == 0
# Slot preserved — wiping here would propagate phantom empties on
# every printer-off push.
assert units[0]["tray"][0]["tray_type"] == "PLA"
def test_zero_bits_with_power_on_still_clears(self):
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF"}]}]
cleared = apply_tray_exist_bits(units, "0", power_on_flag=True)
# Slot is genuinely empty per the printer's report.
assert cleared == 1
assert units[0]["tray"][0]["state"] == 9
assert units[0]["tray"][0]["tray_type"] == ""
def test_nonzero_bits_with_power_off_still_clears_removed_slot(self):
"""#1365: X1C reports power_on_flag=False between prints while the
AMS keeps reporting its actual slot inventory. The guard must skip
ONLY the all-zero + power-off combination, not nonzero + power-off.
"""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [
{
"id": 0,
"tray": [
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000FF"},
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00FF"},
],
}
]
# 0x1 = slot 0 loaded, slot 1 empty. Power off (steady-state idle).
cleared = apply_tray_exist_bits(units, "1", power_on_flag=False)
assert cleared == 1
assert units[0]["tray"][0]["tray_type"] == "PLA"
assert units[0]["tray"][1]["tray_type"] == ""
def test_promotes_state_to_int_nine(self):
"""Downstream `tray_state in {9, 10}` uses `==` — int 9, not "9"."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "state": "11"}]}]
apply_tray_exist_bits(units, "0", power_on_flag=True)
assert units[0]["tray"][0]["state"] == 9
assert isinstance(units[0]["tray"][0]["state"], int)
def test_ams_ht_unit_now_handled_not_skipped(self):
"""AMS-HT (id 128-135) is no longer skipped: it uses its own bit at
16+(ams_id-128). With all bits 0 the HT slot clears like any other
(#2670 — the old skip left the HT permanently stale). See the dedicated
HT bit-math tests below for the encoding."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 128, "tray": [{"id": 0, "tray_type": "PLA"}]}]
cleared = apply_tray_exist_bits(units, "0", power_on_flag=True)
assert cleared == 1
assert units[0]["tray"][0]["tray_type"] == ""
def test_string_ids_handled(self):
"""Bridge cache stores ids as strings (JSON wire format)."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [
{
"id": "0",
"tray": [
{"id": "0", "tray_type": "PLA"},
{"id": "1", "tray_type": "PETG"},
],
}
]
# 0x1 = bit 0 set (slot 0), bit 1 clear (slot 1 empty).
cleared = apply_tray_exist_bits(units, "1", power_on_flag=True)
assert cleared == 1
assert units[0]["tray"][0]["tray_type"] == "PLA"
assert units[0]["tray"][1]["tray_type"] == ""
def test_multi_ams_global_bit_math(self):
"""global_bit = ams_id * 4 + tray_id. Verify AMS 1 slots use
bits 4-7 of the mask, not bits 0-3."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [
{"id": 0, "tray": [{"id": i, "tray_type": "PLA"} for i in range(4)]},
{"id": 1, "tray": [{"id": i, "tray_type": "PETG"} for i in range(4)]},
]
# 0x0f: all slots of AMS 0 loaded, all slots of AMS 1 empty.
cleared = apply_tray_exist_bits(units, "f", power_on_flag=True)
assert cleared == 4
for i in range(4):
assert units[0]["tray"][i]["tray_type"] == "PLA"
assert units[1]["tray"][i]["tray_type"] == ""
def test_state_promoted_even_when_no_stale_data(self):
"""Slot without `tray_type` still gets state=9 — the bitmask is
authoritative, the field wipe just avoids extra log lines.
"""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "state": "11"}]}]
cleared = apply_tray_exist_bits(units, "0", power_on_flag=True)
# No tray_type to clear → cleared counter stays 0 but state is set.
assert cleared == 0
assert units[0]["tray"][0]["state"] == 9
def test_annotate_exists_marks_present_and_absent(self):
"""#2527: annotate_exists writes the tray_exist_bits presence bit onto
every slot so a non-RFID spool (present, no tray_type) is distinguishable
from a truly-empty slot. 0x5 = slots 0,2 present; slots 1,3 absent."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": i} for i in range(4)]}]
apply_tray_exist_bits(units, "5", power_on_flag=True, annotate_exists=True)
exists = [t["exists"] for t in units[0]["tray"]]
assert exists == [True, False, True, False]
def test_annotate_exists_present_unknown_slot_not_cleared(self):
"""A present slot with no tray_type (fresh non-RFID spool) keeps its
state and is marked exists=True — the UI then shows "?" not "Empty"."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
# 0x1 = slot 0 present. Slot 0 has no tray_type (unidentified spool).
units = [{"id": 0, "tray": [{"id": 0, "state": 9}]}]
cleared = apply_tray_exist_bits(units, "1", power_on_flag=True, annotate_exists=True)
assert cleared == 0
assert units[0]["tray"][0]["exists"] is True
# Present slot is left untouched (only absent slots get state=9 forced).
assert units[0]["tray"][0]["state"] == 9
def test_annotate_exists_off_by_default_keeps_wire_clean(self):
"""The VP bridge calls this without annotate_exists, so the slicer-facing
tray dict must NOT gain a non-standard `exists` key."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 0, "tray": [{"id": 0, "tray_type": "PLA"}, {"id": 1}]}]
apply_tray_exist_bits(units, "1", power_on_flag=True)
assert "exists" not in units[0]["tray"][0]
assert "exists" not in units[0]["tray"][1]
def test_ht_unit_presence_bit_is_16_not_ams_id_times_4(self):
"""#2670: AMS-HT (n3s, id 128) is single-tray; its presence bit is
16+(ams_id-128)=bit 16, NOT ams_id*4 (=512, which the old code skipped
outright, so the HT slot never cleared). Real H2D capture: loaded HT-A
reports tray_exist_bits 0x10f7f (bit 16 set); after unload it reports
0xf7f (bit 16 clear). Verified against OrcaSlicer DevFilaSystem.cpp."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
# Loaded (bit 16 set) → slot preserved, exists=True.
loaded = [{"id": 128, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "000000FF"}]}]
assert apply_tray_exist_bits(loaded, "10f7f", power_on_flag=False, annotate_exists=True) == 0
assert loaded[0]["tray"][0]["tray_type"] == "PLA"
assert loaded[0]["tray"][0]["exists"] is True
# Empty (bit 16 clear) → slot cleared, state forced to 9, exists=False.
empty = [{"id": 128, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "000000FF"}]}]
assert apply_tray_exist_bits(empty, "f7f", power_on_flag=False, annotate_exists=True) == 1
assert empty[0]["tray"][0]["tray_type"] == ""
assert empty[0]["tray"][0]["state"] == 9
assert empty[0]["tray"][0]["exists"] is False
def test_ht_second_unit_is_bit_17_not_bit_20(self):
"""#2670: multiple AMS-HT units pack into CONSECUTIVE bits — HT-A=16,
HT-B=17 — NOT the 4-strided bit 20 a naive ams_id*4-style extrapolation
would give. This pins the exact encoding OrcaSlicer uses and guards every
dual-HT printer. 0x20000 sets ONLY bit 17: a bit-20 implementation would
wrongly clear this loaded HT-B."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 129, "tray": [{"id": 0, "tray_type": "PETG", "tray_color": "00FF00FF"}]}]
assert apply_tray_exist_bits(units, "20000", power_on_flag=False, annotate_exists=True) == 0
assert units[0]["tray"][0]["tray_type"] == "PETG"
assert units[0]["tray"][0]["exists"] is True
def test_ht_dual_unit_clears_only_the_empty_one(self):
"""HT-A loaded + HT-B empty in one push, disambiguated by their
consecutive bits. 0x10000 = bit 16 only → HT-A (128) present, HT-B
(129, bit 17) empty."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [
{"id": 128, "tray": [{"id": 0, "tray_type": "PLA"}]},
{"id": 129, "tray": [{"id": 0, "tray_type": "PETG"}]},
]
assert apply_tray_exist_bits(units, "10000", power_on_flag=False, annotate_exists=True) == 1
assert units[0]["tray"][0]["tray_type"] == "PLA" # HT-A present
assert units[0]["tray"][0]["exists"] is True
assert units[1]["tray"][0]["tray_type"] == "" # HT-B cleared
assert units[1]["tray"][0]["exists"] is False
def test_ht_and_regular_ams_use_their_own_formulas_together(self):
"""Regular AMS keeps ams_id*4+tray_id while HT uses 16+(ams_id-128) in a
single call. bits 0x1 = regular AMS0 slot0 present (bit 0); HT-A empty
(bit 16 clear)."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [
{"id": 0, "tray": [{"id": 0, "tray_type": "PLA"}]},
{"id": 128, "tray": [{"id": 0, "tray_type": "ASA"}]},
]
assert apply_tray_exist_bits(units, "1", power_on_flag=True, annotate_exists=True) == 1
assert units[0]["tray"][0]["tray_type"] == "PLA" # regular AMS0 slot0 (bit 0) present
assert units[0]["tray"][0]["exists"] is True
assert units[1]["tray"][0]["tray_type"] == "" # HT-A (bit 16) empty
assert units[1]["tray"][0]["exists"] is False
def test_unknown_ams_id_range_is_left_untouched(self):
"""An id outside regular (0-15) and HT (128-135) has no known bit layout
— the helper must NOT guess a bit and must NOT clear the slot."""
from backend.app.services.bambu_mqtt import apply_tray_exist_bits
units = [{"id": 200, "tray": [{"id": 0, "tray_type": "PLA"}]}]
assert apply_tray_exist_bits(units, "0", power_on_flag=True, annotate_exists=True) == 0
assert units[0]["tray"][0]["tray_type"] == "PLA"
assert "exists" not in units[0]["tray"][0]
class TestNozzleRackData:
"""Tests for nozzle rack data parsing from H2 series device.nozzle.info."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_h2c_nozzle_rack_populated_with_8_entries(self, mqtt_client):
"""H2C provides 8 nozzle entries: IDs 0,1 (L/R hotend) + 16-21 (rack)."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{
"id": 0,
"type": "HS",
"diameter": "0.4",
"wear": 5,
"stat": 1,
"max_temp": 300,
"serial_number": "SN-L",
},
{
"id": 1,
"type": "HS",
"diameter": "0.4",
"wear": 3,
"stat": 0,
"max_temp": 300,
"serial_number": "SN-R",
},
{
"id": 16,
"type": "HS",
"diameter": "0.4",
"wear": 10,
"stat": 0,
"max_temp": 300,
"serial_number": "SN-16",
},
{
"id": 17,
"type": "HH01",
"diameter": "0.6",
"wear": 0,
"stat": 0,
"max_temp": 300,
"serial_number": "SN-17",
},
{
"id": 18,
"type": "HS",
"diameter": "0.4",
"wear": 2,
"stat": 0,
"max_temp": 300,
"serial_number": "SN-18",
},
{
"id": 19,
"type": "",
"diameter": "",
"wear": None,
"stat": None,
"max_temp": 0,
"serial_number": "",
},
{
"id": 20,
"type": "",
"diameter": "",
"wear": None,
"stat": None,
"max_temp": 0,
"serial_number": "",
},
{
"id": 21,
"type": "",
"diameter": "",
"wear": None,
"stat": None,
"max_temp": 0,
"serial_number": "",
},
]
}
}
}
}
mqtt_client._process_message(payload)
assert len(mqtt_client.state.nozzle_rack) == 8
ids = [n["id"] for n in mqtt_client.state.nozzle_rack]
assert ids == [0, 1, 16, 17, 18, 19, 20, 21]
def test_h2d_nozzle_rack_populated_with_2_entries(self, mqtt_client):
"""H2D provides 2 nozzle entries: IDs 0,1 (L/R hotend) — no rack slots."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{
"id": 0,
"type": "HS",
"diameter": "0.4",
"wear": 5,
"stat": 1,
"max_temp": 300,
"serial_number": "SN-L",
},
{
"id": 1,
"type": "HS",
"diameter": "0.4",
"wear": 3,
"stat": 1,
"max_temp": 300,
"serial_number": "SN-R",
},
]
}
}
}
}
mqtt_client._process_message(payload)
assert len(mqtt_client.state.nozzle_rack) == 2
ids = [n["id"] for n in mqtt_client.state.nozzle_rack]
assert ids == [0, 1]
def test_single_nozzle_h2s_populated(self, mqtt_client):
"""H2S provides 1 nozzle entry: ID 0 only — single nozzle printer."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{
"id": 0,
"type": "HS",
"diameter": "0.4",
"wear": 2,
"stat": 1,
"max_temp": 300,
"serial_number": "SN-0",
},
]
}
}
}
}
mqtt_client._process_message(payload)
assert len(mqtt_client.state.nozzle_rack) == 1
assert mqtt_client.state.nozzle_rack[0]["id"] == 0
def test_empty_nozzle_info_does_not_populate_rack(self, mqtt_client):
"""Empty nozzle info list should not populate nozzle_rack."""
payload = {"print": {"device": {"nozzle": {"info": []}}}}
mqtt_client._process_message(payload)
assert mqtt_client.state.nozzle_rack == []
def test_nozzle_rack_sorted_by_id(self, mqtt_client):
"""Nozzle rack entries should be sorted by ID regardless of input order."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{"id": 17, "type": "HS", "diameter": "0.6"},
{"id": 0, "type": "HS", "diameter": "0.4"},
{"id": 16, "type": "HS", "diameter": "0.4"},
{"id": 1, "type": "HS", "diameter": "0.4"},
]
}
}
}
}
mqtt_client._process_message(payload)
ids = [n["id"] for n in mqtt_client.state.nozzle_rack]
assert ids == [0, 1, 16, 17]
def test_nozzle_rack_field_mapping(self, mqtt_client):
"""Verify field mapping from MQTT nozzle_info to nozzle_rack dict keys."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{
"id": 16,
"type": "HH01",
"diameter": "0.6",
"wear": 15,
"stat": 0,
"max_temp": 320,
"serial_number": "SN-ABC123",
"filament_colour": "FF8800",
"filament_id": "F42",
"tray_type": "ABS",
}
]
}
}
}
}
mqtt_client._process_message(payload)
slot = mqtt_client.state.nozzle_rack[0]
assert slot["id"] == 16
assert slot["type"] == "HH01"
assert slot["diameter"] == "0.6"
assert slot["wear"] == 15
assert slot["stat"] == 0
assert slot["max_temp"] == 320
assert slot["serial_number"] == "SN-ABC123"
assert slot["filament_color"] == "FF8800"
assert slot["filament_id"] == "F42"
assert slot["filament_type"] == "ABS"
def test_nozzle_info_updates_nozzle_state(self, mqtt_client):
"""Nozzle info for IDs 0,1 should also update nozzle state (type/diameter)."""
payload = {
"print": {
"device": {
"nozzle": {
"info": [
{"id": 0, "type": "HS", "diameter": "0.4"},
{"id": 1, "type": "HH01", "diameter": "0.6"},
]
}
}
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.nozzles[0].nozzle_type == "HS"
assert mqtt_client.state.nozzles[0].nozzle_diameter == "0.4"
assert mqtt_client.state.nozzles[1].nozzle_type == "HH01"
assert mqtt_client.state.nozzles[1].nozzle_diameter == "0.6"
class TestRequestTopicFailSafe:
"""Tests for graceful degradation when broker rejects request topic subscription."""
@pytest.fixture(autouse=True)
def clear_request_topic_cache(self):
"""Clear class-level cache before each test to avoid cross-test pollution."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
BambuMQTTClient._request_topic_cache.clear()
BambuMQTTClient._request_topic_probe_failures.clear()
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_request_topic_supported_by_default(self, mqtt_client):
"""Request topic subscription is attempted by default."""
assert mqtt_client._request_topic_supported is True
assert mqtt_client._request_topic_confirmed is False
def test_on_subscribe_confirms_success(self, mqtt_client):
"""Successful SUBACK marks request topic as confirmed."""
from paho.mqtt.reasoncodes import ReasonCode
mqtt_client._request_topic_sub_mid = 42
rc = ReasonCode(9, identifier=0) # SUBACK packetType=9, QoS 0 = success
mqtt_client._on_subscribe(None, None, 42, [rc], None)
assert mqtt_client._request_topic_confirmed is True
assert mqtt_client._request_topic_supported is True
assert mqtt_client._request_topic_sub_mid is None
assert mqtt_client._request_topic_sub_time == 0.0
def test_on_subscribe_detects_rejection(self, mqtt_client):
"""SUBACK with failure code disables request topic."""
from paho.mqtt.reasoncodes import ReasonCode
mqtt_client._request_topic_sub_mid = 42
rc = ReasonCode(9, identifier=0x80) # SUBACK packetType=9, 0x80 = failure
mqtt_client._on_subscribe(None, None, 42, [rc], None)
assert mqtt_client._request_topic_supported is False
assert mqtt_client._request_topic_confirmed is False
def test_on_subscribe_ignores_other_mids(self, mqtt_client):
"""SUBACK for other subscriptions (e.g. report topic) is ignored."""
from paho.mqtt.reasoncodes import ReasonCode
mqtt_client._request_topic_sub_mid = 42
rc = ReasonCode(9, identifier=0x80)
mqtt_client._on_subscribe(None, None, 99, [rc], None)
# Not affected — mid doesn't match
assert mqtt_client._request_topic_supported is True
def test_disconnect_after_subscription_disables_topic(self, mqtt_client):
"""Repeated disconnects within 10s of a subscription attempt disable the
request topic.
One is not enough (#2953). Any drop inside the window looks the same as
the broker refusing the topic, so the first is treated as circumstantial
and the subscription is retried on the next connection. A printer that
really does refuse answers the same way every time.
"""
import time
mqtt_client._request_topic_sub_time = time.time()
mqtt_client._request_topic_confirmed = False
mqtt_client._last_message_time = 0.0
mqtt_client._on_disconnect(None, None)
assert mqtt_client._request_topic_supported is True
assert mqtt_client._request_topic_sub_time == 0.0
mqtt_client._request_topic_sub_time = time.time()
mqtt_client._on_disconnect(None, None)
assert mqtt_client._request_topic_supported is False
assert mqtt_client._request_topic_sub_time == 0.0
def test_disconnect_after_confirmation_does_not_disable(self, mqtt_client):
"""Disconnect after SUBACK confirmation keeps request topic enabled."""
import time
mqtt_client._request_topic_sub_time = time.time()
mqtt_client._request_topic_confirmed = True
mqtt_client._last_message_time = 0.0
mqtt_client._on_disconnect(None, None)
assert mqtt_client._request_topic_supported is True
def test_late_disconnect_does_not_disable(self, mqtt_client):
"""Disconnect long after subscription (>10s) doesn't blame request topic."""
import time
mqtt_client._request_topic_sub_time = time.time() - 30.0
mqtt_client._request_topic_confirmed = False
mqtt_client._last_message_time = 0.0
mqtt_client._on_disconnect(None, None)
assert mqtt_client._request_topic_supported is True
def test_on_connect_skips_request_topic_when_unsupported(self, mqtt_client):
"""After marking unsupported, reconnect skips request topic subscription."""
mqtt_client._request_topic_supported = False
subscribe_calls = []
mock_client = type(
"MockClient",
(),
{
"subscribe": lambda self, topic: subscribe_calls.append(topic) or (0, 1),
},
)()
mqtt_client._on_connect(mock_client, None, None, 0)
# Only report topic subscribed, not request topic
assert len(subscribe_calls) == 1
assert subscribe_calls[0] == mqtt_client.topic_subscribe
def test_cache_persists_across_instances(self):
"""New client instance inherits request topic unsupported state from cache."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client1 = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_CACHE",
access_code="12345678",
)
assert client1._request_topic_supported is True
# Simulate disconnect-after-subscribe disabling the topic. Takes two
# (#2953) — the first drop is not treated as an answer.
client1._request_topic_confirmed = False
client1._last_message_time = 0.0
for _ in range(BambuMQTTClient._REQUEST_TOPIC_PROBE_LIMIT):
client1._request_topic_sub_time = __import__("time").time()
client1._on_disconnect(None, None)
assert client1._request_topic_supported is False
# New instance for same serial should inherit the cached state
client2 = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_CACHE",
access_code="12345678",
)
assert client2._request_topic_supported is False
def test_cache_does_not_affect_different_serial(self):
"""Cache is per-serial — different printer is unaffected."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
BambuMQTTClient._request_topic_cache["SERIAL_A"] = False
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="SERIAL_B",
access_code="12345678",
)
assert client._request_topic_supported is True
def test_cache_updated_on_suback_success(self):
"""Successful SUBACK caches positive confirmation."""
from paho.mqtt.reasoncodes import ReasonCode
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_SUBACK",
access_code="12345678",
)
client._request_topic_sub_mid = 42
rc = ReasonCode(9, identifier=0) # Success
client._on_subscribe(None, None, 42, [rc], None)
assert BambuMQTTClient._request_topic_cache["TEST_SUBACK"] is True
def test_cache_updated_on_suback_rejection(self):
"""SUBACK rejection caches negative state."""
from paho.mqtt.reasoncodes import ReasonCode
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_REJECT",
access_code="12345678",
)
client._request_topic_sub_mid = 42
rc = ReasonCode(9, identifier=0x80) # Failure
client._on_subscribe(None, None, 42, [rc], None)
assert BambuMQTTClient._request_topic_cache["TEST_REJECT"] is False
class TestRequestTopicIsCaptured:
"""The MQTT debug log has to show commands going *to* the printer.
Bambuddy subscribes to the request topic as well as the report topic, so
every command the printer is given crosses this client -- ours echoed back
by the broker, and whatever Bambu Studio sends. Those messages used to
return from _on_message before the logging block, which left a capture able
to prove only what the printer said and never what it was told. Answering
"what does Studio put in this field?" from a user's log depends on it
(#2774).
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client.enable_logging(True)
return client
@staticmethod
def _deliver(client, topic, payload):
class _Msg:
pass
msg = _Msg()
msg.topic = topic
msg.payload = json.dumps(payload).encode()
client._on_message(None, None, msg)
def test_a_command_on_the_request_topic_is_logged(self, mqtt_client):
payload = {
"print": {
"command": "ams_filament_drying",
"ams_id": 128,
"temp": 45,
"duration": 12,
"filament": "PLA",
}
}
self._deliver(mqtt_client, mqtt_client.topic_publish, payload)
logs = mqtt_client.get_logs()
assert len(logs) == 1
assert logs[0].topic == mqtt_client.topic_publish
# Filed with the commands rather than with telemetry: the direction
# filter is how someone finds what was sent to the printer.
assert logs[0].direction == "out"
assert logs[0].payload == payload
def test_the_payload_is_kept_whole(self, mqtt_client):
"""The point of the capture is the fields we don't parse."""
payload = {"print": {"command": "ams_filament_drying", "unparsed_field": "keep me"}}
self._deliver(mqtt_client, mqtt_client.topic_publish, payload)
assert mqtt_client.get_logs()[0].payload["print"]["unparsed_field"] == "keep me"
def test_request_topic_messages_are_still_parsed(self, mqtt_client):
"""Logging is additive -- the ams_mapping capture must survive it."""
self._deliver(
mqtt_client,
mqtt_client.topic_publish,
{"print": {"command": "project_file", "ams_mapping": [0, 4, -1, -1]}},
)
assert mqtt_client._captured_ams_mapping == [0, 4, -1, -1]
assert len(mqtt_client.get_logs()) == 1
def test_nothing_is_logged_while_logging_is_off(self, mqtt_client):
mqtt_client.enable_logging(False)
self._deliver(
mqtt_client,
mqtt_client.topic_publish,
{"print": {"command": "project_file", "ams_mapping": [0, -1, -1, -1]}},
)
assert mqtt_client.get_logs() == []
assert mqtt_client._captured_ams_mapping == [0, -1, -1, -1]
def test_the_report_topic_is_still_logged_as_incoming(self, mqtt_client):
"""Telemetry keeps its direction -- the two must stay distinguishable."""
self._deliver(mqtt_client, mqtt_client.topic_subscribe, {"print": {"gcode_state": "IDLE"}})
logs = mqtt_client.get_logs()
assert len(logs) == 1
assert logs[0].direction == "in"
class TestRequestTopicAmsMapping:
"""Tests for capturing ams_mapping from the MQTT request topic."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_captured_ams_mapping_initializes_to_none(self, mqtt_client):
"""Verify _captured_ams_mapping starts as None."""
assert mqtt_client._captured_ams_mapping is None
def test_handle_request_message_captures_ams_mapping(self, mqtt_client):
"""project_file command with ams_mapping stores the mapping."""
data = {
"print": {
"command": "project_file",
"ams_mapping": [0, 4, -1, -1],
"url": "ftp://192.168.1.100/test.3mf",
}
}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping == [0, 4, -1, -1]
def test_handle_request_message_ignores_non_print_commands(self, mqtt_client):
"""Non-project_file commands don't store ams_mapping."""
data = {
"print": {
"command": "pause",
}
}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping is None
def test_handle_request_message_ignores_missing_ams_mapping(self, mqtt_client):
"""project_file command without ams_mapping doesn't store anything."""
data = {
"print": {
"command": "project_file",
"url": "ftp://192.168.1.100/test.3mf",
}
}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping is None
def test_handle_request_message_ignores_non_dict_print(self, mqtt_client):
"""Non-dict print value is safely ignored."""
data = {"print": "not_a_dict"}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping is None
def test_handle_request_message_ignores_missing_print(self, mqtt_client):
"""Message without print key is safely ignored."""
data = {"pushing": {"command": "pushall"}}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping is None
def test_captured_mapping_overwrites_previous(self, mqtt_client):
"""A new print command overwrites a previously captured mapping."""
mqtt_client._captured_ams_mapping = [0, -1, -1, -1]
data = {
"print": {
"command": "project_file",
"ams_mapping": [4, 8, -1, -1],
}
}
mqtt_client._handle_request_message(data)
assert mqtt_client._captured_ams_mapping == [4, 8, -1, -1]
def test_print_start_callback_includes_ams_mapping(self, mqtt_client):
"""on_print_start callback data includes captured ams_mapping."""
start_data = {}
def on_start(data):
start_data.update(data)
mqtt_client.on_print_start = on_start
mqtt_client._captured_ams_mapping = [0, 4, -1, -1]
# Seed a prior state so the first RUNNING push is treated as a real
# state transition rather than a Bambuddy-restart catch-up (#1304).
mqtt_client._previous_gcode_state = "IDLE"
# Trigger print start
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
assert start_data.get("ams_mapping") == [0, 4, -1, -1]
def test_print_start_callback_ams_mapping_none_when_not_captured(self, mqtt_client):
"""on_print_start callback has ams_mapping=None when no mapping captured."""
start_data = {}
def on_start(data):
start_data.update(data)
mqtt_client.on_print_start = on_start
# Seed a prior state so the first RUNNING push is treated as a real
# state transition rather than a Bambuddy-restart catch-up (#1304).
mqtt_client._previous_gcode_state = "IDLE"
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
assert "ams_mapping" in start_data
assert start_data["ams_mapping"] is None
def test_first_running_push_after_bambuddy_restart_does_not_fire_print_start(self, mqtt_client):
"""Regression for #1304: Bambuddy restart mid-print misfired plate check + archive.
When Bambuddy restarts while a print is already in progress, the freshly
constructed BambuMQTTClient has `_previous_gcode_state = None`. The first
push_status the printer sends reports `gcode_state: RUNNING`. Before the
fix, the (None → RUNNING) transition satisfied is_new_print's guard and
fired on_print_start, which then ran plate detection (objects on plate →
paused the live print) AND re-archived the file (duplicate archive).
With the fix in place the on_print_start callback must NOT be called for
this catch-up push, but `_was_running` still tracks the print so
completion detection works the same way as before.
"""
start_data = {}
def on_start(data):
start_data.update(data)
mqtt_client.on_print_start = on_start
# Explicit: this simulates a fresh Bambuddy process attaching to a
# printer that's already in the middle of a print.
mqtt_client._previous_gcode_state = None
mqtt_client._was_running = False
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/big_print.gcode",
"subtask_name": "big_print",
}
}
)
assert start_data == {}, "on_print_start must not fire on Bambuddy-restart catch-up"
# Completion detection still needs to know we're tracking a running job.
assert mqtt_client._was_running is True
# And the state-update bookkeeping ran so the NEXT push won't keep
# treating the first RUNNING as fresh.
assert mqtt_client._previous_gcode_state == "RUNNING"
def test_print_complete_callback_includes_ams_mapping(self, mqtt_client):
"""on_print_complete callback data includes captured ams_mapping."""
complete_data = {}
def on_complete(data):
complete_data.update(data)
mqtt_client.on_print_start = lambda d: None
mqtt_client.on_print_complete = on_complete
mqtt_client._captured_ams_mapping = [0, 9, -1, -1]
# Start print
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
# Complete print
mqtt_client._process_message(
{
"print": {
"gcode_state": "FINISH",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
assert complete_data.get("ams_mapping") == [0, 9, -1, -1]
def test_captured_mapping_cleared_after_print_complete(self, mqtt_client):
"""_captured_ams_mapping is reset to None after print completion."""
mqtt_client.on_print_start = lambda d: None
mqtt_client.on_print_complete = lambda d: None
mqtt_client._captured_ams_mapping = [0, 4, -1, -1]
# Start print
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
# Complete print
mqtt_client._process_message(
{
"print": {
"gcode_state": "FINISH",
"gcode_file": "/data/Metadata/test.gcode",
"subtask_name": "Test",
}
}
)
assert mqtt_client._captured_ams_mapping is None
def test_full_flow_capture_and_deliver(self, mqtt_client):
"""Full flow: slicer sends print command → MQTT captures mapping → completion delivers it."""
complete_data = {}
def on_complete(data):
complete_data.update(data)
mqtt_client.on_print_start = lambda d: None
mqtt_client.on_print_complete = on_complete
# 1. Slicer sends print command (captured from request topic)
mqtt_client._handle_request_message(
{
"print": {
"command": "project_file",
"ams_mapping": [4, 9, -1, -1],
"url": "ftp://192.168.1.100/model.3mf",
}
}
)
assert mqtt_client._captured_ams_mapping == [4, 9, -1, -1]
# 2. Printer reports RUNNING
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/model.gcode",
"subtask_name": "Model",
}
}
)
# 3. Printer reports FINISH
mqtt_client._process_message(
{
"print": {
"gcode_state": "FINISH",
"gcode_file": "/data/Metadata/model.gcode",
"subtask_name": "Model",
}
}
)
assert complete_data["ams_mapping"] == [4, 9, -1, -1]
assert complete_data["status"] == "completed"
# Mapping cleared after completion
assert mqtt_client._captured_ams_mapping is None
# ---------------------------------------------------------------------------
# tray_now disambiguation helpers
# ---------------------------------------------------------------------------
def _ams_payload(tray_now, ams_units=None, tray_exist_bits=None, ams_exist_bits=None):
"""Build minimal print.ams payload for tray_now disambiguation tests."""
ams = {"tray_now": str(tray_now)}
if ams_units is not None:
ams["ams"] = ams_units
if tray_exist_bits is not None:
ams["tray_exist_bits"] = tray_exist_bits
if ams_exist_bits is not None:
ams["ams_exist_bits"] = ams_exist_bits
return {"print": {"ams": ams}}
def _extruder_info_payload(extruders):
"""Build device.extruder.info payload (dual-nozzle detection + snow).
Each entry in *extruders* is a dict with at least ``id`` and ``snow``.
"""
return {
"print": {
"device": {
"extruder": {
"info": extruders,
}
}
}
}
def _extruder_state_payload(state_val):
"""Build device.extruder.state payload (active extruder via bit 8)."""
return {
"print": {
"device": {
"extruder": {
"state": state_val,
}
}
}
}
# ---------------------------------------------------------------------------
# 1. Single-nozzle X1E — direct passthrough
# ---------------------------------------------------------------------------
class TestTrayNowSingleNozzleX1E:
"""Single-nozzle, 1 AMS — tray_now is a direct passthrough."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_X1E",
access_code="12345678",
)
def test_tray_now_direct_passthrough_slot_0_to_3(self, mqtt_client):
"""Each tray_now 0-3 maps 1:1 on single-nozzle printers."""
for slot in range(4):
mqtt_client._process_message(_ams_payload(slot))
assert mqtt_client.state.tray_now == slot
def test_tray_now_255_means_unloaded(self, mqtt_client):
"""tray_now=255 means no filament loaded."""
mqtt_client._process_message(_ams_payload(255))
assert mqtt_client.state.tray_now == 255
def test_single_extruder_does_not_trigger_dual_nozzle(self, mqtt_client):
"""device.extruder.info with 1 entry must NOT set _is_dual_nozzle."""
mqtt_client._process_message(_extruder_info_payload([{"id": 0, "snow": 0xFF00FF}]))
assert mqtt_client._is_dual_nozzle is False
def test_last_loaded_tray_survives_unload(self, mqtt_client):
"""Load tray 2, unload → last_loaded_tray stays 2."""
mqtt_client._process_message(_ams_payload(2))
assert mqtt_client.state.last_loaded_tray == 2
mqtt_client._process_message(_ams_payload(255))
assert mqtt_client.state.tray_now == 255
assert mqtt_client.state.last_loaded_tray == 2
# ---------------------------------------------------------------------------
# 2. Single-nozzle P2S — multiple AMS, global IDs pass through
# ---------------------------------------------------------------------------
class TestTrayNowSingleNozzleP2S:
"""Single-nozzle, 2 AMS — tray_now > 3 passes through as global ID."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_P2S",
access_code="12345678",
)
def test_tray_now_ams1_global_ids_4_to_7(self, mqtt_client):
"""tray_now 4-7 are global IDs for AMS 1 on single-nozzle printers."""
for global_id in range(4, 8):
mqtt_client._process_message(_ams_payload(global_id))
assert mqtt_client.state.tray_now == global_id
def test_tray_change_across_ams_units(self, mqtt_client):
"""Switch from AMS 0 slot 1 → AMS 1 slot 2 (global 6)."""
mqtt_client._process_message(_ams_payload(1))
assert mqtt_client.state.tray_now == 1
mqtt_client._process_message(_ams_payload(6))
assert mqtt_client.state.tray_now == 6
# ---------------------------------------------------------------------------
# 2b. Single-nozzle P2S — multi-AMS local slot disambiguation (#420)
# ---------------------------------------------------------------------------
class TestTrayNowP2SMultiAmsDisambiguation:
"""P2S firmware sends local slot IDs (0-3) in tray_now even with dual AMS.
When ams_exist_bits indicates >1 AMS unit and tray_now is 0-3, the backend
should use the MQTT mapping field (snow-encoded) to resolve the correct
global tray ID.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_P2S_DUAL",
access_code="12345678",
)
return client
def test_resolves_ams1_slot1_from_mapping(self, mqtt_client):
"""tray_now=1 with mapping=[257] → global ID 5 (AMS1-T1).
257 snow-decoded: ams_hw_id=1, slot=1 → global 1*4+1=5.
"""
# Set mapping field in raw_data (as the MQTT handler would)
mqtt_client.state.raw_data["mapping"] = [257]
mqtt_client._process_message(
_ams_payload(1, ams_exist_bits="3") # '3' = 0b11 → AMS 0 and 1
)
assert mqtt_client.state.tray_now == 5
def test_resolves_ams1_slot0_from_mapping(self, mqtt_client):
"""tray_now=0 with mapping=[256] → global ID 4 (AMS1-T0).
256 snow-decoded: ams_hw_id=1, slot=0 → global 1*4+0=4.
"""
mqtt_client.state.raw_data["mapping"] = [256]
mqtt_client._process_message(_ams_payload(0, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 4
def test_resolves_ams1_slot3_from_mapping(self, mqtt_client):
"""tray_now=3 with mapping=[259] → global ID 7 (AMS1-T3).
259 snow-decoded: ams_hw_id=1, slot=3 → global 1*4+3=7.
"""
mqtt_client.state.raw_data["mapping"] = [259]
mqtt_client._process_message(_ams_payload(3, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 7
def test_ams0_slot_unchanged_when_mapping_confirms_ams0(self, mqtt_client):
"""tray_now=1 with mapping=[1] → stays 1 (AMS0-T1).
1 snow-decoded: ams_hw_id=0, slot=1 → global 0*4+1=1.
"""
mqtt_client.state.raw_data["mapping"] = [1]
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 1
def test_multicolor_resolves_ams1_from_multi_entry_mapping(self, mqtt_client):
"""Multi-color print: mapping=[0, 257] → tray_now=1 resolves to AMS1-T1 (5).
Entry 0: ams_hw_id=0, slot=0 (local 0) — doesn't match tray_now=1.
Entry 257: ams_hw_id=1, slot=1 (local 1) — matches tray_now=1 → global 5.
"""
mqtt_client.state.raw_data["mapping"] = [0, 257]
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 5
def test_multicolor_four_slot_mapping(self, mqtt_client):
"""mapping=[65535, 65535, 65535, 257] → tray_now=1 resolves to global 5.
Only entry 257 has local slot=1, other entries are unmapped (65535).
Reproduces exact data from issue #420 support package.
"""
mqtt_client.state.raw_data["mapping"] = [65535, 65535, 65535, 257]
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 5
def test_ambiguous_mapping_falls_back_to_local_slot(self, mqtt_client):
"""Two AMS units with same local slot in mapping → ambiguous, keep local slot.
mapping=[1, 257]: both have local slot 1 (AMS0-T1 and AMS1-T1).
Cannot disambiguate → fall back to tray_now=1.
"""
mqtt_client.state.raw_data["mapping"] = [1, 257]
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 1
def test_no_mapping_falls_back_to_local_slot(self, mqtt_client):
"""No mapping field available → fall back to raw tray_now."""
# No mapping in raw_data (e.g. manual filament load, not during print)
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 1
def test_empty_mapping_falls_back_to_local_slot(self, mqtt_client):
"""Empty mapping list → fall back to raw tray_now."""
mqtt_client.state.raw_data["mapping"] = []
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 1
def test_single_ams_passthrough(self, mqtt_client):
"""Single AMS (ams_exist_bits='1') → tray_now 0-3 is direct global ID."""
mqtt_client._process_message(_ams_payload(2, ams_exist_bits="1"))
assert mqtt_client.state.tray_now == 2
def test_no_ams_exist_bits_passthrough(self, mqtt_client):
"""No ams_exist_bits in payload → fall back to raw tray_now."""
mqtt_client._process_message(_ams_payload(1))
assert mqtt_client.state.tray_now == 1
def test_tray_now_255_unaffected_by_multi_ams(self, mqtt_client):
"""tray_now=255 (unloaded) passes through regardless of AMS count."""
mqtt_client.state.raw_data["mapping"] = [257]
mqtt_client._process_message(_ams_payload(255, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 255
def test_tray_now_above_3_unaffected(self, mqtt_client):
"""tray_now > 3 is already a global ID and passes through directly."""
mqtt_client._process_message(_ams_payload(6, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 6
def test_last_loaded_tray_uses_resolved_global_id(self, mqtt_client):
"""last_loaded_tray should reflect the resolved global ID, not local slot."""
mqtt_client.state.raw_data["mapping"] = [257]
mqtt_client.state.state = "RUNNING"
mqtt_client._process_message(_ams_payload(1, ams_exist_bits="3"))
assert mqtt_client.state.tray_now == 5
assert mqtt_client.state.last_loaded_tray == 5
class TestResolveLocalSlotFromMapping:
"""Unit tests for _resolve_local_slot_from_mapping static method."""
def test_single_match_ams0(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, [1]) == 1
def test_single_match_ams1(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
# 257 = 1*256 + 1 → AMS1 slot1 → global 5
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, [257]) == 5
def test_single_match_ams2(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
# 514 = 2*256 + 2 → AMS2 slot2 → global 10
assert BambuMQTTClient._resolve_local_slot_from_mapping(2, [514]) == 10
def test_unmapped_entries_skipped(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, [65535, 65535, 65535, 257]) == 5
def test_no_match_returns_none(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
# mapping has slot 0 only, looking for slot 2
assert BambuMQTTClient._resolve_local_slot_from_mapping(2, [0]) is None
def test_ambiguous_returns_none(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
# Both AMS0 slot1 (1) and AMS1 slot1 (257) → ambiguous
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, [1, 257]) is None
def test_none_mapping_returns_none(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, None) is None
def test_empty_mapping_returns_none(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
assert BambuMQTTClient._resolve_local_slot_from_mapping(1, []) is None
def test_ams_ht_slot0_match(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
# AMS-HT id=128: snow = 128*256 + 0 = 32768
assert BambuMQTTClient._resolve_local_slot_from_mapping(0, [32768]) == 128
# ---------------------------------------------------------------------------
# 3. H2D Pro — initial state detection
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DSetup:
"""H2D Pro initial state detection."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_H2D",
access_code="12345678",
)
def test_dual_nozzle_detected_from_extruder_info(self, mqtt_client):
"""2 entries in device.extruder.info → _is_dual_nozzle=True."""
mqtt_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 0xFF00FF},
]
)
)
assert mqtt_client._is_dual_nozzle is True
def test_ams_extruder_map_parsed_from_info_field(self, mqtt_client):
"""AMS info field is hex: 0x2003 → ext 0 (right), 0x2104 → ext 1 (left)."""
# MQTT sends info as string; BambuStudio parses as hex via stoull(str, 16)
ams_units = [
{"id": 0, "info": "2003", "tray": [{"id": i} for i in range(4)]},
{"id": 128, "info": "2104", "tray": [{"id": 0}]},
]
payload = {
"print": {
"ams": {
"ams": ams_units,
"tray_now": "255",
"tray_exist_bits": "1000f",
},
}
}
mqtt_client._process_message(payload)
# 0x2003: bits 8-11 = (0x2003 >> 8) & 0xF = 0x20 & 0xF = 0 → extruder 0 (right)
# 0x2104: bits 8-11 = (0x2104 >> 8) & 0xF = 0x21 & 0xF = 1 → extruder 1 (left)
assert mqtt_client.state.ams_extruder_map == {"0": 0, "128": 1}
def test_ams_extruder_map_real_h2d_values(self, mqtt_client):
"""Real H2D MQTT values: AMS2 Pro on right, AMS-HT on left."""
ams_units = [
{"id": 0, "info": "10001003", "tray": [{"id": i} for i in range(4)]},
{"id": 128, "info": "10002104", "tray": [{"id": 0}]},
]
payload = {
"print": {
"ams": {
"ams": ams_units,
"tray_now": "255",
"tray_exist_bits": "1000a",
},
}
}
mqtt_client._process_message(payload)
# 0x10001003: bits 8-11 = (0x10001003 >> 8) & 0xF = 0x10 & 0xF = 0 → right
# 0x10002104: bits 8-11 = (0x10002104 >> 8) & 0xF = 0x21 & 0xF = 1 → left
assert mqtt_client.state.ams_extruder_map == {"0": 0, "128": 1}
def test_ams_extruder_map_skips_uninitialized(self, mqtt_client):
"""extruder_id 0xE means uninitialized AMS — should be skipped."""
ams_units = [
{"id": 0, "info": "e03", "tray": [{"id": i} for i in range(4)]},
]
payload = {
"print": {
"ams": {
"ams": ams_units,
"tray_now": "255",
"tray_exist_bits": "f",
},
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.ams_extruder_map == {}
def test_ams_extruder_map_partial_update_preserves_entries(self, mqtt_client):
"""Partial MQTT update with one AMS should not overwrite other entries."""
# First: full update with both AMS units
full_payload = {
"print": {
"ams": {
"ams": [
{"id": 0, "info": "2003", "tray": [{"id": i} for i in range(4)]},
{"id": 128, "info": "2104", "tray": [{"id": 0}]},
],
"tray_now": "255",
"tray_exist_bits": "1000f",
},
}
}
mqtt_client._process_message(full_payload)
assert mqtt_client.state.ams_extruder_map == {"0": 0, "128": 1}
# Then: partial update with only AMS 0 (no info field this time)
partial_payload = {
"print": {
"ams": {
"ams": [
{"id": 0, "tray": [{"id": 0, "remain": 50}]},
],
"tray_now": "0",
"tray_exist_bits": "1000f",
},
}
}
mqtt_client._process_message(partial_payload)
# Both entries should still be present
assert mqtt_client.state.ams_extruder_map == {"0": 0, "128": 1}
def test_dual_nozzle_detection_before_ams_in_same_message(self, mqtt_client):
"""Dual-nozzle detection at line 538 happens before _handle_ams_data() at line 549.
If both arrive in the same message, tray_now disambiguation already uses dual-nozzle logic.
"""
payload = {
"print": {
"device": {
"extruder": {
"info": [
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 0xFF00FF},
],
"state": 0x0001,
}
},
"ams": {
"ams": [
{"id": 0, "info": "2003", "tray": [{"id": i} for i in range(4)]},
],
"tray_now": "2",
"tray_exist_bits": "f",
},
}
}
mqtt_client._process_message(payload)
# Dual-nozzle was detected; AMS 0 on right extruder (active by default);
# snow is 0xFF00FF (unloaded), so falls through to ams_extruder_map fallback.
# Single AMS on extruder 0 → global_id = 0*4+2 = 2
assert mqtt_client._is_dual_nozzle is True
assert mqtt_client.state.tray_now == 2
# ---------------------------------------------------------------------------
# Shared H2D fixture for classes 4-8
# ---------------------------------------------------------------------------
class _H2DFixtureMixin:
"""Mixin providing a pre-configured H2D Pro client."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_H2D",
access_code="12345678",
)
@pytest.fixture
def h2d_client(self, mqtt_client):
"""Pre-configure as H2D Pro: dual-nozzle + ams_extruder_map."""
mqtt_client._process_message(
{
"print": {
"device": {
"extruder": {
"info": [
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 0xFF00FF},
],
"state": 0x0001, # right extruder active
}
},
"ams": {
"ams": [
{"id": 0, "info": "2003", "tray": [{"id": i} for i in range(4)]},
{"id": 128, "info": "2104", "tray": [{"id": 0}]},
],
"tray_now": "255",
"tray_exist_bits": "1000f",
},
}
}
)
assert mqtt_client._is_dual_nozzle is True
assert mqtt_client.state.ams_extruder_map == {"0": 0, "128": 1}
return mqtt_client
# ---------------------------------------------------------------------------
# 4. H2D Snow field disambiguation
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DSnow(_H2DFixtureMixin):
"""Snow field disambiguation (primary path)."""
def test_snow_disambiguates_ams0_slot(self, h2d_client):
"""snow ext[0]=AMS 0 slot 2, tray_now='2' → global 2."""
# Send snow update FIRST (snow is parsed AFTER tray_now in the same message,
# so we need it in a prior message).
snow_val = 0 << 8 | 2 # AMS 0 slot 2 = raw 2
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": snow_val},
{"id": 1, "snow": 0xFF00FF},
]
)
)
assert h2d_client.state.h2d_extruder_snow.get(0) == 2
# Now send tray_now=2
h2d_client._process_message(_ams_payload(2))
assert h2d_client.state.tray_now == 2
def test_snow_disambiguates_ams_ht_to_128(self, h2d_client):
"""snow ext[1]=AMS HT (128), left active, tray_now='0' → global 128."""
# Snow: extruder 1 → AMS 128 slot 0
snow_val = 128 << 8 | 0 # = 32768
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": snow_val},
]
)
)
assert h2d_client.state.h2d_extruder_snow.get(1) == 128
# Switch to left extruder
h2d_client._process_message(_extruder_state_payload(0x0100))
assert h2d_client.state.active_extruder == 1
# tray_now="0" with left extruder active, snow says AMS HT (128)
# AMS HT snow_slot = 0 (single slot), parsed_tray_now = 0 → match
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
def test_snow_updates_h2d_extruder_snow_state(self, h2d_client):
"""Verify state.h2d_extruder_snow dict is populated correctly."""
snow_ext0 = 1 << 8 | 3 # AMS 1 slot 3 → global 7
snow_ext1 = 0 << 8 | 0 # AMS 0 slot 0 → global 0
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": snow_ext0},
{"id": 1, "snow": snow_ext1},
]
)
)
assert h2d_client.state.h2d_extruder_snow[0] == 7
assert h2d_client.state.h2d_extruder_snow[1] == 0
def test_snow_unloaded_value(self, h2d_client):
"""snow=0xFFFF (ams_id=255, slot=255) → 255 (unloaded)."""
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFFFF},
{"id": 1, "snow": 0xFFFF},
]
)
)
assert h2d_client.state.h2d_extruder_snow[0] == 255
assert h2d_client.state.h2d_extruder_snow[1] == 255
def test_snow_initial_sentinel_not_stored(self, h2d_client):
"""snow=0xFF00FF (firmware initial sentinel) is not parsed into h2d_extruder_snow."""
# 0xFF00FF has ams_id=0xFF00=65280 which doesn't match any branch
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 0xFF00FF},
]
)
)
# Snow dict should remain empty (no matching branch)
assert h2d_client.state.h2d_extruder_snow == {}
# ---------------------------------------------------------------------------
# 5. H2D Pending target disambiguation
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DPendingTarget(_H2DFixtureMixin):
"""Pending target disambiguation (when Bambuddy initiates load)."""
def test_pending_target_matches_slot(self, h2d_client):
"""pending=5, tray_now='1' (5%4=1 matches) → tray_now=5."""
h2d_client.state.pending_tray_target = 5
h2d_client._process_message(_ams_payload(1))
assert h2d_client.state.tray_now == 5
assert h2d_client.state.pending_tray_target is None # cleared
def test_pending_target_slot_mismatch(self, h2d_client):
"""pending=5, tray_now='2' → uses raw slot, clears pending."""
h2d_client.state.pending_tray_target = 5
h2d_client._process_message(_ams_payload(2))
# Slot 2 != 5%4=1 → mismatch, uses raw slot 2
assert h2d_client.state.tray_now == 2
assert h2d_client.state.pending_tray_target is None
def test_pending_target_takes_priority_over_snow(self, h2d_client):
"""When both pending and snow are set, pending wins."""
# Set up snow for extruder 0 → AMS 0 slot 1 → global 1
snow_val = 0 << 8 | 1
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": snow_val},
{"id": 1, "snow": 0xFF00FF},
]
)
)
assert h2d_client.state.h2d_extruder_snow.get(0) == 1
# Set pending target to AMS 1 slot 1 (global 5)
h2d_client.state.pending_tray_target = 5
# tray_now="1" — matches pending (5%4=1), pending should win over snow
h2d_client._process_message(_ams_payload(1))
assert h2d_client.state.tray_now == 5
# ---------------------------------------------------------------------------
# 6. H2D ams_extruder_map fallback
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DFallback(_H2DFixtureMixin):
"""ams_extruder_map fallback (no pending, no snow)."""
def test_single_ams_on_extruder_computes_global_id(self, h2d_client):
"""AMS 0 on right extruder, tray_now='2' → 0*4+2=2."""
# h2d_client has snow=0xFF00FF (unloaded) by default, so snow path skips
h2d_client._process_message(_ams_payload(2))
# AMS 0 is the only AMS on extruder 0 (right, active by default)
# Fallback: single AMS → global = 0*4+2 = 2
assert h2d_client.state.tray_now == 2
def test_multiple_ams_keeps_current_if_valid(self, h2d_client):
"""Current tray matches slot → keeps it (multi-AMS on same extruder)."""
# Set up: two AMS units on the same extruder (right, ext 0)
h2d_client.state.ams_extruder_map = {"0": 0, "1": 0}
# Pre-set tray_now=5 (AMS 1 slot 1) — current_ams=1 which is in ams_on_extruder
h2d_client.state.tray_now = 5
# tray_now="1" → 5%4=1 matches → keep current=5
h2d_client._process_message(_ams_payload(1))
assert h2d_client.state.tray_now == 5
def test_no_ams_on_extruder_uses_raw_slot(self, h2d_client):
"""No AMS mapped to the active extruder → raw slot as global ID."""
# All AMS on left extruder, but right is active
h2d_client.state.ams_extruder_map = {"0": 1, "128": 1}
h2d_client._process_message(_ams_payload(2))
assert h2d_client.state.tray_now == 2
def test_single_ams_ht_on_extruder_returns_unit_id(self, h2d_client):
"""AMS-HT 128 alone on left extruder, slot 0 → global ID 128 (not 512)."""
# Switch to left extruder (where AMS-HT 128 is mapped)
h2d_client._process_message(_extruder_state_payload(0x0100))
# Only AMS-HT 128 on left extruder; no snow available
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
def test_single_ams_ht_ignores_nonzero_slot(self, h2d_client):
"""AMS-HT has single slot; even if printer reports slot 1, global ID = unit ID."""
h2d_client.state.ams_extruder_map = {"129": 0}
h2d_client._process_message(_ams_payload(1))
# AMS-HT 129: global ID = 129, not 129*4+1=517
assert h2d_client.state.tray_now == 129
def test_multiple_ams_keeps_current_ams_ht(self, h2d_client):
"""Current tray is AMS-HT 128, slot 0 reported → keeps 128."""
h2d_client.state.ams_extruder_map = {"0": 0, "128": 0}
h2d_client.state.tray_now = 128
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
def test_multiple_ams_slot_nonzero_excludes_ams_ht(self, h2d_client):
"""Slot > 0 eliminates AMS-HT candidates; single regular AMS left → resolves."""
# AMS 0 + AMS-HT 128 both on right extruder
h2d_client.state.ams_extruder_map = {"0": 0, "128": 0}
h2d_client.state.tray_now = 255 # no current match
# Slot 2 → can't be AMS-HT → only AMS 0 → global = 0*4+2 = 2
h2d_client._process_message(_ams_payload(2))
assert h2d_client.state.tray_now == 2
def test_multiple_ams_slot_nonzero_narrows_to_single_ht_excluded(self, h2d_client):
"""Two regular AMS + one AMS-HT, slot > 0 → AMS-HT excluded but still ambiguous."""
h2d_client.state.ams_extruder_map = {"0": 0, "1": 0, "128": 0}
h2d_client.state.tray_now = 255
# Slot 3 → excludes AMS-HT, but AMS 0 and AMS 1 both remain → ambiguous
h2d_client._process_message(_ams_payload(3))
assert h2d_client.state.tray_now == 3 # raw slot fallback
# ---------------------------------------------------------------------------
# 6b. H2D last_loaded_tray validation
# ---------------------------------------------------------------------------
class TestLastLoadedTrayValidation(_H2DFixtureMixin):
"""last_loaded_tray only stores physically valid tray IDs."""
def test_regular_ams_tray_stored(self, h2d_client):
"""Valid regular AMS tray (0-15) → stored in last_loaded_tray."""
h2d_client.state.tray_now = 7
# Trigger tray_now processing via AMS message
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 1 << 8 | 3}, # AMS 1 slot 3 → global 7
{"id": 1, "snow": 0xFF00FF},
]
)
)
h2d_client._process_message(_ams_payload(3))
assert h2d_client.state.tray_now == 7
assert h2d_client.state.last_loaded_tray == 7
def test_ams_ht_tray_stored(self, h2d_client):
"""Valid AMS-HT tray (128-135) → stored in last_loaded_tray."""
h2d_client._process_message(_extruder_state_payload(0x0100))
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 128 << 8 | 0},
]
)
)
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
assert h2d_client.state.last_loaded_tray == 128
def test_unloaded_not_stored(self, h2d_client):
"""tray_now=255 (unloaded) → last_loaded_tray unchanged."""
h2d_client.state.last_loaded_tray = 5
h2d_client._process_message(_ams_payload(255))
assert h2d_client.state.tray_now == 255
assert h2d_client.state.last_loaded_tray == 5
# ---------------------------------------------------------------------------
# 7. H2D Active extruder switching
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DActiveExtruder(_H2DFixtureMixin):
"""Active extruder switching via device.extruder.state bit 8."""
def test_active_extruder_right_by_default(self, h2d_client):
"""Initial state.active_extruder == 0 (right)."""
assert h2d_client.state.active_extruder == 0
def test_extruder_state_bit8_switches_to_left(self, h2d_client):
"""state=0x100 → active_extruder=1 (left)."""
h2d_client._process_message(_extruder_state_payload(0x0100))
assert h2d_client.state.active_extruder == 1
def test_extruder_state_bit8_switches_back_to_right(self, h2d_client):
"""Cycle 0 → 1 → 0."""
h2d_client._process_message(_extruder_state_payload(0x0100))
assert h2d_client.state.active_extruder == 1
h2d_client._process_message(_extruder_state_payload(0x0001))
assert h2d_client.state.active_extruder == 0
def test_extruder_switch_changes_tray_disambiguation(self, h2d_client):
"""Snow on both extruders; switching active changes which snow is used."""
# Snow: ext 0 → AMS 0 slot 1 (global 1), ext 1 → AMS 128 slot 0 (global 128)
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0 << 8 | 1}, # AMS 0 slot 1 → global 1
{"id": 1, "snow": 128 << 8 | 0}, # AMS HT → global 128
]
)
)
# Right active (default) — tray_now="1" → snow ext[0] says global 1
h2d_client._process_message(_ams_payload(1))
assert h2d_client.state.tray_now == 1
# Switch to left
h2d_client._process_message(_extruder_state_payload(0x0100))
# Left active — tray_now="0" → snow ext[1] says AMS HT (128), slot 0 matches
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
# ---------------------------------------------------------------------------
# 8. Device identification probe (#1684 enabler)
# ---------------------------------------------------------------------------
class TestDeviceIdentificationProbe:
"""One-shot INFO log of any device.* identification fields the firmware
sends. Lets a new-model support bundle self-disclose the internal model
code (e.g. dev_model_name='N2L') without a separate debug build.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_PROBE",
access_code="12345678",
)
def _device_payload(self, device):
return {"print": {"device": device}}
def test_logs_known_id_fields_once(self, mqtt_client, caplog):
import logging
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message(
self._device_payload({"dev_model_name": "N2S", "dev_product_name": "Bambu Lab A1"})
)
matches = [r for r in caplog.records if "Device identification" in r.getMessage()]
assert len(matches) == 1
msg = matches[0].getMessage()
assert "dev_model_name" in msg and "N2S" in msg
assert "dev_product_name" in msg
def test_one_shot_does_not_repeat(self, mqtt_client, caplog):
import logging
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
payload = self._device_payload({"dev_model_name": "N2S"})
mqtt_client._process_message(payload)
mqtt_client._process_message(payload)
mqtt_client._process_message(payload)
matches = [r for r in caplog.records if "Device identification" in r.getMessage()]
assert len(matches) == 1
def test_fallback_dumps_keys_when_no_known_fields(self, mqtt_client, caplog):
"""Future Bambu rename (e.g. model_name without dev_ prefix) still surfaces."""
import logging
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message(self._device_payload({"model_name": "MysteryModel", "extruder": {"state": 0}}))
matches = [r for r in caplog.records if "Device identification" in r.getMessage()]
assert len(matches) == 1
msg = matches[0].getMessage()
assert "no known id fields" in msg
assert "model_name" in msg and "extruder" in msg
# ---------------------------------------------------------------------------
# 8. H2D Full multi-message sequences
# ---------------------------------------------------------------------------
class TestTrayNowDualNozzleH2DFullSequence(_H2DFixtureMixin):
"""Multi-message sequences simulating real H2D Pro prints."""
def test_h2d_right_nozzle_ams0_lifecycle(self, h2d_client):
"""Setup → load AMS 0 slot 1 → verify tray_now=1."""
# Snow update: extruder 0 loading AMS 0 slot 1
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0 << 8 | 1},
{"id": 1, "snow": 0xFF00FF},
]
)
)
# Printer reports tray_now="1"
h2d_client._process_message(_ams_payload(1))
assert h2d_client.state.tray_now == 1
assert h2d_client.state.last_loaded_tray == 1
def test_h2d_left_nozzle_ams_ht_lifecycle(self, h2d_client):
"""Setup → switch left → load AMS HT → verify tray_now=128."""
# Switch to left extruder
h2d_client._process_message(_extruder_state_payload(0x0100))
# Snow: ext 1 → AMS HT slot 0
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0xFF00FF},
{"id": 1, "snow": 128 << 8 | 0},
]
)
)
# Printer reports tray_now="0" (AMS HT single slot)
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
assert h2d_client.state.last_loaded_tray == 128
def test_h2d_multi_color_alternating_nozzles(self, h2d_client):
"""Multi-color print alternating between right and left nozzles.
Sequence:
1. Right loads AMS 0 slot 0 (tray=0)
2. Switch left, load AMS HT (tray=128)
3. Switch right, snow updates, load AMS 0 slot 2 (tray=2)
4. Unload (255)
"""
# Step 1: Right extruder loads AMS 0 slot 0
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0 << 8 | 0},
{"id": 1, "snow": 0xFF00FF},
]
)
)
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 0
# Step 2: Switch to left, load AMS HT
h2d_client._process_message(_extruder_state_payload(0x0100))
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0 << 8 | 0},
{"id": 1, "snow": 128 << 8 | 0},
]
)
)
h2d_client._process_message(_ams_payload(0))
assert h2d_client.state.tray_now == 128
# Step 3: Switch back to right, load AMS 0 slot 2
h2d_client._process_message(_extruder_state_payload(0x0001))
h2d_client._process_message(
_extruder_info_payload(
[
{"id": 0, "snow": 0 << 8 | 2},
{"id": 1, "snow": 128 << 8 | 0},
]
)
)
h2d_client._process_message(_ams_payload(2))
assert h2d_client.state.tray_now == 2
# Step 4: Unload
h2d_client._process_message(_ams_payload(255))
assert h2d_client.state.tray_now == 255
assert h2d_client.state.last_loaded_tray == 2
class TestTrayChangeLog:
"""Tests for tray_change_log tracking during prints (mid-print tray switch)."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TRAYLOG1",
access_code="12345678",
)
return client
def test_tray_change_log_defaults_empty(self, mqtt_client):
"""tray_change_log starts as an empty list."""
assert mqtt_client.state.tray_change_log == []
def test_tray_change_log_seeded_on_print_start(self, mqtt_client):
"""Print start clears log and seeds with initial tray at layer 0."""
mqtt_client.state.tray_now = 2
mqtt_client.state.last_loaded_tray = 2
mqtt_client._previous_gcode_state = "IDLE"
# Transition to RUNNING via _process_message
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "test.3mf",
}
}
)
assert mqtt_client.state.tray_change_log == [(2, 0)]
def test_tray_change_log_cleared_on_new_print(self, mqtt_client):
"""Old log entries are cleared when a new print starts."""
mqtt_client.state.tray_change_log = [(5, 0), (3, 100)]
mqtt_client.state.tray_now = 1
mqtt_client.state.last_loaded_tray = 1
mqtt_client._previous_gcode_state = "IDLE"
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "new.3mf",
}
}
)
assert mqtt_client.state.tray_change_log == [(1, 0)]
# Helper that mirrors the production gate at bambu_mqtt.py:1571 — tests
# below replicate the gate so they validate the *contract* without needing
# to feed a synthetic AMS push through the full _process_message path.
@staticmethod
def _record_if_change(client, tn: int) -> None:
if (0 <= tn <= 15) or (128 <= tn <= 135) or tn == 254:
if tn != client.state.last_loaded_tray and client._was_running and not client._completion_triggered:
client.state.tray_change_log.append((tn, client.state.layer_num))
client.state.last_loaded_tray = tn
def test_tray_change_recorded_during_running(self, mqtt_client):
"""Tray change while RUNNING is appended to the log."""
mqtt_client.state.state = "RUNNING"
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client.state.layer_num = 50
mqtt_client.state.last_loaded_tray = 0
mqtt_client.state.tray_change_log = [(0, 0)]
mqtt_client.state.tray_now = 1
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
assert mqtt_client.state.tray_change_log == [(0, 0), (1, 50)]
def test_tray_change_not_recorded_when_idle(self, mqtt_client):
"""Tray changes outside an active print are NOT logged."""
# IDLE between prints — both lifecycle flags in the cleared state.
mqtt_client.state.state = "IDLE"
mqtt_client._was_running = False
mqtt_client._completion_triggered = False
mqtt_client.state.layer_num = 0
mqtt_client.state.last_loaded_tray = 0
mqtt_client.state.tray_change_log = []
mqtt_client.state.tray_now = 3
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
assert mqtt_client.state.tray_change_log == []
def test_tray_change_recorded_during_pause(self, mqtt_client):
"""Tray change while PAUSE is also logged (AMS can swap during pause)."""
mqtt_client.state.state = "PAUSE"
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client.state.layer_num = 75
mqtt_client.state.last_loaded_tray = 2
mqtt_client.state.tray_change_log = [(2, 0)]
mqtt_client.state.tray_now = 5
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
assert mqtt_client.state.tray_change_log == [(2, 0), (5, 75)]
def test_tray_change_recorded_during_intermediate_state(self, mqtt_client):
"""Tray change during a transient non-RUNNING state mid-print is logged.
Regression for #957: P2S firmware briefly transitions out of RUNNING
(e.g. into LOADING) when the AMS auto-falls-back from an empty spool to
a same-material sibling. The previous gate ``state in ("RUNNING",
"PAUSE")`` missed this transition entirely, so the usage tracker had no
evidence of the switch and double-credited the original tray with the
full 3MF estimate while the remain%-delta path added the fallback
weight on top. The new gate keys on the print-lifecycle flags
(``_was_running and not _completion_triggered``) so any tray change
between print start and completion is captured regardless of the
momentary gcode_state string.
"""
mqtt_client.state.state = "LOADING" # not RUNNING/PAUSE — old gate would skip
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client.state.layer_num = 42
mqtt_client.state.last_loaded_tray = 0
mqtt_client.state.tray_change_log = [(0, 0)]
# AMS auto-fallback: T0 ran out, swapped to T1 of same material
mqtt_client.state.tray_now = 1
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
assert mqtt_client.state.tray_change_log == [(0, 0), (1, 42)]
def test_tray_change_not_recorded_after_completion(self, mqtt_client):
"""Once on_print_complete has fired, further tray changes don't pollute the log."""
mqtt_client.state.state = "FINISH"
mqtt_client._was_running = True
mqtt_client._completion_triggered = True # completion already triggered
mqtt_client.state.layer_num = 0
mqtt_client.state.last_loaded_tray = 1
mqtt_client.state.tray_change_log = [(0, 0), (1, 50)]
mqtt_client.state.tray_now = 2
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
# Log unchanged — completion already triggered so post-print tray
# movement (e.g. printer self-cleaning) doesn't bleed into the next
# print's attribution.
assert mqtt_client.state.tray_change_log == [(0, 0), (1, 50)]
def test_same_tray_not_logged_twice(self, mqtt_client):
"""Same tray value doesn't create duplicate log entries."""
mqtt_client.state.state = "RUNNING"
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client.state.layer_num = 30
mqtt_client.state.last_loaded_tray = 2
mqtt_client.state.tray_change_log = [(2, 0)]
mqtt_client.state.tray_now = 2
self._record_if_change(mqtt_client, mqtt_client.state.tray_now)
assert mqtt_client.state.tray_change_log == [(2, 0)]
def test_multiple_tray_changes(self, mqtt_client):
"""Multiple tray changes create a full history."""
mqtt_client.state.state = "RUNNING"
mqtt_client._was_running = True
mqtt_client._completion_triggered = False
mqtt_client.state.last_loaded_tray = 0
mqtt_client.state.tray_change_log = [(0, 0)]
for tray, layer in [(1, 50), (3, 120), (0, 200)]:
mqtt_client.state.tray_now = tray
mqtt_client.state.layer_num = layer
self._record_if_change(mqtt_client, tray)
assert mqtt_client.state.tray_change_log == [(0, 0), (1, 50), (3, 120), (0, 200)]
class TestDeveloperModeDetection:
"""Tests for developer LAN mode detection from MQTT 'fun' field."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient instance for testing."""
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_developer_mode_initially_none(self, mqtt_client):
"""Verify developer_mode starts as None (unknown)."""
assert mqtt_client.state.developer_mode is None
def test_developer_mode_on_when_bit_clear(self, mqtt_client):
"""Verify developer_mode is True when bit 0x20000000 is clear."""
# Bit 29 clear in lower 32 bits = developer mode ON
payload = {
"print": {
"gcode_state": "IDLE",
"fun": "1C8187FF9CFF",
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.developer_mode is True
def test_developer_mode_off_when_bit_set(self, mqtt_client):
"""Verify developer_mode is False when bit 0x20000000 is set."""
# Bit 29 set in lower 32 bits = developer mode OFF (encryption required)
payload = {
"print": {
"gcode_state": "IDLE",
"fun": "1C81A7FF9CFF",
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.developer_mode is False
def test_developer_mode_exact_bit_check(self, mqtt_client):
"""Verify only bit 0x20000000 matters, not other bits."""
# 0x20000000 in hex = bit 29. Set ONLY that bit.
payload = {
"print": {
"gcode_state": "IDLE",
"fun": "000020000000",
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.developer_mode is False
# All zeros = all bits clear = developer mode ON
payload["print"]["fun"] = "000000000000"
mqtt_client._process_message(payload)
assert mqtt_client.state.developer_mode is True
def test_developer_mode_invalid_fun_ignored(self, mqtt_client):
"""Verify invalid fun values don't crash or change state."""
mqtt_client.state.developer_mode = True
payload = {
"print": {
"gcode_state": "IDLE",
"fun": "not_a_hex_value",
}
}
mqtt_client._process_message(payload)
# Should remain unchanged
assert mqtt_client.state.developer_mode is True
def test_developer_mode_missing_fun_preserves_state(self, mqtt_client):
"""Verify messages without fun field don't reset developer_mode."""
mqtt_client.state.developer_mode = False
payload = {
"print": {
"gcode_state": "RUNNING",
"mc_percent": 50,
}
}
mqtt_client._process_message(payload)
assert mqtt_client.state.developer_mode is False
def test_developer_mode_persists_across_messages(self, mqtt_client):
"""Verify developer_mode set by fun persists across messages without fun."""
# First message sets developer_mode
mqtt_client._process_message(
{
"print": {
"gcode_state": "IDLE",
"fun": "3EC1AFFF9CFF",
}
}
)
assert mqtt_client.state.developer_mode is False
# Subsequent messages without fun don't change it
for _ in range(3):
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"mc_percent": 50,
}
}
)
assert mqtt_client.state.developer_mode is False
class TestMqttCommandVerificationFailed:
"""HMS 0500_0500_0001_0007 is the printer refusing to verify our commands (#2732).
A P1S on firmware 01.10.00.00 answers queries normally while dropping every
control command, so nothing else in the connection looks wrong. This HMS is
the only direct evidence, which makes it authoritative over the probe.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="01S00A000000000",
access_code="12345678",
)
@staticmethod
def _hms_payload(*entries):
return {"print": {"gcode_state": "IDLE", "hms": list(entries)}}
# attr 0x05000500, code 0x00010007 — the values a real P1S sends.
VERIFY_FAILED = {"attr": 83887360, "code": 65543}
OTHER_FAULT = {"attr": 0x03000200, "code": 0x00018012}
def test_hms_forces_developer_mode_false(self, mqtt_client):
mqtt_client.state.developer_mode = True # what the probe wrongly concluded
mqtt_client._process_message(self._hms_payload(self.VERIFY_FAILED))
assert mqtt_client.state.developer_mode is False
def test_hms_is_surfaced_with_its_full_code(self, mqtt_client):
"""The short code collapses to a useless 0500_0007 — full_code must survive."""
from backend.app.services.bambu_mqtt import HMS_MQTT_VERIFY_FAILED
mqtt_client._process_message(self._hms_payload(self.VERIFY_FAILED))
assert [e.full_code for e in mqtt_client.state.hms_errors] == [HMS_MQTT_VERIFY_FAILED]
def test_unrelated_hms_does_not_touch_developer_mode(self, mqtt_client):
mqtt_client.state.developer_mode = True
mqtt_client._process_message(self._hms_payload(self.OTHER_FAULT))
assert mqtt_client.state.developer_mode is True
def test_clearing_the_hms_re_arms_the_probe(self, mqtt_client):
"""Enabling Developer Mode and restarting must not leave a stuck False."""
mqtt_client._process_message(self._hms_payload(self.VERIFY_FAILED))
assert mqtt_client.state.developer_mode is False
mqtt_client._dev_mode_probed = True
mqtt_client._process_message(self._hms_payload())
assert mqtt_client.state.developer_mode is None
assert mqtt_client._dev_mode_probed is False
def test_empty_hms_leaves_a_probe_verdict_alone(self, mqtt_client):
"""Only the HMS-derived latch self-clears; a probe's False is not ours to undo."""
mqtt_client.state.developer_mode = False # from an explicit probe refusal
mqtt_client._process_message(self._hms_payload())
assert mqtt_client.state.developer_mode is False
def test_inconclusive_probe_does_not_overwrite_the_hms_verdict(self, mqtt_client):
mqtt_client._process_message(self._hms_payload(self.VERIFY_FAILED))
mqtt_client._handle_dev_mode_probe_response({"command": "ams_filament_setting", "sequence_id": "3"})
assert mqtt_client.state.developer_mode is False
class TestDeveloperModeProbeInconclusive:
"""An empty probe response proves nothing and must not read as ENABLED (#2732)."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def test_empty_result_stays_unknown(self, mqtt_client):
"""P1S 01.10.00.00 echoes the command back with no `result` field at all."""
mqtt_client._handle_dev_mode_probe_response({"command": "ams_filament_setting", "sequence_id": "3"})
assert mqtt_client.state.developer_mode is None
def test_explicit_success_still_enables(self, mqtt_client):
mqtt_client._handle_dev_mode_probe_response({"sequence_id": "3", "result": "success"})
assert mqtt_client.state.developer_mode is True
def test_verify_failure_still_disables(self, mqtt_client):
mqtt_client._handle_dev_mode_probe_response(
{"sequence_id": "3", "result": "failed", "reason": "mqtt message verify failed"}
)
assert mqtt_client.state.developer_mode is False
def test_inconclusive_response_still_clears_probe_bookkeeping(self, mqtt_client):
"""Whatever the verdict, the response ends the probe (no retry storm)."""
mqtt_client._dev_mode_probe_seq = "3"
mqtt_client._dev_mode_probe_failures = 1
mqtt_client._handle_dev_mode_probe_response({"sequence_id": "3", "result": ""})
assert mqtt_client._dev_mode_probe_seq is None
assert mqtt_client._dev_mode_probe_failures == 0
class TestDeveloperModeProbeTimeout:
"""Tests for developer mode probe timeout, retry, and forced reconnect (#887).
When a printer's MQTT session is half-broken (sends status but ignores
commands), the developer mode probe gets no response. The timeout logic
retries once, then force-closes the socket on the second failure.
"""
@pytest.fixture
def mqtt_client(self):
import time
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
# Simulate connected state with a mock MQTT client
client.state.connected = True
mock_paho = MagicMock()
mock_paho.socket.return_value = MagicMock()
client._client = mock_paho
# Set connect time in the past so the 5s probe delay is satisfied
client._connect_time = time.monotonic() - 10.0
return client
def _make_pushall_data(self):
"""Create a print data dict with >30 keys (triggers probe) and no 'fun' field."""
return {f"key_{i}": i for i in range(35)}
def test_first_timeout_allows_retry(self, mqtt_client):
"""After first probe timeout, _dev_mode_probed resets to allow retry."""
import time
data = self._make_pushall_data()
# First pushall triggers the probe
mqtt_client._update_state(data)
assert mqtt_client._dev_mode_probed is True
assert mqtt_client._dev_mode_probe_seq is not None
assert mqtt_client.state.developer_mode is None
# Simulate 11 seconds passing
mqtt_client._dev_mode_probe_time = time.monotonic() - 11.0
# Next status message detects the timeout
mqtt_client._update_state(data)
assert mqtt_client._dev_mode_probe_failures == 1
assert mqtt_client._dev_mode_probe_seq is None
# Should allow retry on next full message
assert mqtt_client._dev_mode_probed is False
# Connection should NOT be force-closed after 1 failure
assert mqtt_client.state.connected is True
def test_second_timeout_forces_reconnect(self, mqtt_client):
"""After two consecutive probe timeouts, force-close the socket.
Probe timeout detection runs from paho's network thread (no asyncio
loop), so force_reconnect_stale_session routes through socket-close
rather than hard-reset (loop_stop from inside the loop deadlocks)."""
import time
data = self._make_pushall_data()
state_change_called = []
mqtt_client.on_state_change = lambda s: state_change_called.append(True)
# First probe + timeout
mqtt_client._update_state(data)
mqtt_client._dev_mode_probe_time = time.monotonic() - 11.0
mqtt_client._update_state(data)
assert mqtt_client._dev_mode_probe_failures == 1
# Second probe (retry) + timeout
mqtt_client._update_state(data) # triggers new probe
assert mqtt_client._dev_mode_probed is True
mqtt_client._dev_mode_probe_time = time.monotonic() - 11.0
mqtt_client._update_state(data) # detects second timeout
assert mqtt_client._dev_mode_probe_failures == 2
assert mqtt_client.state.connected is False
assert mqtt_client._stale_reconnecting is True
# Sync test → no running loop → socket-close fallback path
mqtt_client._client.socket().close.assert_called()
assert len(state_change_called) > 0
def test_successful_probe_resets_failure_counter(self, mqtt_client):
"""A probe response after a previous failure resets the counter."""
import time
data = self._make_pushall_data()
# First probe + timeout → failure=1
mqtt_client._update_state(data)
seq = mqtt_client._dev_mode_probe_seq
mqtt_client._dev_mode_probe_time = time.monotonic() - 11.0
mqtt_client._update_state(data)
assert mqtt_client._dev_mode_probe_failures == 1
# Retry probe
mqtt_client._update_state(data)
new_seq = mqtt_client._dev_mode_probe_seq
assert new_seq is not None
assert new_seq != seq
# Simulate successful response
mqtt_client._handle_dev_mode_probe_response(
{
"command": "ams_filament_setting",
"sequence_id": new_seq,
"result": "success",
}
)
assert mqtt_client._dev_mode_probe_failures == 0
assert mqtt_client.state.developer_mode is True
assert mqtt_client._dev_mode_probe_seq is None
def test_no_timeout_when_probe_not_sent(self, mqtt_client):
"""The timeout branch is only entered when a probe is pending."""
# No probe sent — _dev_mode_probed is False, _dev_mode_probe_seq is None
data = {"gcode_state": "IDLE", "mc_percent": 0} # < 30 keys
mqtt_client._update_state(data)
assert mqtt_client._dev_mode_probe_failures == 0
def test_on_connect_resets_probe_state_but_preserves_developer_mode(self, mqtt_client):
"""_on_connect resets probe tracking but preserves cached developer_mode."""
import time
mqtt_client._dev_mode_probed = True
mqtt_client._dev_mode_probe_seq = "42"
mqtt_client._dev_mode_probe_time = time.monotonic()
mqtt_client._dev_mode_probe_failures = 2
mqtt_client.state.developer_mode = True
# subscribe() must return (result, mid) tuple
mqtt_client._client.subscribe.return_value = (0, 1)
mqtt_client._on_connect(mqtt_client._client, None, None, 0)
# developer_mode is preserved across reconnects (#887)
assert mqtt_client.state.developer_mode is True
assert mqtt_client._dev_mode_probed is False
assert mqtt_client._dev_mode_probe_seq is None
assert mqtt_client._dev_mode_probe_time == 0.0
assert mqtt_client._dev_mode_probe_failures == 0
assert mqtt_client._connect_time > 0
def test_probe_deferred_when_connect_too_recent(self, mqtt_client):
"""Probe is deferred if less than 5s have passed since _on_connect."""
import time
data = self._make_pushall_data()
# Set connect time to 1 second ago — too recent for probe
mqtt_client._connect_time = time.monotonic() - 1.0
mqtt_client._update_state(data)
# Pushall seen, so needs_probe is set, but probe NOT fired yet
assert mqtt_client._dev_mode_needs_probe is True
assert mqtt_client._dev_mode_probed is False
assert mqtt_client._dev_mode_probe_seq is None
def test_probe_fires_after_delay(self, mqtt_client):
"""Probe fires once 5s have passed since _on_connect."""
import time
data = self._make_pushall_data()
# Set connect time to 6 seconds ago — delay satisfied
mqtt_client._connect_time = time.monotonic() - 6.0
mqtt_client._update_state(data)
# Probe should have fired
assert mqtt_client._dev_mode_needs_probe is True
assert mqtt_client._dev_mode_probed is True
assert mqtt_client._dev_mode_probe_seq is not None
def test_probe_fires_on_incremental_after_delay(self, mqtt_client):
"""After seeing a pushall within 5s, probe fires on later incremental message."""
import time
pushall_data = self._make_pushall_data()
incremental_data = {"gcode_state": "IDLE", "mc_percent": 0} # < 30 keys
# Pushall arrives 1s after connect — too early for probe
mqtt_client._connect_time = time.monotonic() - 1.0
mqtt_client._update_state(pushall_data)
assert mqtt_client._dev_mode_needs_probe is True
assert mqtt_client._dev_mode_probed is False
# 5s later, an incremental update arrives — probe fires now
mqtt_client._connect_time = time.monotonic() - 6.0
mqtt_client._update_state(incremental_data)
assert mqtt_client._dev_mode_probed is True
assert mqtt_client._dev_mode_probe_seq is not None
def test_no_reprobe_when_developer_mode_cached(self, mqtt_client):
"""Auto-reconnect preserves developer_mode, skipping reprobe."""
import time
data = self._make_pushall_data()
# Simulate known developer_mode from previous connection
mqtt_client.state.developer_mode = True
mqtt_client._connect_time = time.monotonic() - 10.0
mqtt_client._update_state(data)
# Should NOT probe — developer_mode is already known
assert mqtt_client._dev_mode_needs_probe is False
assert mqtt_client._dev_mode_probed is False
assert mqtt_client._dev_mode_probe_seq is None
assert mqtt_client.state.developer_mode is True
def test_on_connect_resets_needs_probe(self, mqtt_client):
"""_on_connect resets _dev_mode_needs_probe for a clean start."""
mqtt_client._dev_mode_needs_probe = True
mqtt_client._client.subscribe.return_value = (0, 1)
mqtt_client._on_connect(mqtt_client._client, None, None, 0)
assert mqtt_client._dev_mode_needs_probe is False
class TestVtTrayNormalization:
"""Tests for vt_tray dict→list normalization in _update_state.
MQTT sends vt_tray as a dict for single-slot printers, but all consumers
expect a list. _update_state must normalize it before any callback can
read raw_data, because the dev-mode probe may release the GIL and let
the event loop read the partially-updated state.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_vt_tray_dict_normalized_in_update_state(self, mqtt_client):
"""Verify _update_state wraps a raw vt_tray dict into a list."""
vt_dict = {
"id": "254",
"tray_color": "FF0000",
"tray_type": "PLA",
"tag_uid": "0000000000000000",
"tray_uuid": "00000000000000000000000000000000",
}
data = {"gcode_state": "IDLE", "vt_tray": vt_dict}
mqtt_client._update_state(data)
stored = mqtt_client.state.raw_data.get("vt_tray")
assert isinstance(stored, list)
assert len(stored) == 1
assert stored[0]["tray_color"] == "FF0000"
def test_vt_tray_list_unchanged_in_update_state(self, mqtt_client):
"""Verify _update_state keeps an already-list vt_tray unchanged."""
vt_list = [
{"id": "254", "tray_type": "PLA"},
{"id": "255", "tray_type": "PETG"},
]
data = {"gcode_state": "IDLE", "vt_tray": vt_list}
mqtt_client._update_state(data)
stored = mqtt_client.state.raw_data.get("vt_tray")
assert isinstance(stored, list)
assert len(stored) == 2
def test_preserved_vt_tray_restored_before_probe(self, mqtt_client):
"""Verify preserved vt_tray is restored before dev-mode probe runs.
On the first message, the incremental handler wraps vt_tray into a list
and stores it. _update_state then replaces raw_data with the full data
dict, but must restore preserved fields BEFORE the probe publishes
(which can release the GIL).
"""
# Simulate: incremental handler already stored a wrapped list
mqtt_client.state.raw_data = {
"vt_tray": [{"id": "254", "tray_type": "PLA", "tray_color": "00FF00"}],
}
# Now _update_state runs with new data that has vt_tray as dict
new_data = {
"gcode_state": "IDLE",
"vt_tray": {"id": "254", "tray_type": "PETG", "tray_color": "FF0000"},
}
mqtt_client._update_state(new_data)
# The preserved list (PLA/green) should take priority over new data
stored = mqtt_client.state.raw_data["vt_tray"]
assert isinstance(stored, list)
assert stored[0]["tray_type"] == "PLA"
assert stored[0]["tray_color"] == "00FF00"
def test_first_message_vt_tray_dict_becomes_list(self, mqtt_client):
"""Verify on the very first message, vt_tray dict is still a list.
When there's no previously preserved data, the normalized dict should
remain as a list in raw_data.
"""
# raw_data starts empty — no preserved vt_tray
mqtt_client.state.raw_data = {}
data = {
"gcode_state": "IDLE",
"vt_tray": {"id": "254", "tray_type": "ABS"},
}
mqtt_client._update_state(data)
stored = mqtt_client.state.raw_data["vt_tray"]
assert isinstance(stored, list)
assert stored[0]["tray_type"] == "ABS"
class TestSendDryingCommand:
"""Tests for send_drying_command MQTT payload construction."""
@pytest.fixture
def mqtt_client(self):
"""Create a BambuMQTTClient with a mock MQTT client."""
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
return client
def test_rotate_tray_false_by_default(self, mqtt_client):
"""Verify rotate_tray defaults to False in the MQTT payload."""
mqtt_client.send_drying_command(ams_id=0, temp=55, duration=4, mode=1, filament="PLA")
call_args = mqtt_client._client.publish.call_args
payload = json.loads(call_args[0][1])
assert payload["print"]["rotate_tray"] is False
def test_rotate_tray_true_when_enabled(self, mqtt_client):
"""Verify rotate_tray is True when explicitly enabled."""
mqtt_client.send_drying_command(ams_id=0, temp=55, duration=4, mode=1, filament="PLA", rotate_tray=True)
call_args = mqtt_client._client.publish.call_args
payload = json.loads(call_args[0][1])
assert payload["print"]["rotate_tray"] is True
def test_rotate_tray_false_on_stop(self, mqtt_client):
"""Verify rotate_tray is False when stopping drying (mode=0)."""
mqtt_client.send_drying_command(ams_id=0, temp=0, duration=0, mode=0)
call_args = mqtt_client._client.publish.call_args
payload = json.loads(call_args[0][1])
assert payload["print"]["rotate_tray"] is False
def test_all_required_fields_present(self, mqtt_client):
"""Verify all required MQTT fields are present in the drying command."""
mqtt_client.send_drying_command(ams_id=128, temp=75, duration=8, mode=1, filament="ABS", rotate_tray=True)
call_args = mqtt_client._client.publish.call_args
payload = json.loads(call_args[0][1])
cmd = payload["print"]
assert cmd["command"] == "ams_filament_drying"
assert cmd["ams_id"] == 128
assert cmd["temp"] == 75
assert cmd["duration"] == 8
assert cmd["mode"] == 1
assert cmd["rotate_tray"] is True
assert cmd["filament"] == "ABS"
assert cmd["cooling_temp"] == 20
assert cmd["humidity"] == 0
assert cmd["close_power_conflict"] is False
assert "sequence_id" in cmd
def test_publishes_with_qos_1(self, mqtt_client):
"""Verify drying commands are published with QoS 1."""
mqtt_client.send_drying_command(ams_id=0, temp=55, duration=4)
call_args = mqtt_client._client.publish.call_args
# qos may be positional arg [2] or keyword
qos = call_args.kwargs.get("qos", call_args[0][2] if len(call_args[0]) > 2 else None)
assert qos == 1
def test_start_caches_target_for_badge(self, mqtt_client):
"""mode=1 send populates _drying_targets so the badge can render it."""
mqtt_client.send_drying_command(ams_id=2, temp=65, duration=12, mode=1, filament="PETG")
assert mqtt_client._drying_targets[2] == {"filament": "PETG", "temp": 65, "duration_hours": 12}
def test_start_overwrites_prior_target_for_same_ams(self, mqtt_client):
"""A second start on the same AMS replaces the cached target."""
mqtt_client.send_drying_command(ams_id=0, temp=55, duration=4, mode=1, filament="PLA")
mqtt_client.send_drying_command(ams_id=0, temp=70, duration=6, mode=1, filament="ABS")
assert mqtt_client._drying_targets[0] == {"filament": "ABS", "temp": 70, "duration_hours": 6}
def test_stop_clears_target(self, mqtt_client):
"""mode=0 send drops the cache so the badge stops showing the target."""
mqtt_client.send_drying_command(ams_id=1, temp=55, duration=4, mode=1, filament="PLA")
assert 1 in mqtt_client._drying_targets
mqtt_client.send_drying_command(ams_id=1, temp=0, duration=0, mode=0)
assert 1 not in mqtt_client._drying_targets
def test_targets_isolated_per_ams_id(self, mqtt_client):
"""Stopping one AMS doesn't affect another AMS's cached target."""
mqtt_client.send_drying_command(ams_id=0, temp=55, duration=4, mode=1, filament="PLA")
mqtt_client.send_drying_command(ams_id=128, temp=80, duration=6, mode=1, filament="PA-CF")
mqtt_client.send_drying_command(ams_id=0, temp=0, duration=0, mode=0)
assert 0 not in mqtt_client._drying_targets
assert mqtt_client._drying_targets[128] == {"filament": "PA-CF", "temp": 80, "duration_hours": 6}
class TestStartPrintAmsMapping:
"""Tests for ams_mapping/ams_mapping2 construction in start_print().
BambuStudio converts virtual tray IDs (254/255) to -1 in the flat
ams_mapping and puts the real external spool info only in ams_mapping2.
Passing raw 254/255 in the flat array causes H2D firmware to fail
with 0700_8012 "Failed to get AMS mapping table".
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
return client
def _get_published_command(self, mqtt_client):
"""Extract the parsed print command from the last publish call."""
call_args = mqtt_client._client.publish.call_args
return json.loads(call_args[0][1])["print"]
def test_regular_ams_trays_preserved_in_flat_mapping(self, mqtt_client):
"""Regular AMS tray IDs pass through unchanged in flat ams_mapping."""
mqtt_client.start_print("test.3mf", ams_mapping=[0, 5, 11])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [0, 5, 11]
assert cmd["ams_mapping2"] == [
{"ams_id": 0, "slot_id": 0},
{"ams_id": 1, "slot_id": 1},
{"ams_id": 2, "slot_id": 3},
]
def test_unmapped_slots(self, mqtt_client):
"""Unmapped slots (-1) produce -1 in flat and 0xFF/0xFF in mapping2."""
mqtt_client.start_print("test.3mf", ams_mapping=[-1, -1])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1, -1]
assert cmd["ams_mapping2"] == [
{"ams_id": 255, "slot_id": 255},
{"ams_id": 255, "slot_id": 255},
]
def test_external_main_nozzle_becomes_minus_one_in_flat(self, mqtt_client):
"""Virtual tray 255 (main nozzle) must be -1 in flat mapping."""
mqtt_client.start_print("test.3mf", ams_mapping=[255])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1]
assert cmd["ams_mapping2"] == [{"ams_id": 255, "slot_id": 0}]
def test_single_nozzle_external_spool_uses_main_id(self, mqtt_client):
"""Single-nozzle external spool (254) maps to ams_id=255 (VIRTUAL_TRAY_MAIN_ID).
Firmware reports tray_now=254 for external spool, but the print command
must use ams_id=255 in ams_mapping2. Sending 254 causes the firmware to
target AMS tray 0 instead of external spool (07FF_8012 error).
"""
mqtt_client.start_print("test.3mf", ams_mapping=[254])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1]
assert cmd["ams_mapping2"] == [{"ams_id": 255, "slot_id": 0}]
def test_h2d_external_spool_mixed_with_ams(self, mqtt_client):
"""H2D scenario: AMS trays + unmapped + external deputy nozzle."""
# Reproduces the exact scenario from issue #797:
# 5-slot 3MF, only slot 5 assigned to external deputy nozzle (254)
mqtt_client.start_print("test.3mf", ams_mapping=[-1, -1, -1, -1, 255])
cmd = self._get_published_command(mqtt_client)
# Flat mapping: all -1 (external converted, unmapped stay -1)
assert cmd["ams_mapping"] == [-1, -1, -1, -1, -1]
# Detailed mapping: unmapped slots use 0xFF, external uses real ams_id
assert cmd["ams_mapping2"] == [
{"ams_id": 255, "slot_id": 255},
{"ams_id": 255, "slot_id": 255},
{"ams_id": 255, "slot_id": 255},
{"ams_id": 255, "slot_id": 255},
{"ams_id": 255, "slot_id": 0},
]
def test_ams_ht_trays_preserved_in_flat_mapping(self, mqtt_client):
"""AMS-HT tray IDs (>=128) pass through in flat mapping."""
mqtt_client.start_print("test.3mf", ams_mapping=[128, 131])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [128, 131]
assert cmd["ams_mapping2"] == [
{"ams_id": 128, "slot_id": 0},
{"ams_id": 131, "slot_id": 0},
]
def test_non_h2d_both_external_maps_to_main_id(self, mqtt_client):
"""Non-H2D: both 254 and 255 map to ams_id=255 (single nozzle)."""
mqtt_client.start_print("test.3mf", ams_mapping=[254, 255])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1, -1]
assert cmd["ams_mapping2"] == [
{"ams_id": 255, "slot_id": 0},
{"ams_id": 255, "slot_id": 0},
]
def test_h2d_external_preserves_deputy_id(self, mqtt_client):
"""H2D dual-nozzle: 254 (deputy) stays 254, 255 (main) stays 255."""
mqtt_client.model = "H2D"
mqtt_client.start_print("test.3mf", ams_mapping=[254, 255])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1, -1]
assert cmd["ams_mapping2"] == [
{"ams_id": 254, "slot_id": 0},
{"ams_id": 255, "slot_id": 0},
]
def test_h2d_single_external_deputy(self, mqtt_client):
"""H2D: single external spool on deputy nozzle (254) keeps ams_id=254."""
mqtt_client.model = "H2D Pro"
mqtt_client.start_print("test.3mf", ams_mapping=[254])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1]
assert cmd["ams_mapping2"] == [{"ams_id": 254, "slot_id": 0}]
def test_external_spool_only_sets_use_ams_false(self, mqtt_client):
"""Single external spool on non-H2D printer sets use_ams=False."""
mqtt_client.start_print("test.3mf", ams_mapping=[254], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is False
def test_all_unresolved_keeps_use_ams_true(self, mqtt_client):
"""All-unresolved (-1) is NOT external — must keep use_ams=True (#2589).
A stored [-1] comes from an unresolved mapping (e.g. a frontend
status-load race), not an explicit external-spool selection. Treating it
as external silently started the print against the empty external feed.
Only >=254 may downgrade to use_ams=False.
"""
mqtt_client.start_print("test.3mf", ams_mapping=[-1, -1], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is True
def test_mixed_ams_and_external_keeps_use_ams_true(self, mqtt_client):
"""AMS tray + external spool keeps use_ams=True."""
mqtt_client.start_print("test.3mf", ams_mapping=[0, 254], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is True
def test_h2d_both_external_keeps_use_ams_true(self, mqtt_client):
"""H2D with both external spools keeps use_ams=True (nozzle routing)."""
mqtt_client.model = "H2D"
mqtt_client.start_print("test.3mf", ams_mapping=[254, 255], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is True
def test_empty_ams_mapping_keeps_use_ams_true(self, mqtt_client):
"""Empty ams_mapping list does not override use_ams."""
mqtt_client.start_print("test.3mf", ams_mapping=[], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is True
def test_no_ams_mapping_omits_fields(self, mqtt_client):
"""When ams_mapping is None, neither field is in the command."""
mqtt_client.start_print("test.3mf", ams_mapping=None)
cmd = self._get_published_command(mqtt_client)
assert "ams_mapping" not in cmd
assert "ams_mapping2" not in cmd
def test_x2d_external_preserves_deputy_id(self, mqtt_client):
"""X2D dual-nozzle (#988): 254 (deputy) stays 254, like H2D family.
X2D launched April 2026 and shares the H2D-style dual-extruder
firmware convention — external spool on the deputy (left) nozzle
is addressed as ams_id=254, not coerced to 255.
"""
mqtt_client.model = "X2D"
mqtt_client.start_print("test.3mf", ams_mapping=[254, 255])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1, -1]
assert cmd["ams_mapping2"] == [
{"ams_id": 254, "slot_id": 0},
{"ams_id": 255, "slot_id": 0},
]
def test_x2d_uses_boolean_format_for_calibration_fields(self, mqtt_client):
"""X2D sends calibration fields as JSON booleans, like every model (#1478).
An earlier revision integer-encoded these for the H2 family on the
belief that H2 firmware required 0/1. A BambuStudio request-topic
capture from a real H2D disproved it — BambuStudio sends plain
booleans — so X2D follows the same boolean format.
"""
mqtt_client.model = "X2D"
mqtt_client.start_print(
"test.3mf",
timelapse=True,
bed_levelling="off",
flow_cali="on",
vibration_cali=False,
layer_inspect=True,
)
cmd = self._get_published_command(mqtt_client)
assert cmd["timelapse"] is True
# bed_leveling stays a bool (true only for "on"); the tri-state rides on
# the auto_bed_leveling int.
assert cmd["bed_leveling"] is False
assert cmd["auto_bed_leveling"] == 0
assert cmd["flow_cali"] is True
assert cmd["vibration_cali"] is False
assert cmd["layer_inspect"] is True
# flow_cali on → extrude_cali_flag must request the calibration pass.
assert cmd["extrude_cali_flag"] == 1
def test_p2s_uses_boolean_format(self, mqtt_client):
"""P2S sends calibration fields as JSON booleans (single-nozzle, like X1C/A1/P1)."""
mqtt_client.model = "P2S"
mqtt_client.start_print("test.3mf", timelapse=True, flow_cali="off")
cmd = self._get_published_command(mqtt_client)
assert cmd["timelapse"] is True
assert cmd["flow_cali"] is False
# flow_cali "off" → extrude_cali_flag=0 (firmware skips the pre-print
# calibration stage entirely). "auto" would send 2 instead.
assert cmd["extrude_cali_flag"] == 0
def test_h2s_single_external_spool_uses_main_id(self, mqtt_client):
"""H2S is single-nozzle (#1386): external spool (254) → ams_id=255.
H2S shares serial prefix "094" and the H-family firmware-format
quirks with H2D, but it has a single extruder (nozzle_count=1
confirmed across 9+ support bundles). Routing the deputy-nozzle
sentinel (254) through to firmware on a single-nozzle printer
causes 07FF_8012 "Failed to get AMS mapping table" — exactly the
symptom reporter krootstijn hit when printing without an AMS.
"""
mqtt_client.model = "H2S"
mqtt_client.start_print("test.3mf", ams_mapping=[254])
cmd = self._get_published_command(mqtt_client)
assert cmd["ams_mapping"] == [-1]
assert cmd["ams_mapping2"] == [{"ams_id": 255, "slot_id": 0}]
def test_h2s_no_ams_forces_use_ams_false(self, mqtt_client):
"""H2S with only external spool must drop into the use_ams=False
fallback, like P1S/P1P. The dual-nozzle bypass kept this path
unreachable before #1386 — the firmware then rejected the print
with 07FF_8012 because there was no AMS mapping table.
"""
mqtt_client.model = "H2S"
mqtt_client.start_print("test.3mf", ams_mapping=[254], use_ams=True)
cmd = self._get_published_command(mqtt_client)
assert cmd["use_ams"] is False
def test_h2s_uses_boolean_format_for_calibration_fields(self, mqtt_client):
"""H2S sends calibration fields as JSON booleans (#1478).
The H2S was previously integer-encoded as part of the H2 family. That
made it accept the print command but silently skip flow-dynamics
calibration — the reporter saw poor corner quality from a stale K
value. BambuStudio sends booleans for these fields and pairs flow_cali
with extrude_cali_flag=1 to actually run the calibration pass.
"""
mqtt_client.model = "H2S"
mqtt_client.start_print(
"test.3mf",
timelapse=True,
bed_levelling="off",
flow_cali="on",
vibration_cali=False,
layer_inspect=True,
)
cmd = self._get_published_command(mqtt_client)
assert cmd["timelapse"] is True
assert cmd["bed_leveling"] is False
assert cmd["flow_cali"] is True
assert cmd["vibration_cali"] is False
assert cmd["layer_inspect"] is True
# flow_cali on → extrude_cali_flag=1 so the printer runs the
# flow-dynamics calibration instead of reusing the stored PA value.
assert cmd["extrude_cali_flag"] == 1
def test_bed_leveling_auto_sends_int_two(self, mqtt_client):
"""`bed_levelling="auto"` → bool false + auto_bed_leveling=2.
Matches BambuStudio's ops_auto wire shape: the bool is true only for the
explicit "on" state; "auto" carries its intent in the int (2 = run only
if the bed wasn't levelled recently).
"""
mqtt_client.model = "X1C"
mqtt_client.start_print("test.3mf", bed_levelling="auto")
cmd = self._get_published_command(mqtt_client)
assert cmd["bed_leveling"] is False
assert cmd["auto_bed_leveling"] == 2
def test_bed_leveling_on_sends_int_one(self, mqtt_client):
"""`bed_levelling="on"` → bool true + auto_bed_leveling=1 (force)."""
mqtt_client.model = "X1C"
mqtt_client.start_print("test.3mf", bed_levelling="on")
cmd = self._get_published_command(mqtt_client)
assert cmd["bed_leveling"] is True
assert cmd["auto_bed_leveling"] == 1
def test_flow_cali_auto_sends_int_two(self, mqtt_client):
"""`flow_cali="auto"` → bool false + extrude_cali_flag=2.
#1721 saw stage 8 stay queued on 2 — that is the auto contract (queued,
skipped at runtime if the filament was calibrated recently), which is
exactly what "auto" should do.
"""
mqtt_client.model = "X1C"
mqtt_client.start_print("test.3mf", flow_cali="auto")
cmd = self._get_published_command(mqtt_client)
assert cmd["flow_cali"] is False
assert cmd["extrude_cali_flag"] == 2
def test_nozzle_offset_cali_default_auto_gated_on_single_nozzle(self, mqtt_client):
"""Default (auto) on a single-nozzle printer → wire value `0`.
The default is now "auto", but single-nozzle machines have no second
head to calibrate, so the MQTT layer gates any state to `0` there.
"""
mqtt_client.model = "P1S"
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["nozzle_offset_cali"] == 0
def test_nozzle_offset_cali_ignored_on_single_nozzle(self, mqtt_client):
"""Single-nozzle printer: `nozzle_offset_cali="on"` is silently dropped.
H2S is in the H2 firmware family but single-nozzle. The toggle has
no physical meaning on single-nozzle machines and the UI gates it
behind `nozzle_count==2`. Even if a stale queue item from when the
printer was misidentified as dual carries the flag, the MQTT layer
must downgrade it so firmware never tries to calibrate a head it
doesn't have (#1682).
"""
mqtt_client.model = "P1S"
mqtt_client.start_print("test.3mf", nozzle_offset_cali="on")
cmd = self._get_published_command(mqtt_client)
assert cmd["nozzle_offset_cali"] == 0
def test_nozzle_offset_cali_honored_on_dual_nozzle(self, mqtt_client):
"""Dual-nozzle printer (H2D): `nozzle_offset_cali="on"` → wire value `1`.
H2D is in `DUAL_NOZZLE_MODELS`. The toggle controls whether the
printer runs the nozzle-offset calibration pass before the print
starts. "on"=1 (force), "auto"=2, "off"=0 (#1682).
"""
mqtt_client.model = "H2D"
mqtt_client.start_print("test.3mf", nozzle_offset_cali="on")
cmd = self._get_published_command(mqtt_client)
assert cmd["nozzle_offset_cali"] == 1
def test_nozzle_offset_cali_auto_on_dual_nozzle(self, mqtt_client):
"""Dual-nozzle printer (H2D): `nozzle_offset_cali="auto"` → wire value `2`."""
mqtt_client.model = "H2D"
mqtt_client.start_print("test.3mf", nozzle_offset_cali="auto")
cmd = self._get_published_command(mqtt_client)
assert cmd["nozzle_offset_cali"] == 2
def test_nozzle_offset_cali_off_on_dual_nozzle(self, mqtt_client):
"""Dual-nozzle printer (H2D Pro): `nozzle_offset_cali="off"` → `0` (skip).
Critical for users like #1682 who run diamond nozzles and need to
keep the calibration off.
"""
mqtt_client.model = "H2D Pro"
mqtt_client.start_print("test.3mf", nozzle_offset_cali="off")
cmd = self._get_published_command(mqtt_client)
assert cmd["nozzle_offset_cali"] == 0
class TestStartPrintUniqueIdentityFields:
"""Regression guard: project_id/subtask_id/task_id must be unique per submission (#1011).
Hardcoded "0" values caused third-party MQTT observers (e.g. OctoEverywhere)
to treat archive reprints as continuations of the same job and report
compounding durations on repeat replays. Each start_print call must produce
a distinct, non-zero identity triplet so the printer emits a fresh state
transition. md5 is deliberately left empty — historically firmware treats
"" as "skip validation" and we don't have the file's real digest here.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
return client
def _get_published_command(self, mqtt_client):
call_args = mqtt_client._client.publish.call_args
return json.loads(call_args[0][1])["print"]
def test_identity_fields_are_non_zero(self, mqtt_client):
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["project_id"] != "0"
assert cmd["subtask_id"] != "0"
assert cmd["task_id"] != "0"
def test_identity_fields_are_all_equal_per_submission(self, mqtt_client):
"""All three IDs come from the same submission timestamp — Studio also
uses a single identity per submission across the three fields."""
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["project_id"] == cmd["subtask_id"] == cmd["task_id"]
def test_md5_stays_empty(self, mqtt_client):
"""Deliberate: synthetic md5 risks activating firmware validation."""
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["md5"] == ""
def test_identity_fields_change_between_submissions(self, mqtt_client):
"""Two successive start_print calls must produce different IDs.
Without this, the printer can't tell replays apart and reuses
gcode_start_time from the prior job.
"""
mqtt_client.start_print("test.3mf")
first = self._get_published_command(mqtt_client)
time.sleep(0.002)
mqtt_client.start_print("test.3mf")
second = self._get_published_command(mqtt_client)
assert first["task_id"] != second["task_id"]
assert first["subtask_id"] != second["subtask_id"]
assert first["project_id"] != second["project_id"]
def test_submission_id_is_numeric_string(self, mqtt_client):
"""ID format: digits-only string. Studio uses cloud task IDs that are
also numeric-looking strings; the DB column is VARCHAR(64) and
Bambuddy's own subtask_id parser treats '0'/'' as absent — any valid
digit string that isn't '0' is fine."""
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["task_id"].isdigit()
assert int(cmd["task_id"]) > 0
assert len(cmd["task_id"]) <= 64
def test_last_dispatch_subtask_id_records_the_minted_id(self, mqtt_client):
"""#1485: start_print records the minted id on the client so
on_print_start can persist it on the archive before the printer
echoes subtask_id back — letting a later restart resume by id."""
assert mqtt_client.last_dispatch_subtask_id is None
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert mqtt_client.last_dispatch_subtask_id == cmd["subtask_id"]
def test_last_dispatch_subtask_id_updates_per_submission(self, mqtt_client):
"""Each dispatch overwrites the recorded id with the new submission's."""
mqtt_client.start_print("test.3mf")
first = mqtt_client.last_dispatch_subtask_id
time.sleep(0.002)
mqtt_client.start_print("test.3mf")
assert mqtt_client.last_dispatch_subtask_id != first
assert mqtt_client.last_dispatch_subtask_id == self._get_published_command(mqtt_client)["subtask_id"]
def test_submission_id_fits_signed_int32(self, mqtt_client):
"""Regression for #1042: P1S firmware clamps oversized task identity
fields to signed int32 max (2**31-1 = 2147483647). If we send raw
epoch-ms (~1.7e12), the printer sees a saturated constant on every
submission and treats fresh dispatches as continuations of the last
FAILED job — never leaves IDLE. Keep below 2**31.
"""
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert int(cmd["task_id"]) < 2**31
assert int(cmd["project_id"]) < 2**31
assert int(cmd["subtask_id"]) < 2**31
def test_unrelated_payload_fields_untouched(self, mqtt_client):
"""Regression guard: fix only touches identity fields; everything else
(sequence_id, command verb, calibration defaults, profile_id) must be
unchanged to avoid silently breaking printer behavior."""
mqtt_client.start_print("test.3mf")
cmd = self._get_published_command(mqtt_client)
assert cmd["sequence_id"] == "20000"
assert cmd["command"] == "project_file"
assert cmd["param"] == "Metadata/plate_1.gcode"
assert cmd["url"] == "ftp://test.3mf"
assert cmd["file"] == "test.3mf"
assert cmd["profile_id"] == "0"
assert cmd["subtask_name"] == "test"
# The device-config bitmask is not a per-job field and is no longer
# sent; the printer echoed it back and we read it as telemetry (#3040).
assert "cfg" not in cmd
class TestDeleteKProfileDualNozzleDetection:
"""Regression guard: dual-nozzle detection for K-profile delete.
delete_kprofile branches on dual-nozzle status to pick the wire format.
Source of truth is the runtime `_is_dual_nozzle` flag (set from
device.extruder.info); model name is the fallback used before push
data arrives. Serial-prefix detection alone is wrong — H2S shares
prefix "094" with H2D but is single-nozzle (#1386).
"""
def _make_client(self, *, serial: str = "TEST", model: str | None = None, dual_runtime: bool = False):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number=serial,
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
client.model = model
client._is_dual_nozzle = dual_runtime
return client
def _published(self, client):
return json.loads(client._client.publish.call_args[0][1])["print"]
def test_h2d_model_uses_dual_nozzle_format(self):
client = self._make_client(serial="09400A000000001", model="H2D")
client.delete_kprofile(cali_idx=1, filament_id="GFA00", nozzle_id="HH00-0.4")
cmd = self._published(client)
# Dual-nozzle command omits setting_id.
assert "setting_id" not in cmd
assert cmd["extruder_id"] == 0
def test_x2d_model_uses_dual_nozzle_format(self):
client = self._make_client(serial="20P90A000000001", model="X2D")
client.delete_kprofile(cali_idx=1, filament_id="GFA00", nozzle_id="HH00-0.4")
cmd = self._published(client)
assert "setting_id" not in cmd
assert cmd["extruder_id"] == 0
def test_h2c_model_uses_dual_nozzle_format(self):
"""Post-2026 H2C batches ship with '31B8B' prefix instead of '094' (#1105).
Model-name detection works regardless of serial prefix."""
client = self._make_client(serial="31B8BP000000001", model="H2C")
client.delete_kprofile(cali_idx=1, filament_id="GFA00", nozzle_id="HH00-0.4")
cmd = self._published(client)
assert "setting_id" not in cmd
assert cmd["extruder_id"] == 0
def test_runtime_dual_nozzle_flag_uses_dual_format(self):
"""When _is_dual_nozzle is set from device.extruder.info, the model
fallback isn't needed (covers future dual-nozzle models we haven't
seen yet)."""
client = self._make_client(serial="UNKNOWN", model=None, dual_runtime=True)
client.delete_kprofile(cali_idx=1, filament_id="GFA00", nozzle_id="HH00-0.4")
cmd = self._published(client)
assert "setting_id" not in cmd
def test_h2s_uses_single_nozzle_format(self):
"""H2S shares serial prefix "094" with H2D but is single-nozzle (#1386).
Must take the single-nozzle branch with setting_id included.
"""
client = self._make_client(serial="09400S000000001", model="H2S")
client.delete_kprofile(
cali_idx=1,
filament_id="GFA00",
nozzle_id="HH00-0.4",
setting_id="PFB123",
)
cmd = self._published(client)
assert cmd["setting_id"] == "PFB123"
def test_p2s_uses_single_nozzle_format(self):
"""P2S is single-nozzle — must NOT take the dual-nozzle branch."""
client = self._make_client(serial="22E00A000000001", model="P2S")
client.delete_kprofile(
cali_idx=1,
filament_id="GFA00",
nozzle_id="HH00-0.4",
setting_id="PFB123",
)
cmd = self._published(client)
# Single-nozzle command includes setting_id.
assert cmd["setting_id"] == "PFB123"
def test_x1c_uses_single_nozzle_format(self):
client = self._make_client(serial="00M00A000000001", model="X1C")
client.delete_kprofile(
cali_idx=1,
filament_id="GFA00",
nozzle_id="HH00-0.4",
setting_id="PFB123",
)
cmd = self._published(client)
assert cmd["setting_id"] == "PFB123"
class TestStaleReconnect:
"""Tests for stale connection detection and reconnect without UI bouncing."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_STALE",
access_code="12345678",
)
return client
def test_check_staleness_sets_flag_and_broadcasts_once(self, mqtt_client):
"""check_staleness() should set connected=False, broadcast, and set _stale_reconnecting."""
import time
state_changes = []
mqtt_client.on_state_change = lambda s: state_changes.append(s.connected)
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120 # well past 60s threshold
result = mqtt_client.check_staleness()
assert result is False
assert mqtt_client.state.connected is False
assert mqtt_client._stale_reconnecting is True
assert state_changes == [False] # Exactly one broadcast
def test_check_staleness_noop_when_not_connected(self, mqtt_client):
"""check_staleness() should not set flag when already disconnected."""
import time
mqtt_client.state.connected = False
mqtt_client._last_message_time = time.time() - 120
mqtt_client.check_staleness()
assert mqtt_client._stale_reconnecting is False
def test_check_staleness_noop_when_not_stale(self, mqtt_client):
"""check_staleness() should not set flag when messages are recent."""
import time
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 5 # 5s ago, well within 60s
result = mqtt_client.check_staleness()
assert result is True
assert mqtt_client.state.connected is True
assert mqtt_client._stale_reconnecting is False
def test_check_staleness_logs_serial_hint_when_no_reports(self, mqtt_client, caplog):
"""#1465 — a stale connection that never received a status report logs
an actionable serial-number hint, exactly once."""
import logging
import time
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
mqtt_client._report_messages_since_connect = 0
with caplog.at_level(logging.WARNING):
mqtt_client.check_staleness()
assert mqtt_client._zero_report_hint_logged is True
assert any("zero status reports" in r.getMessage() for r in caplog.records)
# Re-arm staleness — the hint must not log a second time.
caplog.clear()
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
mqtt_client._last_stale_reconnect = 0.0 # bypass the reconnect cooldown
with caplog.at_level(logging.WARNING):
mqtt_client.check_staleness()
assert not any("zero status reports" in r.getMessage() for r in caplog.records)
def test_check_staleness_no_serial_hint_right_after_reconnect(self, mqtt_client, caplog):
"""#2732 — _report_messages_since_connect is reset by _on_connect, so a
reconnect landing just before the staleness check leaves it at 0 for
reasons that have nothing to do with the serial. A healthy P1S was being
told to check its serial number 1 ms after reconnecting."""
import logging
import time
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
mqtt_client._report_messages_since_connect = 0
mqtt_client._connect_time = time.monotonic() # fresh session
with caplog.at_level(logging.WARNING):
mqtt_client.check_staleness()
assert mqtt_client._zero_report_hint_logged is False
assert not any("zero status reports" in r.getMessage() for r in caplog.records)
# The stale reconnect itself still happens — only the hint is suppressed.
assert mqtt_client._stale_reconnecting is True
def test_check_staleness_serial_hint_when_session_old_enough(self, mqtt_client, caplog):
"""A session that has been up past the stale window and still received
nothing is the case the hint was written for."""
import logging
import time
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
mqtt_client._report_messages_since_connect = 0
mqtt_client._connect_time = time.monotonic() - 120
with caplog.at_level(logging.WARNING):
mqtt_client.check_staleness()
assert mqtt_client._zero_report_hint_logged is True
assert any("zero status reports" in r.getMessage() for r in caplog.records)
def test_check_staleness_no_serial_hint_when_reports_received(self, mqtt_client, caplog):
"""A stale connection that DID receive reports (a normal mid-session
quiet gap) must not log the serial-number hint."""
import logging
import time
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
mqtt_client._report_messages_since_connect = 5
with caplog.at_level(logging.WARNING):
mqtt_client.check_staleness()
assert mqtt_client._zero_report_hint_logged is False
assert not any("zero status reports" in r.getMessage() for r in caplog.records)
def test_on_disconnect_skipped_during_stale_reconnect(self, mqtt_client):
"""_on_disconnect should not broadcast state when _stale_reconnecting is set."""
state_changes = []
mqtt_client.on_state_change = lambda s: state_changes.append(s.connected)
mqtt_client._stale_reconnecting = True
mqtt_client.state.connected = False
mqtt_client._on_disconnect(None, None)
# No state change broadcast — check_staleness() already did it
assert state_changes == []
assert mqtt_client.state.connected is False
def test_on_disconnect_fires_event_during_stale_reconnect(self, mqtt_client):
"""_on_disconnect must still fire _disconnection_event even during stale reconnect.
If disconnect() is called while _stale_reconnecting is True (e.g. user removes
the printer before paho reconnects), the event must fire so disconnect() doesn't hang.
"""
import threading
mqtt_client._stale_reconnecting = True
mqtt_client._disconnection_event = threading.Event()
mqtt_client._on_disconnect(None, None)
assert mqtt_client._disconnection_event.is_set()
def test_on_connect_clears_stale_reconnecting_flag(self, mqtt_client):
"""_on_connect should clear _stale_reconnecting and restore connected=True."""
mqtt_client._stale_reconnecting = True
mqtt_client.state.connected = False
subscribe_calls = []
mock_client = type(
"MockClient",
(),
{
"subscribe": lambda self, topic: subscribe_calls.append(topic) or (0, 1),
},
)()
mqtt_client._on_connect(mock_client, None, None, 0)
assert mqtt_client._stale_reconnecting is False
assert mqtt_client.state.connected is True
def test_full_stale_reconnect_cycle_no_bounce(self, mqtt_client):
"""Full cycle: stale → disconnect callback → reconnect. UI should see exactly one disconnect."""
import time
state_changes = []
mqtt_client.on_state_change = lambda s: state_changes.append(s.connected)
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 120
# Step 1: Stale detection triggers
mqtt_client.check_staleness()
assert state_changes == [False]
# Step 2: Paho fires disconnect callback (from socket close)
mqtt_client._on_disconnect(None, None)
# Should NOT add another state change
assert state_changes == [False]
# Step 3: Paho reconnects
subscribe_calls = []
mock_client = type(
"MockClient",
(),
{
"subscribe": lambda self, topic: subscribe_calls.append(topic) or (0, 1),
},
)()
mqtt_client._on_connect(mock_client, None, None, 0)
assert state_changes == [False, True] # Now connected again
assert mqtt_client._stale_reconnecting is False
def test_spurious_disconnect_suppressed_when_recent_messages(self, mqtt_client):
"""Non-error disconnect with recent messages should be suppressed."""
import time
state_changes = []
mqtt_client.on_state_change = lambda s: state_changes.append(s.connected)
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 3 # 3s ago
# Non-error disconnect (rc=None)
mqtt_client._on_disconnect(None, None)
assert state_changes == []
assert mqtt_client.state.connected is True
def test_error_disconnect_not_suppressed_despite_recent_messages(self, mqtt_client):
"""Error disconnect should always be processed, even with recent messages."""
import time
import paho.mqtt.client as mqtt
from paho.mqtt.reasoncodes import ReasonCode
state_changes = []
mqtt_client.on_state_change = lambda s: state_changes.append(s.connected)
mqtt_client.state.connected = True
mqtt_client._last_message_time = time.time() - 3 # 3s ago
# Error disconnect (rc.is_failure = True)
rc = ReasonCode(mqtt.CONNACK >> 4, identifier=0x80) # Failure code
mqtt_client._on_disconnect(None, None, rc=rc)
assert state_changes == [False]
assert mqtt_client.state.connected is False
class TestDoorOpenParsing:
"""Tests for enclosure door state parsing (X1 home_flag bit 23 vs others stat bit 23)."""
def _make_client(self, model: str):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST",
access_code="12345678",
model=model,
)
def test_x1c_door_open_from_home_flag(self):
client = self._make_client("X1C")
# bit 23 set
client._update_state({"home_flag": 0xC0E5CD98})
assert client.state.door_open is True
def test_x1c_door_closed_from_home_flag(self):
client = self._make_client("X1C")
client.state.door_open = True # start "open"
client._update_state({"home_flag": 0xC065CD98})
assert client.state.door_open is False
def test_x1c_ignores_stat_field(self):
# X1C must NOT use stat (bit 23 in stat is unrelated for X1)
client = self._make_client("X1C")
client._update_state({"home_flag": 0xC065CD98, "stat": "47A58000"})
assert client.state.door_open is False # home_flag wins
def test_h2d_door_open_from_stat(self):
client = self._make_client("H2D")
client._update_state({"stat": "640A58000"}) # bit 23 set
assert client.state.door_open is True
def test_h2d_door_closed_from_stat(self):
client = self._make_client("H2D")
client.state.door_open = True
client._update_state({"stat": "640258000"}) # bit 23 cleared
assert client.state.door_open is False
def test_h2d_ignores_home_flag(self):
# Non-X1 must NOT consume home_flag for door state
client = self._make_client("H2D")
client._update_state({"home_flag": 0xC0E5CD98, "stat": "640258000"})
assert client.state.door_open is False # stat wins
def test_invalid_stat_does_not_raise(self):
client = self._make_client("H2D")
client._update_state({"stat": "not-hex"})
assert client.state.door_open is False
class TestSdCardParsing:
"""SD-card state is only set from the top-level `sdcard` field (bool/int/
string variants). home_flag is NOT consulted — heartbeat pushes clear those
bits even when a card is inserted, and the prior badge feature was removed
entirely because no reliable heartbeat-vs-full-push heuristic existed."""
def _make_client(self, model: str = "H2D"):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST",
access_code="12345678",
model=model,
)
def test_home_flag_alone_does_not_touch_sdcard(self):
client = self._make_client()
client.state.sdcard = True
for home_flag in (0x00000000, 0x00000100, 0x00000200):
client._update_state({"home_flag": home_flag})
assert client.state.sdcard is True
def test_sdcard_string_fallback_when_no_home_flag(self):
client = self._make_client()
client._update_state({"sdcard": "HAS_SDCARD_NORMAL"})
assert client.state.sdcard is True
def test_sdcard_int_fallback_when_no_home_flag(self):
# `1 is True` is False — the old strict check flapped here.
client = self._make_client()
client._update_state({"sdcard": 1})
assert client.state.sdcard is True
def test_sdcard_bool_fallback_when_no_home_flag(self):
client = self._make_client()
client._update_state({"sdcard": True})
assert client.state.sdcard is True
client._update_state({"sdcard": False})
assert client.state.sdcard is False
class TestZombieSessionDetection:
"""Tests for ams_filament_setting response tracking (#887).
When a printer's MQTT session degrades so that telemetry flows but
published commands never reach the printer, the zombie detector
counts consecutive unanswered ams_filament_setting commands and
force-reconnects after two.
"""
@pytest.fixture
def mqtt_client(self):
import time
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client.state.connected = True
mock_paho = MagicMock()
mock_paho.socket.return_value = MagicMock()
client._client = mock_paho
client._connect_time = time.monotonic() - 10.0
# Set developer_mode so the dev-mode probe branch doesn't interfere
client.state.developer_mode = True
return client
def test_initial_state_is_clean(self, mqtt_client):
"""Tracking fields start at zero / no pending command."""
assert mqtt_client._last_ams_cmd_time == 0.0
assert mqtt_client._ams_cmd_unanswered == 0
def test_publish_sets_pending_time(self, mqtt_client):
"""set_ams_filament_setting records the publish timestamp."""
import time
before = time.monotonic()
mqtt_client.ams_set_filament_setting(
ams_id=0,
tray_id=0,
tray_info_idx="GFL99",
tray_type="PLA",
tray_sub_brands="",
tray_color="FF0000FF",
nozzle_temp_min=190,
nozzle_temp_max=230,
)
assert mqtt_client._last_ams_cmd_time >= before
def test_reset_slot_sets_pending_time(self, mqtt_client):
"""reset_ams_slot also records the publish timestamp."""
import time
before = time.monotonic()
mqtt_client.reset_ams_slot(ams_id=0, tray_id=0)
assert mqtt_client._last_ams_cmd_time >= before
def test_response_clears_pending(self, mqtt_client):
"""An ams_filament_setting response clears the pending state."""
import time
mqtt_client._last_ams_cmd_time = time.monotonic()
mqtt_client._ams_cmd_unanswered = 1
# Simulate receiving a user-command response (sequence_id "0")
print_data = {
"command": "ams_filament_setting",
"sequence_id": "0",
"result": "success",
}
# Walk the same path as _on_message: command response check then _update_state
cmd = print_data.get("command")
if cmd == "ams_filament_setting" and mqtt_client._last_ams_cmd_time > 0:
mqtt_client._last_ams_cmd_time = 0.0
mqtt_client._ams_cmd_unanswered = 0
assert mqtt_client._last_ams_cmd_time == 0.0
assert mqtt_client._ams_cmd_unanswered == 0
def test_single_timeout_increments_counter(self, mqtt_client):
"""One unanswered command increments the counter but does not reconnect."""
import time
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
assert mqtt_client._last_ams_cmd_time == 0.0
# Should NOT force-reconnect after just one
assert mqtt_client.state.connected is True
def test_two_timeouts_force_reconnect(self, mqtt_client):
"""Two consecutive unanswered commands trigger force_reconnect.
Zombie detection runs from paho's network thread (no asyncio loop), so
the routing in force_reconnect_stale_session falls back to socket-close
— which is the safe option since loop_stop() from inside the loop
thread would deadlock. Hard-reset is reserved for async-context callers
on the queue dispatch path."""
import time
state_change_called = []
mqtt_client.on_state_change = lambda s: state_change_called.append(True)
# First unanswered command
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
assert mqtt_client.state.connected is True
# Second unanswered command
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 0 # reset after reconnect
assert mqtt_client.state.connected is False
assert mqtt_client._stale_reconnecting is True
# Sync test → no running loop → socket-close fallback path
mqtt_client._client.socket().close.assert_called()
assert len(state_change_called) > 0
def test_response_between_timeouts_resets_counter(self, mqtt_client):
"""A successful response after one timeout resets the counter."""
import time
# First unanswered command
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
# Now a response arrives — clear pending
mqtt_client._last_ams_cmd_time = time.monotonic()
mqtt_client._last_ams_cmd_time = 0.0
mqtt_client._ams_cmd_unanswered = 0
# Next unanswered command should be count=1, not count=2
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
assert mqtt_client.state.connected is True # no reconnect
def test_late_response_after_watchdog_clears_counter_issue_1164(self, mqtt_client):
"""Regression for #1164: a late ams_filament_setting response — one
that arrives AFTER the watchdog has already zeroed
`_last_ams_cmd_time` and incremented the unanswered counter — must
still reset the counter. Without this, a single sluggish response
leaves the counter armed at 1 indefinitely; the next slow response
on a totally unrelated command (possibly minutes or hours later)
takes it to 2 and force-reconnects, surfacing as 'AMS slot config
doesn't reach the printer ~6 changes in'."""
import time
# First command publishes, then doesn't get a response for >10s.
# Watchdog fires: counter=1, _last_ams_cmd_time zeroed.
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
assert mqtt_client._last_ams_cmd_time == 0.0 # watchdog cleared it
# Late response arrives — the `_process_message` path used to require
# `_last_ams_cmd_time > 0` before resetting the counter, so this would
# have silently been ignored.
mqtt_client._process_message(
{
"print": {
"command": "ams_filament_setting",
"sequence_id": "0",
"result": "success",
"reason": "success",
}
}
)
# Counter MUST be reset — the response proves the channel is alive.
assert mqtt_client._ams_cmd_unanswered == 0, (
"Late ams_filament_setting response must reset the unanswered "
"counter even when the watchdog already zeroed _last_ams_cmd_time. "
"If this assertion fails the #1164 regression is back: a single "
"sluggish response will leave the counter armed and cause a "
"spurious force_reconnect on the next slow response."
)
# Now even if a future command times out, the counter starts fresh
# and a single timeout doesn't trip the 2x reconnect threshold.
mqtt_client._last_ams_cmd_time = time.monotonic() - 11.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 1
assert mqtt_client.state.connected is True # no force reconnect
def test_on_connect_resets_tracking(self, mqtt_client):
"""_on_connect resets zombie tracking fields."""
import time
mqtt_client._last_ams_cmd_time = time.monotonic()
mqtt_client._ams_cmd_unanswered = 5
# subscribe() must return (result, mid) tuple
mqtt_client._client.subscribe.return_value = (0, 1)
mqtt_client._on_connect(mqtt_client._client, None, None, 0)
assert mqtt_client._last_ams_cmd_time == 0.0
assert mqtt_client._ams_cmd_unanswered == 0
def test_no_check_when_no_command_pending(self, mqtt_client):
"""If no command was published, push_status does not trigger detection."""
assert mqtt_client._last_ams_cmd_time == 0.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 0
def test_no_timeout_within_window(self, mqtt_client):
"""A command published <10s ago should not trigger a timeout."""
import time
mqtt_client._last_ams_cmd_time = time.monotonic() - 5.0
mqtt_client._update_state({"gcode_state": "IDLE"})
assert mqtt_client._ams_cmd_unanswered == 0
assert mqtt_client._last_ams_cmd_time > 0 # still pending
class TestHMSUserActionFiltering:
"""HMS short codes the printer firmware emits during user-cancel sequences
must not appear in state.hms_errors — they're status echoes, not faults,
and shouldn't drive the printer card's "X problem" badge or red pip."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_HMS",
access_code="12345678",
)
def test_task_cancelled_echo_0300_400c_filtered(self, mqtt_client):
"""0300_400C ("The task was canceled.") is the user-cancel echo that was
leaving the printer card stuck on "1 problem" after every stop."""
mqtt_client._update_state({"hms": [{"attr": 0x03000300, "code": 0x400C}]})
assert mqtt_client.state.hms_errors == []
def test_printing_cancelled_echo_0500_400e_filtered(self, mqtt_client):
"""0500_400E ("Printing was cancelled.") — the corresponding nozzle-module
echo that the backend notification path was already suppressing for the
same reason."""
mqtt_client._update_state({"hms": [{"attr": 0x05000300, "code": 0x400E}]})
assert mqtt_client.state.hms_errors == []
def test_real_layer_shift_still_passes_through(self, mqtt_client):
"""0300_4057 (Z-axis step loss) is a real fault and must NOT be filtered."""
mqtt_client._update_state({"hms": [{"attr": 0x03000100, "code": 0x4057}]})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].code == "0x4057"
def test_filter_only_drops_user_action_codes_keeps_concurrent_real_faults(self, mqtt_client):
"""When the user cancels mid-fault, the firmware sends the real fault HMS
alongside the cancel echo. Drop only the echo, keep the real fault."""
mqtt_client._update_state(
{
"hms": [
{"attr": 0x03000300, "code": 0x400C}, # cancel echo — drop
{"attr": 0x07FF0200, "code": 0x8011}, # filament runout — keep
]
}
)
codes = [e.code for e in mqtt_client.state.hms_errors]
assert "0x8011" in codes
assert "0x400c" not in codes
assert len(mqtt_client.state.hms_errors) == 1
def test_print_error_path_also_filters_cancel_echo(self, mqtt_client):
"""`print_error` is a second route that appends into state.hms_errors. The
same user-action codes (e.g. 0500_400E "Printing was cancelled") must be
filtered there too — otherwise the printer card stays on "1 problem"
when the firmware reports the cancel via print_error rather than hms[]."""
mqtt_client._update_state({"print_error": 0x0500_400E})
assert mqtt_client.state.hms_errors == []
def test_print_error_path_passes_real_errors_through(self, mqtt_client):
"""Real print_error codes still reach state.hms_errors."""
mqtt_client._update_state({"print_error": 0x0500_8061})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].code == "0x8061"
class TestHMSFullCode:
"""full_code is the firmware-matching key for HMS-related commands.
Truncating it to the 8-char short code is what caused #1830's silent
rejection on H2C, and the H2D wrong-plate path needs the print_error
32-bit form. Both branches must populate full_code consistently."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_FULLCODE",
access_code="12345678",
)
def test_hms_array_path_populates_16_char_full_code(self, mqtt_client):
"""hms[] entries carry a 64-bit identifier (attr + code, 32 bits each).
The full 16-char hex is what BambuStudio uses to match err on
idle_ignore — the truncated short_code drops 32 bits and the firmware
silently rejects (#1830). Verifies the parser preserves the full
identifier on HMSError.full_code."""
# 0x07FF0200 / 0x8011 → displayed as 07FF_0200_0000_8011 in the wiki
mqtt_client._update_state({"hms": [{"attr": 0x07FF0200, "code": 0x8011}]})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].full_code == "07FF02000000" + "8011"
def test_print_error_path_populates_8_char_full_code(self, mqtt_client):
"""print_error is already 32 bits — no truncation. full_code is the
8-char hex form, which is exactly what the firmware matches against."""
mqtt_client._update_state({"print_error": 0x05008051})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].full_code == "05008051"
def test_print_error_path_carries_the_catalogue_description(self, mqtt_client):
"""The sentence is resolved once, at parse time, so every surface that
reports the fault quotes the same text (#2926)."""
mqtt_client._update_state({"print_error": 0x03008004})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].description == "Filament ran out. Please load new filament."
def test_print_error_path_leaves_description_none_for_an_uncatalogued_code(self, mqtt_client):
"""An undocumented code gets no invented text — the field is the
catalogue's answer, not a placeholder."""
mqtt_client._update_state({"print_error": 0x03009999})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].description is None
def test_hms_array_path_resolves_by_the_full_code(self, mqtt_client):
"""A real P2S fault from #2728, verbatim from the report topic. It resolves
through its full 16-char code, which is how Bambu Studio keys its HMS
texts, and says what the reporter found: a module/firmware mismatch."""
mqtt_client._update_state({"hms": [{"attr": 83886848, "code": 131086}]})
assert len(mqtt_client.state.hms_errors) == 1
error = mqtt_client.state.hms_errors[0]
assert error.full_code == "050003000002000E"
assert error.description.startswith("Some modules are incompatible with the printer's firmware version")
def test_hms_array_leaves_description_none_when_bambu_publishes_no_text(self, mqtt_client):
"""A real P2S fault (#2728) that Bambu lists with empty text. The fault is
still reported; only the text is absent."""
mqtt_client._update_state({"hms": [{"attr": 0x05000200, "code": 0x0003000A}]})
assert len(mqtt_client.state.hms_errors) == 1
assert mqtt_client.state.hms_errors[0].full_code == "050002000003000A"
assert mqtt_client.state.hms_errors[0].description is None
def test_hms_array_catalog_lookup_tries_16_char_first(self, mqtt_client, monkeypatch):
"""When the catalog has both an 8-char and a 16-char entry for the
same fault family, the 16-char (specific variant) wins. The 8-char
is the fallback for codes that aren't in the long-form catalog."""
from backend.app.services import bambu_mqtt as mod
calls = []
def fake_lookup(device, code):
calls.append((device, code))
if len(code) == 16:
return ["RESUME_PRINTING"]
return []
monkeypatch.setattr(mod, "get_actions_for_error_code", fake_lookup)
# SN prefix "TES" — irrelevant for the test, we mocked the lookup.
mqtt_client._update_state({"hms": [{"attr": 0x07FF0200, "code": 0x8011}]})
# 16-char lookup attempted first, then 8-char only if 16-char missed.
assert calls[0][1] == "07FF020000008011"
assert mqtt_client.state.hms_errors[0].actions == ["RESUME_PRINTING"]
def test_hms_array_catalog_falls_back_to_8_char(self, mqtt_client, monkeypatch):
"""If the catalog has no 16-char entry, fall back to the 8-char short
code — that's where base-class HMS codes live."""
from backend.app.services import bambu_mqtt as mod
calls = []
def fake_lookup(device, code):
calls.append((device, code))
if len(code) == 16:
return [] # no specific variant
return ["CHECK_ASSISTANT"] # base class hit
monkeypatch.setattr(mod, "get_actions_for_error_code", fake_lookup)
mqtt_client._update_state({"hms": [{"attr": 0x07FF0200, "code": 0x8011}]})
# Two lookups: 16-char miss, then 8-char hit.
assert len(calls) == 2
assert calls[0][1] == "07FF020000008011"
assert calls[1][1] == "07FF8011"
assert mqtt_client.state.hms_errors[0].actions == ["CHECK_ASSISTANT"]
class TestForceReconnectRouting:
"""#1136 — force_reconnect_stale_session routes between hard-reset (full
paho-client teardown, wipes the QoS 1 queue) and socket-close (the legacy
behaviour, safe to call from paho's own network thread). The routing
decision is based on whether an asyncio loop is running: hard-reset
requires loop_stop() which would deadlock if called from inside the
network thread itself."""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_HARD_RESET",
access_code="12345678",
)
client.state.connected = True
client._client = MagicMock()
return client
def test_routing_falls_back_to_socket_close_without_running_loop(self, mqtt_client):
"""Sync caller → no asyncio loop → socket-close path (legacy behaviour
preserved for paho-thread callers like zombie detection)."""
mqtt_client.force_reconnect_stale_session("test")
mqtt_client._client.socket().close.assert_called()
# Old client is NOT torn down on this path; same-instance reconnect
# via paho's auto-reconnect handles it.
assert mqtt_client._client is not None
def test_routing_uses_hard_reset_when_loop_is_running(self, mqtt_client):
"""Async caller → loop available → hard-reset path wipes the queue."""
import asyncio
original = mqtt_client._client
# Stub connect() so the rebuild doesn't open a real socket.
mqtt_client.connect = lambda loop=None: None
async def _trigger():
mqtt_client.force_reconnect_stale_session("test")
asyncio.run(_trigger())
original.disconnect.assert_called()
original.loop_stop.assert_called()
# connect() stub didn't repopulate _client, so it's None — the contract
# in production is that connect() builds a fresh mqtt.Client here.
assert mqtt_client._client is None
def test_marks_state_disconnected_and_broadcasts(self, mqtt_client):
"""Both routing paths must broadcast the disconnected state once."""
broadcasts: list[bool] = []
mqtt_client.on_state_change = lambda s: broadcasts.append(s.connected)
mqtt_client.force_reconnect_stale_session("test")
assert mqtt_client.state.connected is False
assert mqtt_client._stale_reconnecting is True
assert broadcasts == [False]
class TestHardResetClientDirect:
"""Lower-level coverage of `_hard_reset_client` itself — the helper called
by the routing layer when a full paho-client teardown is safe. These tests
drive the helper directly so they don't depend on the routing decision."""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_HARD_DIRECT",
access_code="12345678",
)
client.state.connected = True
client._client = MagicMock()
# Stub connect() so the rebuild doesn't open a real socket.
client.connect = lambda loop=None: None
return client
def test_disconnects_and_stops_old_client(self, mqtt_client):
"""Old paho client must receive DISCONNECT (broker drops session) +
loop_stop (network thread exits, taking its QoS 1 queue with it)."""
original = mqtt_client._client
mqtt_client._hard_reset_client()
original.disconnect.assert_called()
original.loop_stop.assert_called()
def test_clears_client_reference(self, mqtt_client):
"""Old reference must go to None so subsequent code can't accidentally
publish through the dying client."""
mqtt_client._hard_reset_client()
assert mqtt_client._client is None
def test_swallows_disconnect_exception(self, mqtt_client):
"""A failing disconnect() (e.g. paho already in error state) must not
propagate through async dispatch callers, and a single broken client
could brick every future dispatch."""
original = mqtt_client._client
original.disconnect.side_effect = RuntimeError("boom")
# No exception escapes the call (test would fail if it did).
mqtt_client._hard_reset_client()
# loop_stop is still attempted after the disconnect failure.
original.loop_stop.assert_called()
assert mqtt_client._client is None
class TestStartPrintRecordsDispatchedPlate:
"""Tests for the dispatched-plate record set by start_print() — used by the
/cover route to pick the right thumbnail when the printer's gcode_file
echo doesn't include the plate path (#1166).
Some firmware versions (P1S 01.10.00.00) only put the .3mf filename in
print.gcode_file, so the regex falls back to plate 1 and the printer card
shows the wrong plate's thumbnail. Recording what we dispatched at the
publish site lets resolve_plate_id() return the right plate without
needing to introspect the 3MF.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
return client
def test_dispatched_plate_recorded_after_start_print(self, mqtt_client):
# Default state has no dispatched plate.
assert mqtt_client.state.dispatched_plate_id is None
assert mqtt_client.state.dispatched_subtask is None
mqtt_client.start_print("Luigi.3mf", plate_id=2)
# The subtask_name we record matches the one we send (and the printer
# reflects back via MQTT), so resolve_plate_id() can validate the
# match downstream.
assert mqtt_client.state.dispatched_plate_id == 2
assert mqtt_client.state.dispatched_subtask == "Luigi"
def test_dispatched_plate_default_is_one(self, mqtt_client):
# When start_print is called without plate_id (legacy/single-plate
# flow), we still record plate=1 — the contract is that dispatched_*
# describes the active dispatch.
mqtt_client.start_print("Single.3mf")
assert mqtt_client.state.dispatched_plate_id == 1
assert mqtt_client.state.dispatched_subtask == "Single"
def test_dispatched_plate_overwritten_by_subsequent_dispatch(self, mqtt_client):
# Each dispatch replaces the prior record so we can never serve a
# stale plate from an older print.
mqtt_client.start_print("First.3mf", plate_id=4)
mqtt_client.start_print("Second.3mf", plate_id=2)
assert mqtt_client.state.dispatched_plate_id == 2
assert mqtt_client.state.dispatched_subtask == "Second"
def test_dispatched_plate_not_recorded_when_publish_skipped(self, mqtt_client):
# If start_print early-returns because we're not connected, no record
# should land — otherwise the next print's /cover call would believe
# a phantom dispatch happened.
mqtt_client.state.connected = False
result = mqtt_client.start_print("Phantom.3mf", plate_id=3)
assert result is False
assert mqtt_client.state.dispatched_plate_id is None
assert mqtt_client.state.dispatched_subtask is None
class TestStartPrintNozzleMappingDispatch:
"""H2C dual-nozzle-rack (#1780) — nozzle_mapping on dispatch.
BambuStudio's project_file MQTT command for O1C2 carries a per-filament
physical nozzle position ID array (`nozzle_mapping`). Without forwarding
it, the H2C firmware falls back to "last matching nozzle type" auto-pick
and ignores the user's slicer choice. Tests pin the gate, the parse, the
no-op cases, and the malformed-JSON safety net.
The original #1780 attempt also captured `nozzles_info` but a wire capture
on H2C confirmed BambuStudio never sends that field — the capture/dispatch
paths for it were dropped in the same release.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_O1C2",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
return client
def _published_print_cmd(self, mqtt_client):
call_args = mqtt_client._client.publish.call_args
return json.loads(call_args[0][1])["print"]
def test_dual_nozzle_includes_nozzle_mapping(self, mqtt_client):
"""Dual-nozzle + nozzle_mapping present → parsed JSON array injected
verbatim onto the dispatched project_file command."""
mqtt_client._is_dual_nozzle = True
mqtt_client.start_print(
"test.3mf",
nozzle_mapping=json.dumps([16, -1, -1, 1, -1, -1, -1, -1]),
)
cmd = self._published_print_cmd(mqtt_client)
# List, not string — the wire shape must match BambuStudio's.
assert cmd["nozzle_mapping"] == [16, -1, -1, 1, -1, -1, -1, -1]
def test_single_nozzle_omits_nozzle_mapping_even_if_set(self, mqtt_client):
"""A single-nozzle printer must NOT emit the rack field even if the
caller passes it (defense-in-depth — the queue item could legitimately
carry a stale capture from before a model change)."""
mqtt_client._is_dual_nozzle = False
mqtt_client.model = "P1S" # single-nozzle
mqtt_client.start_print(
"test.3mf",
nozzle_mapping=json.dumps([16, 0, 19]),
)
cmd = self._published_print_cmd(mqtt_client)
assert "nozzle_mapping" not in cmd
def test_dual_nozzle_no_field_no_injection(self, mqtt_client):
"""Dual-nozzle printer + no slicer pick (NULL on queue item) → command
carries no nozzle_mapping. The firmware then runs its normal
auto-pick, which is the pre-fix behaviour for any non-O1C2 dual-
nozzle model that has no rack to disambiguate against anyway."""
mqtt_client._is_dual_nozzle = True
mqtt_client.start_print("test.3mf", nozzle_mapping=None)
cmd = self._published_print_cmd(mqtt_client)
assert "nozzle_mapping" not in cmd
def test_malformed_nozzle_mapping_is_logged_and_omitted(self, mqtt_client, caplog):
"""Invalid JSON on the queue item must NOT block the dispatch. Log a
warning and let the firmware auto-pick — the failure mode is just
the pre-fix behaviour, not a worse one. Fail-open is correct here
because the alternative would silently brick every dispatch on a
single bad row."""
mqtt_client._is_dual_nozzle = True
with caplog.at_level("WARNING"):
result = mqtt_client.start_print(
"test.3mf",
nozzle_mapping="not valid json {",
)
assert result is True # dispatch still proceeded
cmd = self._published_print_cmd(mqtt_client)
assert "nozzle_mapping" not in cmd
assert any("Invalid nozzle_mapping" in rec.message for rec in caplog.records)
def test_empty_string_field_is_treated_as_absent(self, mqtt_client):
"""An empty-string column value (legacy data, or a NOT NULL DB
recovery shim) must behave the same as NULL — no injection, no
parse error log."""
mqtt_client._is_dual_nozzle = True
mqtt_client.start_print("test.3mf", nozzle_mapping="")
cmd = self._published_print_cmd(mqtt_client)
assert "nozzle_mapping" not in cmd
class TestFilamentTrackSwitchDetection:
"""Tests for Filament Track Switch (FTS) accessory detection (#1162).
The FTS is an accessory that sits between an AMS and the printer's
extruders, dynamically routing any slot to either nozzle. When installed,
each AMS unit reports info bits 8-11 = 0xE (uninitialized) since slots are
no longer tied to a specific extruder. Detection comes from the presence of
the print.device.fila_switch object in MQTT push_status.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def test_fts_default_not_installed(self, mqtt_client):
"""Without any MQTT data, fila_switch.installed must be False so the
frontend keeps applying the per-extruder filter on regular dual-nozzle
printers."""
assert mqtt_client.state.fila_switch.installed is False
assert mqtt_client.state.fila_switch.in_slots == []
assert mqtt_client.state.fila_switch.out_extruders == []
def test_fts_detected_from_device_fila_switch(self, mqtt_client):
"""A push_status with print.device.fila_switch present must mark FTS
installed and capture its routing arrays. Mirrors the user's MQTT
bundle in #1162."""
data = {
"gcode_state": "RUNNING",
"device": {
"fila_switch": {
"in": [-1, 2],
"info": 2,
"out": [0, 1],
"stat": 0,
}
},
}
mqtt_client._update_state(data)
fs = mqtt_client.state.fila_switch
assert fs.installed is True
assert fs.in_slots == [-1, 2]
assert fs.out_extruders == [0, 1]
assert fs.stat == 0
assert fs.info == 2
def test_fts_absent_when_no_fila_switch_field(self, mqtt_client):
"""A push_status that has device.* but no fila_switch must leave
fila_switch.installed = False — only that specific field flips it on."""
data = {
"gcode_state": "IDLE",
"device": {"extruder": {"state": 0}},
}
mqtt_client._update_state(data)
assert mqtt_client.state.fila_switch.installed is False
def test_fts_handles_missing_in_out_arrays(self, mqtt_client):
"""If the firmware sends fila_switch with missing or non-list in/out,
we must still mark it installed (presence is the signal) and default
the arrays to empty lists rather than crashing."""
data = {
"gcode_state": "IDLE",
"device": {"fila_switch": {"stat": 0, "info": 0}},
}
mqtt_client._update_state(data)
fs = mqtt_client.state.fila_switch
assert fs.installed is True
assert fs.in_slots == []
assert fs.out_extruders == []
class TestFilamentTrackSwitchInletBinding:
"""Which FTS inlet each AMS is plumbed into, from AMS ``info`` bits 24-27.
With a switch installed an AMS is no longer bound to one extruder — it is
bound to one of the switch's two *inlets*, and reaches both nozzles through
it. That binding is what the printer's "Manual AMS Setup" screen sets, and
it is the only per-AMS side information there is: ``ams_extruder_map`` is
empty on these machines because bits 8-11 read 0xE for every unit.
Bit layout and the 0=In-B / 1=In-A ordering are BambuStudio's
(``DevFilaSystem.cpp``, ``DevFilaSwitch::SwitchPos``), not inferred.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
@staticmethod
def _info(*, inlet_bits: int, extruder: int = 0xE, ams_type: int = 1) -> str:
"""Build an AMS ``info`` hex string with the fields we read out of it."""
return f"{(inlet_bits << 24) | (extruder << 8) | ams_type:08X}"
@staticmethod
def _frame(client, ams_units: list[dict], *, fts: bool = True) -> None:
"""Drive one push_status through the real entry point.
Deliberately goes through ``_process_message`` rather than calling the
AMS handler directly: the ordering between the switch block and the AMS
block is the thing most likely to break, and only this path exercises it.
"""
print_data = {"gcode_state": "IDLE", "ams": {"ams": ams_units}}
if fts:
print_data["device"] = {"fila_switch": {"in": [-1, -1], "out": [1, 0], "stat": 0, "info": 0}}
client._process_message({"print": print_data})
def test_inlet_a_from_bits_24_27(self, mqtt_client):
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=1), "tray": []}])
assert mqtt_client.state.ams_switch_inlet == {"0": "A"}
def test_inlet_b_from_bits_24_27(self, mqtt_client):
"""0 is In-B, not "unset" — the enum is ordered B first."""
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=0), "tray": []}])
assert mqtt_client.state.ams_switch_inlet == {"0": "B"}
def test_the_maintainers_layout(self, mqtt_client):
"""Four units split across both inlets, as on the H2C in #1162's
follow-up: AMS-A and an AMS-HT on In-A, AMS-B and AMS-C on In-B."""
self._frame(
mqtt_client,
[
{"id": "0", "info": self._info(inlet_bits=1), "tray": []},
{"id": "1", "info": self._info(inlet_bits=0), "tray": []},
{"id": "2", "info": self._info(inlet_bits=0), "tray": []},
{"id": "128", "info": self._info(inlet_bits=1, ams_type=4), "tray": []},
],
)
assert mqtt_client.state.ams_switch_inlet == {"0": "A", "1": "B", "2": "B", "128": "A"}
# Every unit reads 0xE, so the extruder map stays empty — which is
# exactly why a left/right label cannot be derived on these machines.
assert mqtt_client.state.ams_extruder_map == {}
def test_no_inlet_read_without_a_switch(self, mqtt_client):
"""Without an FTS, 0xE means an uninitialised unit and bits 24-27 carry
nothing. Reading them anyway would invent inlet "B" for every AMS."""
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=0), "tray": []}], fts=False)
assert mqtt_client.state.ams_switch_inlet == {}
def test_a_normally_bound_ams_is_untouched(self, mqtt_client):
"""An AMS that still reports a real extruder id keeps using it, switch
or no switch — only 0xE units are inlet-bound."""
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=1, extruder=1), "tray": []}])
assert mqtt_client.state.ams_extruder_map == {"0": 1}
assert mqtt_client.state.ams_switch_inlet == {}
def test_binding_survives_a_frame_without_the_switch_block(self, mqtt_client):
"""Partial push_status frames carry the AMS block without device.*.
The switch stays installed (sticky) so the binding must not be dropped."""
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=1), "tray": []}])
mqtt_client._process_message(
{
"print": {
"gcode_state": "IDLE",
"ams": {"ams": [{"id": "0", "info": self._info(inlet_bits=1), "tray": []}]},
}
}
)
assert mqtt_client.state.ams_switch_inlet == {"0": "A"}
def test_a_rebind_is_picked_up(self, mqtt_client):
""" "Join IN-B" on the printer screen flips the bits; we must follow it
rather than keeping the first value we ever saw."""
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=1), "tray": []}])
self._frame(mqtt_client, [{"id": "0", "info": self._info(inlet_bits=0), "tray": []}])
assert mqtt_client.state.ams_switch_inlet == {"0": "B"}
def test_unparseable_info_is_skipped(self, mqtt_client):
self._frame(mqtt_client, [{"id": "0", "info": "not-hex", "tray": []}])
assert mqtt_client.state.ams_switch_inlet == {}
class TestFilamentTrackSwitchInletSlotDecode:
"""``fila_switch.in`` decoding — snow-encoded, and ordered B before A."""
def test_decodes_ams_and_slot(self):
from backend.app.services.bambu_mqtt import FilaSwitchState
# 0x0102 = AMS 1 slot 2 on In-A; 0x0003 = AMS 0 slot 3 on In-B.
fs = FilaSwitchState(installed=True, in_slots=[0x0003, 0x0102])
assert fs.inlet_slot("A") == (1, 2)
assert fs.inlet_slot("B") == (0, 3)
def test_empty_inlet_is_none(self):
from backend.app.services.bambu_mqtt import FilaSwitchState
fs = FilaSwitchState(installed=True, in_slots=[-1, 0x0102])
assert fs.inlet_slot("B") is None
assert fs.inlet_slot("A") == (1, 2)
def test_missing_or_unknown_inlet_is_none(self):
from backend.app.services.bambu_mqtt import FilaSwitchState
assert FilaSwitchState(installed=True).inlet_slot("A") is None
assert FilaSwitchState(installed=True, in_slots=[0x0003, 0x0102]).inlet_slot("C") is None
class TestAmsLoadFilamentEncoding:
"""Per-target ams_change_filament command encoding (#891)."""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
# Pretend the MQTT layer is connected so the publish path is reached.
client._client = MagicMock()
client.state.connected = True
return client
@staticmethod
def _published(client) -> dict:
"""Return the JSON of the most recent publish() call."""
last_call = client._client.publish.call_args_list[-1]
topic, payload, *_ = last_call.args
return json.loads(payload)
def test_ams_slot_uses_local_index_and_minus_one_temps(self, mqtt_client):
"""tray_id=5 → ams_id=1, slot_id=1, target=5, curr/tar=-1."""
assert mqtt_client.ams_load_filament(5) is True
cmd = self._published(mqtt_client)["print"]
assert cmd["command"] == "ams_change_filament"
assert cmd["ams_id"] == 1
assert cmd["slot_id"] == 1
assert cmd["target"] == 5
assert cmd["curr_temp"] == -1
assert cmd["tar_temp"] == -1
def test_external_left_keeps_legacy_encoding(self, mqtt_client):
"""tray_id=254 → ams_id=255, slot_id=254, target=254, curr/tar=-1.
This is the original capture from a single-extruder printer; preserved
verbatim so existing single-external setups don't regress.
"""
assert mqtt_client.ams_load_filament(254) is True
cmd = self._published(mqtt_client)["print"]
assert cmd["ams_id"] == 255
assert cmd["slot_id"] == 254
assert cmd["target"] == 254
assert cmd["curr_temp"] == -1
assert cmd["tar_temp"] == -1
def test_external_right_uses_extruder_index_and_actual_temp(self, mqtt_client):
"""tray_id=255 → captured BambuStudio shape on dual-nozzle H2D:
ams_id=255, slot_id=0 (right extruder), target=255, curr/tar = right
nozzle temp.
"""
# Simulate a heated right nozzle.
mqtt_client.state.temperatures["nozzle_2"] = 215.0
assert mqtt_client.ams_load_filament(255) is True
cmd = self._published(mqtt_client)["print"]
assert cmd["ams_id"] == 255
assert cmd["slot_id"] == 0
assert cmd["target"] == 255
assert cmd["curr_temp"] == 215
assert cmd["tar_temp"] == 215
def test_external_right_falls_back_when_nozzle_cold(self, mqtt_client):
"""If the right nozzle reports < 180 °C, fall back to a sane default
so the printer accepts the command rather than rejecting it on a
nonsensical temperature.
"""
mqtt_client.state.temperatures["nozzle_2"] = 25.0
assert mqtt_client.ams_load_filament(255) is True
cmd = self._published(mqtt_client)["print"]
assert cmd["curr_temp"] == 215
assert cmd["tar_temp"] == 215
def test_returns_false_when_disconnected(self, mqtt_client):
"""Disconnected client must not publish anything."""
mqtt_client.state.connected = False
assert mqtt_client.ams_load_filament(0) is False
mqtt_client._client.publish.assert_not_called()
def test_extruder_id_is_absent_unless_asked_for(self, mqtt_client):
"""The field must not appear on a printer that did not ask for it.
BambuStudio only sets it when a Filament Track Switch is installed
(``command_ams_change_filament`` takes it as std::optional). Everywhere
else the firmware derives the hotend from the AMS binding, and sending a
value would be us guessing at something it already knows.
"""
assert mqtt_client.ams_load_filament(5) is True
assert "extruder_id" not in self._published(mqtt_client)["print"]
@pytest.mark.parametrize("extruder_id", [0, 1])
def test_extruder_id_rides_along_when_given(self, mqtt_client, extruder_id):
"""With a switch fitted the hotend has to be named, or nothing happens."""
assert mqtt_client.ams_load_filament(5, extruder_id=extruder_id) is True
assert self._published(mqtt_client)["print"]["extruder_id"] == extruder_id
class TestAmsUnloadFilamentTargeting:
"""Which hotend an unload acts on, for dual-nozzle printers.
``tray_now`` is a single printer-wide value, so with both hotends loaded it
names only one of them. BambuStudio addresses the unload by walking its
extruders for the one fed from the clicked slot
(``StatusPanel::on_ams_unload``) and publishes nothing when none matches.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient, ExtruderSlot
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
# The check only runs once the printer has reported two extruders; a
# single-nozzle machine has nothing to disambiguate.
client._is_dual_nozzle = True
# Right hotend fed from AMS 1 slot 1 (global tray 5), left from AMS 0
# slot 2 (global tray 2). tray_now names only the first of the two.
client.state.tray_now = 5
client.state.extruder_slots = {
0: ExtruderSlot(ams_id=1, slot_id=1, has_filament=True),
1: ExtruderSlot(ams_id=0, slot_id=2, has_filament=True),
}
return client
@staticmethod
def _published(client) -> dict:
last_call = client._client.publish.call_args_list[-1]
_topic, payload, *_ = last_call.args
return json.loads(payload)
def test_an_addressed_unload_targets_that_slots_ams(self, mqtt_client):
"""Tray 2 is on the left hotend, which tray_now does not name."""
assert mqtt_client.ams_unload_filament(2) is True
cmd = self._published(mqtt_client)["print"]
assert cmd["ams_id"] == 0
assert cmd["slot_id"] == 255
assert cmd["target"] == 255
def test_an_unaddressed_unload_still_follows_tray_now(self, mqtt_client):
"""Single-nozzle printers have no slot to pass; that path is unchanged."""
assert mqtt_client.ams_unload_filament() is True
assert self._published(mqtt_client)["print"]["ams_id"] == 1
def test_a_slot_no_hotend_holds_publishes_nothing(self, mqtt_client):
"""Clicking Unload on an idle slot is a no-op, not a command."""
assert mqtt_client.ams_unload_filament(7) is False
mqtt_client._client.publish.assert_not_called()
def test_the_check_is_skipped_when_the_printer_reports_no_extruder_slots(self, mqtt_client):
"""An empty map means "did not say", never "no hotend holds it".
Every printer outside the H2/X2 series omits ``device.extruder.info``,
and reading that silence as a negative would break unload on all of them.
"""
mqtt_client.state.extruder_slots = {}
assert mqtt_client.ams_unload_filament(7) is True
assert self._published(mqtt_client)["print"]["ams_id"] == 1
def test_a_single_nozzle_printer_is_never_gated_on_snow(self, mqtt_client):
"""One hotend means tray_now is already unambiguous.
Single-nozzle machines do report ``device.extruder.info`` — BambuStudio
has a branch for it and an X1C sends the block — but nobody has read a
single-nozzle ``snow`` off the wire. Running the match there would stake
every X1C/P1S/A1 unload on an unverified encoding, so it is not run.
"""
mqtt_client._is_dual_nozzle = False
assert mqtt_client.ams_unload_filament(7) is True
assert self._published(mqtt_client)["print"]["ams_id"] == 1
def test_the_external_spool_is_not_matched_against_ams_slots(self, mqtt_client):
"""254/255 are not ams*4+slot, so the slot arithmetic cannot describe them."""
assert mqtt_client.ams_unload_filament(254) is True
assert self._published(mqtt_client)["print"]["ams_id"] == 255
class TestParseExtruderSlots:
"""Decoding ``device.extruder.info`` into per-hotend loaded slots."""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
return client
def test_snow_decodes_to_ams_and_slot(self, mqtt_client):
"""snow is bits 8-15 = AMS id, bits 0-7 = slot — same shape as fila_switch.in."""
mqtt_client._parse_extruder_slots({"device": {"extruder": {"info": [{"id": 0, "snow": 0x0102, "info": 0b10}]}}})
slot = mqtt_client.state.extruder_slots[0]
assert (slot.ams_id, slot.slot_id) == (1, 2)
assert slot.has_filament is True
def test_the_empty_sentinel_is_not_read_as_a_slot(self, mqtt_client):
"""0xFFFF would otherwise decode to the nonexistent AMS 255 slot 255."""
mqtt_client._parse_extruder_slots({"device": {"extruder": {"info": [{"id": 1, "snow": 0xFFFF, "info": 0}]}}})
slot = mqtt_client.state.extruder_slots[1]
assert slot.ams_id is None and slot.slot_id is None
assert slot.has_filament is False
def test_a_payload_without_the_block_keeps_the_last_answer(self, mqtt_client):
"""A temperatures-only frame must not read as "both hotends are empty"."""
mqtt_client._parse_extruder_slots({"device": {"extruder": {"info": [{"id": 0, "snow": 0x0003, "info": 0b10}]}}})
mqtt_client._parse_extruder_slots({"bed_temper": 60})
assert mqtt_client.state.extruder_slots[0].ams_id == 0
def test_holds_answers_for_one_slot_only(self, mqtt_client):
from backend.app.services.bambu_mqtt import ExtruderSlot
assert ExtruderSlot(ams_id=1, slot_id=2).holds(1, 2) is True
assert ExtruderSlot(ams_id=1, slot_id=2).holds(1, 3) is False
assert ExtruderSlot().holds(0, 0) is False
class TestAmsFilamentSettingExternalSpoolEncoding:
"""Encoding of `ams_filament_setting` / `reset_ams_slot` for the external spool.
Regression coverage for #1279. The encoding is verified against a captured
BambuStudio → X1C exchange (May 2026):
REQ {"command":"ams_filament_setting","ams_id":255,"tray_id":254,"slot_id":0,...}
REP {"result":"success",...}
The previous code sent `tray_id: 0` for the single-external case, which the
P1S in #1279 rejected with `result: "fail"`.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._client = MagicMock()
client.state.connected = True
return client
def _published(self, mqtt_client):
call_args = mqtt_client._client.publish.call_args
return json.loads(call_args[0][1])["print"]
def test_single_external_uses_tray_id_254(self, mqtt_client):
"""X1C/P1S/A1 (single external slot): ams_id=255, tray_id=254, slot_id=0."""
# Simulate a single-external printer: vt_tray is a single-element list.
mqtt_client.state.raw_data = {"vt_tray": [{"id": "255"}]}
assert mqtt_client.ams_set_filament_setting(
ams_id=255,
tray_id=0,
tray_info_idx="GFL99",
tray_type="PLA",
tray_sub_brands="Generic PLA",
tray_color="000000FF",
nozzle_temp_min=190,
nozzle_temp_max=230,
)
cmd = self._published(mqtt_client)
assert cmd["command"] == "ams_filament_setting"
assert cmd["ams_id"] == 255
assert cmd["tray_id"] == 254, (
"Single-external `ams_filament_setting` must send tray_id=254 "
"(verified via BambuStudio→X1C capture). Sending tray_id=0 "
"is what the P1S in #1279 rejects."
)
assert cmd["slot_id"] == 0
def test_single_external_reset_uses_tray_id_254(self, mqtt_client):
"""reset_ams_slot shares the convention — same encoding."""
mqtt_client.state.raw_data = {"vt_tray": [{"id": "255"}]}
assert mqtt_client.reset_ams_slot(ams_id=255, tray_id=0)
cmd = self._published(mqtt_client)
assert cmd["command"] == "ams_filament_setting"
assert cmd["ams_id"] == 255
assert cmd["tray_id"] == 254
assert cmd["slot_id"] == 0
# Reset clears the filament identity
assert cmd["tray_info_idx"] == ""
assert cmd["tray_type"] == ""
def test_regular_ams_tray_unchanged(self, mqtt_client):
"""Regular AMS slots (ams_id <= 3) keep their existing encoding."""
mqtt_client.state.raw_data = {"vt_tray": []}
assert mqtt_client.ams_set_filament_setting(
ams_id=0,
tray_id=2,
tray_info_idx="GFA01",
tray_type="PLA",
tray_sub_brands="PLA Matte",
tray_color="FFFFFFFF",
nozzle_temp_min=190,
nozzle_temp_max=230,
)
cmd = self._published(mqtt_client)
assert cmd["ams_id"] == 0
assert cmd["tray_id"] == 2
assert cmd["slot_id"] == 2
def test_ams_ht_unchanged(self, mqtt_client):
"""AMS-HT (ams_id >= 128) keeps its single-tray-per-unit encoding."""
mqtt_client.state.raw_data = {"vt_tray": []}
assert mqtt_client.ams_set_filament_setting(
ams_id=128,
tray_id=0,
tray_info_idx="GFA01",
tray_type="PLA",
tray_sub_brands="PLA Matte",
tray_color="FFFFFFFF",
nozzle_temp_min=190,
nozzle_temp_max=230,
)
cmd = self._published(mqtt_client)
assert cmd["ams_id"] == 128
assert cmd["tray_id"] == 0
assert cmd["slot_id"] == 0
def test_dual_external_left_keeps_legacy_encoding(self, mqtt_client):
"""H2D dual-external (`vt_tray` length > 1): not in the X1C capture, so
left at the legacy `mqtt_tray_id = 0` until verified separately."""
mqtt_client.state.raw_data = {"vt_tray": [{"id": "254"}, {"id": "255"}]}
assert mqtt_client.ams_set_filament_setting(
ams_id=255,
tray_id=0, # Ext-L
tray_info_idx="GFA01",
tray_type="PLA",
tray_sub_brands="PLA Matte",
tray_color="FFFFFFFF",
nozzle_temp_min=190,
nozzle_temp_max=230,
)
cmd = self._published(mqtt_client)
# Ext-L → mqtt_ams_id = 254
assert cmd["ams_id"] == 254
# tray_id stays at 0 for dual external; this pins current behavior so
# a future capture-driven change shows up in the diff.
assert cmd["tray_id"] == 0
assert cmd["slot_id"] == 0
class TestDryCountdownStall:
"""A ``dry_time`` the firmware set but whose countdown never ticks is a
parked command, not a running cycle — ``dry_countdown_stalled`` is how the
UI stops showing an active-drying badge for it. Live countdowns decrement
once a minute; the stall threshold (150 s) is two missed ticks plus jitter.
Found on an H2D mid-print: two AMS-HT cycles running, the third unit's
timer frozen at its full 720 while the AMS never heated."""
@pytest.fixture
def mqtt_client(self, monkeypatch):
from backend.app.services import bambu_mqtt as mod
clock = {"now": 1000.0}
monkeypatch.setattr(mod.time, "monotonic", lambda: clock["now"])
client = mod.BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST-STALL",
access_code="12345678",
)
client._test_clock = clock # Expose for tests to advance
return client
def _unit(self, mqtt_client, ams_id=0):
for u in mqtt_client.state.raw_data["ams"]:
if int(u["id"]) == ams_id:
return u
raise AssertionError(f"AMS {ams_id} not in raw_data")
def test_frozen_countdown_flags_stalled(self, mqtt_client):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False
mqtt_client._test_clock["now"] += 151
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is True
def test_ticking_countdown_never_flags(self, mqtt_client):
"""A live cycle decrements every minute; repeats of the same value
inside the minute must not flag either."""
for dt, value in ((0, 720), (60, 719), (100, 719), (120, 718)):
mqtt_client._test_clock["now"] = 1000.0 + dt
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": value, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False, dt
def test_active_dry_status_vouches_for_frozen_countdown(self, mqtt_client):
"""When the firmware's own info phase says Drying, a frozen countdown
is trusted as live — the phase field outranks the tick heuristic."""
# info bits 4-7 = 2 (Drying) -> 0x20
frame = {"ams": [{"id": "0", "dry_time": 720, "info": "20", "tray": []}]}
mqtt_client._handle_ams_data(frame)
mqtt_client._test_clock["now"] += 300
mqtt_client._handle_ams_data(frame)
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False
def test_active_phase_clears_stall_on_transient_zero(self, mqtt_client):
"""A Checking/Drying phase is authoritative even when its transient
dry_time=0 frame is ignored for completion-edge tracking (#2759)."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
mqtt_client._test_clock["now"] += 151
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is True
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "info": "20", "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False
assert mqtt_client._previous_dry_times[0] == 720
def test_fresh_start_gets_grace_before_flagging(self, mqtt_client):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
mqtt_client._test_clock["now"] += 30
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
mqtt_client._test_clock["now"] += 30
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False
def test_finished_cycle_never_reads_stalled(self, mqtt_client):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 1, "tray": []}]})
mqtt_client._test_clock["now"] += 200
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert self._unit(mqtt_client)["dry_countdown_stalled"] is False
class TestDryingCompleteCallback:
"""#1349 — fires ``on_drying_complete(ams_id)`` on a dry_time falling edge."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
events: list[int] = []
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST-DRYING",
access_code="12345678",
on_drying_complete=events.append,
)
client._drying_events = events # Expose for assertions
return client
def test_falling_edge_fires_callback(self, mqtt_client):
"""First push reports drying active, second reports drying done."""
# Push 1: AMS 0 drying with 60 minutes remaining.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 60, "tray": []}]})
assert mqtt_client._drying_events == []
# Push 2: dry_time hits 0 → callback fires with the AMS id.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == [0]
def test_no_fire_when_dry_time_never_started(self, mqtt_client):
"""dry_time = 0 across consecutive pushes does NOT fire — there was
no drying cycle to finish. Guards against the seed-from-zero false
positive on startup."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == []
def test_falling_edge_fires_once(self, mqtt_client):
"""Subsequent zero-pushes after the edge don't refire the callback."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 30, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == [0]
def test_per_ams_tracking(self, mqtt_client):
"""Two AMS units finishing drying at different times each fire once
— the falling-edge state is keyed per AMS id."""
# Both start drying.
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 30, "tray": []}, {"id": "1", "dry_time": 30, "tray": []}]}
)
# AMS 0 finishes, AMS 1 still drying.
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 0, "tray": []}, {"id": "1", "dry_time": 15, "tray": []}]}
)
assert mqtt_client._drying_events == [0]
# AMS 1 finishes.
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 0, "tray": []}, {"id": "1", "dry_time": 0, "tray": []}]}
)
assert mqtt_client._drying_events == [0, 1]
def test_restart_drying_after_completion_refires_callback(self, mqtt_client):
"""A new drying cycle after the previous one finished fires the
callback again on its own falling edge — covers the user manually
starting a second dry from the UI."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 30, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
# New cycle starts.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 45, "tray": []}]})
# And finishes.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == [0, 0]
def test_tray_only_partial_does_not_fake_completion(self, mqtt_client):
"""#1462 — a tray-bearing partial update that omits dry_time must not
be read as dry_time=0. The pre-fix merge dropped dry_time on such
partials, so the falling-edge detector saw a 60→0 edge and fired a
false 'drying complete' seconds after drying started — which armed
smart-plug auto-off and killed the printer mid-cycle."""
# Drying active, 60 minutes remaining.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 60, "tray": []}]})
assert mqtt_client._drying_events == []
# Printer sends a tray-bearing partial carrying NO dry_time field.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "tray": []}]})
assert mqtt_client._drying_events == []
# dry_time survived the partial in the merged AMS state.
assert mqtt_client.state.raw_data["ams"][0]["dry_time"] == 60
# Drying genuinely finishes → the real edge still fires exactly once.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == [0]
def test_transient_zero_while_checking_is_not_completion(self, mqtt_client):
"""#2759 — between the command ack and the countdown settling, firmware
publishes a dry_time of 0 while the AMS is still in its Checking phase.
The reporter's log caught 720 → 0 → 719 one minute into a 12-hour
cycle: it dropped the cached target (so the badge guessed the filament
from tray 1 and read "PETG @ 65°C" for a PLA dry) and armed smart-plug
auto-off."""
mqtt_client._drying_targets[0] = {"filament": "PLA", "temp": 45}
# Cycle starts: 12 hours, unit reports dry_status 1 (Checking).
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "info": "11402113", "tray": []}]})
assert mqtt_client._drying_events == []
# The blip: dry_time 0, still Checking.
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "info": "11402113", "tray": []}]})
assert mqtt_client._drying_events == []
# And the user's chosen target survived it.
assert mqtt_client._drying_targets[0] == {"filament": "PLA", "temp": 45}
# Countdown settles and the unit moves to dry_status 2 (Drying).
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 719, "info": "11402123", "tray": []}]})
assert mqtt_client._drying_events == []
# Twelve hours later it really finishes, back to dry_status 0 (Off).
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "info": "11402103", "tray": []}]})
assert mqtt_client._drying_events == [0]
assert 0 not in mqtt_client._drying_targets
def test_zero_while_stopping_completes(self, mqtt_client):
"""dry_status 4 (Stopping) means the cycle is ending, not running — the
edge must still fire so smart-plug auto-off runs when a user stops a
dry early."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "info": "11402123", "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "info": "11402143", "tray": []}]})
assert mqtt_client._drying_events == [0]
def test_absent_dry_status_still_completes(self, mqtt_client):
"""The phase gate is a suppression, not a requirement: firmware that
never reports an info hex must still be able to end a cycle."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 720, "tray": []}]})
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert mqtt_client._drying_events == [0]
def test_early_end_logs_firmware_reason_codes(self, mqtt_client, caplog):
"""#2770 — a 12-hour cycle the firmware abandoned 20 minutes in logged
only 'drying complete', so the report carried no evidence of why. An
early end now names the shortfall and the reason fields we already
parse: phase, sub-phase, cannot-dry codes and live HMS."""
from backend.app.services.bambu_mqtt import HMSError
mqtt_client.state.hms_errors = [
HMSError(code="0x2000003", attr=0x07008000, module=7, severity=2, full_code="0700800002000003")
]
mqtt_client._client = MagicMock()
mqtt_client.send_drying_command(ams_id=0, temp=65, duration=12, mode=1, filament="PETG")
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 700, "info": "10002123", "dry_sf_reason": [1], "tray": []}]}
)
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 0, "info": "10002103", "dry_sf_reason": [1], "tray": []}]}
)
assert mqtt_client._drying_events == [0]
message = "\n".join(r.getMessage() for r in caplog.records)
assert "drying ended early" in message
# The shortfall, against the duration we asked the firmware for.
assert "700 of 720 minutes" in message
# dry_status 0 (Off) and dry_sub_status 0 from info hex 10002103.
assert "dry_status=0" in message
assert "dry_sub_status=0" in message
# InsufficientPower, and the AMS heater-fan HMS that goes with it.
assert "dry_sf_reason=[1]" in message
assert "0700800002000003" in message
def test_early_end_without_a_cached_target_still_logs(self, mqtt_client, caplog):
"""A cycle Bambuddy did not start — from the printer's screen, from
Studio, or from before a restart — has no cached duration to compare
against. The remaining time alone still proves it was cut short, so the
reason codes must be logged rather than withheld for lack of a target."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 480, "tray": []}]})
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
message = "\n".join(r.getMessage() for r in caplog.records)
assert "drying ended early" in message
assert "480 of ? minutes" in message
assert "hms=none" in message
def test_stop_we_sent_is_not_blamed_on_the_firmware(self, mqtt_client, caplog):
"""A stop Bambuddy sends — print takes priority, or the user's Stop
button — also ends the cycle far short of its duration, which on the
telemetry alone looks exactly like the firmware abandoning it. It must
be named as ours rather than reported as an unexplained early end."""
mqtt_client._client = MagicMock()
mqtt_client.send_drying_command(ams_id=0, temp=65, duration=12, mode=1, filament="PETG")
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 700, "tray": []}]})
mqtt_client.send_drying_command(ams_id=0, temp=0, duration=0, mode=0)
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
message = "\n".join(r.getMessage() for r in caplog.records)
assert "drying stopped by Bambuddy" in message
assert "ended early" not in message
# And the attribution is consumed, so a later firmware-ended cycle on
# the same unit is not credited to a stop we sent hours earlier.
mqtt_client.send_drying_command(ams_id=0, temp=65, duration=12, mode=1, filament="PETG")
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 700, "tray": []}]})
caplog.clear()
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
assert "drying ended early" in "\n".join(r.getMessage() for r in caplog.records)
def test_cycle_that_runs_to_term_keeps_the_plain_completion_log(self, mqtt_client, caplog):
"""The countdown of a cycle that finishes normally is all but exhausted
when it drops to 0. Nothing needs explaining, so it keeps the one-line
message it has always had — the early-end diagnostics must not become
noise on every completed dry."""
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 1, "tray": []}]})
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data({"ams": [{"id": "0", "dry_time": 0, "tray": []}]})
message = "\n".join(r.getMessage() for r in caplog.records)
assert "drying complete (dry_time 1 → 0" in message
assert "ended early" not in message
def test_every_cycle_end_records_the_box_conditions(self, mqtt_client, caplog):
"""Whether auto-drying re-arms is decided by the unit's temperature and
humidity at the moment the cycle ends, so both belong on the line that
reports the end — normal or early. Reconstructing them for #2770 meant
cross-referencing hourly alarm lines against scheduler debug that was
switched off at the time."""
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 1, "temp": "63.0", "humidity_raw": "16", "tray": []}]}
)
with caplog.at_level(logging.INFO, logger="backend.app.services.bambu_mqtt"):
mqtt_client._handle_ams_data(
{"ams": [{"id": "0", "dry_time": 0, "temp": "63.0", "humidity_raw": "16", "tray": []}]}
)
message = "\n".join(r.getMessage() for r in caplog.records)
assert "temp=63.0" in message
assert "humidity=16" in message
class TestPrintRunningObservedCallback:
"""#1485 follow-up: on_print_running_observed fires the FIRST time we
see ``state == RUNNING`` for a printer whose print started before
Bambuddy came up. It lets main.py capture a timelapse baseline at
restart-recovery time — when on_print_start was suppressed by the
#1304 first-push guard. Must NOT fire when on_print_start handles the
transition (avoids double-capture), and must NOT fire again after
the first observation in the same session.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def test_fires_on_first_running_push_after_startup(self, mqtt_client):
"""First push the client sees has _previous_gcode_state=None, so the
#1304 guard suppresses on_print_start. on_print_running_observed
must fire instead so the consumer can recover."""
start_calls: list[dict] = []
running_observed_calls: list[dict] = []
mqtt_client.on_print_start = lambda data: start_calls.append(data)
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
# Pristine state — exactly what we have right after BambuMQTTClient
# construction following a Bambuddy restart.
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
}
}
)
assert start_calls == [], "on_print_start must be suppressed by the #1304 guard"
assert len(running_observed_calls) == 1
assert running_observed_calls[0]["filename"] == "/data/Metadata/test_print.gcode"
assert running_observed_calls[0]["subtask_name"] == "Test_Print"
def test_does_not_fire_when_print_start_fires(self, mqtt_client):
"""Normal print start (a real state transition from non-RUNNING to
RUNNING) goes through on_print_start; on_print_running_observed
must stay quiet so the consumer doesn't capture the baseline twice."""
start_calls: list[dict] = []
running_observed_calls: list[dict] = []
mqtt_client.on_print_start = lambda data: start_calls.append(data)
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = "IDLE" # Not None — past the #1304 guard
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
}
}
)
assert len(start_calls) == 1, "on_print_start should fire on a real start transition"
assert running_observed_calls == [], "on_print_running_observed must not double up with on_print_start"
def test_fires_only_once_per_session(self, mqtt_client):
"""Subsequent RUNNING pushes in the same session must not re-fire the
callback — the baseline only needs to be captured once, the consumer
treats repeat calls as a hint to skip via the in-memory dict guard."""
running_observed_calls: list[dict] = []
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
msg = {
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
}
}
mqtt_client._process_message(msg)
mqtt_client._process_message(msg)
mqtt_client._process_message(msg)
assert len(running_observed_calls) == 1
def test_does_not_fire_when_not_running(self, mqtt_client):
"""An IDLE / PREPARE / FINISH first-push must not trigger the
restart-recovery path — there's no print to baseline."""
running_observed_calls: list[dict] = []
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
mqtt_client._process_message(
{
"print": {
"gcode_state": "IDLE",
"gcode_file": "",
"subtask_name": "",
}
}
)
assert running_observed_calls == []
def test_does_not_fire_without_current_file(self, mqtt_client):
"""RUNNING with no file is ill-formed (firmware glitch / transient).
We need ``current_file`` to find the right archive, so skip the
callback rather than fire it with a meaningless payload."""
running_observed_calls: list[dict] = []
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "",
"subtask_name": "",
}
}
)
assert running_observed_calls == []
def test_safe_when_callback_not_set(self, mqtt_client):
"""No callback configured → silently skip; no AttributeError on the
firing branch."""
mqtt_client.on_print_running_observed = None
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
# Should not raise.
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
}
}
)
assert mqtt_client._was_running is True
def test_payload_shape_matches_print_start(self, mqtt_client):
"""The payload shape must mirror on_print_start so main.py's
consumer can reuse the same dict fields (filename / subtask_name /
remaining_time / raw_data / ams_mapping). Test pins the keys."""
running_observed_calls: list[dict] = []
mqtt_client.on_print_running_observed = lambda data: running_observed_calls.append(data)
mqtt_client._was_running = False
mqtt_client._previous_gcode_state = None
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/test_print.gcode",
"subtask_name": "Test_Print",
"mc_remaining_time": 42,
}
}
)
assert len(running_observed_calls) == 1
payload = running_observed_calls[0]
assert set(payload.keys()) == {
"filename",
"subtask_name",
"remaining_time",
"raw_data",
"ams_mapping",
}
class TestTotalLayersPreservation:
"""#1771: P1S firmware resets `total_layer_num` to 0 at print end. Without
this guard, the usage tracker's split path saw `state.total_layers = 0` at
completion and dumped the whole print onto the last spool.
These tests pin the preservation pattern (mirror of `_last_valid_layer_num`)
and the explicit reset on new print start so the previous print's total
can't bleed into the next.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
return client
def test_nonzero_total_layer_num_sets_state(self, mqtt_client):
# Baseline: a fresh push with the slicer's total updates state.total_layers.
mqtt_client._process_message({"print": {"total_layer_num": 260}})
assert mqtt_client.state.total_layers == 260
def test_zero_total_layer_num_does_not_clobber_cached_value(self, mqtt_client):
# Firmware-reset frame: total_layer_num=0 arrives mid- or end-of-print.
# The guard must NOT overwrite the previously-captured 260.
mqtt_client._process_message({"print": {"total_layer_num": 260}})
mqtt_client._process_message({"print": {"total_layer_num": 0}})
assert mqtt_client.state.total_layers == 260
def test_print_start_explicitly_resets_total_layers(self, mqtt_client):
# Without the explicit reset on print start, the previous print's total
# would persist into the new print until its first total_layer_num push
# arrived — which is exactly the kind of cross-print bleed the
# preservation guard above otherwise opens up.
mqtt_client._process_message({"print": {"total_layer_num": 260}})
assert mqtt_client.state.total_layers == 260
# Simulate the new-print-start trigger shape (is_new_print path):
# state was previously RUNNING on an old file; now we observe a
# different file going RUNNING.
mqtt_client._previous_gcode_state = "RUNNING"
mqtt_client._previous_gcode_file = "/data/Metadata/old_print.gcode"
mqtt_client._was_running = True
mqtt_client._process_message(
{
"print": {
"gcode_state": "RUNNING",
"gcode_file": "/data/Metadata/new_print.gcode",
"subtask_name": "new_print",
}
}
)
assert mqtt_client.state.total_layers == 0
class TestAmsFilamentBackupHoldTimer:
"""Regression: stale push_status arriving within the hold window after a
toggle command MUST NOT flip ams_filament_backup back to the printer's
old cfg. Same race-guard pattern xcam uses for spaghetti / first-layer
detector settings.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
# Pretend we're connected so _set_print_option actually publishes.
client.state.connected = True
client._client = MagicMock()
return client
def test_cfg_push_with_old_value_is_ignored_during_hold(self, mqtt_client):
# User toggled ON via badge → command sent → state optimistically set.
mqtt_client.set_ams_filament_backup(True)
assert mqtt_client.state.ams_filament_backup is True
# Within the 3 s hold window, a stale push_status arrives still showing
# the printer's old cfg (bit 18 cleared). The parser must NOT flip our
# optimistic state back to OFF — otherwise the badge flickers ON→OFF→ON.
mqtt_client._process_message({"print": {"cfg": "C0340BC219"}}) # bit18=0
assert mqtt_client.state.ams_filament_backup is True
def test_cfg_push_after_hold_expires_overrides_state(self, mqtt_client):
# After the hold window, the printer's real cfg becomes authoritative
# so a genuine slicer-side or display toggle that we did NOT initiate
# propagates correctly.
mqtt_client.set_ams_filament_backup(True)
mqtt_client._xcam_hold_start["print_option_auto_switch_filament"] = time.time() - 10.0
mqtt_client._process_message({"print": {"cfg": "C0340BC219"}}) # bit18=0
assert mqtt_client.state.ams_filament_backup is False
def test_cfg_push_with_matching_value_during_hold_is_a_noop(self, mqtt_client):
# Same-value push during hold doesn't trigger the change branch at all
# (no state mutation, no log spam, hold timer stays armed).
mqtt_client.set_ams_filament_backup(True)
before_hold = mqtt_client._xcam_hold_start["print_option_auto_switch_filament"]
mqtt_client._process_message({"print": {"cfg": "C0340FC219"}}) # bit18=1
assert mqtt_client.state.ams_filament_backup is True
# Hold timer still armed — sub-second push didn't reset it.
assert mqtt_client._xcam_hold_start["print_option_auto_switch_filament"] == before_hold
class TestCommandAckIsNotTelemetry:
"""Regression (#3040): a printer's command acknowledgement echoes the
fields Bambuddy sent, so ingesting one as status reads our own request
back as the printer's state.
Bambuddy used to put ``"cfg": "0"`` in every project_file. The ack came
back carrying it, bit 18 read as "AMS Filament Backup OFF", and on the
families that don't repeat ``cfg`` in their periodic frames (P1S, A1,
A1 Mini, A2L) the wrong value stuck until the user toggled it — which
silently disabled the prefer-lowest-remaining gate for the rest of the day.
"""
@pytest.fixture
def mqtt_client(self):
from unittest.mock import MagicMock
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client.state.connected = True
client._client = MagicMock()
return client
def test_project_file_ack_does_not_clear_backup_state(self, mqtt_client):
mqtt_client.state.ams_filament_backup = True
mqtt_client._process_message(
{"print": {"command": "project_file", "sequence_id": "20000", "cfg": "0", "result": "success"}}
)
assert mqtt_client.state.ams_filament_backup is True
def test_project_file_ack_leaves_unknown_backup_unknown(self, mqtt_client):
"""A1 / A1 Mini never report cfg, so the state must stay None ("unknown")
— the value the prefer-lowest gate reads as "preserve old behaviour"."""
assert mqtt_client.state.ams_filament_backup is None
mqtt_client._process_message({"print": {"command": "project_file", "cfg": "0"}})
assert mqtt_client.state.ams_filament_backup is None
def test_push_status_still_updates_backup_state(self, mqtt_client):
mqtt_client.state.ams_filament_backup = True
mqtt_client._process_message({"print": {"command": "push_status", "cfg": "C0340BC219"}}) # bit18=0
assert mqtt_client.state.ams_filament_backup is False
def test_status_frame_without_command_still_updates_backup_state(self, mqtt_client):
"""Some firmwares omit `command` on a status frame; those stay trusted."""
mqtt_client.state.ams_filament_backup = False
mqtt_client._process_message({"print": {"cfg": "C0340FC219"}}) # bit18=1
assert mqtt_client.state.ams_filament_backup is True
def test_project_file_ack_does_not_clear_timelapse_state(self, mqtt_client):
"""The ack echoes the per-job timelapse request, not the recorder."""
mqtt_client.state.timelapse = True
mqtt_client._process_message({"print": {"command": "project_file", "timelapse": False}})
assert mqtt_client.state.timelapse is True
def test_push_status_still_updates_timelapse_state(self, mqtt_client):
mqtt_client.state.timelapse = True
mqtt_client._process_message({"print": {"command": "push_status", "timelapse": False}})
assert mqtt_client.state.timelapse is False
# ---------------------------------------------------------------------------
# 2c. Single-nozzle H2S — external-spool tray_now override (#1822)
# ---------------------------------------------------------------------------
class TestTrayNowH2SExternalSpoolOverride:
"""H2S firmware reports tray_now as the AMS's idle slot (typically 0)
instead of 254 when the active feed is the external spool.
Bambuddy detects the all-external case via the slicer-captured
ams_mapping (every entry 254, or -1 when the command carried no
ams_mapping2 to resolve it from, #3166) and promotes tray_now to 254 so
the UI active-tray highlight matches the real feed.
The override is intentionally narrow:
* only fires when ams_mapping is captured AND every entry is external
* does not touch mixed prints ([5, -1]) or AMS-only prints ([5])
* does not fire when no ams_mapping is captured (printer-screen start)
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST_H2S",
access_code="12345678",
)
def test_all_external_mapping_promotes_tray_now_to_254(self, mqtt_client):
"""Reporter's scenario: H2S, single nozzle, captured ams_mapping=[-1],
firmware sends tray_now=0 -> Bambuddy promotes to 254."""
mqtt_client._captured_ams_mapping = [-1]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 254
def test_multi_external_mapping_also_promotes(self, mqtt_client):
"""Multi-filament print, every filament mapped to external. Still
all-external -> still promotes."""
mqtt_client._captured_ams_mapping = [-1, -1, -1]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 254
def test_resolved_external_mapping_promotes(self, mqtt_client):
"""Since #3166 the capture resolves the external spool from
ams_mapping2, so a single-nozzle all-external print arrives as [254]
rather than [-1]. The override must still fire."""
mqtt_client._captured_ams_mapping = [254]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 254
def test_ams_only_mapping_does_not_override(self, mqtt_client):
"""ams_mapping=[5] (AMS slot 5 only) -> firmware value trusted as-is.
Without the all-external guard, this would falsely override real
AMS-slot prints."""
mqtt_client._captured_ams_mapping = [5]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 0
def test_mixed_mapping_does_not_override(self, mqtt_client):
"""Mixed mapping (AMS slot 5 + external): we have no evidence the
firmware misreports mid-print swaps, so leave tray_now alone."""
mqtt_client._captured_ams_mapping = [5, -1]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 0
def test_no_captured_mapping_does_not_override(self, mqtt_client):
"""Prints started from the printer screen (or before Bambuddy
connected) have no captured ams_mapping. Behaviour unchanged from
pre-#1822 — we accept the wrong value rather than guess."""
mqtt_client._captured_ams_mapping = None
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 0
def test_empty_captured_mapping_does_not_override(self, mqtt_client):
"""Empty list (defensive — should not happen in practice but
all([]) returns True). Treat as no signal, not as all-external."""
mqtt_client._captured_ams_mapping = []
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 0
def test_unloaded_after_print_still_resolves_correctly(self, mqtt_client):
"""When the firmware unloads (tray_now=255), the override is skipped
because the branch only fires for tray_now in 0-3."""
mqtt_client._captured_ams_mapping = [-1]
mqtt_client._process_message(_ams_payload(0))
assert mqtt_client.state.tray_now == 254
mqtt_client._process_message(_ams_payload(255))
assert mqtt_client.state.tray_now == 255
class TestNoLastLayerFinishPhotoTrigger:
"""#2547: the layer_num→total_layer_num edge must NOT trigger a photo.
That edge is the moment the printer *starts* the final layer. On the H2C
capture that closed #2547 it arrived at 92% with `mc_remaining_time=2`,
three minutes and one filament change before the print actually ended, so
the photo showed the toolhead mid-print over the part. It also latched
`_finish_photo_captured`, which locked out the two triggers that fire at a
real end-of-print — so these tests pin both halves: the edge is silent, and
the later triggers still work after it has passed.
#1867 (End G-code ejecting the plate before FINISH) is handled in
`on_finish_photo_moment` via `print_dispatch_context`, not here.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._was_running = True
client.state.total_layers = 100
client.state.layer_num = 99
return client
def test_reaching_the_last_layer_fires_nothing(self, mqtt_client):
events = []
mqtt_client.on_finish_photo_moment = lambda data: events.append(data)
mqtt_client._process_message({"print": {"layer_num": 100}})
assert events == []
assert mqtt_client._finish_photo_captured is False
def test_stage_22_still_fires_after_the_last_layer_started(self, mqtt_client):
"""The regression the removed trigger caused: stage 22 is the good
moment on firmware that emits it, and it arrives *after* the last-layer
edge. The old latch swallowed it."""
events = []
mqtt_client.on_finish_photo_moment = lambda data: events.append(data)
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client.state.progress = 100
mqtt_client._process_message({"print": {"stg_cur": 22}})
assert [e["trigger"] for e in events] == ["stage_22"]
def test_finish_state_still_fires_after_the_last_layer_started(self, mqtt_client):
"""H2C/A1 Mini never emit stage 22, so FINISH is their only moment —
and it is now reachable, where the latch used to block it."""
events = []
completion_events = []
mqtt_client.on_finish_photo_moment = lambda data: events.append(data)
mqtt_client.on_print_complete = lambda data: completion_events.append(data)
mqtt_client._previous_gcode_state = "RUNNING"
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
assert [e["trigger"] for e in events] == ["finish_state"]
assert len(completion_events) == 1
def test_no_photo_trigger_fires_repeatedly_across_the_last_layer(self, mqtt_client):
"""A three-minute last layer publishes many frames at layer_num ==
total. None of them may produce a moment."""
events = []
mqtt_client.on_finish_photo_moment = lambda data: events.append(data)
for percent in (92, 93, 94, 95, 97, 98, 99):
mqtt_client._process_message({"print": {"layer_num": 100, "mc_percent": percent}})
assert events == []
class TestBillingProgressTracking:
"""The latest positive MQTT progress is the fallback for partial billing."""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def test_current_frame_is_retained_and_zero_reset_does_not_overwrite_it(self, mqtt_client):
"""Even the first positive frame must survive an immediate printer abort."""
mqtt_client._process_message({"print": {"mc_percent": 25}})
assert mqtt_client._last_valid_progress == 25
mqtt_client._process_message({"print": {"mc_percent": 0}})
assert mqtt_client._last_valid_progress == 25
class TestPrintProgressCallback:
"""#2547: `on_print_progress` keeps the finish-photo frame bank fresh.
Layer changes stop firing the instant the final layer begins, so the bank
would otherwise stay stale for the whole length of that layer. Progress is
the field that keeps advancing there — and it freezes before the End G-code
runs, which is what keeps a swapped plate out of the bank (#1867).
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._was_running = True
return client
def test_fires_on_each_advance(self, mqtt_client):
seen = []
mqtt_client.on_print_progress = seen.append
for percent in (92, 93, 94):
mqtt_client._process_message({"print": {"mc_percent": percent}})
assert seen == [92, 93, 94]
def test_does_not_fire_when_progress_is_unchanged(self, mqtt_client):
"""Most frames repeat the same percent; each one would otherwise cost a
camera grab that contends with the live view."""
seen = []
mqtt_client.on_print_progress = seen.append
mqtt_client._process_message({"print": {"mc_percent": 92}})
mqtt_client._process_message({"print": {"mc_percent": 92}})
mqtt_client._process_message({"print": {"mc_percent": 92}})
assert seen == [92]
def test_does_not_fire_when_progress_goes_backwards(self, mqtt_client):
"""Firmware resets progress to 0 on cancel — that is not the print
advancing, and banking a frame there would be banking a cancelled bed."""
seen = []
mqtt_client.on_print_progress = seen.append
mqtt_client._process_message({"print": {"mc_percent": 92}})
mqtt_client._process_message({"print": {"mc_percent": 0}})
assert seen == [92]
def test_does_not_fire_when_no_print_is_running(self, mqtt_client):
mqtt_client._was_running = False
seen = []
mqtt_client.on_print_progress = seen.append
mqtt_client._process_message({"print": {"mc_percent": 92}})
assert seen == []
def test_absent_callback_is_not_an_error(self, mqtt_client):
mqtt_client.on_print_progress = None
mqtt_client._process_message({"print": {"mc_percent": 92}})
assert mqtt_client.state.progress == 92
class TestPresumedPowerOffRecovery:
"""#2629: a smart-plug turn-off marks the printer offline optimistically.
When the plug does not actually feed the printer, the printer keeps
publishing — and the forced 'unknown' state must be undone, or it sticks
until the next full pushall and the queue scheduler stalls forever.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client.state.connected = True
client.state.state = "FINISH"
return client
@staticmethod
def _report(client, payload):
"""Feed a report-topic message through the real _on_message path."""
class _Msg:
def __init__(self, topic, data):
self.topic = topic
self.payload = json.dumps(data).encode()
client._on_message(None, None, _Msg(client.topic_subscribe, payload))
def test_mark_power_off_blanks_state_and_remembers_it(self, mqtt_client):
assert mqtt_client.mark_power_off() is True
assert mqtt_client.state.connected is False
assert mqtt_client.state.state == "unknown"
assert mqtt_client._state_before_power_off == "FINISH"
def test_mark_power_off_noop_when_already_disconnected(self, mqtt_client):
mqtt_client.state.connected = False
assert mqtt_client.mark_power_off() is False
assert mqtt_client._state_before_power_off is None
def test_second_mark_does_not_overwrite_saved_state(self, mqtt_client):
mqtt_client.mark_power_off()
# Something flips connected back (a partial message) before the second mark
mqtt_client.state.connected = True
mqtt_client.mark_power_off()
assert mqtt_client._state_before_power_off == "FINISH"
def test_partial_report_restores_state(self, mqtt_client):
"""The steady-state push_status carries no gcode_state — the pre-off
state must come back anyway, otherwise 'unknown' is permanent."""
mqtt_client.mark_power_off()
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
assert mqtt_client.state.connected is True
assert mqtt_client.state.state == "FINISH"
assert mqtt_client._state_before_power_off is None
def test_restore_broadcasts_state_change(self, mqtt_client):
broadcasts = []
mqtt_client.on_state_change = lambda state: broadcasts.append(state.state)
mqtt_client.mark_power_off()
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
assert "FINISH" in broadcasts
def test_fresh_gcode_state_wins_over_restored_state(self, mqtt_client):
"""A report that does carry gcode_state is authoritative."""
mqtt_client.mark_power_off()
self._report(mqtt_client, {"print": {"gcode_state": "IDLE"}})
assert mqtt_client.state.state == "IDLE"
def test_restore_happens_only_once(self, mqtt_client):
"""After recovery a later genuine blank must not be undone by a stale
saved state."""
mqtt_client.mark_power_off()
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
# Printer really loses power now: state blanked, nothing to restore from
mqtt_client.state.state = "unknown"
assert mqtt_client._restore_state_after_false_power_off() is False
assert mqtt_client.state.state == "unknown"
def test_request_topic_traffic_does_not_restore(self, mqtt_client):
"""Only the printer's own report topic proves it is alive; the request
topic also carries slicer/Bambuddy commands."""
mqtt_client.mark_power_off()
class _Msg:
topic = mqtt_client.topic_publish
payload = json.dumps({"print": {"command": "project_file"}}).encode()
mqtt_client._on_message(None, None, _Msg())
assert mqtt_client.state.state == "unknown"
assert mqtt_client._state_before_power_off == "FINISH"
def test_reconnect_discards_saved_state(self, mqtt_client):
"""A real power cut drops the MQTT session; on reconnect the saved state
is stale and must not be broadcast ahead of the printer's first report."""
from unittest.mock import MagicMock
mqtt_client.mark_power_off()
paho = MagicMock()
paho.subscribe.return_value = (0, 1) # (MQTT_ERR_SUCCESS, mid)
mqtt_client._on_connect(paho, None, {}, 0)
assert mqtt_client._state_before_power_off is None
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
assert mqtt_client.state.state == "unknown"
def test_already_unknown_state_is_not_saved(self, mqtt_client):
"""A printer that never reported has nothing to restore — saving
'unknown' would make the recovery broadcast a no-op state change."""
mqtt_client.state.state = "unknown"
assert mqtt_client.mark_power_off() is True
assert mqtt_client._state_before_power_off is None
def test_message_interleaved_with_mark_does_not_strand_unknown(self, mqtt_client):
"""mark_power_off runs on the event loop, _on_message on the paho
thread. A message landing mid-mark must not consume the saved state and
leave the printer stuck on 'unknown' — the next message must recover."""
# Simulate the worst interleaving: a report is processed after the state
# was blanked but before the previous state was recorded.
mqtt_client.state.connected = False
mqtt_client.state.state = "unknown"
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
# ...now the rest of the mark completes.
mqtt_client._state_before_power_off = "FINISH"
self._report(mqtt_client, {"print": {"wifi_signal": "-30dBm"}})
assert mqtt_client.state.state == "FINISH"
class TestKProfileResponseDoesNotClobberNozzle:
"""#2663: the K-profile fetch (get_kprofiles) probes every nozzle size
0.2/0.4/0.6/0.8 with an ``extrusion_cali_get`` request. Each response
echoes the *requested* nozzle_diameter at the top level, which is NOT the
installed hardware. _process_message must not feed those responses to
_update_state, or the real nozzle size gets overwritten (typically to 0.8,
the last size probed) and the #1899 dispatch guard then blocks prints.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="A1TEST",
access_code="12345678",
)
def test_kprofile_response_does_not_overwrite_nozzle_diameter(self, mqtt_client):
# A genuine pushall reports the real 0.4mm nozzle.
mqtt_client._process_message({"print": {"nozzle_diameter": "0.4"}})
assert mqtt_client.state.nozzles[0].nozzle_diameter == "0.4"
# The K-profile probe's 0.8mm response arrives (as it did on the
# reporter's A1s). It must NOT clobber the hardware nozzle.
mqtt_client._process_message(
{
"print": {
"command": "extrusion_cali_get",
"nozzle_diameter": "0.8",
"filaments": [],
"sequence_id": "1501",
}
}
)
assert mqtt_client.state.nozzles[0].nozzle_diameter == "0.4"
def test_kprofile_response_is_still_parsed(self, mqtt_client):
# Skipping _update_state must not skip the K-profile handler: the
# response's profiles still populate state.kprofiles.
mqtt_client._process_message(
{
"print": {
"command": "extrusion_cali_get",
"nozzle_diameter": "0.4",
"filaments": [
{
"cali_idx": 0,
"nozzle_diameter": "0.4",
"filament_id": "GFA00",
"name": "PLA",
"k_value": "0.020000",
}
],
}
}
)
assert len(mqtt_client.state.kprofiles) == 1
assert mqtt_client.state.kprofiles[0].filament_id == "GFA00"
def test_genuine_pushall_still_updates_nozzle(self, mqtt_client):
# The one legitimate source of the hardware nozzle still works, and a
# later pushall corrects a value an old build left wrong.
mqtt_client.state.nozzles[0].nozzle_diameter = "0.8"
mqtt_client._process_message({"print": {"nozzle_diameter": "0.4"}})
assert mqtt_client.state.nozzles[0].nozzle_diameter == "0.4"
class TestKProfileNozzleDiameterFromEnvelope:
"""#1748: every K-profile came back as 0.4mm on single-nozzle printers.
``extrusion_cali_get`` carries ``nozzle_diameter`` only on the response
envelope — the per-filament entries hold just setting_id, filament_id,
name, k_value, n_coef and cali_idx. The parser read the field per entry
with a "0.4" default, so a 0.6/0.8 nozzle's profiles were all stamped 0.4.
Beyond the K-Profiles display that broke the cali_idx cascade in the
inventory and Spoolman assign paths, which match on nozzle_diameter.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="X1ETEST",
access_code="12345678",
)
@staticmethod
def _response(nozzle="0.8", entries=None, seq="48"):
"""A verbatim-shaped extrusion_cali_get payload from the #1748 report."""
if entries is None:
entries = [
{
"setting_id": "GFSNLS02_07",
"filament_id": "GFSNL02",
"name": "SUNLU PLA Matte WHITE 0.8",
"k_value": "0.01750",
"n_coef": "1.000",
"cali_idx": 265,
"is_history_setting": True,
}
]
print_data = {"command": "extrusion_cali_get", "filament_id": "", "filaments": entries}
if nozzle is not None:
print_data["nozzle_diameter"] = nozzle
if seq is not None:
print_data["sequence_id"] = seq
return {"print": print_data}
def test_broadcast_uses_envelope_diameter(self, mqtt_client):
# No request in flight: the unsolicited broadcast still has to record
# the right diameter, because state.kprofiles is what the assign paths
# read when nobody has just fetched.
mqtt_client._process_message(self._response(nozzle="0.8"))
assert [p.nozzle_diameter for p in mqtt_client.state.kprofiles] == ["0.8"]
@pytest.mark.asyncio
async def test_awaited_response_uses_envelope_diameter(self, mqtt_client):
profiles = await self._fetch(mqtt_client, "0.6", self._response(nozzle="0.6", seq="7"))
assert [p.nozzle_diameter for p in profiles] == ["0.6"]
def test_entry_value_still_wins(self, mqtt_client):
# Dual-nozzle firmware does put the field on each entry; that stays
# authoritative, since a batch can legitimately span nozzles.
entries = [{"cali_idx": 1, "filament_id": "GFA00", "name": "PLA", "nozzle_diameter": "0.4"}]
mqtt_client._process_message(self._response(nozzle="0.8", entries=entries))
assert mqtt_client.state.kprofiles[0].nozzle_diameter == "0.4"
def test_empty_entry_value_falls_back_to_envelope(self, mqtt_client):
entries = [{"cali_idx": 1, "filament_id": "GFA00", "name": "PLA", "nozzle_diameter": ""}]
mqtt_client._process_message(self._response(nozzle="0.8", entries=entries))
assert mqtt_client.state.kprofiles[0].nozzle_diameter == "0.8"
def test_no_envelope_value_falls_back_to_default(self, mqtt_client):
# Neither source available: keep the old default rather than let
# str(None) write the literal string "None" into the profile.
mqtt_client._process_message(self._response(nozzle=None))
assert mqtt_client.state.kprofiles[0].nozzle_diameter == "0.4"
@staticmethod
async def _fetch(client, nozzle, response):
"""Run get_kprofiles, feeding `response` in as the printer's answer."""
client.state.connected = True
client._client = MagicMock()
client._client.publish.side_effect = lambda *a, **kw: client._process_message(response)
return await client.get_kprofiles(nozzle_diameter=nozzle, timeout=2.0)
class TestKProfileWriteAcks:
"""#2718: K-profile writes were fire-and-forget.
``set_kprofiles_batch`` published and returned True immediately, and the
printer's ``extrusion_cali_set`` answer was logged at DEBUG and dropped, so
a rejected write was reported to the user as saved. Two facts measured on
real hardware shape the fix: the printer echoes our ``sequence_id`` back
(so the ack can be correlated), and it answers ``result: "fail",
reason: "invalid tray_id"`` to ``tray_id: -1`` on single-nozzle firmware
while applying the write anyway — flipping that field to 0 is what makes
``result`` trustworthy.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="X1CTEST",
access_code="12345678",
)
client.state.connected = True
client._client = MagicMock()
return client
@staticmethod
def _sent(client):
return json.loads(client._client.publish.call_args[0][1])["print"]
def test_set_sends_tray_id_zero(self, mqtt_client):
mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
assert self._sent(mqtt_client)["filaments"][0]["tray_id"] == 0
def test_batch_sends_tray_id_zero(self, mqtt_client):
mqtt_client.set_kprofiles_batch([{"filament_id": "GFL99", "name": "t", "k_value": "0.020000"}])
assert self._sent(mqtt_client)["filaments"][0]["tray_id"] == 0
def test_writers_return_their_sequence_id(self, mqtt_client):
seq = mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
assert seq == self._sent(mqtt_client)["sequence_id"]
assert seq in mqtt_client._pending_cali_acks
def test_writers_return_none_when_disconnected(self, mqtt_client):
mqtt_client.state.connected = False
assert mqtt_client.set_kprofile(filament_id="GFL99", name="t", k_value="0.02") is None
assert mqtt_client.set_kprofiles_batch([{"filament_id": "GFL99"}]) is None
assert mqtt_client.delete_kprofile(cali_idx=1, filament_id="GFL99", nozzle_id="HH00-0.4") is None
def test_per_tray_extrusion_cali_set_advances_the_sequence_id(self, mqtt_client):
# It used to reuse the previous command's id, which would silently
# defeat the correlation the write path now depends on.
before = mqtt_client._sequence_id
mqtt_client.extrusion_cali_set(tray_id=0, k_value=0.02)
assert mqtt_client._sequence_id > before
assert self._sent(mqtt_client)["sequence_id"] == str(mqtt_client._sequence_id)
@pytest.mark.asyncio
async def test_failure_ack_is_reported_as_failure(self, mqtt_client):
seq = mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
mqtt_client._process_message(
{
"print": {
"command": "extrusion_cali_set",
"result": "fail",
"reason": "invalid tray_id",
"sequence_id": seq,
}
}
)
ok, detail = await mqtt_client.await_cali_ack(seq, timeout=2.0)
assert ok is False
assert detail == "invalid tray_id"
@pytest.mark.asyncio
async def test_success_ack_passes(self, mqtt_client):
seq = mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
mqtt_client._process_message(
{"print": {"command": "extrusion_cali_set", "result": "success", "reason": "", "sequence_id": seq}}
)
ok, _ = await mqtt_client.await_cali_ack(seq, timeout=2.0)
assert ok is True
@pytest.mark.asyncio
async def test_ack_for_another_write_does_not_resolve_this_one(self, mqtt_client):
seq = mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
mqtt_client._process_message(
{
"print": {
"command": "extrusion_cali_set",
"result": "fail",
"reason": "invalid tray_id",
"sequence_id": "999999",
}
}
)
# Unrelated sequence_id: this write is still unanswered, so it times
# out rather than inheriting someone else's failure.
ok, detail = await mqtt_client.await_cali_ack(seq, timeout=0.3)
assert ok is True
assert "no acknowledgement" in detail
@pytest.mark.asyncio
async def test_silence_is_not_treated_as_rejection(self, mqtt_client):
# Firmware that never answers must not turn every save into an error.
seq = mqtt_client.delete_kprofile(cali_idx=1, filament_id="GFL99", nozzle_id="HH00-0.4")
ok, detail = await mqtt_client.await_cali_ack(seq, timeout=0.3)
assert ok is True
assert "no acknowledgement" in detail
@pytest.mark.asyncio
async def test_pending_slot_is_released(self, mqtt_client):
seq = mqtt_client.set_kprofile(filament_id="GFL99", name="test", k_value="0.022000")
await mqtt_client.await_cali_ack(seq, timeout=0.3)
assert mqtt_client._pending_cali_acks == {}
def test_delete_ack_is_matched_too(self, mqtt_client):
seq = mqtt_client.delete_kprofile(cali_idx=1, filament_id="GFL99", nozzle_id="HH00-0.4")
mqtt_client._process_message(
{"print": {"command": "extrusion_cali_del", "result": "success", "sequence_id": seq}}
)
assert mqtt_client._pending_cali_acks[seq]["result"] == "success"
class TestKProfileRequestCorrelation:
"""#1748: K-profile requests timed out whenever two were in flight.
Responses were matched to requests by nozzle diameter alone, held in one
shared ``_expected_kprofile_nozzle`` slot. A second request overwrote the
first's expectation, so the first's valid answer was discarded as a
mismatch and that request timed out even though the printer had replied.
Correlation now runs off the sequence_id we send, with the nozzle match
kept as a fallback for firmware that doesn't echo it.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="X1ETEST",
access_code="12345678",
)
client.state.connected = True
client._client = MagicMock()
return client
@staticmethod
def _response(nozzle, seq, name):
return {
"print": {
"command": "extrusion_cali_get",
"nozzle_diameter": nozzle,
"sequence_id": seq,
"filaments": [{"cali_idx": 1, "filament_id": "GFA00", "name": name, "k_value": "0.020000"}],
}
}
@pytest.mark.asyncio
async def test_concurrent_requests_each_get_their_own_response(self, mqtt_client):
# The failing sequence from the report: 0.8 is requested, then 0.4,
# then the 0.8 answer lands. Under nozzle-only matching the expected
# slot already said 0.4, so the 0.8 answer was dropped on the floor.
seen: list[str] = []
def publish(_topic, payload, **_kw):
seen.append(json.loads(payload)["print"]["sequence_id"])
mqtt_client._client.publish.side_effect = publish
big = asyncio.create_task(mqtt_client.get_kprofiles(nozzle_diameter="0.8", timeout=5.0))
small = asyncio.create_task(mqtt_client.get_kprofiles(nozzle_diameter="0.4", timeout=5.0))
await asyncio.sleep(0) # let both publish before either answer arrives
assert len(seen) == 2
mqtt_client._process_message(self._response("0.8", seen[0], "wide"))
mqtt_client._process_message(self._response("0.4", seen[1], "narrow"))
assert [p.name for p in await big] == ["wide"]
assert [p.name for p in await small] == ["narrow"]
@pytest.mark.asyncio
async def test_falls_back_to_nozzle_match_when_sequence_id_is_not_echoed(self, mqtt_client):
# Firmware that answers with its own sequence_id must keep working.
mqtt_client._client.publish.side_effect = lambda *a, **kw: mqtt_client._process_message(
self._response("0.6", "9999", "echoed-nothing")
)
profiles = await mqtt_client.get_kprofiles(nozzle_diameter="0.6", timeout=2.0)
assert [p.name for p in profiles] == ["echoed-nothing"]
@pytest.mark.asyncio
async def test_unrelated_broadcast_does_not_clobber_a_pending_fetch(self, mqtt_client):
# The printer broadcasts 0.4 profiles unsolicited. One arriving while a
# 0.8 fetch is open must neither satisfy nor overwrite it.
def publish(_topic, payload, **_kw):
seq = json.loads(payload)["print"]["sequence_id"]
mqtt_client._process_message(self._response("0.4", "9999", "broadcast"))
mqtt_client._process_message(self._response("0.8", seq, "wanted"))
mqtt_client._client.publish.side_effect = publish
profiles = await mqtt_client.get_kprofiles(nozzle_diameter="0.8", timeout=2.0)
assert [p.name for p in profiles] == ["wanted"]
assert [p.name for p in mqtt_client.state.kprofiles] == ["wanted"]
@pytest.mark.asyncio
async def test_pending_entry_is_released_on_timeout(self, mqtt_client):
# A timed-out attempt must not leave its entry behind, or a later
# broadcast would be matched to a request nobody is waiting on.
profiles = await mqtt_client.get_kprofiles(nozzle_diameter="0.8", timeout=0.01, max_retries=1)
assert profiles == []
assert mqtt_client._pending_kprofile_requests == {}
class TestConnectRefusalReporting:
"""#2698: a refused CONNACK must leave a trace.
``_on_connect``'s failure branch used to be a bare ``connected = False``.
A printer refusing our access code then looked exactly like one that was
powered off: paho reports the follow-up drop as the generic "Unspecified
error", so the support bundle from a 30-second reconnect loop carried no
hint of the real cause. Bambu speaks MQTT 3.1.1, whose CONNACK return codes
4 and 5 paho maps to reason codes 134 / 135.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
@staticmethod
def _connack(v3_return_code):
from paho.mqtt.client import convert_connack_rc_to_reason_code
return convert_connack_rc_to_reason_code(v3_return_code)
def test_no_error_recorded_before_any_attempt(self, mqtt_client):
assert mqtt_client.last_connect_error is None
assert mqtt_client.last_connect_error_name is None
@pytest.mark.parametrize("v3_rc", [4, 5])
def test_credential_refusal_recorded(self, mqtt_client, v3_rc, caplog):
with caplog.at_level(logging.WARNING):
mqtt_client._on_connect(None, None, None, self._connack(v3_rc))
assert mqtt_client.state.connected is False
assert mqtt_client.last_connect_error == "auth_rejected"
assert "refused" in caplog.text.lower()
# The remedy has to be in the log — that line is what a maintainer
# reads out of a support bundle.
assert "access code" in caplog.text.lower()
# Never leak the credential itself into a bundle.
assert "12345678" not in caplog.text
def test_non_credential_refusal_recorded_separately(self, mqtt_client, caplog):
# CONNACK 3 = server unavailable: a real refusal, but not about creds.
with caplog.at_level(logging.WARNING):
mqtt_client._on_connect(None, None, None, self._connack(3))
assert mqtt_client.last_connect_error == "refused"
assert "access code" not in caplog.text.lower()
def test_successful_connect_clears_previous_error(self, mqtt_client):
mqtt_client._on_connect(None, None, None, self._connack(5))
assert mqtt_client.last_connect_error == "auth_rejected"
mock_client = type("MockClient", (), {"subscribe": lambda self, topic: (0, 1)})()
mqtt_client._on_connect(mock_client, None, None, 0)
assert mqtt_client.state.connected is True
assert mqtt_client.last_connect_error is None
assert mqtt_client.last_connect_error_name is None
def test_disconnect_line_carries_the_refusal(self, mqtt_client, caplog):
"""The reconnect loop is what fills the log, so it must say why."""
mqtt_client._on_connect(None, None, None, self._connack(5))
caplog.clear()
with caplog.at_level(logging.WARNING):
mqtt_client._on_disconnect(None, None)
assert "MQTT disconnected" in caplog.text
assert "refused" in caplog.text
assert "Not authorized" in caplog.text
def test_disconnect_line_unchanged_without_a_refusal(self, mqtt_client, caplog):
with caplog.at_level(logging.WARNING):
mqtt_client._on_disconnect(None, None)
assert "MQTT disconnected" in caplog.text
assert "refused" not in caplog.text
class TestEndOfPrintProbe:
"""Tests for #2547: the end-of-print telemetry probe.
The probe exists to answer a question no existing support bundle can:
what do the stage/action fields do between the last object layer and
gcode_state=FINISH? stg_cur=22 was supposed to mark "toolhead parked,
before filament unload" (#1721) and fires on no model in the field, and
Bambuddy drops every other stage field unread. These tests pin the
window's boundaries and the guarantee that instrumentation stays
instrumentation — it must never raise into the ingest path.
"""
LOGGER = "backend.app.services.bambu_mqtt"
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
client = BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
client._was_running = True
client.state.state = "RUNNING"
client.state.total_layers = 100
client.state.layer_num = 98
client.state.progress = 90.0
client.state.remaining_time = 12
return client
def test_silent_when_debug_logging_is_off(self, mqtt_client, caplog):
"""The probe is a debug tool; at INFO it must cost nothing and say
nothing, including for a frame that would otherwise open the window."""
with caplog.at_level(logging.INFO, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
assert "EOP-PROBE" not in caplog.text
assert mqtt_client._eop_probe_open is False
def test_does_not_open_mid_print(self, mqtt_client, caplog):
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 99, "mc_percent": 91}})
assert "EOP-PROBE" not in caplog.text
assert mqtt_client._eop_probe_open is False
def test_opens_on_the_last_layer_frame_itself(self, mqtt_client, caplog):
"""The frame carrying the signal must be captured, not just the ones
after it — so the probe has to read the raw frame rather than state,
which _update_state only updates further down the same call."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100, "stg_cur": 0}})
assert "EOP-PROBE open" in caplog.text
assert "'layer_num': 100" in caplog.text
assert mqtt_client._eop_probe_open is True
def test_opens_on_progress_when_the_last_layer_packet_is_missed(self, mqtt_client, caplog):
"""The layer_num edge is a single transient packet and is dropped
intermittently (the reason #1867 needed a second mechanism). Progress
has to be able to open the window on its own."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"mc_percent": 99}})
assert "EOP-PROBE open" in caplog.text
assert mqtt_client._eop_probe_open is True
def test_zero_remaining_does_not_open_before_the_print_progresses(self, mqtt_client, caplog):
"""mc_remaining_time reads 0 during pre-print calibration too, so it
only counts once progress is non-zero."""
mqtt_client.state.progress = 0.0
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"mc_remaining_time": 0, "mc_percent": 0}})
assert "EOP-PROBE" not in caplog.text
def test_does_not_open_when_the_print_never_ran(self, mqtt_client, caplog):
"""Bambuddy restarted mid-print, or firmware replayed a stale frame."""
mqtt_client._was_running = False
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
assert "EOP-PROBE" not in caplog.text
def test_logs_only_changed_fields_after_opening(self, mqtt_client, caplog):
"""Most probed fields are static across the window; logging all of
them every frame would bury the transitions we're looking for."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100, "stg_cur": 0}})
caplog.clear()
# Identical frame — nothing moved, so nothing to say.
mqtt_client._process_message({"print": {"layer_num": 100, "stg_cur": 0}})
assert "EOP-PROBE" not in caplog.text
mqtt_client._process_message({"print": {"layer_num": 100, "stg_cur": 22}})
assert "'stg_cur': 22" in caplog.text
assert "layer_num" not in caplog.text.split("EOP-PROBE")[-1]
def test_captures_the_fields_bambuddy_does_not_parse(self, mqtt_client, caplog):
"""The whole point: mc_stage / mc_action / print_real_action are read
by nothing else in the codebase, so only the probe can show them."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client._process_message(
{
"print": {
"mc_stage": 3,
"mc_action": 8,
"print_real_action": 2,
"print_gcode_action": 5,
"stg_cd": 1,
"home_flag": 2231371,
"spd_lvl": 0,
}
}
)
for field in ("mc_stage", "mc_action", "print_real_action", "print_gcode_action", "stg_cd", "spd_lvl"):
assert field in caplog.text
def test_closes_on_finish_and_does_not_reopen(self, mqtt_client, caplog):
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
assert "EOP-PROBE 2 CLOSE" in caplog.text
assert mqtt_client._eop_probe_open is False
assert mqtt_client._eop_probe_armed is False
caplog.clear()
# Firmware re-sending FINISH, or a stale replay, must not restart it.
mqtt_client._process_message({"print": {"layer_num": 100, "mc_percent": 100}})
assert "EOP-PROBE" not in caplog.text
def test_closing_frame_is_self_contained_when_nothing_changed(self, mqtt_client, caplog):
"""A FINISH frame that repeats values already seen still has to log
something — otherwise the window has no visible end."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"gcode_state": "RUNNING", "mc_percent": 100}})
caplog.clear()
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
# Same value the probe already recorded on the opening frame.
mqtt_client._eop_probe_open = True
mqtt_client._eop_probe_armed = True
mqtt_client._eop_probe_last = {"gcode_state": "FINISH"}
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
assert "CLOSE" in caplog.text
assert "'gcode_state': 'FINISH'" in caplog.text
def test_rearms_for_the_next_print(self, mqtt_client, caplog):
# A completion callback is what lets _update_state finish the print
# (and clear _was_running), which the new-print detection depends on.
mqtt_client.on_print_complete = lambda data: None
mqtt_client.state.gcode_file = "current.3mf"
mqtt_client._previous_gcode_state = "RUNNING"
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
assert mqtt_client._eop_probe_armed is False
# New print: RUNNING again with a file, after the previous print
# completed. _update_state rearms the probe alongside the
# finish-photo one-shot.
mqtt_client._process_message(
{"print": {"gcode_state": "RUNNING", "gcode_file": "next.3mf", "subtask_name": "next"}}
)
assert mqtt_client._eop_probe_armed is True
caplog.clear()
mqtt_client.state.total_layers = 50
mqtt_client._process_message({"print": {"layer_num": 50}})
assert "EOP-PROBE open" in caplog.text
def test_frame_budget_caps_output_but_still_logs_the_close(self, mqtt_client, caplog):
"""A long final layer holds the window open at ~1 frame/second; the
user still has to be able to upload the resulting log."""
from backend.app.services.bambu_mqtt import _END_OF_PRINT_PROBE_MAX_FRAMES
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
for i in range(_END_OF_PRINT_PROBE_MAX_FRAMES + 50):
mqtt_client._process_message({"print": {"mc_remaining_time": i}})
assert "frame budget" in caplog.text
caplog.clear()
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
assert "CLOSE" in caplog.text
def test_opens_on_numeric_strings(self, mqtt_client, caplog):
"""Firmware sends these as ints or as numeric strings depending on
model and field, so the window checks must coerce rather than compare
a str against an int and silently never open."""
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": "100", "mc_percent": "99"}})
assert "EOP-PROBE open" in caplog.text
assert mqtt_client._eop_probe_open is True
def test_coercion_helper_falls_back_on_junk(self, mqtt_client):
"""Unit-level, because feeding junk through _process_message would trip
the pre-existing parsers before ever reaching the probe. The guarantee
under test is only that the probe's own reads can't raise."""
assert mqtt_client._probe_number("100") == 100.0
assert mqtt_client._probe_number("not-a-number", 7) == 7
assert mqtt_client._probe_number(None) is None
assert mqtt_client._probe_number({"unexpected": "shape"}, 0) == 0
def test_probe_failure_cannot_break_ingest(self, mqtt_client, caplog, monkeypatch):
"""Instrumentation must stay instrumentation: if the probe ever throws,
state parsing still has to complete."""
def boom(_data):
raise RuntimeError("probe exploded")
monkeypatch.setattr(mqtt_client, "_probe_end_of_print", boom)
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"gcode_state": "RUNNING", "layer_num": 100}})
assert mqtt_client.state.layer_num == 100
assert "EOP-PROBE failed" in caplog.text
def test_never_logs_the_access_code(self, mqtt_client, caplog):
with caplog.at_level(logging.DEBUG, logger=self.LOGGER):
mqtt_client._process_message({"print": {"layer_num": 100}})
mqtt_client._process_message({"print": {"gcode_state": "FINISH"}})
probe_lines = [line for line in caplog.text.splitlines() if "EOP-PROBE" in line]
assert probe_lines
assert not any("12345678" in line for line in probe_lines)
class TestAmsFilamentSettingRefusalLogging:
"""A refused `ams_filament_setting` reaches the log at INFO (#2756).
The reporter configured a slot on an X1C six times. Every request returned
HTTP 200, every publish carried the complete `GFG99`/`GFSG99` pair, and
every #2582 read-back showed the previous profile still in place — with no
record anywhere of what the printer answered, because the response sat at
DEBUG and support bundles are collected at INFO.
Only a non-success is promoted. This command is not rare — every spool
assignment and every K-profile re-apply sends one — so logging each ack
would bury the one line worth reading.
"""
@pytest.fixture
def mqtt_client(self):
from backend.app.services.bambu_mqtt import BambuMQTTClient
return BambuMQTTClient(
ip_address="192.168.1.100",
serial_number="TEST123",
access_code="12345678",
)
def _refusals(self, caplog):
return [line for line in caplog.text.splitlines() if "ams_filament_setting refused" in line]
def test_refusal_is_logged_at_info_with_result_and_reason(self, mqtt_client, caplog):
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message(
{
"print": {
"command": "ams_filament_setting",
"result": "fail",
"reason": "invalid tray_id",
"ams_id": 0,
"tray_id": 1,
"sequence_id": "0",
}
}
)
refusals = self._refusals(caplog)
assert len(refusals) == 1
# The reason is the whole point of the promotion — a bare "fail" would
# not have told the reporter anything the read-back hadn't already.
assert "result=fail" in refusals[0]
assert "invalid tray_id" in refusals[0]
assert "ams_id=0" in refusals[0]
assert "tray_id=1" in refusals[0]
def test_success_stays_quiet(self, mqtt_client, caplog):
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message(
{"print": {"command": "ams_filament_setting", "result": "success", "sequence_id": "0"}}
)
assert self._refusals(caplog) == []
def test_response_without_a_result_field_stays_quiet(self, mqtt_client, caplog):
"""Firmware that omits `result` tells us nothing — don't invent a refusal."""
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message({"print": {"command": "ams_filament_setting", "sequence_id": "0"}})
assert self._refusals(caplog) == []
def test_developer_mode_probe_failure_is_not_reported_as_a_refusal(self, mqtt_client, caplog):
"""The probe sends this command to the external slot *expecting* a
refusal on P1 firmware — that is a reading, not a fault, and promoting
it would put an alarming line in every P1 bundle on every reconnect."""
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._dev_mode_probe_seq = "7"
mqtt_client._process_message(
{
"print": {
"command": "ams_filament_setting",
"result": "failed",
"reason": "mqtt message verify failed",
"sequence_id": "7",
}
}
)
assert self._refusals(caplog) == []
def test_user_command_is_not_mistaken_for_the_probe(self, mqtt_client, caplog):
"""User-initiated publishes hardcode sequence_id "0", so a refusal is
still reported while a probe is outstanding under a different seq."""
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._dev_mode_probe_seq = "7"
mqtt_client._process_message(
{
"print": {
"command": "ams_filament_setting",
"result": "fail",
"reason": "",
"sequence_id": "0",
}
}
)
assert len(self._refusals(caplog)) == 1
def test_extrusion_cali_sel_is_untouched(self, mqtt_client, caplog):
"""The sibling in the same branch keeps its DEBUG-only handling; this
change is scoped to the write #2756 is about."""
caplog.set_level(logging.INFO, logger="backend.app.services.bambu_mqtt")
mqtt_client._process_message({"print": {"command": "extrusion_cali_sel", "result": "fail", "sequence_id": "0"}})
assert self._refusals(caplog) == []
assert "extrusion_cali_sel" not in caplog.text
Reference in New Issue View Git Blame Copy Permalink