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

add rest methods for testing

Browse Source 
update rest tests with new methods
This commit is contained in:
Simon Stürz 2015-12-08 16:56:13 +01:00 committed by Michael Zanetti
parent 18df770d64
commit aa5cba8189
8 changed files with 505 additions and 582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
tests/auto/devices/testdevices.cpp
View File

@ -67,6 +67,8 @@ private slots:
void addDisplayPinDevices_data(); void addDisplayPinDevices_data();
void addDisplayPinDevices(); void addDisplayPinDevices();
void parentChildDevices();
void getActionTypes_data(); void getActionTypes_data();
void getActionTypes(); void getActionTypes();
@ -532,6 +534,79 @@ void TestDevices::addDisplayPinDevices()
} }
void TestDevices::parentChildDevices()
{
// add parent device
QVariantMap params;
params.insert("deviceClassId", mockParentDeviceClassId);
QVariant response = injectAndWait("Devices.AddConfiguredDevice", params);
verifyDeviceError(response);
DeviceId parentDeviceId = DeviceId(response.toMap().value("params").toMap().value("deviceId").toString());
QVERIFY(!parentDeviceId.isNull());
// find child device
response = injectAndWait("Devices.GetConfiguredDevices");
QVariantList devices = response.toMap().value("params").toMap().value("devices").toList();
DeviceId childDeviceId;
foreach (const QVariant deviceVariant, devices) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("parentId") == parentDeviceId.toString()) {
//qDebug() << QJsonDocument::fromVariant(deviceVariant).toJson();
childDeviceId = DeviceId(deviceMap.value("id").toString());
}
}
}
QVERIFY2(!childDeviceId.isNull(), "Could not find child device");
// Try to remove the child device
params.clear();
params.insert("deviceId", childDeviceId.toString());
response = injectAndWait("Devices.RemoveConfiguredDevice", params);
verifyDeviceError(response, DeviceManager::DeviceErrorDeviceIsChild);
// check if the child device is still there
response = injectAndWait("Devices.GetConfiguredDevices");
devices = response.toMap().value("params").toMap().value("devices").toList();
bool found = false;
foreach (const QVariant deviceVariant, devices) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("id") == childDeviceId.toString()) {
found = true;
break;
}
}
}
QVERIFY2(found, "Could not find child device.");
// remove the parent device
params.clear();
params.insert("deviceId", parentDeviceId.toString());
response = injectAndWait("Devices.RemoveConfiguredDevice", params);
verifyDeviceError(response);
// check if the child device is still there
response = injectAndWait("Devices.GetConfiguredDevices");
devices = response.toMap().value("params").toMap().value("devices").toList();
found = false;
foreach (const QVariant deviceVariant, devices) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("id") == childDeviceId.toString()) {
found = true;
break;
}
}
}
QVERIFY2(!found, "Could not find child device.");
}
void TestDevices::getActionTypes_data() void TestDevices::getActionTypes_data()
{ {
QTest::addColumn<DeviceClassId>("deviceClassId"); QTest::addColumn<DeviceClassId>("deviceClassId");
@ -947,9 +1022,8 @@ void TestDevices::editByDiscovery()
QVERIFY2(found, "Device missing in config!"); QVERIFY2(found, "Device missing in config!");
QCOMPARE(deviceMap.value("id").toString(), deviceId.toString()); QCOMPARE(deviceMap.value("id").toString(), deviceId.toString());
if (deviceMap.contains("setupComplete")) { if (deviceMap.contains("setupComplete"))
QVERIFY2(deviceMap.value("setupComplete").toBool(), "Setup not completed after edit"); QVERIFY2(deviceMap.value("setupComplete").toBool(), "Setup not completed after edit");
}
// Note: this shows that by discovery a not editable param (name) can be changed! // Note: this shows that by discovery a not editable param (name) can be changed!
foreach (QVariant param, deviceMap.value("params").toList()) { foreach (QVariant param, deviceMap.value("params").toList()) {

138
tests/auto/guhtestbase.cpp
View File

@ -43,6 +43,8 @@ DeviceClassId mockDeviceClassId = DeviceClassId("753f0d32-0468-4d08-82ed-1964aab
DeviceClassId mockDeviceAutoClassId = DeviceClassId("ab4257b3-7548-47ee-9bd4-7dc3004fd197"); DeviceClassId mockDeviceAutoClassId = DeviceClassId("ab4257b3-7548-47ee-9bd4-7dc3004fd197");
DeviceClassId mockPushButtonDeviceClassId = DeviceClassId("9e03144c-e436-4eea-82d9-ccb33ef778db"); DeviceClassId mockPushButtonDeviceClassId = DeviceClassId("9e03144c-e436-4eea-82d9-ccb33ef778db");
DeviceClassId mockDisplayPinDeviceClassId = DeviceClassId("296f1fd4-e893-46b2-8a42-50d1bceb8730"); DeviceClassId mockDisplayPinDeviceClassId = DeviceClassId("296f1fd4-e893-46b2-8a42-50d1bceb8730");
DeviceClassId mockParentDeviceClassId = DeviceClassId("a71fbde9-9a38-4bf8-beab-c8aade2608ba");
DeviceClassId mockChildDeviceClassId = DeviceClassId("40893c9f-bc47-40c1-8bf7-b390c7c1b4fc");
DeviceClassId mockDeviceDiscoveryClassId = DeviceClassId("1bbaf751-36b7-4d3d-b05a-58dab2a3be8c"); DeviceClassId mockDeviceDiscoveryClassId = DeviceClassId("1bbaf751-36b7-4d3d-b05a-58dab2a3be8c");
DeviceClassId mockDeviceAsyncSetupClassId = DeviceClassId("c08a8b27-8200-413d-b96b-4cff78b864d9"); DeviceClassId mockDeviceAsyncSetupClassId = DeviceClassId("c08a8b27-8200-413d-b96b-4cff78b864d9");
DeviceClassId mockDeviceBrokenClassId = DeviceClassId("ba5fb404-c9ce-4db4-8cd4-f48c61c24b13"); DeviceClassId mockDeviceBrokenClassId = DeviceClassId("ba5fb404-c9ce-4db4-8cd4-f48c61c24b13");
@ -174,6 +176,142 @@ QVariant GuhTestBase::checkNotification(const QSignalSpy &spy, const QString &no
return QVariant(); return QVariant();
} }
QVariant GuhTestBase::getAndWait(const QNetworkRequest &request, const int &expectedStatus)
{
QNetworkAccessManager nam;
QSignalSpy clientSpy(&nam, SIGNAL(finished(QNetworkReply*)));
QNetworkReply *reply = nam.get(request);
clientSpy.wait();
if (clientSpy.count() != 1) {
qWarning() << "Got no response for get request";
reply->deleteLater();
return QVariant();
}
QByteArray data = reply->readAll();
verifyReply(reply, data, expectedStatus);
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qWarning() << "JSON parser error" << error.errorString();
return QVariant();
}
return jsonDoc.toVariant();
}
QVariant GuhTestBase::deleteAndWait(const QNetworkRequest &request, const int &expectedStatus)
{
QNetworkAccessManager nam;
QSignalSpy clientSpy(&nam, SIGNAL(finished(QNetworkReply*)));
QNetworkReply *reply = nam.deleteResource(request);
clientSpy.wait();
if (clientSpy.count() != 1) {
qWarning() << "Got no response for delete request";
reply->deleteLater();
return QVariant();
}
QByteArray data = reply->readAll();
verifyReply(reply, data, expectedStatus);
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qWarning() << "JSON parser error" << error.errorString();
return QVariant();
}
return jsonDoc.toVariant();
}
QVariant GuhTestBase::postAndWait(const QNetworkRequest &request, const QVariant &params, const int &expectedStatus)
{
QNetworkAccessManager nam;
QSignalSpy clientSpy(&nam, SIGNAL(finished(QNetworkReply*)));
QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact);
QNetworkReply *reply = nam.post(request, payload);
clientSpy.wait();
if (clientSpy.count() != 1) {
qWarning() << "Got no response for post request";
reply->deleteLater();
return QVariant();
}
QByteArray data = reply->readAll();
verifyReply(reply, data, expectedStatus);
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qWarning() << "JSON parser error" << error.errorString();
return QVariant();
}
return jsonDoc.toVariant();
}
QVariant GuhTestBase::putAndWait(const QNetworkRequest &request, const QVariant &params, const int &expectedStatus)
{
QNetworkAccessManager nam;
QSignalSpy clientSpy(&nam, SIGNAL(finished(QNetworkReply*)));
QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact);
QNetworkReply *reply = nam.put(request, payload);
clientSpy.wait();
if (clientSpy.count() != 1) {
qWarning() << "Got no response for put request";
reply->deleteLater();
return QVariant();
}
QByteArray data = reply->readAll();
verifyReply(reply, data, expectedStatus);
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qWarning() << "JSON parser error" << error.errorString();
return QVariant();
}
return jsonDoc.toVariant();
}
void GuhTestBase::verifyReply(QNetworkReply *reply, const QByteArray &data, const int &expectedStatus)
{
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatus);
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
Q_UNUSED(jsonDoc);
}
bool GuhTestBase::enableNotifications() bool GuhTestBase::enableNotifications()
{ {
QVariantMap notificationParams; QVariantMap notificationParams;

9
tests/auto/guhtestbase.h
View File

@ -38,6 +38,8 @@ extern DeviceClassId mockDeviceClassId;
extern DeviceClassId mockDeviceAutoClassId; extern DeviceClassId mockDeviceAutoClassId;
extern DeviceClassId mockPushButtonDeviceClassId; extern DeviceClassId mockPushButtonDeviceClassId;
extern DeviceClassId mockDisplayPinDeviceClassId; extern DeviceClassId mockDisplayPinDeviceClassId;
extern DeviceClassId mockParentDeviceClassId;
extern DeviceClassId mockChildDeviceClassId;
extern DeviceClassId mockDeviceDiscoveryClassId; extern DeviceClassId mockDeviceDiscoveryClassId;
extern DeviceClassId mockDeviceAsyncSetupClassId; extern DeviceClassId mockDeviceAsyncSetupClassId;
extern DeviceClassId mockDeviceBrokenClassId; extern DeviceClassId mockDeviceBrokenClassId;
@ -70,6 +72,13 @@ protected:
QVariant injectAndWait(const QString &method, const QVariantMap &params = QVariantMap()); QVariant injectAndWait(const QString &method, const QVariantMap &params = QVariantMap());
QVariant checkNotification(const QSignalSpy &spy, const QString &notification); QVariant checkNotification(const QSignalSpy &spy, const QString &notification);
QVariant getAndWait(const QNetworkRequest &request, const int &expectedStatus = 200);
QVariant deleteAndWait(const QNetworkRequest &request, const int &expectedStatus = 200);
QVariant postAndWait(const QNetworkRequest &request, const QVariant &params, const int &expectedStatus = 200);
QVariant putAndWait(const QNetworkRequest &request, const QVariant &params, const int &expectedStatus = 200);
void verifyReply(QNetworkReply *reply, const QByteArray &data, const int &expectedStatus);
bool enableNotifications(); bool enableNotifications();
bool disableNotifications(); bool disableNotifications();

190
tests/auto/restdeviceclasses/testrestdeviceclasses.cpp
View File

@ -58,30 +58,14 @@ private slots:
}; };
#include "testrestdeviceclasses.moc" #include "testrestdeviceclasses.moc"
void TestRestDeviceClasses::getSupportedDevices() void TestRestDeviceClasses::getSupportedDevices()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this); // Get all deviceclasses
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/deviceclasses")));
QVariantList deviceClassesList = response.toList();
// Get all devices QVERIFY2(deviceClassesList.count() > 0, "Not enought deviceclasses.");
QNetworkRequest request;
request.setUrl(QUrl("http://localhost:3333/api/v1/deviceclasses"));
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
QByteArray data = reply->readAll();
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList deviceClassesList = jsonDoc.toVariant().toList();
QVERIFY2(deviceClassesList.count() >= 1, "not enought deviceclasses.");
// Get each of thouse devices individualy // Get each of thouse devices individualy
foreach (const QVariant &deviceClass, deviceClassesList) { foreach (const QVariant &deviceClass, deviceClassesList) {
@ -89,15 +73,10 @@ void TestRestDeviceClasses::getSupportedDevices()
QNetworkRequest request; QNetworkRequest request;
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1").arg(deviceClassMap.value("id").toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1").arg(deviceClassMap.value("id").toString())));
clientSpy.clear();
QNetworkReply *reply = nam->get(request); response = getAndWait(request);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not get device");
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
} }
nam->deleteLater();
} }
void TestRestDeviceClasses::getActionTypes_data() void TestRestDeviceClasses::getActionTypes_data()
@ -105,14 +84,15 @@ void TestRestDeviceClasses::getActionTypes_data()
QTest::addColumn<DeviceClassId>("deviceClassId"); QTest::addColumn<DeviceClassId>("deviceClassId");
QTest::addColumn<ActionTypeId>("actionTypeId"); QTest::addColumn<ActionTypeId>("actionTypeId");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QTest::newRow("all ActionTypes") << mockDeviceClassId << ActionTypeId() << 200; QTest::newRow("all ActionTypes") << mockDeviceClassId << ActionTypeId() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("ActionType async") << mockDeviceClassId << mockActionIdAsync << 200; QTest::newRow("ActionType async") << mockDeviceClassId << mockActionIdAsync << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("ActionType no params") << mockDeviceClassId << mockActionIdNoParams << 200; QTest::newRow("ActionType no params") << mockDeviceClassId << mockActionIdNoParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("ActionType failing") << mockDeviceClassId << mockActionIdFailing << 200; QTest::newRow("ActionType failing") << mockDeviceClassId << mockActionIdFailing << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("ActionType with params") << mockDeviceClassId << mockActionIdWithParams << 200; QTest::newRow("ActionType with params") << mockDeviceClassId << mockActionIdWithParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockActionIdNoParams << 404; QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockActionIdNoParams << 404 << DeviceManager::DeviceErrorDeviceClassNotFound;
QTest::newRow("invalid ActionTypeId") << mockDeviceClassId << ActionTypeId::createActionTypeId() << 404; QTest::newRow("invalid ActionTypeId") << mockDeviceClassId << ActionTypeId::createActionTypeId() << 404 << DeviceManager::DeviceErrorActionTypeNotFound;
} }
void TestRestDeviceClasses::getActionTypes() void TestRestDeviceClasses::getActionTypes()
@ -120,9 +100,7 @@ void TestRestDeviceClasses::getActionTypes()
QFETCH(DeviceClassId, deviceClassId); QFETCH(DeviceClassId, deviceClassId);
QFETCH(ActionTypeId, actionTypeId); QFETCH(ActionTypeId, actionTypeId);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QNetworkRequest request; QNetworkRequest request;
if (!actionTypeId.isNull()) { if (!actionTypeId.isNull()) {
@ -132,12 +110,11 @@ void TestRestDeviceClasses::getActionTypes()
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/actiontypes").arg(deviceClassId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/actiontypes").arg(deviceClassId.toString())));
} }
QNetworkReply *reply = nam->get(request); QVariant response = getAndWait(request, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not read get action type response");
QCOMPARE(clientSpy.count(), 1); if (expectedStatusCode != 200)
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
} }
void TestRestDeviceClasses::getStateTypes_data() void TestRestDeviceClasses::getStateTypes_data()
@ -145,12 +122,13 @@ void TestRestDeviceClasses::getStateTypes_data()
QTest::addColumn<DeviceClassId>("deviceClassId"); QTest::addColumn<DeviceClassId>("deviceClassId");
QTest::addColumn<StateTypeId>("stateTypeId"); QTest::addColumn<StateTypeId>("stateTypeId");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QTest::newRow("all ActionTypes") << mockDeviceClassId << StateTypeId() << 200; QTest::newRow("all ActionTypes") << mockDeviceClassId << StateTypeId() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("StateType bool") << mockDeviceClassId << mockBoolStateId << 200; QTest::newRow("StateType bool") << mockDeviceClassId << mockBoolStateId << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("StateType int") << mockDeviceClassId << mockIntStateId << 200; QTest::newRow("StateType int") << mockDeviceClassId << mockIntStateId << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockBoolStateId << 404; QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockBoolStateId << 404 << DeviceManager::DeviceErrorDeviceClassNotFound;
QTest::newRow("invalid StateTypeId") << mockDeviceClassId << StateTypeId::createStateTypeId() << 404; QTest::newRow("invalid StateTypeId") << mockDeviceClassId << StateTypeId::createStateTypeId() << 404 << DeviceManager::DeviceErrorStateTypeNotFound;
} }
void TestRestDeviceClasses::getStateTypes() void TestRestDeviceClasses::getStateTypes()
@ -158,9 +136,7 @@ void TestRestDeviceClasses::getStateTypes()
QFETCH(DeviceClassId, deviceClassId); QFETCH(DeviceClassId, deviceClassId);
QFETCH(StateTypeId, stateTypeId); QFETCH(StateTypeId, stateTypeId);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QNetworkRequest request; QNetworkRequest request;
if (!stateTypeId.isNull()) { if (!stateTypeId.isNull()) {
@ -170,12 +146,11 @@ void TestRestDeviceClasses::getStateTypes()
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/statetypes").arg(deviceClassId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/statetypes").arg(deviceClassId.toString())));
} }
QNetworkReply *reply = nam->get(request); QVariant response = getAndWait(request, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not read get action type response");
QCOMPARE(clientSpy.count(), 1); if (expectedStatusCode != 200)
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
} }
void TestRestDeviceClasses::getEventTypes_data() void TestRestDeviceClasses::getEventTypes_data()
@ -183,12 +158,13 @@ void TestRestDeviceClasses::getEventTypes_data()
QTest::addColumn<DeviceClassId>("deviceClassId"); QTest::addColumn<DeviceClassId>("deviceClassId");
QTest::addColumn<EventTypeId>("eventTypeId"); QTest::addColumn<EventTypeId>("eventTypeId");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QTest::newRow("all ActionTypes") << mockDeviceClassId << EventTypeId() << 200; QTest::newRow("all ActionTypes") << mockDeviceClassId << EventTypeId() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("EventType 1") << mockDeviceClassId << mockEvent1Id << 200; QTest::newRow("EventType 1") << mockDeviceClassId << mockEvent1Id << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("EventType 2") << mockDeviceClassId << mockEvent2Id << 200; QTest::newRow("EventType 2") << mockDeviceClassId << mockEvent2Id << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockEvent2Id << 404; QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockEvent2Id << 404 << DeviceManager::DeviceErrorDeviceClassNotFound;
QTest::newRow("invalid EventTypeId") << mockDeviceClassId << EventTypeId::createEventTypeId() << 404; QTest::newRow("invalid EventTypeId") << mockDeviceClassId << EventTypeId::createEventTypeId() << 404 << DeviceManager::DeviceErrorEventTypeNotFound;
} }
void TestRestDeviceClasses::getEventTypes() void TestRestDeviceClasses::getEventTypes()
@ -196,9 +172,7 @@ void TestRestDeviceClasses::getEventTypes()
QFETCH(DeviceClassId, deviceClassId); QFETCH(DeviceClassId, deviceClassId);
QFETCH(EventTypeId, eventTypeId); QFETCH(EventTypeId, eventTypeId);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QNetworkRequest request; QNetworkRequest request;
if (!eventTypeId.isNull()) { if (!eventTypeId.isNull()) {
@ -208,12 +182,11 @@ void TestRestDeviceClasses::getEventTypes()
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/eventtypes").arg(deviceClassId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/eventtypes").arg(deviceClassId.toString())));
} }
QNetworkReply *reply = nam->get(request); QVariant response = getAndWait(request, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not read get action type response");
QCOMPARE(clientSpy.count(), 1); if (expectedStatusCode != 200)
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
} }
void TestRestDeviceClasses::discoverDevices_data() void TestRestDeviceClasses::discoverDevices_data()
@ -222,6 +195,7 @@ void TestRestDeviceClasses::discoverDevices_data()
QTest::addColumn<int>("resultCount"); QTest::addColumn<int>("resultCount");
QTest::addColumn<QVariantList>("discoveryParams"); QTest::addColumn<QVariantList>("discoveryParams");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QVariantList discoveryParams; QVariantList discoveryParams;
QVariantMap resultCountParam; QVariantMap resultCountParam;
@ -229,9 +203,9 @@ void TestRestDeviceClasses::discoverDevices_data()
resultCountParam.insert("value", 1); resultCountParam.insert("value", 1);
discoveryParams.append(resultCountParam); discoveryParams.append(resultCountParam);
QTest::newRow("valid deviceClassId without params") << mockDeviceClassId << 2 << QVariantList() << 200; QTest::newRow("valid deviceClassId without params") << mockDeviceClassId << 2 << QVariantList() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("valid deviceClassId with params") << mockDeviceClassId << 1 << discoveryParams << 200; QTest::newRow("valid deviceClassId with params") << mockDeviceClassId << 1 << discoveryParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid deviceClassId") << DeviceClassId::createDeviceClassId() << 0 << QVariantList() << 404; QTest::newRow("invalid deviceClassId") << DeviceClassId::createDeviceClassId() << 0 << QVariantList() << 404 << DeviceManager::DeviceErrorDeviceClassNotFound;
} }
void TestRestDeviceClasses::discoverDevices() void TestRestDeviceClasses::discoverDevices()
@ -240,85 +214,51 @@ void TestRestDeviceClasses::discoverDevices()
QFETCH(int, resultCount); QFETCH(int, resultCount);
QFETCH(QVariantList, discoveryParams); QFETCH(QVariantList, discoveryParams);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
QVariantMap params; QVariantMap params;
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("discoveryParams", discoveryParams); params.insert("discoveryParams", discoveryParams);
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// DISCOVER // DISCOVER
QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
if (!discoveryParams.isEmpty()) { if (!discoveryParams.isEmpty()) {
QUrlQuery query; QUrlQuery query;
query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact));
url.setQuery(query); url.setQuery(query);
} }
QNetworkRequest request(url); QVariant response = getAndWait(QNetworkRequest(url), expectedStatusCode);
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); QVERIFY2(!response.isNull(), "Could not read response");
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
QByteArray data = reply->readAll();
reply->deleteLater();
if (expectedStatusCode != 200) if (expectedStatusCode != 200) {
QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
return; return;
}
// check response // check response
QJsonParseError error; QVariantList foundDevices = response.toList();
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList foundDevices = jsonDoc.toVariant().toList();
QCOMPARE(foundDevices.count(), resultCount); QCOMPARE(foundDevices.count(), resultCount);
//qDebug() << jsonDoc.toJson();
// ADD the discovered device // ADD the discovered device
request.setUrl(QUrl("http://localhost:3333/api/v1/devices")); QNetworkRequest request(QUrl("http://localhost:3333/api/v1/devices"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
DeviceDescriptorId descriptorId = DeviceDescriptorId(foundDevices.first().toMap().value("id").toString()); DeviceDescriptorId descriptorId = DeviceDescriptorId(foundDevices.first().toMap().value("id").toString());
//qDebug() << descriptorId;
params.clear(); params.clear();
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("deviceDescriptorId", descriptorId.toString()); params.insert("deviceDescriptorId", descriptorId.toString());
clientSpy.clear(); response = postAndWait(request, params, expectedStatusCode);
QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); QVERIFY2(!response.isNull(), "Could not read response");
//qDebug() << payload;
reply = nam->post(request, payload);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
data = reply->readAll();
//qDebug() << data;
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
QCOMPARE(statusCode, expectedStatusCode);
jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
QVariantMap response = jsonDoc.toVariant().toMap();
DeviceId deviceId = DeviceId(response.value("id").toString());
QVERIFY2(!deviceId.isNull(), "got invalid device id"); QVERIFY2(!deviceId.isNull(), "got invalid device id");
// REMOVE added device
request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); // REMOVE added device
//qDebug() << request.url().toString(); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
clientSpy.clear(); response = deleteAndWait(request);
reply = nam->deleteResource(request); QVERIFY2(!response.isNull(), "Could not delete device");
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, expectedStatusCode);
nam->deleteLater();
} }
QTEST_MAIN(TestRestDeviceClasses) QTEST_MAIN(TestRestDeviceClasses)

