Apply code review fixes and add level-mapping tests

Guard against malformed adapter.diagnostic params in
onNotificationReceived: if params is not a JSON object the signal is not
emitted and a warning is logged instead of silently forwarding empty
strings.

Add explicit "warning" branch to onAdapterDiagnostic and an else branch
that logs the unknown level so unrecognised values are visible rather
than being silently promoted.

New test diagnosticMalformedParams verifies no signal is emitted for
non-object params. New tst_modbuspoll covers all four branches of the
level-mapping logic (debug, info, warning, unknown) using a captured
Qt message handler.

https://claude.ai/code/session_01UhRoTiKzKdkuurvzKQBVjr

Author: claude

src/ProtocolAdapter/adapterclient.cpp

@@ -162,12 +162,20 @@ void AdapterClient::onHandshakeTimeout()
 
 void AdapterClient::onNotificationReceived(QString method, QJsonValue params)
 {
-    if (method == QStringLiteral("adapter.diagnostic"))
+    if (method != QStringLiteral("adapter.diagnostic"))
     {
-        QJsonObject obj = params.toObject();
-        emit diagnosticReceived(obj.value(QStringLiteral("level")).toString(),
-                                obj.value(QStringLiteral("message")).toString());
+        return;
+    }
+
+    if (!params.isObject())
+    {
+        qCWarning(scopeComm) << "AdapterClient: adapter.diagnostic params is not an object";
+        return;
     }
+
+    QJsonObject obj = params.toObject();
+    emit diagnosticReceived(obj.value(QStringLiteral("level")).toString(),
+                            obj.value(QStringLiteral("message")).toString());
 }
 
 void AdapterClient::handleLifecycleResponse(const QString& method, const QJsonObject& result)

src/communication/modbuspoll.cpp

@@ -138,10 +138,14 @@ void ModbusPoll::onAdapterDiagnostic(const QString& level, const QString& messag
     {
         qCInfo(scopeComm) << message;
     }
-    else
+    else if (level == QStringLiteral("warning"))
     {
         qCWarning(scopeComm) << message;
     }
+    else
+    {
+        qCWarning(scopeComm) << "AdapterClient: unknown diagnostic level:" << level << "-" << message;
+    }
 }
 
 QStringList ModbusPoll::buildRegisterExpressions(const QList<DataPoint>& registerList)

tests/CMakeLists.txt

@@ -49,6 +49,7 @@ endfunction()
 
 set(CMAKE_AUTOUIC_SEARCH_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/../src/dialogs ${CMAKE_CURRENT_SOURCE_DIR}/../src/customwidgets)
 
+add_subdirectory(communication)
 add_subdirectory(customwidgets)
 add_subdirectory(datahandling)
 add_subdirectory(dialogs)

tests/ProtocolAdapter/tst_adapterclient.cpp

@@ -321,6 +321,19 @@ void TestAdapterClient::diagnosticNotificationDebugLevel()
     QCOMPARE(spyDiagnostic.at(0).at(1).toString(), QStringLiteral("polling started"));
 }
 
