From 1c008d0bef678b1e281849fd649730b4353e04a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Simon=20St=C3=BCrz?= Date: Thu, 19 Mar 2015 13:19:24 +0100 Subject: [PATCH] fixed inline comments and added a test --- server/jsonrpc/ruleshandler.cpp | 25 ++++++++----- tests/auto/rules/testrules.cpp | 65 +++++++++++++++++++++++++++++---- 2 files changed, 72 insertions(+), 18 deletions(-) diff --git a/server/jsonrpc/ruleshandler.cpp b/server/jsonrpc/ruleshandler.cpp index 8f99b25b..ce859fd7 100644 --- a/server/jsonrpc/ruleshandler.cpp +++ b/server/jsonrpc/ruleshandler.cpp @@ -133,36 +133,39 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) if (params.contains("eventDescriptor") || params.contains("eventDescriptorList")) { if (params.contains("exitActions")) { QVariantMap returns; - qWarning() << "The exitActions will never be executed if the rule contains any eventDescriptor."; + qWarning() << "The exitActions will never be executed if the rule contains an eventDescriptor."; returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidRuleFormat)); return createReply(returns); } } - + // Check and unpack eventDescriptors QList eventDescriptorList; if (params.contains("eventDescriptor")) { QVariantMap eventMap = params.value("eventDescriptor").toMap(); + qDebug() << "unpacking eventDescriptor" << eventMap; eventDescriptorList.append(JsonTypes::unpackEventDescriptor(eventMap)); } else if (params.contains("eventDescriptorList")) { - foreach (const QVariant &eventVariant, params.value("eventDescriptorList").toList()) { + QVariantList eventDescriptors = params.value("eventDescriptorList").toList(); + qDebug() << "unpacking eventDescriptorList:" << eventDescriptors; + foreach (const QVariant &eventVariant, eventDescriptors) { QVariantMap eventMap = eventVariant.toMap(); eventDescriptorList.append(JsonTypes::unpackEventDescriptor(eventMap)); } } - qDebug() << "unpacking:" << params.value("stateEvaluator").toMap(); + // Check and unpack stateEvaluator + qDebug() << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap(); StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap()); + // Check and unpack actions QList actions; QVariantList actionList = params.value("actions").toList(); qDebug() << "unpacking actions:" << actionList; foreach (const QVariant &actionVariant, actionList) { QVariantMap actionMap = actionVariant.toMap(); RuleAction action(ActionTypeId(actionMap.value("actionTypeId").toString()), DeviceId(actionMap.value("deviceId").toString())); - qDebug() << "actionParams from json" << actionMap.value("ruleActionParams"); RuleActionParamList actionParamList = JsonTypes::unpackRuleActionParams(actionMap.value("ruleActionParams").toList()); - qDebug() << "unpacked actionParamList:" << actionParamList; foreach (const RuleActionParam &ruleActionParam, actionParamList) { if (!ruleActionParam.isValid()) { qWarning() << "ERROR: got actionParam with value AND eventTypeId!"; @@ -173,7 +176,6 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) } action.setRuleActionParams(actionParamList); - qDebug() << "params in action" << action.ruleActionParams(); actions.append(action); } @@ -202,7 +204,9 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) QVariant::Type actionParamType = getActionParamType(ruleAction.actionTypeId(), ruleActionParam.name()); if (eventParamType != actionParamType) { QVariantMap returns; - qWarning() << "RuleActionParam" << ruleActionParam.name() << " and given event param have not the same type."; + qWarning() << "RuleActionParam" << ruleActionParam.name() << " and given event param " << ruleActionParam.eventParamName() << "have not the same type:"; + qWarning() << " -> actionParamType:" << actionParamType; + qWarning() << " -> eventParamType:" << eventParamType; returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorTypesNotMatching)); return createReply(returns); } @@ -218,13 +222,14 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) return createReply(returns); } + // Check and unpack exitActions QList exitActions; if (params.contains("exitActions")) { QVariantList exitActionList = params.value("exitActions").toList(); + qDebug() << "unpacking exitActions:" << exitActionList; foreach (const QVariant &actionVariant, exitActionList) { QVariantMap actionMap = actionVariant.toMap(); RuleAction action(ActionTypeId(actionMap.value("actionTypeId").toString()), DeviceId(actionMap.value("deviceId").toString())); - qDebug() << "params from json" << actionMap.value("ruleActionParams"); if (action.isEventBased()) { qWarning() << "ERROR: got exitAction with a param value containing an eventTypeId!"; QVariantMap returns; @@ -232,7 +237,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) return createReply(returns); } action.setRuleActionParams(JsonTypes::unpackRuleActionParams(actionMap.value("ruleActionParams").toList())); - qDebug() << "params in action" << action.ruleActionParams(); + qDebug() << "params in exitAction" << action.ruleActionParams(); exitActions.append(action); } } diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp index 71ef292f..e12e979a 100644 --- a/tests/auto/rules/testrules.cpp +++ b/tests/auto/rules/testrules.cpp @@ -62,6 +62,8 @@ private slots: void testStateChange(); void enableDisableRule(); + + void testEventBasedAction(); }; void TestRules::cleanupMockHistory() { @@ -183,12 +185,6 @@ void TestRules::addRemoveRules_data() validEventDescriptor3.insert("deviceId", m_mockDeviceId); validEventDescriptor3.insert("paramDescriptors", QVariantList()); - QVariantMap validEventDescriptor4; - validEventDescriptor4.insert("eventTypeId", mockEvent1Id); - validEventDescriptor4.insert("deviceId", m_mockDeviceId); - validEventDescriptor4.insert("paramDescriptors", QVariantList()); - - // EventDescriptorList QVariantList eventDescriptorList; eventDescriptorList.append(validEventDescriptor1); @@ -254,7 +250,7 @@ void TestRules::addRemoveRules_data() QTest::newRow("valid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << validActionEventBased << QVariantMap() << validEventDescriptor3 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorNoError << true << "ActionEventRule1"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased2 << QVariantMap() << validEventDescriptor3 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule"; - QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor4 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << false << "TestRule"; + QTest::newRow("invalid rule. enabled, 1 Action (eventBased), types not matching, name") << true << invalidActionEventBased3 << QVariantMap() << validEventDescriptor1 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorTypesNotMatching << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 EventDescriptor, name") << true << invalidActionEventBased << QVariantMap() << validEventDescriptor2 << QVariantList() << QVariantMap() << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule"; QTest::newRow("invalid rule. enabled, 1 Action (eventBased), 1 StateEvaluator, name") << true << validActionEventBased << QVariantMap() << QVariantMap() << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidRuleActionParameter << false << "TestRule"; @@ -303,8 +299,8 @@ void TestRules::addRemoveRules() if (!eventDescriptorList.isEmpty()) { params.insert("eventDescriptorList", eventDescriptorList); } + QVariantList exitActions; if (!exitAction1.isEmpty()) { - QVariantList exitActions; exitActions.append(exitAction1); params.insert("exitActions", exitActions); } @@ -361,6 +357,9 @@ void TestRules::addRemoveRules() 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"); + params.clear(); params.insert("ruleId", newRuleId); response = injectAndWait("Rules.RemoveRule", params); @@ -969,5 +968,55 @@ void TestRules::enableDisableRule() verifyRuleExecuted(mockActionIdNoParams); } +void TestRules::testEventBasedAction() +{ + // Add a rule + QVariantMap addRuleParams; + QVariantMap eventDescriptor; + eventDescriptor.insert("eventTypeId", mockIntStateId); + eventDescriptor.insert("deviceId", m_mockDeviceId); + addRuleParams.insert("eventDescriptor", eventDescriptor); + addRuleParams.insert("name", "TestRule"); + addRuleParams.insert("enabled", true); + + QVariantList actions; + QVariantMap action; + QVariantList ruleActionParams; + QVariantMap param1; + param1.insert("name", "mockActionParam1"); + param1.insert("eventTypeId", mockIntStateId); + param1.insert("eventParamName", "value"); + QVariantMap param2; + param2.insert("name", "mockActionParam2"); + param2.insert("value", true); + ruleActionParams.append(param1); + ruleActionParams.append(param2); + action.insert("actionTypeId", mockActionIdWithParams); + action.insert("deviceId", m_mockDeviceId); + action.insert("ruleActionParams", ruleActionParams); + actions.append(action); + addRuleParams.insert("actions", actions); + + qDebug() << addRuleParams; + + QVariant response = injectAndWait("Rules.AddRule", addRuleParams); + verifyRuleError(response); + + // Change the state + QNetworkAccessManager nam; + QSignalSpy spy(&nam, SIGNAL(finished(QNetworkReply*))); + + // state state to 42 + qDebug() << "setting mock int state to 42"; + QNetworkRequest request(QUrl(QString("http://localhost:%1/setstate?%2=%3").arg(m_mockDevice1Port).arg(mockIntStateId.toString()).arg(42))); + QNetworkReply *reply = nam.get(request); + spy.wait(); + QCOMPARE(spy.count(), 1); + reply->deleteLater(); + + verifyRuleExecuted(mockActionIdWithParams); + // TODO: check if this action was realy executed with the int state value 42 +} + #include "testrules.moc" QTEST_MAIN(TestRules)