write more tests for the rules engine.

decouple jsonrpc versioning from application versioning

libguh/types/eventdescriptor.cpp

@@ -32,19 +32,13 @@
 
 /*! Constructs an EventDescriptor describing an Event.
  */
-EventDescriptor::EventDescriptor(const EventDescriptorId &id, const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors):
+EventDescriptor::EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors):
-    m_id(id),
     m_eventTypeId(eventTypeId),
     m_deviceId(deviceId),
     m_paramDescriptors(paramDescriptors)
 {
 }
 
-EventDescriptorId EventDescriptor::id() const
-{
-    return m_id;
-}
-
 /*! Returns the id of the \l{EventType} which describes this Event.*/
 EventTypeId EventDescriptor::eventTypeId() const
 {

libguh/types/eventdescriptor.h

@@ -30,9 +30,7 @@
 class EventDescriptor
 {
 public:
-    EventDescriptor(const EventDescriptorId &id, const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors = QList<ParamDescriptor>());
+    EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors = QList<ParamDescriptor>());
-
-    EventDescriptorId id() const;
 
     EventTypeId eventTypeId() const;
     DeviceId deviceId() const;
@@ -46,7 +44,6 @@ public:
     bool operator ==(const Event &event) const;
 
 private:
-    EventDescriptorId m_id;
     EventTypeId m_eventTypeId;
     DeviceId m_deviceId;
     QList<ParamDescriptor> m_paramDescriptors;

libguh/types/statedescriptor.cpp

@@ -19,14 +19,12 @@
 #include "statedescriptor.h"
 
 StateDescriptor::StateDescriptor():
-    m_id(StateDescriptorId::createStateDescriptorId()),
     m_operatorType(ValueOperatorEquals)
 {
 
 }
 
-StateDescriptor::StateDescriptor(const StateDescriptorId &id, const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType):
+StateDescriptor::StateDescriptor(const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType):
-    m_id(id),
     m_stateTypeId(stateTypeId),
     m_deviceId(deviceId),
     m_stateValue(stateValue),
@@ -35,11 +33,6 @@ StateDescriptor::StateDescriptor(const StateDescriptorId &id, const StateTypeId
 
 }
 
-StateDescriptorId StateDescriptor::id() const
-{
-    return m_id;
-}
-
 StateTypeId StateDescriptor::stateTypeId() const
 {
     return m_stateTypeId;
@@ -77,13 +70,13 @@ bool StateDescriptor::operator ==(const State &state) const
     case ValueOperatorEquals:
         return m_stateValue == state.value();
     case ValueOperatorGreater:
-        return m_stateValue > state.value();
+        return state.value() > m_stateValue;
     case ValueOperatorGreaterOrEqual:
-        return m_stateValue >= state.value();
+        return state.value() >= m_stateValue;
     case ValueOperatorLess:
-        return m_stateValue < state.value();
+        return state.value() < m_stateValue;
     case ValueOperatorLessOrEqual:
-        return m_stateValue <= state.value();
+        return state.value() <= m_stateValue;
     case ValueOperatorNotEquals:
         return m_stateValue != state.value();
     }

libguh/types/statedescriptor.h

@@ -31,9 +31,7 @@ class StateDescriptor
 {
 public:
     StateDescriptor();
-    StateDescriptor(const StateDescriptorId &id, const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType = ValueOperatorEquals);
+    StateDescriptor(const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType = ValueOperatorEquals);
-
-    StateDescriptorId id() const;
 
     StateTypeId stateTypeId() const;
     DeviceId deviceId() const;
@@ -46,7 +44,6 @@ public:
     bool operator !=(const State &state) const;
 
 private:
-    StateDescriptorId m_id;
     StateTypeId m_stateTypeId;
     DeviceId m_deviceId;
     QVariant m_stateValue;

libguh/typeutils.h

@@ -43,11 +43,8 @@ DECLARE_TYPE_ID(DeviceDescriptor)
 
 DECLARE_TYPE_ID(EventType)
 DECLARE_TYPE_ID(Event)
-DECLARE_TYPE_ID(EventDescriptor)
 DECLARE_TYPE_ID(StateType)
 DECLARE_TYPE_ID(State)
-DECLARE_TYPE_ID(StateDescriptor)
-DECLARE_TYPE_ID(StateEvaluator)
 DECLARE_TYPE_ID(ActionType)
 DECLARE_TYPE_ID(Action)
 DECLARE_TYPE_ID(Plugin)
@@ -67,4 +64,7 @@ enum StateOperator {
     StateOperatorOr
 };
 
+Q_DECLARE_METATYPE(ValueOperator)
+Q_DECLARE_METATYPE(StateOperator)
+
 #endif // TYPEUTILS_H

server/jsonrpc/jsonrpcserver.cpp

@@ -42,6 +42,8 @@
 #include <QJsonDocument>
 #include <QStringList>
 
+#define JSON_PROTOCOL_VERSION 1
+
 JsonRPCServer::JsonRPCServer(QObject *parent):
     JsonHandler(parent),
 #ifdef TESTING_ENABLED
@@ -66,6 +68,7 @@ JsonRPCServer::JsonRPCServer(QObject *parent):
     setDescription("Version", "Version of this Guh/JSONRPC interface.");
     setParams("Version", params);
     returns.insert("version", "string");
+    returns.insert("protocol version", "string");
     setReturns("Version", returns);
 
     params.clear(); returns.clear();
@@ -118,6 +121,7 @@ JsonReply* JsonRPCServer::Version(const QVariantMap &params) const
 
     QVariantMap data;
     data.insert("version", GUH_VERSION_STRING);
+    data.insert("protocol version", JSON_PROTOCOL_VERSION);
     return createReply(data);
 }
 
@@ -251,6 +255,7 @@ void JsonRPCServer::clientConnected(const QUuid &clientId)
     handshake.insert("id", 0);
     handshake.insert("server", "guh JSONRPC interface");
     handshake.insert("version", GUH_VERSION_STRING);
+    handshake.insert("protocol version", JSON_PROTOCOL_VERSION);
     QJsonDocument jsonDoc = QJsonDocument::fromVariant(handshake);
     m_tcpServer->sendData(clientId, jsonDoc.toJson());
 }