544
tests/auto/restdevices/testrestdevices.cpp
View File

@ -53,6 +53,8 @@ private slots:
void addDisplayPinDevices_data(); void addDisplayPinDevices_data();
void addDisplayPinDevices(); void addDisplayPinDevices();
void parentChildDevices();
void executeAction_data(); void executeAction_data();
void executeAction(); void executeAction();
@ -65,53 +67,23 @@ private slots:
void editByDiscovery_data(); void editByDiscovery_data();
void editByDiscovery(); void editByDiscovery();
private:
// for debugging
void printResponse(QNetworkReply *reply, const QByteArray &data);
}; };
void TestRestDevices::getConfiguredDevices() void TestRestDevices::getConfiguredDevices()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this);
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// Get all devices // Get all devices
QNetworkRequest request; QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/devices")));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); QVERIFY2(!response.isNull(), "Could not get device");
request.setUrl(QUrl("http://localhost:3333/api/v1/devices")); QVariantList deviceList = response.toList();
QNetworkReply *reply;
reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
QByteArray data = reply->readAll();
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList deviceList = jsonDoc.toVariant().toList();
QVERIFY2(deviceList.count() >= 2, "not enought devices."); QVERIFY2(deviceList.count() >= 2, "not enought devices.");
// Get each of thouse devices individualy // Get each of thouse devices individualy
foreach (const QVariant &device, deviceList) { foreach (const QVariant &device, deviceList) {
QVariantMap deviceMap = device.toMap(); QVariantMap deviceMap = device.toMap();
QNetworkRequest request; QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceMap.value("id").toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); response = getAndWait(request);
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceMap.value("id").toString()))); QVERIFY2(!response.isNull(), "Could not get device");
clientSpy.clear();
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
} }
nam->deleteLater();
} }
void TestRestDevices::addConfiguredDevice_data() void TestRestDevices::addConfiguredDevice_data()
@ -179,49 +151,21 @@ void TestRestDevices::addConfiguredDevice()
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("deviceParams", deviceParams); params.insert("deviceParams", deviceParams);
QNetworkAccessManager *nam = new QNetworkAccessManager(); QNetworkRequest request(QUrl("http://localhost:3333/api/v1/devices"));
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// Get all devices
QNetworkRequest request;
request.setUrl(QUrl("http://localhost:3333/api/v1/devices"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); QVariant response = postAndWait(request, params, expectedStatusCode);
qDebug() << "sending" << payload; QVERIFY2(!response.isNull(), "Could not add device");
QNetworkReply *reply = nam->post(request, payload);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
QByteArray data = reply->readAll();
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
if (expectedStatusCode == 200) { if (expectedStatusCode == 200) {
// remove added device // remove added device
QJsonParseError error; DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error); QVERIFY2(!deviceId.isNull(), "invalid device id for removing");
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantMap response = jsonDoc.toVariant().toMap();
DeviceId deviceId = DeviceId(response.value("id").toString()); QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
QVERIFY2(!deviceId.isNull(),"invalid device id for removing"); response = deleteAndWait(deleteRequest);
QVERIFY2(!response.isNull(), "Could not delete device");
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->deleteResource(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, 200);
} }
nam->deleteLater();
} }
void TestRestDevices::addPushButtonDevices_data() void TestRestDevices::addPushButtonDevices_data()
@ -252,31 +196,14 @@ void TestRestDevices::addPushButtonDevices()
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("discoveryParams", discoveryParams); params.insert("discoveryParams", discoveryParams);
QNetworkAccessManager *nam = new QNetworkAccessManager(this); // create URL
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
QUrlQuery query; QUrlQuery query;
query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact));
url.setQuery(query); url.setQuery(query);
clientSpy.clear(); QVariant response = getAndWait(QNetworkRequest(url));
QNetworkRequest request(url); QVariantList foundDevices = response.toList();
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
QByteArray data = reply->readAll();
reply->deleteLater();
// check response
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList foundDevices = jsonDoc.toVariant().toList();
QCOMPARE(foundDevices.count(), 1); QCOMPARE(foundDevices.count(), 1);
DeviceDescriptorId deviceDescriptoId(foundDevices.first().toMap().value("id").toString()); DeviceDescriptorId deviceDescriptoId(foundDevices.first().toMap().value("id").toString());
@ -288,21 +215,12 @@ void TestRestDevices::addPushButtonDevices()
QNetworkRequest pairRequest(QUrl("http://localhost:3333/api/v1/devices/pair")); QNetworkRequest pairRequest(QUrl("http://localhost:3333/api/v1/devices/pair"));
pairRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); pairRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->post(pairRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
data = reply->readAll();
reply->deleteLater();
response = postAndWait(pairRequest, params);
QVERIFY2(!response.isNull(), "Could not pair device");
// check response PairingTransactionId pairingTransactionId(response.toMap().value("pairingTransactionId").toString());
jsonDoc = QJsonDocument::fromJson(data, &error); QString displayMessage = response.toMap().value("displayMessage").toString();
QCOMPARE(error.error, QJsonParseError::NoError);
PairingTransactionId pairingTransactionId(jsonDoc.toVariant().toMap().value("pairingTransactionId").toString());
QString displayMessage = jsonDoc.toVariant().toMap().value("displayMessage").toString();
qDebug() << "displayMessage" << displayMessage; qDebug() << "displayMessage" << displayMessage;
@ -315,32 +233,19 @@ void TestRestDevices::addPushButtonDevices()
QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing")); QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing"));
confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->post(confirmPairingRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); response = postAndWait(confirmPairingRequest, params, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not confirm pairing device");
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
data = reply->readAll();
reply->deleteLater();
if (expectedStatusCode == 200) { if (expectedStatusCode == 200) {
jsonDoc = QJsonDocument::fromJson(data, &error); // remove added device
QCOMPARE(error.error, QJsonParseError::NoError); DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
QVERIFY2(!deviceId.isNull(), "invalid device id for removing");
DeviceId deviceId(jsonDoc.toVariant().toMap().value("id").toString()); QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
// delete it response = deleteAndWait(deleteRequest);
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); QVERIFY2(!response.isNull(), "Could not delete device");
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->deleteResource(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, 200);
} }
nam->deleteLater();
} }
void TestRestDevices::addDisplayPinDevices_data() void TestRestDevices::addDisplayPinDevices_data()
@ -371,31 +276,14 @@ void TestRestDevices::addDisplayPinDevices()
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("discoveryParams", discoveryParams); params.insert("discoveryParams", discoveryParams);
QNetworkAccessManager *nam = new QNetworkAccessManager(this); // create URL
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
QUrlQuery query; QUrlQuery query;
query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact));
url.setQuery(query); url.setQuery(query);
clientSpy.clear(); QVariant response = getAndWait(QNetworkRequest(url));
QNetworkRequest request(url); QVariantList foundDevices = response.toList();
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
QByteArray data = reply->readAll();
reply->deleteLater();
// check response
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList foundDevices = jsonDoc.toVariant().toList();
QCOMPARE(foundDevices.count(), 1); QCOMPARE(foundDevices.count(), 1);
DeviceDescriptorId deviceDescriptoId(foundDevices.first().toMap().value("id").toString()); DeviceDescriptorId deviceDescriptoId(foundDevices.first().toMap().value("id").toString());
@ -407,20 +295,12 @@ void TestRestDevices::addDisplayPinDevices()
QNetworkRequest pairRequest(QUrl("http://localhost:3333/api/v1/devices/pair")); QNetworkRequest pairRequest(QUrl("http://localhost:3333/api/v1/devices/pair"));
pairRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); pairRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->post(pairRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact));
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
data = reply->readAll();
reply->deleteLater();
// check response response = postAndWait(pairRequest, params);
jsonDoc = QJsonDocument::fromJson(data, &error); QVERIFY2(!response.isNull(), "Could not pair device");
QCOMPARE(error.error, QJsonParseError::NoError);
PairingTransactionId pairingTransactionId(jsonDoc.toVariant().toMap().value("pairingTransactionId").toString()); PairingTransactionId pairingTransactionId(response.toMap().value("pairingTransactionId").toString());
QString displayMessage = jsonDoc.toVariant().toMap().value("displayMessage").toString(); QString displayMessage = response.toMap().value("displayMessage").toString();
qDebug() << "displayMessage" << displayMessage; qDebug() << "displayMessage" << displayMessage;
@ -431,32 +311,93 @@ void TestRestDevices::addDisplayPinDevices()
QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing")); QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing"));
confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->post(confirmPairingRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); response = postAndWait(confirmPairingRequest, params, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not confirm pairing device");
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
data = reply->readAll();
reply->deleteLater();
if (expectedStatusCode == 200) { if (expectedStatusCode == 200) {
jsonDoc = QJsonDocument::fromJson(data, &error); // remove added device
QCOMPARE(error.error, QJsonParseError::NoError); DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
QVERIFY2(!deviceId.isNull(), "invalid device id for removing");
DeviceId deviceId(jsonDoc.toVariant().toMap().value("id").toString()); QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
// delete it response = deleteAndWait(deleteRequest);
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); QVERIFY2(!response.isNull(), "Could not delete device");
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->deleteResource(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, 200);
} }
nam->deleteLater(); }
void TestRestDevices::parentChildDevices()
{
// Add parent device
QVariantMap params;
params.insert("deviceClassId", mockParentDeviceClassId);
QVariantMap nameParam;
nameParam.insert("name", "name");
nameParam.insert("value", "Test edit mockdevice");
params.insert("deviceParams", QVariantList() << nameParam);
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices")));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
QVariant response = postAndWait(request, params);
QVERIFY2(!response.isNull(), "Could not read add device response");
DeviceId parentDeviceId = DeviceId(response.toMap().value("id").toString());
QVERIFY2(parentDeviceId != DeviceId(), "DeviceId not returned");
// find child device
response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/devices")));
QVariantList deviceList = response.toList();
DeviceId childDeviceId;
foreach (const QVariant deviceVariant, deviceList) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("parentId") == parentDeviceId.toString()) {
childDeviceId = DeviceId(deviceMap.value("id").toString());
}
}
}
QVERIFY2(!childDeviceId.isNull(), "Could not find child device");
// try to remove child device
QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(childDeviceId.toString())));
response = deleteAndWait(deleteRequest, 400);
QVERIFY2(!response.isNull(), "Could not delete device");
QCOMPARE(JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorDeviceIsChild), response.toMap().value("error").toString());
// check if the child device is still there
response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/devices")));
deviceList = response.toList();
bool found = false;
foreach (const QVariant deviceVariant, deviceList) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("id") == childDeviceId.toString()) {
found = true;
break;
}
}
}
QVERIFY2(found, "Could not find child device.");
// remove the parent device
deleteRequest.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(parentDeviceId.toString())));
response = deleteAndWait(deleteRequest);
QVERIFY2(!response.isNull(), "Could not delete device");
// check if the child device is still there
response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/devices")));
deviceList = response.toList();
found = false;
foreach (const QVariant deviceVariant, deviceList) {
QVariantMap deviceMap = deviceVariant.toMap();
if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) {
if (deviceMap.value("id") == childDeviceId.toString()) {
found = true;
break;
}
}
}
QVERIFY2(!found, "Could not find child device.");
} }
void TestRestDevices::executeAction_data() void TestRestDevices::executeAction_data()
@ -465,6 +406,7 @@ void TestRestDevices::executeAction_data()
QTest::addColumn<ActionTypeId>("actionTypeId"); QTest::addColumn<ActionTypeId>("actionTypeId");
QTest::addColumn<QVariantList>("actionParams"); QTest::addColumn<QVariantList>("actionParams");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QVariantList params; QVariantList params;
QVariantMap param1; QVariantMap param1;
@ -476,13 +418,13 @@ void TestRestDevices::executeAction_data()
param2.insert("value", true); param2.insert("value", true);
params.append(param2); params.append(param2);
QTest::newRow("valid action") << m_mockDeviceId << mockActionIdWithParams << params << 200; QTest::newRow("valid action") << m_mockDeviceId << mockActionIdWithParams << params << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid deviceId") << DeviceId::createDeviceId() << mockActionIdWithParams << params << 404; QTest::newRow("invalid deviceId") << DeviceId::createDeviceId() << mockActionIdWithParams << params << 404 << DeviceManager::DeviceErrorDeviceNotFound;
QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << 404; QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << 404 << DeviceManager::DeviceErrorActionTypeNotFound;
QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << 500; QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << 500 << DeviceManager::DeviceErrorMissingParameter;
QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << 200; QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << 500; QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << 500 << DeviceManager::DeviceErrorSetupFailed;
QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << 500; QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << 500 << DeviceManager::DeviceErrorSetupFailed;
} }
void TestRestDevices::executeAction() void TestRestDevices::executeAction()
@ -491,39 +433,39 @@ void TestRestDevices::executeAction()
QFETCH(ActionTypeId, actionTypeId); QFETCH(ActionTypeId, actionTypeId);
QFETCH(QVariantList, actionParams); QFETCH(QVariantList, actionParams);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
// execute action // execute action
QNetworkAccessManager nam; QVariantMap params;
QSignalSpy spy(&nam, SIGNAL(finished(QNetworkReply*))); params.insert("params", actionParams);
QVariantMap payloadMap;
payloadMap.insert("params", actionParams);
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices/%1/execute/%2").arg(deviceId.toString()).arg(actionTypeId.toString()))); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices/%1/execute/%2").arg(deviceId.toString()).arg(actionTypeId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
spy.clear(); QVariant response = postAndWait(request, params, expectedStatusCode);
QNetworkReply *reply = nam.post(request, QJsonDocument::fromVariant(payloadMap).toJson(QJsonDocument::Compact)); QVERIFY2(!response.isNull(), "Could not read execute action response");
spy.wait(); QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
QCOMPARE(spy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
// Fetch action execution history from mock device // Fetch action execution history from mock device
spy.clear(); QNetworkAccessManager nam;
request = QNetworkRequest(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port))); QSignalSpy spy(&nam, SIGNAL(finished(QNetworkReply*)));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
reply = nam.get(request); request.setUrl(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port)));
QNetworkReply *reply = nam.get(request);
spy.wait(); spy.wait();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QByteArray data = reply->readAll();
reply->deleteLater(); reply->deleteLater();
QByteArray data = reply->readAll();
if (error == DeviceManager::DeviceErrorNoError) {
QVERIFY2(actionTypeId == ActionTypeId(data), QString("ActionTypeId mismatch. Got %1, Expected: %2")
.arg(ActionTypeId(data).toString()).arg(actionTypeId.toString()).toLatin1().data());
} else {
QVERIFY2(data.length() == 0, QString("Data is %1, should be empty.").arg(QString(data)).toLatin1().data());
}
// cleanup for the next run // cleanup for the next run
spy.clear(); spy.clear();
request.setUrl(QUrl(QString("http://localhost:%1/clearactionhistory").arg(m_mockDevice1Port))); request.setUrl(QUrl(QString("http://localhost:%1/clearactionhistory").arg(m_mockDevice1Port)));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
reply = nam.get(request); reply = nam.get(request);
spy.wait(); spy.wait();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
@ -531,12 +473,12 @@ void TestRestDevices::executeAction()
spy.clear(); spy.clear();
request.setUrl(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port))); request.setUrl(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port)));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
reply = nam.get(request); reply = nam.get(request);
spy.wait(); spy.wait();
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
reply->deleteLater(); reply->deleteLater();
data = reply->readAll(); data = reply->readAll();
qDebug() << "cleared data:" << data;
} }
void TestRestDevices::getStateValue_data() void TestRestDevices::getStateValue_data()
@ -548,11 +490,12 @@ void TestRestDevices::getStateValue_data()
QTest::addColumn<DeviceId>("deviceId"); QTest::addColumn<DeviceId>("deviceId");
QTest::addColumn<StateTypeId>("stateTypeId"); QTest::addColumn<StateTypeId>("stateTypeId");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QTest::newRow("existing state") << device->id() << mockIntStateId << 200; QTest::newRow("existing state") << device->id() << mockIntStateId << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("all states") << device->id() << StateTypeId() << 200; QTest::newRow("all states") << device->id() << StateTypeId() << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << 404; QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << 404 << DeviceManager::DeviceErrorDeviceNotFound;
QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << 404; QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << 404 << DeviceManager::DeviceErrorStateTypeNotFound;
} }
void TestRestDevices::getStateValue() void TestRestDevices::getStateValue()
@ -560,9 +503,7 @@ void TestRestDevices::getStateValue()
QFETCH(DeviceId, deviceId); QFETCH(DeviceId, deviceId);
QFETCH(StateTypeId, stateTypeId); QFETCH(StateTypeId, stateTypeId);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QNetworkRequest request; QNetworkRequest request;
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
@ -573,16 +514,11 @@ void TestRestDevices::getStateValue()
// Get all states // Get all states
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1/states").arg(deviceId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1/states").arg(deviceId.toString())));
} }
qDebug() << request.url(); QVariant response = getAndWait(request, expectedStatusCode);
QVERIFY2(!response.isNull(), "Could not read get state value response");
if (expectedStatusCode != 200)
QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
nam->deleteLater();
} }
void TestRestDevices::editDevices_data() void TestRestDevices::editDevices_data()
@ -624,12 +560,13 @@ void TestRestDevices::editDevices_data()
QTest::addColumn<bool>("broken"); QTest::addColumn<bool>("broken");
QTest::addColumn<QVariantList>("newDeviceParams"); QTest::addColumn<QVariantList>("newDeviceParams");
QTest::addColumn<int>("expectedStatusCode"); QTest::addColumn<int>("expectedStatusCode");
QTest::addColumn<DeviceManager::DeviceError>("error");
QTest::newRow("valid - change async param") << false << asyncChangeDeviceParams << 200; QTest::newRow("valid - change async param") << false << asyncChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("valid - change httpport param") << false << httpportChangeDeviceParams << 200; QTest::newRow("valid - change httpport param") << false << httpportChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("valid - change httpport and async param") << false << asyncAndPortChangeDeviceParams << 200; QTest::newRow("valid - change httpport and async param") << false << asyncAndPortChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError;
QTest::newRow("invalid - change name param (not writable)") << false << nameChangedDeviceParams << 500; QTest::newRow("invalid - change name param (not writable)") << false << nameChangedDeviceParams << 500 << DeviceManager::DeviceErrorParameterNotWritable;
QTest::newRow("invalid - change all params (except broken)") << false << changeAllWritableDeviceParams << 500; QTest::newRow("invalid - change all params (except broken)") << false << changeAllWritableDeviceParams << 500 << DeviceManager::DeviceErrorParameterNotWritable;
} }
void TestRestDevices::editDevices() void TestRestDevices::editDevices()
@ -637,6 +574,7 @@ void TestRestDevices::editDevices()
QFETCH(bool, broken); QFETCH(bool, broken);
QFETCH(QVariantList, newDeviceParams); QFETCH(QVariantList, newDeviceParams);
QFETCH(int, expectedStatusCode); QFETCH(int, expectedStatusCode);
QFETCH(DeviceManager::DeviceError, error);
// add device // add device
QVariantMap params; QVariantMap params;
@ -660,29 +598,16 @@ void TestRestDevices::editDevices()
deviceParams.append(httpportParam); deviceParams.append(httpportParam);
params.insert("deviceParams", deviceParams); params.insert("deviceParams", deviceParams);
// add a mockdevice // ADD a mockdevice
QNetworkAccessManager *nam = new QNetworkAccessManager();
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices"))); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices")));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
QNetworkReply *reply = nam->post(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); QVariant response = postAndWait(request, params);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not read add device response");
QCOMPARE(clientSpy.count(), 1);
QByteArray data = reply->readAll(); DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, 200);
QVariantMap responseMap = QJsonDocument::fromJson(data).toVariant().toMap();
DeviceId deviceId = DeviceId(responseMap.value("id").toString());
qDebug() << deviceId.toString();
QVERIFY2(deviceId != DeviceId(), "DeviceId not returned"); QVERIFY2(deviceId != DeviceId(), "DeviceId not returned");
// now EDIT the added device // now EDIT the added device
QVariantMap editParams; QVariantMap editParams;
editParams.insert("deviceId", deviceId); editParams.insert("deviceId", deviceId);
@ -690,43 +615,25 @@ void TestRestDevices::editDevices()
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
reply = nam->put(request, QJsonDocument::fromVariant(editParams).toJson(QJsonDocument::Compact)); response = putAndWait(request, editParams, expectedStatusCode);
clientSpy.wait(); QVERIFY2(!response.isNull(), "Could not read edit device response");
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
// if the edit should have been successfull // if the edit should have been successfull
if (expectedStatusCode == 200) { if (expectedStatusCode == 200) {
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear(); response = getAndWait(request);
reply = nam->get(request); QVariantMap deviceMap = response.toMap();
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QVariantMap deviceMap = QJsonDocument::fromJson(reply->readAll()).toVariant().toMap();
verifyParams(newDeviceParams, deviceMap.value("params").toList(), false); verifyParams(newDeviceParams, deviceMap.value("params").toList(), false);
} else {
QCOMPARE(statusCode, 200); QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString());
reply->deleteLater();
} }
// delete it // delete it
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); response = deleteAndWait(request);
clientSpy.clear(); QVERIFY2(!response.isNull(), "Could not delete device");
reply = nam->deleteResource(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, 200);
nam->deleteLater();
} }
void TestRestDevices::editByDiscovery_data() void TestRestDevices::editByDiscovery_data()
@ -756,9 +663,6 @@ void TestRestDevices::editByDiscovery()
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("discoveryParams", discoveryParams); params.insert("discoveryParams", discoveryParams);
QNetworkAccessManager *nam = new QNetworkAccessManager(this);
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
if (!discoveryParams.isEmpty()) { if (!discoveryParams.isEmpty()) {
@ -767,22 +671,8 @@ void TestRestDevices::editByDiscovery()
url.setQuery(query); url.setQuery(query);
} }
clientSpy.clear();
QNetworkRequest request(url); QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); QVariantList foundDevices = getAndWait(request).toList();
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
QByteArray data = reply->readAll();
reply->deleteLater();
// check response
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList foundDevices = jsonDoc.toVariant().toList();
QCOMPARE(foundDevices.count(), resultCount); QCOMPARE(foundDevices.count(), resultCount);
// add Discovered Device 1 port 55555 // add Discovered Device 1 port 55555
@ -801,46 +691,25 @@ void TestRestDevices::editByDiscovery()
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("deviceDescriptorId", descriptorId1.toString()); params.insert("deviceDescriptorId", descriptorId1.toString());
clientSpy.clear(); QVariant response = postAndWait(request, params, expectedStatusCode);
QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); QVERIFY2(!response.isNull(), "Could not delete device");
reply = nam->post(request, payload);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
data = reply->readAll();
reply->deleteLater();
jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantMap response = jsonDoc.toVariant().toMap();
DeviceId deviceId = DeviceId(response.value("id").toString()); DeviceId deviceId = DeviceId(response.toMap().value("id").toString());
QVERIFY(!deviceId.isNull()); QVERIFY(!deviceId.isNull());
// and now rediscover, and edit the first device with the second // and now rediscover, and edit the first device with the second
params.clear(); params.clear();
params.insert("deviceClassId", deviceClassId); params.insert("deviceClassId", deviceClassId);
params.insert("discoveryParams", discoveryParams); params.insert("discoveryParams", discoveryParams);
clientSpy.clear();
url = QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); url = QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString()));
QUrlQuery query2; QUrlQuery query2;
query2.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); query2.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact));
url.setQuery(query2); url.setQuery(query2);
request = QNetworkRequest(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); response = getAndWait(QNetworkRequest(url), expectedStatusCode);
reply = nam->get(request);
clientSpy.wait(); foundDevices = response.toList();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
data = reply->readAll();
reply->deleteLater();
// check response
jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
foundDevices = jsonDoc.toVariant().toList();
QCOMPARE(foundDevices.count(), resultCount); QCOMPARE(foundDevices.count(), resultCount);
// get the second device // get the second device
@ -864,38 +733,13 @@ void TestRestDevices::editByDiscovery()
request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear(); response = putAndWait(request, params, expectedStatusCode);
payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); QVERIFY2(!response.isNull(), "Could not delete device");
reply = nam->put(request, payload);
clientSpy.wait();
QCOMPARE(clientSpy.count(), 1);
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, expectedStatusCode);
reply->deleteLater();
// remove added device // remove added device
request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString())));
clientSpy.clear(); response = deleteAndWait(request);
reply = nam->deleteResource(request); QVERIFY2(!response.isNull(), "Could not delete device");
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
reply->deleteLater();
QCOMPARE(statusCode, expectedStatusCode);
nam->deleteLater();
}
void TestRestDevices::printResponse(QNetworkReply *reply, const QByteArray &data)
{
qDebug() << "-------------------------------";
qDebug() << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() << reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString();
foreach (const QNetworkReply::RawHeaderPair &headerPair, reply->rawHeaderPairs()) {
qDebug() << headerPair.first << ":" << headerPair.second;
}
qDebug() << "-------------------------------";
qDebug() << data;
qDebug() << "-------------------------------";
} }
#include "testrestdevices.moc" #include "testrestdevices.moc"

