From 44bdfbcb13ada2b1c266be62bce290763acc79b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Simon=20St=C3=BCrz?= Date: Mon, 29 Jun 2015 17:55:02 +0200 Subject: [PATCH] add tests --- server/jsonrpc/ruleshandler.cpp | 2 +- tests/auto/api.json | 35 +++- tests/auto/guhtestbase.cpp | 59 +++++- tests/auto/guhtestbase.h | 5 + tests/auto/rules/testrules.cpp | 335 ++++++++++++++++++++++++++++++++ 5 files changed, 427 insertions(+), 9 deletions(-) diff --git a/server/jsonrpc/ruleshandler.cpp b/server/jsonrpc/ruleshandler.cpp index 6d3381a3..11abbaa5 100644 --- a/server/jsonrpc/ruleshandler.cpp +++ b/server/jsonrpc/ruleshandler.cpp @@ -277,7 +277,7 @@ JsonReply *RulesHandler::EditRule(const QVariantMap ¶ms) RuleEngine::RuleError status = GuhCore::instance()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled); QVariantMap returns; if (status == RuleEngine::RuleErrorNoError) { - returns.insert("ruleId", ruleId.toString()); + returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->findRule(ruleId))); } returns.insert("ruleError", JsonTypes::ruleErrorToString(status)); return createReply(returns); diff --git a/tests/auto/api.json b/tests/auto/api.json index 94393bc0..781fdb94 100644 --- a/tests/auto/api.json +++ b/tests/auto/api.json @@ -1,4 +1,4 @@ -26 +27 { "methods": { "Actions.ExecuteAction": { @@ -309,7 +309,7 @@ } }, "Rules.DisableRule": { - "description": "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled.", + "description": "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.", "params": { "ruleId": "Uuid" }, @@ -317,8 +317,31 @@ "ruleError": "$ref:RuleError" } }, + "Rules.EditRule": { + "description": "Edit the parameters of a rule. The configuration of the rule with the given ruleId will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.", + "params": { + "actions": [ + "$ref:RuleAction" + ], + "name": "String", + "o:enabled": "Bool", + "o:eventDescriptor": "$ref:EventDescriptor", + "o:eventDescriptorList": [ + "$ref:EventDescriptor" + ], + "o:exitActions": [ + "$ref:RuleAction" + ], + "o:stateEvaluator": "$ref:StateEvaluator", + "ruleId": "Uuid" + }, + "returns": { + "o:rule": "$ref:Rule", + "ruleError": "$ref:RuleError" + } + }, "Rules.EnableRule": { - "description": "Enabled a rule that has previously been disabled.", + "description": "Enabled a rule that has previously been disabled.If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.", "params": { "ruleId": "Uuid" }, @@ -429,6 +452,12 @@ "rule": "$ref:Rule" } }, + "Rules.RuleConfigurationChanged": { + "description": "Emitted whenever the configuration of a Rule changed.", + "params": { + "rule": "$ref:Rule" + } + }, "Rules.RuleRemoved": { "description": "Emitted whenever a Rule was removed.", "params": { diff --git a/tests/auto/guhtestbase.cpp b/tests/auto/guhtestbase.cpp index f96f0933..c92976ee 100644 --- a/tests/auto/guhtestbase.cpp +++ b/tests/auto/guhtestbase.cpp @@ -27,6 +27,7 @@ #include #include +#include #include #include #include @@ -111,7 +112,7 @@ void GuhTestBase::cleanupTestCase() QVariant GuhTestBase::injectAndWait(const QString &method, const QVariantMap ¶ms) { QVariantMap call; - call.insert("id", m_commandId++); + call.insert("id", m_commandId); call.insert("method", method); call.insert("params", params); @@ -124,11 +125,59 @@ QVariant GuhTestBase::injectAndWait(const QString &method, const QVariantMap &pa spy.wait(); } - // Make sure the response it a valid JSON string - QJsonParseError error; - jsonDoc = QJsonDocument::fromJson(spy.takeFirst().last().toByteArray(), &error); + for (int i = 0; i < spy.count(); i++) { + // Make sure the response it a valid JSON string + QJsonParseError error; + jsonDoc = QJsonDocument::fromJson(spy.at(i).last().toByteArray(), &error); + if (error.error != QJsonParseError::NoError) { + qWarning() << "JSON parser error" << error.errorString(); + return QVariant(); + } + QVariantMap response = jsonDoc.toVariant().toMap(); + if (response.value("id").toInt() == m_commandId) { + m_commandId++; + return jsonDoc.toVariant(); + } + } + m_commandId++; + return QVariant(); +} - return jsonDoc.toVariant(); +QVariant GuhTestBase::checkNotification(const QSignalSpy &spy, const QString ¬ification) +{ + qDebug() << "Got" << spy.count() << "notifications while waiting for" << notification; + for (int i = 0; i < spy.count(); i++) { + // Make sure the response it a valid JSON string + QJsonParseError error; + QJsonDocument jsonDoc = QJsonDocument::fromJson(spy.at(i).last().toByteArray(), &error); + if (error.error != QJsonParseError::NoError) { + qWarning() << "JSON parser error" << error.errorString(); + return QVariant(); + } + + QVariantMap response = jsonDoc.toVariant().toMap(); + if (response.value("notification").toString() == notification) { + return jsonDoc.toVariant(); + } + } + return QVariant(); +} + +bool GuhTestBase::enableNotifications() +{ + QVariantMap notificationParams; + notificationParams.insert("enabled", true); + QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", notificationParams); + + return response.toMap().value("params").toMap().value("enabled").toBool(); +} + +bool GuhTestBase::disableNotifications() +{ + QVariantMap notificationParams; + notificationParams.insert("enabled", true); + QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", notificationParams); + return !response.toMap().value("params").toMap().value("enabled").toBool(); } void GuhTestBase::restartServer() diff --git a/tests/auto/guhtestbase.h b/tests/auto/guhtestbase.h index 74ba70e3..d3127a14 100644 --- a/tests/auto/guhtestbase.h +++ b/tests/auto/guhtestbase.h @@ -31,6 +31,7 @@ #include #include #include +#include #include extern DeviceClassId mockDeviceClassId; @@ -63,6 +64,10 @@ protected slots: protected: QVariant injectAndWait(const QString &method, const QVariantMap ¶ms = QVariantMap()); + QVariant checkNotification(const QSignalSpy &spy, const QString ¬ification); + + bool enableNotifications(); + bool disableNotifications(); inline void verifyError(const QVariant &response, const QString &fieldName, const QString &error) { diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp index 5e325d5e..eb239d5c 100644 --- a/tests/auto/rules/testrules.cpp +++ b/tests/auto/rules/testrules.cpp @@ -50,6 +50,9 @@ private slots: void addRemoveRules_data(); void addRemoveRules(); + void editRules_data(); + void editRules(); + void removeInvalidRule(); void loadStoreConfig(); @@ -373,6 +376,338 @@ void TestRules::addRemoveRules() QVERIFY2(rules.count() == 0, "There should be no rules."); } +void TestRules::editRules_data() +{ + // RuleAction + QVariantMap validActionNoParams; + validActionNoParams.insert("actionTypeId", mockActionIdNoParams); + validActionNoParams.insert("deviceId", m_mockDeviceId); + validActionNoParams.insert("ruleActionParams", QVariantList()); + + QVariantMap invalidAction; + invalidAction.insert("actionTypeId", ActionTypeId()); + invalidAction.insert("deviceId", m_mockDeviceId); + invalidAction.insert("ruleActionParams", QVariantList()); + + // RuleExitAction + QVariantMap validExitActionNoParams; + validExitActionNoParams.insert("actionTypeId", mockActionIdNoParams); + validExitActionNoParams.insert("deviceId", m_mockDeviceId); + validExitActionNoParams.insert("ruleActionParams", QVariantList()); + + QVariantMap invalidExitAction; + invalidExitAction.insert("actionTypeId", ActionTypeId()); + invalidExitAction.insert("deviceId", m_mockDeviceId); + invalidExitAction.insert("ruleActionParams", QVariantList()); + + // StateDescriptor + QVariantMap stateDescriptor; + stateDescriptor.insert("stateTypeId", mockIntStateId); + stateDescriptor.insert("deviceId", m_mockDeviceId); + stateDescriptor.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorLess)); + stateDescriptor.insert("value", "20"); + + // StateEvaluator + QVariantMap validStateEvaluator; + validStateEvaluator.insert("stateDescriptor", stateDescriptor); + validStateEvaluator.insert("operator", JsonTypes::stateOperatorToString(Types::StateOperatorAnd)); + + QVariantMap invalidStateEvaluator; + stateDescriptor.remove("deviceId"); + invalidStateEvaluator.insert("stateDescriptor", stateDescriptor); + + // EventDescriptor + QVariantMap validEventDescriptor1; + validEventDescriptor1.insert("eventTypeId", mockEvent1Id); + validEventDescriptor1.insert("deviceId", m_mockDeviceId); + validEventDescriptor1.insert("paramDescriptors", QVariantList()); + + QVariantMap validEventDescriptor2; + validEventDescriptor2.insert("eventTypeId", mockEvent2Id); + validEventDescriptor2.insert("deviceId", m_mockDeviceId); + QVariantList params; + QVariantMap param1; + param1.insert("name", "mockParamInt"); + param1.insert("value", 3); + param1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); + params.append(param1); + validEventDescriptor2.insert("paramDescriptors", params); + + QVariantMap validEventDescriptor3; + validEventDescriptor3.insert("eventTypeId", mockEvent2Id); + validEventDescriptor3.insert("deviceId", m_mockDeviceId); + validEventDescriptor3.insert("paramDescriptors", QVariantList()); + + // EventDescriptorList + QVariantList eventDescriptorList; + eventDescriptorList.append(validEventDescriptor1); + eventDescriptorList.append(validEventDescriptor2); + + QVariantMap invalidEventDescriptor; + invalidEventDescriptor.insert("eventTypeId", mockEvent1Id); + invalidEventDescriptor.insert("deviceId", DeviceId()); + invalidEventDescriptor.insert("paramDescriptors", QVariantList()); + + // RuleAction event based + QVariantMap validActionEventBased; + validActionEventBased.insert("actionTypeId", mockActionIdWithParams); + validActionEventBased.insert("deviceId", m_mockDeviceId); + QVariantMap validActionEventBasedParam1; + validActionEventBasedParam1.insert("name", "mockActionParam1"); + validActionEventBasedParam1.insert("eventTypeId", mockEvent2Id); + validActionEventBasedParam1.insert("eventParamName", "mockParamInt"); + QVariantMap validActionEventBasedParam2; + validActionEventBasedParam2.insert("name", "mockActionParam2"); + validActionEventBasedParam2.insert("value", false); + validActionEventBased.insert("ruleActionParams", QVariantList() << validActionEventBasedParam1 << validActionEventBasedParam2); + + QVariantMap invalidActionEventBased; + invalidActionEventBased.insert("actionTypeId", mockActionIdNoParams); + invalidActionEventBased.insert("deviceId", m_mockDeviceId); + validActionEventBasedParam1.insert("value", 10); + invalidActionEventBased.insert("ruleActionParams", QVariantList() << validActionEventBasedParam1); + + QVariantMap invalidActionEventBased2; + invalidActionEventBased2.insert("actionTypeId", mockActionIdWithParams); + invalidActionEventBased2.insert("deviceId", m_mockDeviceId); + QVariantMap invalidActionEventBasedParam2; + invalidActionEventBasedParam2.insert("name", "mockActionParam1"); + invalidActionEventBasedParam2.insert("eventTypeId", mockEvent1Id); + invalidActionEventBasedParam2.insert("eventParamName", "value"); + QVariantMap invalidActionEventBasedParam3; + invalidActionEventBasedParam3.insert("name", "mockActionParam2"); + invalidActionEventBasedParam3.insert("value", 2); + invalidActionEventBased2.insert("ruleActionParams", QVariantList() << invalidActionEventBasedParam2 << invalidActionEventBasedParam3); + + QVariantMap invalidActionEventBased3; + invalidActionEventBased3.insert("actionTypeId", mockActionIdWithParams); + invalidActionEventBased3.insert("deviceId", m_mockDeviceId); + QVariantMap invalidActionEventBasedParam4; + invalidActionEventBasedParam4.insert("name", "mockActionParam1"); + invalidActionEventBasedParam4.insert("eventTypeId", mockEvent1Id); + invalidActionEventBasedParam4.insert("eventParamName", "mockParamInt"); + invalidActionEventBased3.insert("ruleActionParams", QVariantList() << invalidActionEventBasedParam4); + + QTest::addColumn("enabled"); + QTest::addColumn("action"); + QTest::addColumn("exitAction"); + QTest::addColumn("eventDescriptor"); + QTest::addColumn("eventDescriptorList"); + QTest::addColumn("stateEvaluator"); + QTest::addColumn("error"); + QTest::addColumn("name"); + + // Rules with event based actions + QTest::newRow("valid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << QVariantMap() << validEventDescriptor3 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorNoError << "ActionEventRule1"; + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased2 << QVariantMap() << validEventDescriptor3 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule"; + + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << "TestRule"; + + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule"; + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << "TestRule"; + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; + QTest::newRow("invalid rule. enabled, 1 Action, 1 ExitAction (EventBased), name") << true << validActionNoParams << validActionEventBased << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; + + // Rules with exit actions + QTest::newRow("valid rule. enabled, 1 Action, 1 Exit Action, 1 StateEvaluator, name") << true << validActionNoParams << validExitActionNoParams << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; + QTest::newRow("valid rule. disabled, 1 Action, 1 Exit Action, 1 StateEvaluator, name") << false << validActionNoParams << validExitActionNoParams << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; + QTest::newRow("invalid rule. 1 Action, 1 Exit Action, 1 EventDescriptor, 1 StateEvaluator, name") << true << validActionNoParams << validExitActionNoParams << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; + QTest::newRow("invalid rule. 1 Action, 1 Exit Action, eventDescriptorList, 1 StateEvaluator, name") << true << validActionNoParams << validExitActionNoParams << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleFormat << "TestRule"; + + // Rules without exit actions + QTest::newRow("valid rule. enabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; + QTest::newRow("valid rule. diabled, 1 EventDescriptor, StateEvaluator, 1 Action, name") << false << validActionNoParams << QVariantMap() << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; + QTest::newRow("valid rule. 2 EventDescriptors, 1 Action, name") << true << validActionNoParams << QVariantMap() << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError << "TestRule"; + QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << true << validActionNoParams << QVariantMap() << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter << "TestRule"; +} + +void TestRules::editRules() +{ + QFETCH(bool, enabled); + QFETCH(QVariantMap, action); + QFETCH(QVariantMap, exitAction); + QFETCH(QVariantMap, eventDescriptor); + QFETCH(QVariantList, eventDescriptorList); + QFETCH(QVariantMap, stateEvaluator); + QFETCH(RuleEngine::RuleError, error); + QFETCH(QString, name); + + // Add the rule we want to edit + QVariantList eventParamDescriptors; + QVariantMap eventDescriptor1; + eventDescriptor1.insert("eventTypeId", mockEvent1Id); + eventDescriptor1.insert("deviceId", m_mockDeviceId); + eventDescriptor1.insert("paramDescriptors", QVariantList()); + QVariantMap eventDescriptor2; + eventDescriptor2.insert("eventTypeId", mockEvent2Id); + eventDescriptor2.insert("deviceId", m_mockDeviceId); + eventDescriptor2.insert("paramDescriptors", QVariantList()); + QVariantMap eventParam1; + eventParam1.insert("name", "mockParamInt"); + eventParam1.insert("value", 3); + eventParam1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); + eventParamDescriptors.append(eventParam1); + eventDescriptor2.insert("paramDescriptors", eventParamDescriptors); + + QVariantList eventDescriptorList1; + eventDescriptorList1.append(eventDescriptor1); + eventDescriptorList1.append(eventDescriptor2); + + QVariantMap stateEvaluator0; + QVariantMap stateDescriptor1; + stateDescriptor1.insert("deviceId", m_mockDeviceId); + stateDescriptor1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); + stateDescriptor1.insert("stateTypeId", mockIntStateId); + stateDescriptor1.insert("value", 1); + QVariantMap stateDescriptor2; + stateDescriptor2.insert("deviceId", m_mockDeviceId); + stateDescriptor2.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); + stateDescriptor2.insert("stateTypeId", mockBoolStateId); + stateDescriptor2.insert("value", true); + QVariantMap stateEvaluator1; + stateEvaluator1.insert("stateDescriptor", stateDescriptor1); + stateEvaluator1.insert("operator", JsonTypes::stateOperatorToString(Types::StateOperatorAnd)); + QVariantMap stateEvaluator2; + stateEvaluator2.insert("stateDescriptor", stateDescriptor2); + stateEvaluator2.insert("operator", JsonTypes::stateOperatorToString(Types::StateOperatorAnd)); + QVariantList childEvaluators; + childEvaluators.append(stateEvaluator1); + childEvaluators.append(stateEvaluator2); + stateEvaluator0.insert("childEvaluators", childEvaluators); + stateEvaluator0.insert("operator", JsonTypes::stateOperatorToString(Types::StateOperatorAnd)); + + QVariantMap action1; + action1.insert("actionTypeId", mockActionIdNoParams); + action1.insert("deviceId", m_mockDeviceId); + action1.insert("ruleActionParams", QVariantList()); + QVariantMap action2; + action2.insert("actionTypeId", mockActionIdWithParams); + qDebug() << "got action id" << mockActionIdWithParams; + action2.insert("deviceId", m_mockDeviceId); + QVariantList action2Params; + QVariantMap action2Param1; + action2Param1.insert("name", "mockActionParam1"); + action2Param1.insert("value", 5); + action2Params.append(action2Param1); + QVariantMap action2Param2; + action2Param2.insert("name", "mockActionParam2"); + action2Param2.insert("value", true); + action2Params.append(action2Param2); + action2.insert("ruleActionParams", action2Params); + + // RuleAction event based + QVariantMap validActionEventBased; + validActionEventBased.insert("actionTypeId", mockActionIdWithParams); + validActionEventBased.insert("deviceId", m_mockDeviceId); + QVariantMap validActionEventBasedParam1; + validActionEventBasedParam1.insert("name", "mockActionParam1"); + validActionEventBasedParam1.insert("eventTypeId", mockEvent2Id); + validActionEventBasedParam1.insert("eventParamName", "mockParamInt"); + QVariantMap validActionEventBasedParam2; + validActionEventBasedParam2.insert("name", "mockActionParam2"); + validActionEventBasedParam2.insert("value", false); + validActionEventBased.insert("ruleActionParams", QVariantList() << validActionEventBasedParam1 << validActionEventBasedParam2); + + QVariantList validEventDescriptors3; + QVariantMap validEventDescriptor3; + validEventDescriptor3.insert("eventTypeId", mockEvent2Id); + validEventDescriptor3.insert("deviceId", m_mockDeviceId); + validEventDescriptor3.insert("paramDescriptors", QVariantList()); + validEventDescriptors3.append(validEventDescriptor3); + + QVariantMap params; + QVariantList actions; + actions.append(action1); + actions.append(action2); + params.insert("actions", actions); + params.insert("eventDescriptorList", eventDescriptorList1); + params.insert("stateEvaluator", stateEvaluator0); + params.insert("name", "TestRule"); + QVariant response = injectAndWait("Rules.AddRule", params); + + RuleId ruleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString()); + verifyRuleError(response); + + // enable notifications + QCOMPARE(enableNotifications(), true); + + // now create the new rule and edit the original one + params.clear(); + params.insert("ruleId", ruleId.toString()); + params.insert("name", name); + + if (!eventDescriptor.isEmpty()) { + params.insert("eventDescriptor", eventDescriptor); + } + if (!eventDescriptorList.isEmpty()) { + params.insert("eventDescriptorList", eventDescriptorList); + } + actions.clear(); + actions.append(action); + params.insert("actions", actions); + + QVariantList exitActions; + if (!exitAction.isEmpty()) { + exitActions.append(exitAction); + params.insert("exitActions", exitActions); + } + params.insert("stateEvaluator", stateEvaluator); + if (!enabled) { + params.insert("enabled", enabled); + } + + // Setup connection to mock client + QSignalSpy clientSpy(m_mockTcpServer, SIGNAL(outgoingData(QUuid,QByteArray))); + response.clear(); + response = injectAndWait("Rules.EditRule", params); + verifyRuleError(response, error); + if (error == RuleEngine::RuleErrorNoError){ + QVariant notification = checkNotification(clientSpy, "Rules.RuleConfigurationChanged"); + QVERIFY2(notification != QVariant(), "not received \"Rules.RuleConfigurationChanged\" notification"); + + + // now check if the received rule matches the our new rule + QVariantMap rule = response.toMap().value("params").toMap().value("rule").toMap(); + + QVERIFY2(rule.value("enabled").toBool() == enabled, "Rule enabled state doesn't match"); + QVariantList eventDescriptors = rule.value("eventDescriptors").toList(); + if (!eventDescriptor.isEmpty()) { + QVERIFY2(eventDescriptors.count() == 1, "There shoud be exactly one eventDescriptor"); + QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, "Event descriptor doesn't match"); + } else if (eventDescriptorList.isEmpty()){ + QVERIFY2(eventDescriptors.count() == eventDescriptorList.count(), QString("There shoud be exactly %1 eventDescriptor").arg(eventDescriptorList.count()).toLatin1().data()); + foreach (const QVariant &eventDescriptorVariant, eventDescriptorList) { + bool found = false; + foreach (const QVariant &replyEventDescriptorVariant, eventDescriptors) { + if (eventDescriptorVariant.toMap().value("deviceId") == replyEventDescriptorVariant.toMap().value("deviceId") && + eventDescriptorVariant.toMap().value("eventTypeId") == replyEventDescriptorVariant.toMap().value("eventTypeId")) { + found = true; + QVERIFY2(eventDescriptorVariant == replyEventDescriptorVariant, "Event descriptor doesn't match"); + } + } + QVERIFY2(found, "Missing event descriptor"); + } + } + + QVariantList replyActions = rule.value("actions").toList(); + QVERIFY2(actions == replyActions, "Actions don't match"); + + QVariantList replyExitActions = rule.value("exitActions").toList(); + QVERIFY2(exitActions == replyExitActions, "ExitActions don't match"); + } + + // Remove th rule + params.clear(); + params.insert("ruleId", ruleId); + response = injectAndWait("Rules.RemoveRule", params); + verifyRuleError(response); + + // check if removed + response = injectAndWait("Rules.GetRules"); + QVariantList rules = response.toMap().value("params").toMap().value("rules").toList(); + QVERIFY2(rules.count() == 0, "There should be no rules."); +} + void TestRules::removeInvalidRule() { QVariantMap params;