server/jsonrpc/jsontypes.cpp

@@ -89,14 +89,12 @@ void JsonTypes::init()
     s_state.insert("value", "variant");
 
     // StateDescriptor
-    s_stateDescriptor.insert("id", "uuid");
     s_stateDescriptor.insert("stateTypeId", "uuid");
     s_stateDescriptor.insert("deviceId", "uuid");
     s_stateDescriptor.insert("value", "variant");
     s_stateDescriptor.insert("operator", valueOperatorTypesRef());
 
     // StateEvaluator
-    s_stateEvaluator.insert("id", "uuid");
     s_stateEvaluator.insert("o:stateDescriptor", stateDescriptorRef());
     s_stateEvaluator.insert("o:childEvaluators", QVariantList() << stateEvaluatorRef());
     s_stateEvaluator.insert("o:operator", stateOperatorTypesRef());
@@ -280,7 +278,6 @@ QVariantMap JsonTypes::packStateType(const StateType &stateType)
 QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescriptor)
 {
     QVariantMap variantMap;
-    variantMap.insert("id", stateDescriptor.id().toString());
     variantMap.insert("stateTypeId", stateDescriptor.stateTypeId().toString());
     variantMap.insert("deviceId", stateDescriptor.deviceId().toString());
     variantMap.insert("value", stateDescriptor.stateValue());
@@ -291,7 +288,6 @@ QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescripto
 QVariantMap JsonTypes::packStateEvaluator(const StateEvaluator &stateEvaluator)
 {
     QVariantMap variantMap;
-    variantMap.insert("id", stateEvaluator.id());
     variantMap.insert("stateDescriptor", packStateDescriptor(stateEvaluator.stateDescriptor()));
     QVariantList childEvaluators;
     foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators()) {
@@ -483,7 +479,7 @@ EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescrip
     EventTypeId eventTypeId(eventDescriptorMap.value("eventTypeId").toString());
     DeviceId eventDeviceId(eventDescriptorMap.value("deviceId").toString());
     QList<ParamDescriptor> eventParams = JsonTypes::unpackParamDescriptors(eventDescriptorMap.value("paramDescriptors").toList());
-    EventDescriptor eventDescriptor(EventDescriptorId::createEventDescriptorId(), eventTypeId, eventDeviceId, eventParams);
+    EventDescriptor eventDescriptor(eventTypeId, eventDeviceId, eventParams);
     return eventDescriptor;
 }
 

server/jsonrpc/ruleshandler.cpp

@@ -41,6 +41,7 @@ RulesHandler::RulesHandler(QObject *parent) :
     setDescription("AddRule", "Add a rule.");
     params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef());
     params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef());
