Merge branch 'main' into feat/printer-agent-impl

tests/slic3rutils/CMakeLists.txt

@@ -6,7 +6,7 @@ add_executable(${_TEST_NAME}_tests
     test_creality_cfs_match.cpp
     test_dev_mapping.cpp
     test_device_access.cpp
-    test_moonraker_discovery.cpp
+    test_moonraker_printer_agent.cpp
     test_network_discovery.cpp
     test_filament_bitmap_utils.cpp
     test_colour_picker_field.cpp

tests/slic3rutils/test_imgui_wrapper.cpp

@@ -1,6 +1,7 @@
-// How ImGuiWrapper turns wx mouse events into ImGui input. ImGuiWrapper lives in libslic3r_gui; this is
-// the suite that links it. Same Windows include prologue as test_texture_color_palette.cpp (wx pulls in
-// <windows.h>; keep WIN32_LEAN_AND_MEAN / NOMINMAX ahead of it).
+// How ImGuiWrapper turns wx mouse events into ImGui input, and when it reports that ImGui owns a key.
+// ImGuiWrapper lives in libslic3r_gui; this is the suite that links it. Same Windows include prologue
+// as test_texture_color_palette.cpp (wx pulls in <windows.h>; keep WIN32_LEAN_AND_MEAN / NOMINMAX
+// ahead of it).
 #ifdef WIN32
     #ifndef WIN32_LEAN_AND_MEAN
         #define WIN32_LEAN_AND_MEAN
@@ -17,12 +18,15 @@
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 
 #include <imgui/imgui.h>
+#include <imgui/imgui_internal.h>
 #include <wx/event.h>
 
 #include "slic3r/GUI/ImGuiWrapper.hpp"
+#include "slic3r/GUI/KeyChord.hpp"
 
 using Catch::Matchers::WithinAbs;
 using Slic3r::GUI::ImGuiWrapper;
+using Slic3r::GUI::KeyChord;
 
 namespace {
 
@@ -41,6 +45,45 @@ float wheel_after(int rotation, wxMouseWheelAxis axis)
     return ImGui::GetIO().MouseWheel;
 }
 
+// Runs ImGui frames without OpenGL by building the font atlas on the CPU.
+struct ImGuiFrames
+{
+    ImGuiWrapper imgui;
+
+    ImGuiFrames()
+    {
+        imgui.set_display_size(800.f, 600.f);
+        unsigned char* pixels = nullptr;
+        int            width = 0, height = 0;
+        ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+    }
+
+    template<class Draw> void frame(Draw draw)
+    {
+        ImGui::NewFrame();
+        draw();
+        ImGui::EndFrame();
+    }
+
+    // SetKeyboardFocusHere() activates the field in the next frame that draws it.
+    void draw_input(bool focus)
+    {
+        ImGui::Begin("window");
+        if (focus)
+            ImGui::SetKeyboardFocusHere();
+        ImGui::InputText("##text", text, sizeof(text));
+        ImGui::End();
+    }
+
+    char text[16] = "";
+};
+
+void draw_modal()
+{
+    if (ImGui::BeginPopupModal("modal"))
+        ImGui::EndPopup();
+}
+
 } // namespace
 
 TEST_CASE("a vertical wheel event steps ImGui's wheel in its own direction", "[ImGuiWrapper]")
@@ -59,3 +102,62 @@ TEST_CASE("a wheel event with no rotation or on the horizontal axis does not ste
     }));
     CHECK_THAT(wheel_after(rotation, axis), WithinAbs(0.0, 0.0));
 }
