ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

write more tests for the rules engine.

Browse Source 
decouple jsonrpc versioning from application versioning
This commit is contained in:
Michael Zanetti 2014-06-19 01:10:56 +02:00
parent d2f02d650b
commit 16645498db
15 changed files with 129 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libguh/types/eventdescriptor.cpp
View File

@ -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):
m_id(id),
EventDescriptor::EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors):
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
{

5
libguh/types/eventdescriptor.h
View File

@ -30,9 +30,7 @@
class EventDescriptor
{
public:
EventDescriptor(const EventDescriptorId &id, const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors = QList<ParamDescriptor>());
EventDescriptorId id() const;
EventDescriptor(const EventTypeId &eventTypeId, const DeviceId &deviceId, const QList<ParamDescriptor> &paramDescriptors = QList<ParamDescriptor>());
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;

17
libguh/types/statedescriptor.cpp
View File

@ -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();
}

5
libguh/types/statedescriptor.h
View File

@ -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;

6
libguh/typeutils.h
View File

@ -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

5
server/jsonrpc/jsonrpcserver.cpp
View File

@ -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());
}

6
server/jsonrpc/jsontypes.cpp
View File

@ -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;
}

1
server/jsonrpc/ruleshandler.cpp
View File

@ -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);

10
server/ruleengine.cpp
View File

@ -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) {
settings.beginGroup("EventDescriptor-" + eventDescriptor.id().toString());
for (int i = 0; i < eventDescriptorList.count(); i++) {
const EventDescriptor &eventDescriptor = eventDescriptorList.at(i);
settings.beginGroup("EventDescriptor-" + QString::number(i));
settings.setValue("deviceId", eventDescriptor.deviceId().toString());
settings.setValue("eventTypeId", eventDescriptor.eventTypeId());

37
server/stateevaluator.cpp
View File

@ -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):
m_id(id),
m_stateDescriptor(statedescriptor)
{
}
StateEvaluator::StateEvaluator(const StateEvaluatorId &id, QList<StateEvaluator> childEvaluators, StateOperator stateOperator):
m_id(id),
StateEvaluator::StateEvaluator(QList<StateEvaluator> 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());

9
server/stateevaluator.h
View File

@ -32,11 +32,8 @@ public:
OperatorTypeOr
};
StateEvaluator();
StateEvaluator(const StateEvaluatorId &id, const StateDescriptor &statedescriptor);
StateEvaluator(const StateEvaluatorId &id, QList<StateEvaluator> childEvaluators = QList<StateEvaluator>(), StateOperator stateOperator = StateOperatorAnd);
StateEvaluatorId id() const;
StateEvaluator(const StateDescriptor &stateDescriptor);
StateEvaluator(QList<StateEvaluator> childEvaluators = QList<StateEvaluator>(), 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<StateEvaluator> m_childEvaluators;
StateOperator m_operatorType;
};
#endif // STATEEVALUATOR_H

8
tests/auto/api.json
View File

@ -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"
],

1
tests/auto/guhtestbase.h
View File

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

94
tests/auto/rules/testrules.cpp
View File

@ -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<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. 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>("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)

6
tests/auto/versioning/testversioning.cpp
View File

@ -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"));