+    params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
     QVariantList actions;
     actions.append(JsonTypes::actionRef());
     params.insert("actions", actions);

server/ruleengine.cpp

@@ -85,7 +85,6 @@ RuleEngine::RuleEngine(QObject *parent) :
         foreach (QString eventGroupName, settings.childGroups()) {
             if (eventGroupName.startsWith("EventDescriptor-")) {
                 settings.beginGroup(eventGroupName);
-                EventDescriptorId eventDescriptorId(eventGroupName.remove(QRegExp("^EventDescriptor-")));
                 EventTypeId eventTypeId(settings.value("eventTypeId").toString());
                 DeviceId deviceId(settings.value("deviceId").toString());
 
@@ -100,7 +99,7 @@ RuleEngine::RuleEngine(QObject *parent) :
                     }
                 }
 
-                EventDescriptor eventDescriptor(eventDescriptorId, eventTypeId, deviceId, params);
+                EventDescriptor eventDescriptor(eventTypeId, deviceId, params);
                 eventDescriptorList.append(eventDescriptor);
                 settings.endGroup();
             }
@@ -164,7 +163,7 @@ QList<Action> RuleEngine::evaluateEvent(const Event &event)
     For convenience, this creates a Rule without any \l{State} comparison. */
 RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QList<EventDescriptor> &eventDescriptorList, const QList<Action> &actions)
 {
-    return addRule(ruleId, eventDescriptorList, StateEvaluator(StateEvaluatorId::createStateEvaluatorId()), actions);
+    return addRule(ruleId, eventDescriptorList, StateEvaluator(), actions);
 }
 
 /*! Add a new \l{Rule} with the given \a event, \a states and \a actions to the engine. */