+
+TEST_CASE("an InputText counts as active only while it holds the keyboard", "[ImGuiWrapper]")
+{
+    ImGuiFrames f;
+    f.frame([&] { f.draw_input(false); });
+    CHECK_FALSE(f.imgui.text_input_active());
+
+    f.frame([&] { f.draw_input(true); });
+    f.frame([&] { f.draw_input(false); });
+    CHECK(f.imgui.text_input_active());
+
+    f.frame([] {});
+    f.frame([] {});
+    CHECK_FALSE(f.imgui.text_input_active());
+}
+
+TEST_CASE("a modal counts as open from its first frame until a frame no longer draws it", "[ImGuiWrapper]")
+{
+    ImGuiFrames f;
+    CHECK_FALSE(f.imgui.modal_popup_open());
+
+    f.frame([] {
+        ImGui::OpenPopup("modal");
+        draw_modal();
+    });
+    CHECK(f.imgui.modal_popup_open());
+
+    // A frame opened by input, before anything is drawn in it.
+    ImGui::NewFrame();
+    CHECK(f.imgui.modal_popup_open());
+    draw_modal();
+    ImGui::EndFrame();
+    CHECK(f.imgui.modal_popup_open());
+
+    // A frame that no longer draws it, as when its canvas is hidden.
+    f.frame([] {});
+    REQUIRE(ImGui::GetTopMostPopupModal() != nullptr);
+    CHECK_FALSE(f.imgui.modal_popup_open());
+}
+
+TEST_CASE("ImGui owns every key under a modal and text-editing keys in an active InputText", "[ImGuiWrapper]")
+{
+    ImGuiFrames    f;
+    const KeyChord letter{ 'A' };
+    const KeyChord save{ 'S', wxMOD_CONTROL };
+    CHECK_FALSE(f.imgui.owns_key(letter));
+    CHECK_FALSE(f.imgui.owns_key(save));
+
+    f.frame([&] { f.draw_input(true); });
+    f.frame([&] { f.draw_input(false); });
+    CHECK(f.imgui.owns_key(letter));
+    CHECK_FALSE(f.imgui.owns_key(save));
+
+    f.frame([] {
+        ImGui::OpenPopup("modal");
+        draw_modal();
+    });
+    CHECK(f.imgui.owns_key(save));
+}

tests/slic3rutils/test_moonraker_discovery.cpp

@@ -1,51 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <string>
-#include "slic3r/Utils/MoonrakerPrinterAgent.hpp"
-
-using namespace Slic3r;
-
-namespace {
-
-class DiscoveryAgent : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
-    using MoonrakerPrinterAgent::device_info;
-    mutable unsigned fetch_count = 0;
-
-protected:
-    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
-    {
-        ++fetch_count;
-        info.dev_name = "Test printer";
-        return true;
-    }
-};
-
-} // namespace
-
-TEST_CASE("Moonraker discovery waits for a complete device identity", "[MoonrakerDiscovery]")
-{
-    DiscoveryAgent agent("");
-    unsigned announcements = 0;
-    nlohmann::json announcement;
-    agent.set_on_ssdp_msg_fn([&](std::string payload) {
-        ++announcements;
-        announcement = nlohmann::json::parse(payload);
-    });
-
-    agent.start_discovery(true, false);
-    REQUIRE(announcements == 0);
-    REQUIRE(agent.fetch_count == 0);
-
-    agent.device_info.dev_id = "127.0.0.1:7125";
-    agent.device_info.dev_ip = agent.device_info.dev_id;
-    agent.device_info.base_url = "http://127.0.0.1:7125";
-    agent.start_discovery(true, false);
-    REQUIRE(announcements == 1);
-    REQUIRE(agent.fetch_count == 1);
-    REQUIRE(announcement.at("dev_id") == agent.device_info.dev_id);
-    REQUIRE(announcement.at("dev_ip") == agent.device_info.dev_ip);
-    REQUIRE(announcement.at("dev_name") == "Test printer");
-}

tests/slic3rutils/test_moonraker_printer_agent.cpp