+void TestAdapterClient::diagnosticMalformedParams()
+{
+    auto* mock = new MockAdapterProcess();
+    AdapterClient client(mock);
+
+    QSignalSpy spyDiagnostic(&client, &AdapterClient::diagnosticReceived);
+
+    /* params is not an object — diagnosticReceived must not be emitted */
+    mock->injectNotification("adapter.diagnostic", QJsonValue(42));
+
+    QCOMPARE(spyDiagnostic.count(), 0);
+}
+
 void TestAdapterClient::processErrorEmitsSessionError()
 {
     auto* mock = new MockAdapterProcess();

tests/ProtocolAdapter/tst_adapterclient.h

@@ -20,6 +20,7 @@ private slots:
     void notificationIgnored();
     void diagnosticNotificationForwarded();
     void diagnosticNotificationDebugLevel();
+    void diagnosticMalformedParams();
     void processErrorEmitsSessionError();
     void stopSessionDuringLifecycle();
     void doubleStopSession();

tests/communication/CMakeLists.txt

@@ -0,0 +1 @@
+add_xtest(tst_modbuspoll)

tests/communication/tst_modbuspoll.cpp

@@ -0,0 +1,84 @@
+#include "tst_modbuspoll.h"
+
+#include "communication/modbuspoll.h"
+#include "models/settingsmodel.h"
+
+#include <QLoggingCategory>
+#include <QTest>
+
+namespace
+{
+    QtMsgType g_capturedType{};
+    QString g_capturedMessage{};
+
+    void captureHandler(QtMsgType type, const QMessageLogContext&, const QString& msg)
+    {
+        g_capturedType = type;
+        g_capturedMessage = msg;
+    }
+}
+
+void TestModbusPoll::init()
+{
+    _pSettingsModel = new SettingsModel;
+    _pModbusPoll = new ModbusPoll(_pSettingsModel);
+    /* Enable debug output for scope.comm so qCDebug calls reach the handler */
+    QLoggingCategory::setFilterRules(QStringLiteral("scope.comm.debug=true"));
+}
+
+void TestModbusPoll::cleanup()
+{
+    QLoggingCategory::setFilterRules(QString());
+    delete _pModbusPoll;
+    delete _pSettingsModel;
+}
+
+void TestModbusPoll::diagnosticDebugLevel()
+{
+    QtMessageHandler previous = qInstallMessageHandler(captureHandler);
+    QMetaObject::invokeMethod(_pModbusPoll, "onAdapterDiagnostic",
+                              Q_ARG(QString, QStringLiteral("debug")),
+                              Q_ARG(QString, QStringLiteral("polling started")));
+    qInstallMessageHandler(previous);
+
+    QCOMPARE(g_capturedType, QtDebugMsg);
+    QVERIFY(g_capturedMessage.contains(QStringLiteral("polling started")));
+}
+
+void TestModbusPoll::diagnosticInfoLevel()
+{
+    QtMessageHandler previous = qInstallMessageHandler(captureHandler);
+    QMetaObject::invokeMethod(_pModbusPoll, "onAdapterDiagnostic",
+                              Q_ARG(QString, QStringLiteral("info")),
+                              Q_ARG(QString, QStringLiteral("session active")));
+    qInstallMessageHandler(previous);
+
+    QCOMPARE(g_capturedType, QtInfoMsg);
+    QVERIFY(g_capturedMessage.contains(QStringLiteral("session active")));
+}
+
+void TestModbusPoll::diagnosticWarningLevel()
+{
+    QtMessageHandler previous = qInstallMessageHandler(captureHandler);
+    QMetaObject::invokeMethod(_pModbusPoll, "onAdapterDiagnostic",
+                              Q_ARG(QString, QStringLiteral("warning")),
+                              Q_ARG(QString, QStringLiteral("register read failed")));
+    qInstallMessageHandler(previous);
+
+    QCOMPARE(g_capturedType, QtWarningMsg);
+    QVERIFY(g_capturedMessage.contains(QStringLiteral("register read failed")));
+}
+
+void TestModbusPoll::diagnosticUnknownLevel()
+{
+    QtMessageHandler previous = qInstallMessageHandler(captureHandler);
+    QMetaObject::invokeMethod(_pModbusPoll, "onAdapterDiagnostic",
+                              Q_ARG(QString, QStringLiteral("critical")),
+                              Q_ARG(QString, QStringLiteral("unexpected error")));
+    qInstallMessageHandler(previous);
+
+    QCOMPARE(g_capturedType, QtWarningMsg);
+    QVERIFY(g_capturedMessage.contains(QStringLiteral("unknown diagnostic level")));
+}
+
+QTEST_GUILESS_MAIN(TestModbusPoll)

tests/communication/tst_modbuspoll.h

@@ -0,0 +1,26 @@
+#ifndef TST_MODBUSPOLL_H
+#define TST_MODBUSPOLL_H
+
+#include <QObject>
+
+class ModbusPoll;
+class SettingsModel;
+
+class TestModbusPoll : public QObject
+{
+    Q_OBJECT
+private slots:
+    void init();
+    void cleanup();
+
+    void diagnosticDebugLevel();
+    void diagnosticInfoLevel();
+    void diagnosticWarningLevel();
+    void diagnosticUnknownLevel();
+
+private:
+    SettingsModel* _pSettingsModel{ nullptr };
+    ModbusPoll* _pModbusPoll{ nullptr };
+};
+
+#endif // TST_MODBUSPOLL_H