@@ -224,8 +223,9 @@ RuleEngine::RuleError RuleEngine::addRule(const RuleId &ruleId, const QList<Even
     QSettings settings(m_settingsFile);
     settings.beginGroup(rule.id().toString());
     settings.beginGroup("events");
-    foreach (const EventDescriptor &eventDescriptor, eventDescriptorList) {
+    for (int i = 0; i < eventDescriptorList.count(); i++) {
-        settings.beginGroup("EventDescriptor-" + eventDescriptor.id().toString());
+        const EventDescriptor &eventDescriptor = eventDescriptorList.at(i);
+        settings.beginGroup("EventDescriptor-" + QString::number(i));
         settings.setValue("deviceId", eventDescriptor.deviceId().toString());
         settings.setValue("eventTypeId", eventDescriptor.eventTypeId());
 

server/stateevaluator.cpp

@@ -20,31 +20,19 @@
 #include "guhcore.h"
 #include "devicemanager.h"
 
-StateEvaluator::StateEvaluator()
+StateEvaluator::StateEvaluator(const StateDescriptor &stateDescriptor):
+    m_stateDescriptor(stateDescriptor)
 {
 
 }
 
-StateEvaluator::StateEvaluator(const StateEvaluatorId &id, const StateDescriptor &statedescriptor):
+StateEvaluator::StateEvaluator(QList<StateEvaluator> childEvaluators, StateOperator stateOperator):
-    m_id(id),
+    m_stateDescriptor(),
-    m_stateDescriptor(statedescriptor)
-{
-
-}
-
-StateEvaluator::StateEvaluator(const StateEvaluatorId &id, QList<StateEvaluator> childEvaluators, StateOperator stateOperator):
-    m_id(id),
     m_childEvaluators(childEvaluators),
-    m_operatorType(stateOperator),
+    m_operatorType(stateOperator)
-    m_stateDescriptor()
 {
 }
 
-StateEvaluatorId StateEvaluator::id() const
-{
-    return m_id;
-}
-
 StateDescriptor StateEvaluator::stateDescriptor() const
 {
     return m_stateDescriptor;
@@ -83,7 +71,7 @@ bool StateEvaluator::evaluate() const
             qWarning() << "Device not existing!";
             return false;
         }
-        if (device->hasState(m_stateDescriptor.stateTypeId())) {
+        if (!device->hasState(m_stateDescriptor.stateTypeId())) {
             qWarning() << "Device found, but it does not appear to have such a state!";
             return false;
         }
@@ -104,9 +92,7 @@ void StateEvaluator::dumpToSettings(QSettings &settings, const QString &groupNam
 {
     settings.beginGroup(groupName);
 
-    settings.setValue("id", m_id.toString());
     settings.beginGroup("stateDescriptor");
-    settings.setValue("stateDescriptorId", m_stateDescriptor.id().toString());
     settings.setValue("stateTypeId", m_stateDescriptor.stateTypeId().toString());
     settings.setValue("deviceId", m_stateDescriptor.deviceId().toString());
     settings.setValue("value", m_stateDescriptor.stateValue());
@@ -116,8 +102,8 @@ void StateEvaluator::dumpToSettings(QSettings &settings, const QString &groupNam
     settings.setValue("operator", m_operatorType);
 
     settings.beginGroup("childEvaluators");
-    foreach (const StateEvaluator &evaluator, m_childEvaluators) {
+    for (int i = 0; i < m_childEvaluators.count(); i++) {
-        evaluator.dumpToSettings(settings, "stateEvaluator-" + evaluator.id().toString());
+        m_childEvaluators.at(i).dumpToSettings(settings, "stateEvaluator-" + QString::number(i));
     }
     settings.endGroup();
 
@@ -127,18 +113,15 @@ void StateEvaluator::dumpToSettings(QSettings &settings, const QString &groupNam
 StateEvaluator StateEvaluator::loadFromSettings(QSettings &settings, const QString &groupName)
 {
     settings.beginGroup(groupName);
-    StateEvaluatorId id(settings.value("id").toString());
-
     settings.beginGroup("stateDescriptor");
-    StateDescriptorId stateDescriptorId(settings.value("stateDescriptorId").toString());
     StateTypeId stateTypeId(settings.value("stateTypeId").toString());
     DeviceId deviceId(settings.value("deviceId").toString());
     QVariant stateValue = settings.value("value");
     ValueOperator valueOperator = (ValueOperator)settings.value("operator").toInt();
-    StateDescriptor stateDescriptor(stateDescriptorId, stateTypeId, deviceId, stateValue, valueOperator);
+    StateDescriptor stateDescriptor(stateTypeId, deviceId, stateValue, valueOperator);
     settings.endGroup();
 
-    StateEvaluator ret(id, stateDescriptor);
+    StateEvaluator ret(stateDescriptor);
 
     ret.setOperatorType((StateOperator)settings.value("operator").toInt());
 

server/stateevaluator.h

@@ -32,11 +32,8 @@ public:
         OperatorTypeOr
     };
 
-    StateEvaluator();
+    StateEvaluator(const StateDescriptor &stateDescriptor);
-    StateEvaluator(const StateEvaluatorId &id, const StateDescriptor &statedescriptor);
+    StateEvaluator(QList<StateEvaluator> childEvaluators = QList<StateEvaluator>(), StateOperator stateOperator = StateOperatorAnd);
-    StateEvaluator(const StateEvaluatorId &id, QList<StateEvaluator> childEvaluators = QList<StateEvaluator>(), StateOperator stateOperator = StateOperatorAnd);
-
-    StateEvaluatorId id() const;
 
     StateDescriptor stateDescriptor() const;
 
@@ -53,12 +50,10 @@ public:
     static StateEvaluator loadFromSettings(QSettings &settings, const QString &groupPrefix);
 
 private:
-    StateEvaluatorId m_id;
     StateDescriptor m_stateDescriptor;
 
     QList<StateEvaluator> m_childEvaluators;
     StateOperator m_operatorType;
-
 };
 
 #endif // STATEEVALUATOR_H

tests/auto/api.json

@@ -1,4 +1,4 @@
-0.1.8
+1
 {
     "methods": {
         "Actions.ExecuteAction": {
@@ -210,6 +210,7 @@
             "params": {
             },
             "returns": {
+                "protocol version": "string",
                 "version": "string"
             }
         },
@@ -222,7 +223,8 @@
                 "o:eventDescriptor": "$ref:EventDescriptor",
                 "o:eventDescriptorList": [
                     "$ref:EventDescriptor"
-                ]
+                ],
+                "o:stateEvaluator": "$ref:StateEvaluator"
             },
             "returns": {
                 "errorMessage": "string",
@@ -397,13 +399,11 @@
         },
         "StateDescriptor": {
             "deviceId": "uuid",
-            "id": "uuid",
             "operator": "$ref:ValueOperatorType",
             "stateTypeId": "uuid",
             "value": "variant"
         },
         "StateEvaluator": {
-            "id": "uuid",
             "o:childEvaluators": [
                 "$ref:StateEvaluator"
             ],

tests/auto/guhtestbase.h

@@ -43,6 +43,7 @@ extern ActionTypeId mockActionIdAsyncFailing;
 extern EventTypeId mockEvent1Id;
 extern EventTypeId mockEvent2Id;
 extern StateTypeId mockIntStateId;
+extern StateTypeId mockBoolStateId;
 
 class MockTcpServer;
 

tests/auto/rules/testrules.cpp

@@ -40,20 +40,38 @@ private slots:
     void loadStoreConfig();
 
     void evaluateEvent();
+
+    void testStateEvaluator_data();
+    void testStateEvaluator();
+
+    void testStateEvaluator2();
 };
 
 void TestRules::addRules_data()
 {
-    QVariantMap validAction;
+    QVariantMap validActionNoParams;
-    validAction.insert("actionTypeId", mockActionIdNoParams);
+    validActionNoParams.insert("actionTypeId", mockActionIdNoParams);
-    validAction.insert("deviceId", m_mockDeviceId);
+    validActionNoParams.insert("deviceId", m_mockDeviceId);
-    validAction.insert("params", QVariantList());
+    validActionNoParams.insert("params", QVariantList());
 
     QVariantMap invalidAction;
     invalidAction.insert("actionTypeId", ActionTypeId());
     invalidAction.insert("deviceId", m_mockDeviceId);
     invalidAction.insert("params", QVariantList());
 
+    QVariantMap stateDescriptor;
+    stateDescriptor.insert("stateTypeId", mockIntStateId);
+    stateDescriptor.insert("deviceId", m_mockDeviceId);
+    stateDescriptor.insert("operator", "OperatorTypeLess");
+    stateDescriptor.insert("value", "20");
+
+    QVariantMap validStateEvaluator;
+    validStateEvaluator.insert("stateDescriptor", stateDescriptor);
+
+    QVariantMap invalidStateEvaluator;
+    stateDescriptor.remove("deviceId");
+    invalidStateEvaluator.insert("stateDescriptor", stateDescriptor);
+
     QVariantMap validEventDescriptor1;
     validEventDescriptor1.insert("eventTypeId", mockEvent1Id);
     validEventDescriptor1.insert("deviceId", m_mockDeviceId);
@@ -82,14 +100,16 @@ void TestRules::addRules_data()
     QTest::addColumn<QVariantMap>("action1");
     QTest::addColumn<QVariantMap>("eventDescriptor");
     QTest::addColumn<QVariantList>("eventDescriptorList");
+    QTest::addColumn<QVariantMap>("stateEvaluator");
     QTest::addColumn<bool>("success");
 
 
-    QTest::newRow("valid rule. 1 EventDescriptor, 1 Action") << validAction << validEventDescriptor1 << QVariantList() << true;
+    QTest::newRow("valid rule. 1 EventDescriptor, StateEvaluator, 1 Action") << validActionNoParams << validEventDescriptor1 << QVariantList() << validStateEvaluator << true;
-    QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validAction << QVariantMap() << eventDescriptorList << true;
+    QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validActionNoParams << QVariantMap() << eventDescriptorList << validStateEvaluator << true;
-    QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validAction << validEventDescriptor1 << eventDescriptorList << false;
+    QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validActionNoParams << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << false;
-    QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << false;
+    QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << validStateEvaluator << false;
-    QTest::newRow("invalid event descriptor") << validAction << invalidEventDescriptor << QVariantList() << false;
+    QTest::newRow("invalid event descriptor") << validActionNoParams << invalidEventDescriptor << QVariantList() << validStateEvaluator << false;
+//    QTest::newRow("invalid state evaluator") << validActionNoParams << invalidEventDescriptor << QVariantList() << invalidStateEvaluator << false;
 
 }
 
@@ -98,6 +118,7 @@ void TestRules::addRules()
     QFETCH(QVariantMap, action1);
     QFETCH(QVariantMap, eventDescriptor);
     QFETCH(QVariantList, eventDescriptorList);
+    QFETCH(QVariantMap, stateEvaluator);
     QFETCH(bool, success);
 
     QVariantMap params;
@@ -111,10 +132,11 @@ void TestRules::addRules()
     if (!eventDescriptorList.isEmpty()) {
         params.insert("eventDescriptorList", eventDescriptorList);
     }
+    params.insert("stateEvaluator", stateEvaluator);
     QVariant response = injectAndWait("Rules.AddRule", params);
+    verifySuccess(response, success);
 
     RuleId newRuleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString());
-    verifySuccess(response, success);
 
     response = injectAndWait("Rules.GetRules");
     QVariantList rules = response.toMap().value("params").toMap().value("rules").toList();
@@ -306,5 +328,57 @@ void TestRules::evaluateEvent()
     QVERIFY2(mockActionIdNoParams == ActionTypeId(actionHistory), "Action not triggered");
 }
 
+void TestRules::testStateEvaluator_data()
+{
+    QTest::addColumn<DeviceId>("deviceId");
+    QTest::addColumn<StateTypeId>("stateTypeId");
+    QTest::addColumn<QVariant>("value");
+    QTest::addColumn<ValueOperator>("operatorType");
+    QTest::addColumn<bool>("shouldMatch");
+
+    QTest::newRow("equals, not matching") << m_mockDeviceId << mockIntStateId << QVariant(7777) << ValueOperatorEquals << false;
+    QTest::newRow("equals, matching") << m_mockDeviceId << mockIntStateId << QVariant(10) << ValueOperatorEquals << true;
+
+    QTest::newRow("not equal, not matching") << m_mockDeviceId << mockIntStateId << QVariant(10) << ValueOperatorNotEquals << false;
+    QTest::newRow("not equal, matching") << m_mockDeviceId << mockIntStateId << QVariant(7777) << ValueOperatorNotEquals << true;
+
+    QTest::newRow("Greater, not matching") << m_mockDeviceId << mockIntStateId << QVariant(7777) << ValueOperatorGreater << false;
+    QTest::newRow("Greater, matching") << m_mockDeviceId << mockIntStateId << QVariant(2) << ValueOperatorGreater << true;
+    QTest::newRow("GreaterOrEqual, not matching") << m_mockDeviceId << mockIntStateId << QVariant(7777) << ValueOperatorGreaterOrEqual << false;
+    QTest::newRow("GreaterOrEqual, matching (greater)") << m_mockDeviceId << mockIntStateId << QVariant(2) << ValueOperatorGreaterOrEqual << true;
+    QTest::newRow("GreaterOrEqual, matching (equals)") << m_mockDeviceId << mockIntStateId << QVariant(10) << ValueOperatorGreaterOrEqual << true;
+
+    QTest::newRow("Less, not matching") << m_mockDeviceId << mockIntStateId << QVariant(2) << ValueOperatorLess << false;
+    QTest::newRow("Less, matching") << m_mockDeviceId << mockIntStateId << QVariant(7777) << ValueOperatorLess << true;
+    QTest::newRow("LessOrEqual, not matching") << m_mockDeviceId << mockIntStateId << QVariant(2) << ValueOperatorLessOrEqual << false;
+    QTest::newRow("LessOrEqual, matching (less)") << m_mockDeviceId << mockIntStateId << QVariant(777) << ValueOperatorLessOrEqual << true;
+    QTest::newRow("LessOrEqual, matching (equals)") << m_mockDeviceId << mockIntStateId << QVariant(10) << ValueOperatorLessOrEqual << true;
+}
+
+void TestRules::testStateEvaluator()
+{
+    QFETCH(DeviceId, deviceId);
+    QFETCH(StateTypeId, stateTypeId);
+    QFETCH(QVariant, value);
+    QFETCH(ValueOperator, operatorType);
+    QFETCH(bool, shouldMatch);
+
+    StateDescriptor descriptor(stateTypeId, deviceId, value, operatorType);
+    StateEvaluator evaluator(descriptor);
+    QVERIFY2(evaluator.evaluate() == shouldMatch, "State shouldn't match");
+
+}
+
+void TestRules::testStateEvaluator2()
+{
+//    StateDescriptor descriptor1(mockIntStateId, deviceId, value, operatorType);
+//    StateEvaluator evaluator1(descriptor);
+
+//    StateDescriptor descriptor2(mockBoolStateId, deviceId, value, operatorType);
+//    StateEvaluator evaluator2(descriptor);
+
+//    StateEvaluator mainEvaluator()
+}
+
 #include "testrules.moc"
 QTEST_MAIN(TestRules)

tests/auto/versioning/testversioning.cpp

@@ -43,10 +43,14 @@ void TestVersioning::version()
     QVariant response = injectAndWait("JSONRPC.Version");
 
     QString version = response.toMap().value("params").toMap().value("version").toString();
+    QVariant protocolVersion = response.toMap().value("params").toMap().value("protocol version");
     qDebug() << "Got version:" << version << "( Expected:" << GUH_VERSION_STRING << ")";
 
     QVERIFY2(!version.isEmpty(), "Version is empty.");
     QCOMPARE(version, QString(GUH_VERSION_STRING));
+
+    QVERIFY2(!protocolVersion.toString().isEmpty(), "Protocol version is empty.");
+    QVERIFY2(protocolVersion.canConvert(QVariant::Int), "Protocol version is not an integer.");
 }
 
 void TestVersioning::apiChangeBumpsVersion()
@@ -55,7 +59,7 @@ void TestVersioning::apiChangeBumpsVersion()
     QString newFilePath = QString(TESTS_SOURCE_DIR) + "/api.json.new";
 
     QVariant response = injectAndWait("JSONRPC.Version", QVariantMap());
-    QByteArray newVersion = response.toMap().value("params").toMap().value("version").toByteArray();
+    QByteArray newVersion = response.toMap().value("params").toMap().value("protocol version").toByteArray();
 
     response = injectAndWait("JSONRPC.Introspect", QVariantMap());
     QJsonDocument jsonDoc = QJsonDocument::fromVariant(response.toMap().value("params"));