@@ -0,0 +1,636 @@
+#include <catch2/catch_message.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstddef>
+#include <functional>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/beast/core/error.hpp>
+#include <boost/beast/core/flat_buffer.hpp>
+#include <boost/beast/http/message.hpp>
+#include <boost/beast/http/read.hpp>
+#include <boost/beast/http/status.hpp>
+#include <boost/beast/http/string_body.hpp>
+#include <boost/beast/http/write.hpp>
+#include <boost/beast/websocket/error.hpp>
+#include <boost/beast/websocket/rfc6455.hpp>
+#include <boost/beast/websocket/stream.hpp>
+#include <nlohmann/json.hpp>
+
+#include "slic3r/Utils/IPrinterAgent.hpp"
+#include "slic3r/Utils/MoonrakerPrinterAgent.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+namespace beast     = boost::beast;
+namespace http      = beast::http;
+namespace websocket = beast::websocket;
+namespace net       = boost::asio;
+using tcp           = net::ip::tcp;
+using namespace std::chrono_literals;
+
+class DiscoveryAgent : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
+    using MoonrakerPrinterAgent::device_info;
+    mutable unsigned fetch_count = 0;
+
+protected:
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    {
+        ++fetch_count;
+        info.dev_name = "Test printer";
+        return true;
+    }
+};
+
+class StreamAgent : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
+    using MoonrakerPrinterAgent::ws_timings;
+
+    // Starts the stream the way a connection does, from a snapshot of the connection settings.
+    void start_stream(const std::string& base_url, bool use_ssl = false)
+    {
+        const std::string dev_id = "printer";
+        ConnectionSettings connection;
+        connection.dev_id   = dev_id;
+        connection.base_url = base_url;
+        connection.use_ssl  = use_ssl;
+        start_status_stream(dev_id, std::move(connection));
+    }
+
+    void stop_stream() { stop_status_stream(); }
+
+protected:
+    bool init_device_info(const PrinterConnectionParams& params) override
+    {
+        device_info          = MoonrakerDeviceInfo{};
+        device_info.dev_id   = params.dev_id;
+        device_info.dev_ip   = params.host;
+        device_info.base_url = std::string(params.use_ssl ? "https://" : "http://") + params.host + ":" + params.port;
+        return true;
+    }
+
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    {
+        info.dev_name = "Test printer";
+        return true;
+    }
+};
+
+enum class Behavior {
+    SilentBeforeHandshake,     // Accepts the connection and never answers
+    Silent,                    // Completes the upgrade, then never reads or sends
+    AnswersPings,              // Reports a status, then answers pings and sends nothing else
+    AnswersPingsWithoutStatus, // Answers pings but never reports a status
+    Chatters,                  // Reports a status, then answers pings and sends notifications that carry no status
+    HangsUp,                   // Reports a status, then closes the websocket
+    HangsUpWithoutAnswer,      // Closes the websocket without sending anything
+    IgnoresClose,              // Reports Klippy disconnected, then never answers the close
+    StallsObjectList,          // Never answers the stream's object list request
+    StallsStatusQuery,         // Never answers HTTP requests until released, then hangs up on them
+    RejectsTls,                // Records the first byte of the stream, which a TLS client sends as a handshake
+};
+
+class FakePrinter
+{
+public:
+    explicit FakePrinter(Behavior behavior) : m_behavior(behavior)
+    {
+        m_accept_thread = std::thread([this] { accept_loop(); });
+    }
+
+    ~FakePrinter()
+    {
+        release();
+        m_stopping = true;
+        // Wakes the blocking accept.
+        tcp::socket wake{m_accept_ioc};
+        beast::error_code ec;
+        wake.connect(m_acceptor.local_endpoint(), ec);
+        m_accept_thread.join();
+        for (std::thread& connection : m_connections)
+            connection.join();
+    }
+
+    std::string host() const { return "127.0.0.1"; }
+    std::string port() const { return std::to_string(m_acceptor.local_endpoint().port()); }
+    std::string base_url() const { return "http://" + host() + ":" + port(); }
+
+    // A connection is ready once it reaches the state its behavior waits in.
+    bool wait_for_ready_connections(int count, std::chrono::milliseconds timeout = 10s)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, timeout, [&] { return m_ready >= count; });
+    }
+
+    bool wait_for_http_requests(int count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_http_requests >= count; });
+    }
+
+    // Waits until the printer, once released, has hung up on `count` stalled HTTP requests.
+    bool wait_for_http_hang_ups(int count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_http_hung_up >= count; });
+    }
+
+    int close_frames()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_close_frames;
+    }
+
+    // First byte the stream sent, or -1 until it has sent one.
+    bool wait_for_first_byte()
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_first_byte >= 0; });
+    }
+
+    int first_byte()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_first_byte;
+    }
+
+    // Hangs up every connection that is waiting.
+    void release()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_released = true;
+        m_changed.notify_all();
+    }
+
+private:
+    void accept_loop()
+    {
+        for (;;) {
+            // Each connection gets its own io_context, so a connection that runs one never runs another's handlers.
+            auto ioc = std::make_unique<net::io_context>();
+            tcp::socket socket{*ioc};
+            beast::error_code ec;
+            m_acceptor.accept(socket, ec);
+            if (ec || m_stopping)
+                return;
+            m_connections.emplace_back(
+                [this, ioc = std::move(ioc), socket = std::move(socket)]() mutable { serve(*ioc, std::move(socket)); });
+        }
+    }
+
+    void serve(net::io_context& ioc, tcp::socket socket)
+    {
+        if (m_behavior == Behavior::SilentBeforeHandshake) {
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+
+        if (m_behavior == Behavior::RejectsTls) {
+            char              first = 0;
+            beast::error_code ec;
+            socket.read_some(net::buffer(&first, 1), ec);
+            if (!ec) {
+                std::lock_guard<std::mutex> lock(m_mutex);
+                m_first_byte = static_cast<unsigned char>(first);
+                m_changed.notify_all();
+            }
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+
+        beast::flat_buffer buffer;
+        http::request<http::string_body> request;
+        beast::error_code ec;
+        http::read(socket, buffer, request, ec);
+        if (ec)
+            return;
+        // The agent also queries the printer's status and object list over plain HTTP.
+        if (!websocket::is_upgrade(request)) {
+            serve_http(socket, request);
+            return;
+        }
+
+        websocket::stream<tcp::socket> ws{std::move(socket)};
+        ws.accept(request, ec);
+        // Without its object list the stream never sends the subscribe request.
+        const int requests = m_behavior == Behavior::StallsObjectList ? 1 : 2;
+        for (int i = 0; i < requests && !ec; ++i) {
+            beast::flat_buffer message;
+            ws.read(message, ec);
+        }
+        if (!ec && (m_behavior == Behavior::AnswersPings || m_behavior == Behavior::Chatters || m_behavior == Behavior::HangsUp)) {
+            const std::string status =
+                nlohmann::json{{"jsonrpc", "2.0"}, {"id", 1}, {"result", {{"status", {{"print_stats", {{"state", "standby"}}}}}}}}.dump();
+            ws.write(net::buffer(status), ec);
+        }
+        if (ec)
+            return;
+
+        switch (m_behavior) {
+        case Behavior::AnswersPings:
+        case Behavior::AnswersPingsWithoutStatus:
+        case Behavior::Chatters:
+            mark_ready();
+            answer_pings(ioc, ws, m_behavior == Behavior::Chatters);
+            break;
+        case Behavior::HangsUp:
+        case Behavior::HangsUpWithoutAnswer:
+            ws.close(websocket::close_code::normal, ec);
+            mark_ready();
+            break;
+        case Behavior::IgnoresClose: {
+            const std::string notification = nlohmann::json{{"jsonrpc", "2.0"}, {"method", "notify_klippy_disconnected"}}.dump();
+            ws.write(net::buffer(notification), ec);
+            mark_ready();
+            wait_for_release();
+            break;
+        }
+        case Behavior::StallsObjectList: answer_pings(ioc, ws, false); break;
+        default: mark_ready(); wait_for_release();
+        }
+    }
+
+    void serve_http(tcp::socket& socket, const http::request<http::string_body>& request)
+    {
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            ++m_http_requests;
+            m_changed.notify_all();
+        }
+        if (m_behavior == Behavior::StallsObjectList) {
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+        if (m_behavior == Behavior::StallsStatusQuery) {
+            wait_for_release();
+            beast::error_code ec;
+            socket.close(ec);
+            std::lock_guard<std::mutex> lock(m_mutex);
+            ++m_http_hung_up;
+            m_changed.notify_all();
+            return;
+        }
+        http::response<http::string_body> response{http::status::not_found, request.version()};
+        response.prepare_payload();
+        beast::error_code ec;
+        http::write(socket, response, ec);
+    }
+
+    // Keeps a read pending, which answers pings, until released or closed, and with `chatter` also sends a notification every 50 ms.
+    void answer_pings(net::io_context& ioc, websocket::stream<tcp::socket>& ws, bool chatter)
+    {
+        const std::string notification = nlohmann::json{{"jsonrpc", "2.0"},
+                                                        {"method", "notify_proc_stat_update"},
+                                                        {"params", nlohmann::json::array({nlohmann::json::object()})}}
+                                             .dump();
+        beast::flat_buffer message;
+        bool reading                    = true;
+        bool writing                    = false;
+        std::function<void()> read_next = [&] {
+            ws.async_read(message, [&](beast::error_code ec, std::size_t) {
+                message.clear();
+                if (ec == websocket::error::closed) {
+                    std::lock_guard<std::mutex> lock(m_mutex);
+                    ++m_close_frames;
+                }
+                if (ec)
+                    reading = false;
+                else
+                    read_next();
+            });
+        };
+        read_next();
+
+        auto next_notification = std::chrono::steady_clock::now();
+        while (reading && !wait_for_release(10ms)) {
+            if (chatter && !writing && std::chrono::steady_clock::now() >= next_notification) {
+                writing = true;
+                next_notification += 50ms;
+                ws.async_write(net::buffer(notification), [&](beast::error_code, std::size_t) { writing = false; });
+            }
+            ioc.restart();
+            ioc.run_for(20ms);
+        }
+        beast::error_code ignored;
+        ws.next_layer().close(ignored);
+        while (reading || writing) {
+            ioc.restart();
+            ioc.run_for(20ms);
+        }
+    }
+
+    void mark_ready()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        ++m_ready;
+        m_changed.notify_all();
+    }
+
+    void wait_for_release()
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        m_changed.wait(lock, [this] { return m_released; });
+    }
+
+    bool wait_for_release(std::chrono::milliseconds timeout)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, timeout, [this] { return m_released; });
+    }
+
+    const Behavior m_behavior;
+    net::io_context m_accept_ioc;
+    tcp::acceptor m_acceptor{m_accept_ioc, {net::ip::make_address("127.0.0.1"), 0}};
+    std::atomic<bool> m_stopping{false};
+    std::thread m_accept_thread;
+    std::vector<std::thread> m_connections;
+    std::mutex m_mutex;
+    std::condition_variable m_changed;
+    int m_ready         = 0;
+    int m_http_requests = 0;
+    int m_http_hung_up  = 0;
+    int m_close_frames  = 0;
+    int m_first_byte    = -1;
+    bool m_released     = false;
+};
+
+// Records when the agent dispatches a status report.
+class Reports
+{
+public:
+    void attach(StreamAgent& agent)
+    {
+        agent.set_on_local_message_fn([this](std::string, std::string) {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_times.push_back(std::chrono::steady_clock::now());
+            m_changed.notify_all();
+        });
+    }
+
+    bool wait_for(std::size_t count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_times.size() >= count; });
+    }
+
+    std::vector<std::chrono::steady_clock::time_point> times()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_times;
+    }
+
+private:
+    std::mutex m_mutex;
+    std::condition_variable m_changed;
+    std::vector<std::chrono::steady_clock::time_point> m_times;
+};
+
+// A printer and a stream agent connected to it.
+struct StreamFixture
+{
+    explicit StreamFixture(Behavior behavior) : printer(behavior) {}
+
+    // Runs before the members are destroyed, so the agent's destructor never joins a stream the printer still holds open.
+    ~StreamFixture() { printer.release(); }
+
+    void start() { agent.start_stream(printer.base_url()); }
+
+    // Runs the stream as a wss client; the printer must be served on the same port.
+    void start_secure() { agent.start_stream("https://" + printer.host() + ":" + printer.port(), true); }
+
+    // Stops the stream, giving it `limit` to return before the printer hangs up on it.
+    bool stops_within(std::chrono::milliseconds limit)
+    {
+        auto stopped       = std::async(std::launch::async, [this] { agent.stop_stream(); });
+        const bool in_time = stopped.wait_for(limit) == std::future_status::ready;
+        printer.release();
+        stopped.wait();
+        return in_time;
+    }
+
+    FakePrinter printer;
+    StreamAgent agent{""};
+};
+
+} // namespace
+
+TEST_CASE("Moonraker discovery waits for a complete device identity", "[MoonrakerPrinterAgent][Discovery]")
+{
+    DiscoveryAgent agent("");
+    unsigned announcements = 0;
+    nlohmann::json announcement;
+    agent.set_on_ssdp_msg_fn([&](std::string payload) {
+        ++announcements;
+        announcement = nlohmann::json::parse(payload);
+    });
+
+    agent.start_discovery(true, false);
+    REQUIRE(announcements == 0);
+    REQUIRE(agent.fetch_count == 0);
+
+    agent.device_info.dev_id = "127.0.0.1:7125";
+    agent.device_info.dev_ip = agent.device_info.dev_id;
+    agent.device_info.base_url = "http://127.0.0.1:7125";
+    agent.start_discovery(true, false);
+    REQUIRE(announcements == 1);
+    REQUIRE(agent.fetch_count == 1);
+    REQUIRE(announcement.at("dev_id") == agent.device_info.dev_id);
+    REQUIRE(announcement.at("dev_ip") == agent.device_info.dev_ip);
+    REQUIRE(announcement.at("dev_name") == "Test printer");
+}
+
+TEST_CASE("Stopping the status stream gives a silent printer no more than its timeouts", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // An open websocket gets the 200 ms close timeout, and a stalled object list request up to 1 s of curl progress to see the stop.
+    const auto [behavior, limit] = GENERATE(table<Behavior, std::chrono::milliseconds>({
+        {Behavior::SilentBeforeHandshake, 500ms},
+        {Behavior::Silent, 1000ms},
+        {Behavior::StallsObjectList, 2000ms},
+    }));
+    CAPTURE(static_cast<int>(behavior));
+
+    StreamFixture f(behavior);
+    f.agent.ws_timings.close = 200ms;
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    CHECK(f.stops_within(limit));
+}
+
+TEST_CASE("A secure status stream opens with a TLS handshake", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::RejectsTls);
+    f.start_secure();
+    REQUIRE(f.printer.wait_for_first_byte());
+    // 0x16 is a TLS handshake record; a plaintext client would send "GET".
+    CHECK(f.printer.first_byte() == 0x16);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("Stopping the status stream sends the printer a close frame", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // A stop while the stream reads, and one while it waits on the object list request.
+    const Behavior behavior = GENERATE(Behavior::AnswersPings, Behavior::StallsObjectList);
+    CAPTURE(static_cast<int>(behavior));
+
+    StreamFixture f(behavior);
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    CHECK(f.stops_within(3s));
+    CHECK(f.printer.close_frames() == 1);
+}
+
+TEST_CASE("Stopping the status stream does not wait out the reconnect delay", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUp);
+    f.agent.ws_timings.reconnect_delay = 10s;
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+    // Lets the stream reach its reconnect wait.
+    std::this_thread::sleep_for(200ms);
+
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream reconnects when the printer stops answering", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // An unanswered close ends at whichever of the handshake and close timeouts is shorter.
+    const auto [behavior, handshake, close] = GENERATE(table<Behavior, std::chrono::milliseconds, std::chrono::milliseconds>({
+        {Behavior::Silent, 300ms, 1000ms},
+        {Behavior::IgnoresClose, 300ms, 1000ms},
+        {Behavior::IgnoresClose, 1000ms, 200ms},
+    }));
+    CAPTURE(static_cast<int>(behavior), handshake.count(), close.count());
+
+    StreamFixture f(behavior);
+    f.agent.ws_timings.handshake       = handshake;
+    f.agent.ws_timings.close           = close;
+    f.agent.ws_timings.idle            = 400ms;
+    f.agent.ws_timings.reconnect_delay = 20ms;
+    f.start();
+
+    CHECK(f.printer.wait_for_ready_connections(2));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream reconnects at the shortest delay while the printer answers", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUp);
+    f.agent.ws_timings.reconnect_delay = 50ms;
+    f.start();
+
+    // Twelve 50 ms waits; a backoff that kept doubling would need over 10 s.
+    CHECK(f.printer.wait_for_ready_connections(12, 3s));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream keeps retrying a printer that never answers", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUpWithoutAnswer);
+    f.agent.ws_timings.reconnect_delay = 1ms;
+    f.start();
+
+    // The backoff stops doubling at 32 ms, so 20 attempts take well under the wait.
+    CHECK(f.printer.wait_for_ready_connections(20));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A callback on the stream thread can stop the status stream", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    std::promise<void> stopped;
+    std::once_flag stopped_once;
+    StreamFixture f(Behavior::AnswersPings);
+    f.agent.set_on_local_message_fn([&](std::string, std::string) {
+        std::call_once(stopped_once, [&] {
+            f.agent.stop_stream();
+            stopped.set_value();
+        });
+    });
+    f.start();
+
+    REQUIRE(stopped.get_future().wait_for(5s) == std::future_status::ready);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A quiet printer that is still up keeps reporting its status", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    Reports reports;
+    StreamFixture f(Behavior::AnswersPings);
+    f.agent.ws_timings.idle      = 400ms;
+    f.agent.ws_timings.heartbeat = 300ms;
+    reports.attach(f.agent);
+    f.start();
+
+    // The status the printer sent, then two heartbeats.
+    REQUIRE(reports.wait_for(3));
+    const auto times = reports.times();
+    // The steady clock is compared in whole milliseconds, so allow 1 ms of rounding.
+    CHECK(times[1] - times[0] >= 299ms);
+    CHECK(times[2] - times[1] >= 299ms);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream sends no heartbeat while the printer has nothing new to report", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    const Behavior behavior = GENERATE(Behavior::Chatters, Behavior::AnswersPingsWithoutStatus);
+    CAPTURE(static_cast<int>(behavior));
+
+    Reports reports;
+    StreamFixture f(behavior);
+    f.agent.ws_timings.idle      = 400ms;
+    f.agent.ws_timings.heartbeat = 800ms;
+    reports.attach(f.agent);
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    // The chattering printer's status, and nothing from the one that never sent a status.
+    const std::size_t expected = behavior == Behavior::Chatters ? 1 : 0;
+    std::this_thread::sleep_for(1500ms);
+    CHECK(reports.times().size() == expected);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A disconnect during the connection queries keeps the status stream from starting", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::StallsStatusQuery);
+    PrinterConnectionParams params;
+    params.dev_id = "printer";
+    params.host   = f.printer.host();
+    params.port   = f.printer.port();
+    f.agent.connect_printer(params);
+    REQUIRE(f.printer.wait_for_http_requests(1));
+
+    // disconnect_printer joins the worker running the stalled query, so it is called aside and the
+    // printer is released to let that query return.
+    auto disconnecting = std::async(std::launch::async, [&] { f.agent.disconnect_printer(); });
+    f.printer.release();
+    // The query has returned once the printer hangs up on it, and a stream would connect right after.
+    REQUIRE(f.printer.wait_for_http_hang_ups(1));
+    CHECK_FALSE(f.printer.wait_for_ready_connections(1, 500ms));
+    disconnecting.wait();
+}

