"""Exercise the real message UI and queue together, including app downloads.""" from pathlib import Path import shutil import subprocess import tempfile import unittest from test_message_navigation import PREAMBLE from test_replay_reset_integration import extract_braced ROOT = Path(__file__).resolve().parents[1] UI_MEMBERS = r''' int _msgcount = 0; bool connected = false, pairing = false, _deferred_msg_preview = false; int getMsgCount() const { return _msgcount; } bool hasConnection() const { return connected; } bool isPairingScreenActive() const { return pairing; } bool shouldWakeDisplayForMessage() const { return !connected; } void setCurrScreen(UIScreen* screen) { curr = screen; } void newMsg(uint8_t, const char*, const char*, int, int, const char*, int); void msgRead(int); void syncMessageQueue(int, int = -1); int getPreviewCount() const; const char* inboxTitle() const; const char* client = "USB"; const char* connectedClientLabel() const { return connected ? client : nullptr; } bool hasBluetoothConnection() const { return connected && (std::string(client) == "BLUETOOTH" || std::string(client) == "BLE + USB"); } bool isBluetoothEnabled() const { return true; } bool isPairingPromptActive() const { return pairing; } ''' QUEUE = r''' #define DISPLAY_CLASS TestDisplay #define MAX_FRAME_SIZE 32 class MyMesh { struct Frame { int len; uint8_t buf[MAX_FRAME_SIZE]; bool isChannelMsg() const { return buf[0] == 17; } } frames[4]; public: UITask* _ui; int offline_queue_len = 0, offline_queue_head = 0; explicit MyMesh(UITask* ui) : _ui(ui) {} int getOfflineQueueCapacity() const { return 4; } Frame& offlineQueueFrameAt(int index) { return frames[(offline_queue_head + index) % 4]; } bool addToOfflineQueue(const uint8_t*, int); int peekOfflineQueue(uint8_t*); void popOfflineQueue(); int getFromOfflineQueue(uint8_t*); bool receive(const char* text, uint8_t kind = 17) { uint8_t bytes[2] = {kind, uint8_t(text[0])}; bool queued = addToOfflineQueue(bytes, sizeof(bytes)); _ui->newMsg(1, "Alice", text, offline_queue_len, 0, "Public", queued ? offline_queue_len - 1 : -1); return queued; } void download() { uint8_t frame[MAX_FRAME_SIZE]; getFromOfflineQueue(frame); } }; ''' SCENARIOS = r''' using namespace mesh::ui; int main() { resetArduinoMock(); displayPowerPrefs().battery.mode = DisplayMode::On; Display display; display.servicePower(false); Screen home; UITask task(display); MsgPreviewScreen messages(&task); task.home = task.curr = &home; task.msg_preview = &messages; MyMesh mesh(&task); // Reproduce issue #5: twelve messages arrive and the connected app fetches // every one. History retains twelve, while Pending returns to zero. task.connected = true; for (int i = 0; i < 12; ++i) { mesh.receive("received by phone"); assert(task.curr == &home); assert(task.getMsgCount() == 1); mesh.download(); assert(task.curr == &home && task.getMsgCount() == 0); assert(task.getPreviewCount() == i + 1); } assert(std::string(task.inboxTitle()) == "HISTORY"); displayPowerPrefs().inbox = DisplayInboxMode::Pending; assert(task.getPreviewCount() == 0 && !messages.hasMessages()); assert(std::string(task.inboxTitle()) == "INBOX"); displayPowerPrefs().inbox = DisplayInboxMode::Unread; assert(task.getPreviewCount() == 12); // App delivery is not a local read. assert(std::string(task.inboxTitle()) == "UNREAD"); task.curr = &messages; display.turnOff(); messages.render(display); assert(task.getPreviewCount() == 12); // A dark display cannot mark it read. display.turnOn(); messages.render(display); assert(task.getPreviewCount() == 11); messages.render(display); assert(task.getPreviewCount() == 11); // Redraws do not consume another item. // A connected client's new message must not replace the text being browsed. displayPowerPrefs().inbox = DisplayInboxMode::History; mesh.receive("new while browsing"); display.clear(); messages.render(display); assert(display.contains("received by phone")); mesh.download(); assert(task.curr == &messages && task.getPreviewCount() == 13); // Without a client, select the new arrival. Reading it does not drain the // delivery queue; it remains available to the next phone connection. task.connected = false; task.curr = &home; mesh.receive("offline arrival"); assert(task.curr == &messages && task.getMsgCount() == 1); display.clear(); messages.render(display); assert(display.contains("offline arrival")); assert(mesh.offline_queue_len == 1); mesh.download(); // Non-text frames occupy queue positions too. Full queues can evict a // channel message in the middle; Pending must hide only that exact entry. displayPowerPrefs().inbox = DisplayInboxMode::Pending; const uint8_t other[1] = {99}; assert(mesh.addToOfflineQueue(other, 1)); assert(task.getMsgCount() == 1 && !messages.hasMessages()); mesh.receive("evicted channel"); mesh.receive("retained channel"); assert(mesh.addToOfflineQueue(other, 1)); mesh.receive("replacement channel"); assert(task.getMsgCount() == 4); assert(messages.messageCount() == 4); // Includes the two non-text frames. display.clear(); messages.render(display); assert(display.contains("replacement channel")); messages.handleInput(KEY_NEXT); display.clear(); messages.render(display); assert(display.contains("retained channel")); messages.handleInput(KEY_NEXT); assert(task.curr == &home); // Evicted entry was excluded. mesh.download(); // Non-text head, with no matching history entry. assert(task.getMsgCount() == 3); mesh.download(); // Retained channel. mesh.download(); // Other non-text frame. assert(task.getMsgCount() == 1 && messages.hasMessages()); mesh.download(); assert(task.getMsgCount() == 0 && !messages.hasMessages()); // Rejecting a fifth direct message must not assign it another frame's slot. for (int i = 0; i < 4; ++i) assert(mesh.addToOfflineQueue(other, 1)); assert(!mesh.receive("not queued", 7)); assert(!messages.hasMessages()); while (mesh.offline_queue_len) mesh.download(); assert(!messages.hasMessages()); displayPowerPrefs().inbox = DisplayInboxMode::History; for (int i = 0; i < 40; ++i) { mesh.receive("ring wrap"); mesh.download(); } assert(task.getPreviewCount() == 32 && task.getMsgCount() == 0); displayPowerPrefs().inbox = DisplayInboxMode::Pending; assert(!messages.hasMessages()); #if COMPANION_FEATURE_READER // Receiving and downloading messages must leave an open reader alone. Screen reader; task.reader = task.curr = &reader; for (bool connected : {false, true}) { task.connected = connected; for (int i = 0; i < 2; ++i) { mesh.receive("while reading"); assert(task.isReaderActive()); } for (int remaining : {1, 0}) { mesh.download(); assert(task.getMsgCount() == remaining); assert(task.isReaderActive()); } } #endif } ''' class CompanionInboxTest(unittest.TestCase): def test_labels_use_enabled_connected_interfaces(self): abstract = (ROOT / "examples/companion_radio/AbstractUITask.h").read_text() label = extract_braced(abstract, "const char* connectedClientLabel() const") source = r''' #include #include #include struct Link : BaseSerialInterface { bool enabled = false, connected = false; void enable() override { enabled = true; } void disable() override { enabled = false; } bool isEnabled() const override { return enabled; } bool isConnected() const override { return connected; } bool isReadBusy() const override { return false; } bool isWriteBusy() const override { return false; } size_t writeFrame(const uint8_t*, size_t len) override { return len; } size_t checkRecvFrame(uint8_t*) override { return 0; } }; struct UI { MultiSerialInterface* _interfaceManager; bool hasBluetoothConnection() const { return _interfaceManager->isBluetoothConnected(); } '''+ label + r''' }; int main() { MultiSerialInterface interfaces; Link usb, ble, wifi; interfaces.addInterface(InterfaceType::USB, &usb); interfaces.addInterface(InterfaceType::Bluetooth, &ble); interfaces.addInterface(InterfaceType::WiFi, &wifi); UI ui{&interfaces}; interfaces.enable(); assert(ui.connectedClientLabel() == nullptr); usb.connected = true; assert(std::string(ui.connectedClientLabel()) == "USB"); ble.connected = true; assert(std::string(ui.connectedClientLabel()) == "BLE + USB"); usb.disable(); assert(std::string(ui.connectedClientLabel()) == "BLUETOOTH"); ble.connected = false; wifi.connected = true; assert(std::string(ui.connectedClientLabel()) == "TCP"); interfaces.disable(); assert(ui.connectedClientLabel() == nullptr); } ''' self.compile_and_run(source) def test_home_history_pending_and_connections_fit(self): source = (ROOT / "examples/companion_radio/ui-new/UITask.cpp").read_text() first_page = extract_braced(source, "if (_page == HomePage::FIRST)") first_page = first_page.rsplit("#if UI_MESSAGES_HOME_PAGE == 1", 1)[0] + "}" first_page = first_page.replace("if (_page == HomePage::FIRST)", "") preamble = PREAMBLE.replace("int getMsgCount() const { return 0; }", UI_MEMBERS) preamble = preamble.replace("bool getChannel(int channel", "uint32_t getBLEPin() const { return 123456; }\n bool getChannel(int channel") implementation = r''' #include #include #define PRESS_LABEL "Press" int UITask::getPreviewCount() const { return 12; } const char* UITask::inboxTitle() const { return "HISTORY"; } void renderHome(DisplayDriver& display, UITask* _task) { char tmp[80]; const int body_top = 14; '''+ first_page + r''' } struct MeasuredDisplay : Display { int size = 1; MeasuredDisplay(int w, int h) { setDimensions(w, h); } void setTextSize(int value) override { size = value; } uint16_t getTextWidth(const char* text) override { return strlen(text) * 6 * size; } void print(const char* text) override { assert(y >= 0 && y + 8 * size <= height()); for (const auto& line : lines) { // Home text owns distinct horizontal bands; every text run is centered. assert(y >= line.y + line.color || y + 8 * size <= line.y); } Display::print(text); lines.back().color = 8 * size; // Save glyph height for overlap detection. } }; int main() { for (const auto dims : {std::pair{240,135}, {135,240}, {128,64}, {160,80}}) { for (const char* client : {"USB", "BLUETOOTH", "BLE + USB", "TCP"}) { MeasuredDisplay display(dims.first, dims.second); UITask task(display); task._msgcount = 0; task.connected = true; task.client = client; renderHome(display, &task); assert(display.contains("HISTORY: 12")); assert(display.contains("Pending: 0")); if (task.hasBluetoothConnection()) { assert(display.contains("CONNECTED")); if (dims.second >= 135) assert(display.contains(client)); } else { // A wired/TCP connection must not conceal an unpaired BLE PIN. assert(display.contains("123456")); assert(!display.contains("CONNECTED")); } } } } ''' self.compile_and_run(preamble + implementation) def compile_and_run(self, source, reader_enabled=0): compiler = shutil.which("g++") or shutil.which("clang++") self.assertIsNotNone(compiler) with tempfile.TemporaryDirectory(prefix="mesh-inbox-test-") as directory: executable = Path(directory) / "inbox.exe" result = subprocess.run([ compiler, "-std=c++17", f"-DCOMPANION_FEATURE_READER={reader_enabled}", "-I" + str(ROOT / "src"), "-I" + str(ROOT / "test/mocks"), "-x", "c++", "-", str(ROOT / "src/helpers/ui/MomentaryButton.cpp"), str(ROOT / "src/helpers/ui/DisplayDriver.cpp"), "-o", str(executable), ], input=source, text=True, capture_output=True) self.assertEqual(result.returncode, 0, result.stderr) result = subprocess.run([str(executable)], text=True, capture_output=True) self.assertEqual(result.returncode, 0, result.stdout + result.stderr) def test_real_ui_and_delivery_queue(self): ui = (ROOT / "examples/companion_radio/ui-new/UITask.cpp").read_text() mesh = (ROOT / "examples/companion_radio/MyMesh.cpp").read_text() preamble = PREAMBLE.replace("int getMsgCount() const { return 0; }", UI_MEMBERS) implementation = extract_braced(ui, "class MsgPreviewScreen :") + ";\n" for signature in ("void UITask::newMsg(", "void UITask::msgRead(", "void UITask::syncMessageQueue(", "int UITask::getPreviewCount(", "const char* UITask::inboxTitle("): implementation += extract_braced(ui, signature) + "\n" implementation += QUEUE for signature in ("bool MyMesh::addToOfflineQueue(", "int MyMesh::peekOfflineQueue(", "void MyMesh::popOfflineQueue(", "int MyMesh::getFromOfflineQueue("): implementation += extract_braced(mesh, signature) + "\n" for reader_enabled in (0, 1): with self.subTest(reader_enabled=reader_enabled): self.compile_and_run(preamble + implementation + SCENARIOS, reader_enabled) def test_summary_shows_newest_visible_message_per_thread(self): ui = (ROOT / "examples/companion_radio/ui-new/UITask.cpp").read_text() implementation = extract_braced(ui, "class MsgPreviewScreen :") + ";\n" scenarios = r''' struct SummaryDisplay : Display { SummaryDisplay() { setDimensions(160, 160); } }; int main() { using namespace mesh::ui; SummaryDisplay display; UITask task(display); MsgPreviewScreen messages(&task); messages.addPreview(1, "Alice", "old public", 0, "Public", 0); messages.addPreview(1, "Bob", "pending public", 0, "Public", 1); messages.addPreview(1, "Alice", "delivered public", 0, "Public"); messages.addPreview(1, "Carol", "second channel", 2, "Second", 2); messages.addPreview(0xFF, "Dan", "old direct", -1, nullptr, 3); messages.addPreview(0xFF, "Dan", "new direct", -1, nullptr, 4); for (auto mode : {DisplayInboxMode::History, DisplayInboxMode::Pending, DisplayInboxMode::Unread}) { displayPowerPrefs().inbox = mode; display.clear(); messages.renderSummary(display); assert(display.rectangles.size() == 3); // One divider per thread. assert(display.contains("Public") && display.contains("Second")); assert(display.contains("Direct: Dan")); assert(display.contains("second channel") && display.contains("new direct")); assert(!display.contains("old public") && !display.contains("old direct")); // A delivered newer entry cannot hide the newest pending entry. const bool pending = mode == DisplayInboxMode::Pending; assert(display.contains("pending public") == pending); assert(display.contains("delivered public") == !pending); } } ''' self.compile_and_run(PREAMBLE + implementation + scenarios) def test_summary_uses_newest_visible_message_per_thread(self): ui = (ROOT / "examples/companion_radio/ui-new/UITask.cpp").read_text() preamble = PREAMBLE.replace("int getMsgCount() const { return 0; }", UI_MEMBERS) implementation = extract_braced(ui, "class MsgPreviewScreen :") + ";\n" scenarios = r''' int main() { using namespace mesh::ui; resetArduinoMock(); displayPowerPrefs().battery.mode = DisplayMode::On; Display display; display.servicePower(false); UITask task(display); MsgPreviewScreen messages(&task); task.msg_preview = task.curr = &messages; messages.addPreview(1, "Alice", "older pending", 0, "Public", 0); messages.addPreview(1, "Bob", "newer delivered", 0, "Public"); auto expect = [&](DisplayInboxMode mode, const char* wanted, const char* hidden) { displayPowerPrefs().inbox = mode; display.clear(); messages.renderSummary(display); if (!display.contains(wanted) || display.contains(hidden)) { fprintf(stderr, "summary mode=%u expected=%s hidden=%s\n", unsigned(mode), wanted, hidden); for (const auto& line : display.lines) fprintf(stderr, "rendered: %s\n", line.text.c_str()); } assert(display.contains(wanted) && !display.contains(hidden)); }; expect(DisplayInboxMode::History, "newer delivered", "older pending"); expect(DisplayInboxMode::Pending, "older pending", "newer delivered"); // Unread changes the count; read previews remain browseable as documented. displayPowerPrefs().inbox = DisplayInboxMode::History; display.clear(); messages.render(display); expect(DisplayInboxMode::Unread, "newer delivered", "older pending"); assert(messages.messageCount() == 1); messages.queueRemoved(0); expect(DisplayInboxMode::Pending, "No messages heard", "older pending"); expect(DisplayInboxMode::History, "newer delivered", "older pending"); } ''' self.compile_and_run(preamble + implementation + scenarios) if __name__ == "__main__": unittest.main()