From 16645498db0b9dc3798024527a08e3e26d2f82a8 Mon Sep 17 00:00:00 2001 From: Michael Zanetti Date: Thu, 19 Jun 2014 01:10:56 +0200 Subject: [PATCH] write more tests for the rules engine. decouple jsonrpc versioning from application versioning --- libguh/types/eventdescriptor.cpp | 8 +- libguh/types/eventdescriptor.h | 5 +- libguh/types/statedescriptor.cpp | 17 ++--- libguh/types/statedescriptor.h | 5 +- libguh/typeutils.h | 6 +- server/jsonrpc/jsonrpcserver.cpp | 5 ++ server/jsonrpc/jsontypes.cpp | 6 +- server/jsonrpc/ruleshandler.cpp | 1 + server/ruleengine.cpp | 10 +-- server/stateevaluator.cpp | 37 +++------- server/stateevaluator.h | 9 +-- tests/auto/api.json | 8 +- tests/auto/guhtestbase.h | 1 + tests/auto/rules/testrules.cpp | 94 +++++++++++++++++++++--- tests/auto/versioning/testversioning.cpp | 6 +- 15 files changed, 129 insertions(+), 89 deletions(-) diff --git a/libguh/types/eventdescriptor.cpp b/libguh/types/eventdescriptor.cpp index d30bf66e..2752327c 100644 --- a/libguh/types/eventdescriptor.cpp +++ b/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 ¶mDescriptors): - m_id(id), +EventDescriptor::EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList ¶mDescriptors): 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 { diff --git a/libguh/types/eventdescriptor.h b/libguh/types/eventdescriptor.h index 5a01caaa..b666a748 100644 --- a/libguh/types/eventdescriptor.h +++ b/libguh/types/eventdescriptor.h @@ -30,9 +30,7 @@ class EventDescriptor { public: - EventDescriptor(const EventDescriptorId &id, const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList ¶mDescriptors = QList()); - - EventDescriptorId id() const; + EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList ¶mDescriptors = QList()); 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 m_paramDescriptors; diff --git a/libguh/types/statedescriptor.cpp b/libguh/types/statedescriptor.cpp index 53e6e615..92edc3a7 100644 --- a/libguh/types/statedescriptor.cpp +++ b/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): - m_id(id), +StateDescriptor::StateDescriptor(const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType): 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(); } diff --git a/libguh/types/statedescriptor.h b/libguh/types/statedescriptor.h index 4eb66885..e44f8871 100644 --- a/libguh/types/statedescriptor.h +++ b/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); - - StateDescriptorId id() const; + StateDescriptor(const StateTypeId &stateTypeId, const DeviceId &deviceId, const QVariant &stateValue, ValueOperator operatorType = ValueOperatorEquals); 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; diff --git a/libguh/typeutils.h b/libguh/typeutils.h index 4f8f6585..86798553 100644 --- a/libguh/typeutils.h +++ b/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 diff --git a/server/jsonrpc/jsonrpcserver.cpp b/server/jsonrpc/jsonrpcserver.cpp index ecf753ba..8a3978d8 100644 --- a/server/jsonrpc/jsonrpcserver.cpp +++ b/server/jsonrpc/jsonrpcserver.cpp @@ -42,6 +42,8 @@ #include #include +#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 ¶ms) 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()); } diff --git a/server/jsonrpc/jsontypes.cpp b/server/jsonrpc/jsontypes.cpp index 8b549c76..423f7181 100644 --- a/server/jsonrpc/jsontypes.cpp +++ b/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 eventParams = JsonTypes::unpackParamDescriptors(eventDescriptorMap.value("paramDescriptors").toList()); - EventDescriptor eventDescriptor(EventDescriptorId::createEventDescriptorId(), eventTypeId, eventDeviceId, eventParams); + EventDescriptor eventDescriptor(eventTypeId, eventDeviceId, eventParams); return eventDescriptor; } diff --git a/server/jsonrpc/ruleshandler.cpp b/server/jsonrpc/ruleshandler.cpp index 13315b91..880a7992 100644 --- a/server/jsonrpc/ruleshandler.cpp +++ b/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); diff --git a/server/ruleengine.cpp b/server/ruleengine.cpp index 51e23518..9e69094d 100644 --- a/server/ruleengine.cpp +++ b/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 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 &eventDescriptorList, const QList &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 childEvaluators, StateOperator stateOperator): - m_id(id), +StateEvaluator::StateEvaluator(QList childEvaluators, StateOperator stateOperator): + m_stateDescriptor(), m_childEvaluators(childEvaluators), - m_operatorType(stateOperator), - m_stateDescriptor() + m_operatorType(stateOperator) { } -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) { - evaluator.dumpToSettings(settings, "stateEvaluator-" + evaluator.id().toString()); + for (int i = 0; i < m_childEvaluators.count(); i++) { + 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()); diff --git a/server/stateevaluator.h b/server/stateevaluator.h index db8e97b6..480c87f9 100644 --- a/server/stateevaluator.h +++ b/server/stateevaluator.h @@ -32,11 +32,8 @@ public: OperatorTypeOr }; - StateEvaluator(); - StateEvaluator(const StateEvaluatorId &id, const StateDescriptor &statedescriptor); - StateEvaluator(const StateEvaluatorId &id, QList childEvaluators = QList(), StateOperator stateOperator = StateOperatorAnd); - - StateEvaluatorId id() const; + StateEvaluator(const StateDescriptor &stateDescriptor); + StateEvaluator(QList childEvaluators = QList(), StateOperator stateOperator = StateOperatorAnd); StateDescriptor stateDescriptor() const; @@ -53,12 +50,10 @@ public: static StateEvaluator loadFromSettings(QSettings &settings, const QString &groupPrefix); private: - StateEvaluatorId m_id; StateDescriptor m_stateDescriptor; QList m_childEvaluators; StateOperator m_operatorType; - }; #endif // STATEEVALUATOR_H diff --git a/tests/auto/api.json b/tests/auto/api.json index 9b7a3eaf..a44a084a 100644 --- a/tests/auto/api.json +++ b/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" ], diff --git a/tests/auto/guhtestbase.h b/tests/auto/guhtestbase.h index 4a05dbeb..3ba77908 100644 --- a/tests/auto/guhtestbase.h +++ b/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; diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp index eb9d8263..d6a76d2f 100644 --- a/tests/auto/rules/testrules.cpp +++ b/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; - validAction.insert("actionTypeId", mockActionIdNoParams); - validAction.insert("deviceId", m_mockDeviceId); - validAction.insert("params", QVariantList()); + QVariantMap validActionNoParams; + validActionNoParams.insert("actionTypeId", mockActionIdNoParams); + validActionNoParams.insert("deviceId", m_mockDeviceId); + 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("action1"); QTest::addColumn("eventDescriptor"); QTest::addColumn("eventDescriptorList"); + QTest::addColumn("stateEvaluator"); QTest::addColumn("success"); - QTest::newRow("valid rule. 1 EventDescriptor, 1 Action") << validAction << validEventDescriptor1 << QVariantList() << true; - QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validAction << QVariantMap() << eventDescriptorList << true; - QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validAction << validEventDescriptor1 << eventDescriptorList << false; - QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << false; - QTest::newRow("invalid event descriptor") << validAction << invalidEventDescriptor << QVariantList() << false; + QTest::newRow("valid rule. 1 EventDescriptor, StateEvaluator, 1 Action") << validActionNoParams << validEventDescriptor1 << QVariantList() << validStateEvaluator << true; + QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validActionNoParams << QVariantMap() << eventDescriptorList << validStateEvaluator << true; + QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validActionNoParams << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << false; + QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << validStateEvaluator << 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"); + QTest::addColumn("stateTypeId"); + QTest::addColumn("value"); + QTest::addColumn("operatorType"); + QTest::addColumn("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) diff --git a/tests/auto/versioning/testversioning.cpp b/tests/auto/versioning/testversioning.cpp index 6a0d5c61..5b87ba87 100644 --- a/tests/auto/versioning/testversioning.cpp +++ b/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"));