tests/slic3rutils/test_shortcuts.cpp

@@ -126,6 +126,55 @@ TEST_CASE("Only modified or non-printable chords qualify as menu accelerators",
     CHECK(registry.accelerator(Shortcut::KeyboardShortcuts).empty());
 }
 
+TEST_CASE("Typing, caret, deletion and clipboard chords edit text", "[Shortcuts]")
+{
+    CHECK(KeyChord{ 'A' }.edits_text());
+    CHECK(KeyChord{ 'A', wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_SPACE }.edits_text());
+    CHECK(KeyChord{ WXK_BACK }.edits_text());
+    CHECK(KeyChord{ WXK_DELETE }.edits_text());
+    CHECK(KeyChord{ WXK_BACK, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_RIGHT, wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_HOME }.edits_text());
+    CHECK(KeyChord{ WXK_END, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_DELETE, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_PAGEUP, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_RETURN }.edits_text());
+    CHECK(KeyChord{ WXK_TAB, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_ESCAPE }.edits_text());
+    CHECK(KeyChord{ WXK_PAGEDOWN }.edits_text());
+    for (int key : { 'A', 'C', 'V', 'X', 'Y', 'Z' })
+        CHECK(KeyChord{ key, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ 'Z', wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+
+    CHECK_FALSE(KeyChord{ WXK_TAB, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_RETURN, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_PAGEDOWN, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_ESCAPE, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'S', wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'S', wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+    CHECK_FALSE(KeyChord{ '0', wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_F5 }.edits_text());
+    CHECK_FALSE(KeyChord{}.edits_text());
+#ifdef __APPLE__
+    CHECK(KeyChord{ 'E', wxMOD_ALT }.edits_text());
+    CHECK(KeyChord{ 'K', wxMOD_RAW_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_ALT }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_RAW_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'E', wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+#else
+    CHECK(KeyChord{ 'Q', wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ 'E', wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+#endif
+}
+
 TEST_CASE("Chords the desktop keeps for itself are recognized", "[Shortcuts]")
 {
 #ifdef _WIN32
@@ -186,6 +235,21 @@ TEST_CASE("Default bindings never collide inside a context", "[Shortcuts]")
     }
 }
 
+TEST_CASE("No default Global binding except the Speed Dial's Space edits text", "[Shortcuts]")
+{
+    ShortcutRegistry registry;
+    size_t           checked = 0;
+    for (size_t i = 0; i < size_t(Shortcut::Count); ++i) {
+        const ShortcutInfo& info = shortcut_info(Shortcut(i));
+        if ((info.contexts & context_bit(ShortcutContext::Global)) == 0 || info.id == Shortcut::SpeedDial)
+            continue;
+        CAPTURE(info.key);
+        CHECK_FALSE(registry.binding(info.id).edits_text());
+        ++checked;
+    }
+    CHECK(checked > 0);
+}
+
 TEST_CASE("Shift and Ctrl variants of stepping shortcuts are left unbound", "[Shortcuts]")
 {
     ShortcutRegistry registry;