61
tests/auto/restplugins/testrestplugins.cpp
View File

@ -52,63 +52,30 @@ private slots:
void TestRestPlugins::getPlugins() void TestRestPlugins::getPlugins()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this);
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// Get all plugins // Get all plugins
QNetworkRequest request; QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/plugins")));
request.setUrl(QUrl("http://localhost:3333/api/v1/plugins")); QVariantList pluginList = response.toList();
QNetworkReply *reply = nam->get(request); QVERIFY2(pluginList.count() > 0, "Not enought plugins.");
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
QByteArray data = reply->readAll(); // Get each of thouse plugins individualy
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList pluginList = jsonDoc.toVariant().toList();
QVERIFY2(pluginList.count() >= 1, "there should be at least one plugin.");
// Get each of thouse devices individualy
foreach (const QVariant &plugin, pluginList) { foreach (const QVariant &plugin, pluginList) {
QVariantMap pluginMap = plugin.toMap(); QVariantMap pluginMap = plugin.toMap();
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1").arg(pluginMap.value("id").toString()))); if (!VendorId(pluginMap.value("id").toString()).isNull()) {
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1").arg(pluginMap.value("id").toString())));
clientSpy.clear(); response = getAndWait(request);
QNetworkReply *reply = nam->get(request); QVERIFY2(!response.isNull(), "Could not get plugin");
clientSpy.wait(); }
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
} }
nam->deleteLater();
} }
void TestRestPlugins::getPluginConfiguration() void TestRestPlugins::getPluginConfiguration()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this); // Get plugin config
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(mockPluginId.toString())));
QVariant response = getAndWait(request);
// Get all plugins QVariantList configurations = response.toList();
QNetworkRequest request; QVERIFY2(configurations.count() == 2, "there should be 2 configurations");
request.setUrl(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(mockPluginId.toString())));
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
QByteArray data = reply->readAll();
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
// QVariantList configurations = jsonDoc.toVariant().toList();
// QVERIFY2(configurations.count() == 2, "there should be 2 configurations");
} }
//void TestRestPlugins::setPluginConfiguration_data() //void TestRestPlugins::setPluginConfiguration_data()

32
tests/auto/restrules/testrestrules.cpp
View File

@ -899,43 +899,19 @@ void TestRestRules::enableDisableRule()
void TestRestRules::getRules() void TestRestRules::getRules()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this);
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// Get all rules // Get all rules
QNetworkRequest request; QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/rules")));
request.setUrl(QUrl("http://localhost:3333/api/v1/rules")); QVariantList rulesList = response.toList();
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
QByteArray data = reply->readAll();
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList rulesList = jsonDoc.toVariant().toList();
QVERIFY2(rulesList.count() == 0, "there should be at least one vendor."); QVERIFY2(rulesList.count() == 0, "there should be at least one vendor.");
// Get each of thouse rules individualy
foreach (const QVariant &rule, rulesList) { foreach (const QVariant &rule, rulesList) {
QVariantMap ruleMap = rule.toMap(); QVariantMap ruleMap = rule.toMap();
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleMap.value("id").toString()))); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleMap.value("id").toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json");
clientSpy.clear();
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
response = getAndWait(request);
QVERIFY2(!response.isNull(), "Could not get rule");
} }
nam->deleteLater();
} }

35
tests/auto/restvendors/testrestvendors.cpp
View File

@ -47,45 +47,20 @@ private slots:
void TestRestVendors::getVendors() void TestRestVendors::getVendors()
{ {
QNetworkAccessManager *nam = new QNetworkAccessManager(this);
QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*)));
// Get all vendors // Get all vendors
QNetworkRequest request; QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/vendors")));
request.setUrl(QUrl("http://localhost:3333/api/v1/vendors")); QVariantList vendorList = response.toList();
QNetworkReply *reply = nam->get(request); QVERIFY2(vendorList.count() > 0, "Not enought vendors.");
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
QByteArray data = reply->readAll();
reply->deleteLater();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
QCOMPARE(error.error, QJsonParseError::NoError);
QVariantList vendorList = jsonDoc.toVariant().toList();
QVERIFY2(vendorList.count() >= 1, "there should be at least one vendor.");
// Get each of thouse vendors individualy // Get each of thouse vendors individualy
foreach (const QVariant &vendor, vendorList) { foreach (const QVariant &vendor, vendorList) {
QVariantMap vendorMap = vendor.toMap(); QVariantMap vendorMap = vendor.toMap();
if (!VendorId(vendorMap.value("id").toString()).isNull()) { if (!VendorId(vendorMap.value("id").toString()).isNull()) {
QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/vendors/%1").arg(vendorMap.value("id").toString()))); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/vendors/%1").arg(vendorMap.value("id").toString())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); response = getAndWait(request);
clientSpy.clear(); QVERIFY2(!response.isNull(), "Could not get vendor");
QNetworkReply *reply = nam->get(request);
clientSpy.wait();
QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver");
int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
QCOMPARE(statusCode, 200);
jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
reply->deleteLater();
} }
} }
nam->deleteLater();
} }