From aa5cba818971a772af4ca660b5aad79e14e68c3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Simon=20St=C3=BCrz?= Date: Tue, 8 Dec 2015 16:56:13 +0100 Subject: [PATCH] add rest methods for testing update rest tests with new methods --- tests/auto/devices/testdevices.cpp | 78 ++- tests/auto/guhtestbase.cpp | 138 +++++ tests/auto/guhtestbase.h | 9 + .../testrestdeviceclasses.cpp | 190 +++--- tests/auto/restdevices/testrestdevices.cpp | 544 +++++++----------- tests/auto/restplugins/testrestplugins.cpp | 61 +- tests/auto/restrules/testrestrules.cpp | 32 +- tests/auto/restvendors/testrestvendors.cpp | 35 +- 8 files changed, 505 insertions(+), 582 deletions(-) diff --git a/tests/auto/devices/testdevices.cpp b/tests/auto/devices/testdevices.cpp index b9eb236a..34d43540 100644 --- a/tests/auto/devices/testdevices.cpp +++ b/tests/auto/devices/testdevices.cpp @@ -67,6 +67,8 @@ private slots: void addDisplayPinDevices_data(); void addDisplayPinDevices(); + void parentChildDevices(); + void getActionTypes_data(); 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() { QTest::addColumn("deviceClassId"); @@ -947,9 +1022,8 @@ void TestDevices::editByDiscovery() QVERIFY2(found, "Device missing in config!"); 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"); - } // Note: this shows that by discovery a not editable param (name) can be changed! foreach (QVariant param, deviceMap.value("params").toList()) { diff --git a/tests/auto/guhtestbase.cpp b/tests/auto/guhtestbase.cpp index 5102f3fb..a7425e44 100644 --- a/tests/auto/guhtestbase.cpp +++ b/tests/auto/guhtestbase.cpp @@ -43,6 +43,8 @@ DeviceClassId mockDeviceClassId = DeviceClassId("753f0d32-0468-4d08-82ed-1964aab DeviceClassId mockDeviceAutoClassId = DeviceClassId("ab4257b3-7548-47ee-9bd4-7dc3004fd197"); DeviceClassId mockPushButtonDeviceClassId = DeviceClassId("9e03144c-e436-4eea-82d9-ccb33ef778db"); 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 mockDeviceAsyncSetupClassId = DeviceClassId("c08a8b27-8200-413d-b96b-4cff78b864d9"); DeviceClassId mockDeviceBrokenClassId = DeviceClassId("ba5fb404-c9ce-4db4-8cd4-f48c61c24b13"); @@ -174,6 +176,142 @@ QVariant GuhTestBase::checkNotification(const QSignalSpy &spy, const QString &no 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 ¶ms, 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 ¶ms, 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() { QVariantMap notificationParams; diff --git a/tests/auto/guhtestbase.h b/tests/auto/guhtestbase.h index 1902e63c..026bd075 100644 --- a/tests/auto/guhtestbase.h +++ b/tests/auto/guhtestbase.h @@ -38,6 +38,8 @@ extern DeviceClassId mockDeviceClassId; extern DeviceClassId mockDeviceAutoClassId; extern DeviceClassId mockPushButtonDeviceClassId; extern DeviceClassId mockDisplayPinDeviceClassId; +extern DeviceClassId mockParentDeviceClassId; +extern DeviceClassId mockChildDeviceClassId; extern DeviceClassId mockDeviceDiscoveryClassId; extern DeviceClassId mockDeviceAsyncSetupClassId; extern DeviceClassId mockDeviceBrokenClassId; @@ -70,6 +72,13 @@ protected: QVariant injectAndWait(const QString &method, const QVariantMap ¶ms = QVariantMap()); QVariant checkNotification(const QSignalSpy &spy, const QString ¬ification); + 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 ¶ms, const int &expectedStatus = 200); + QVariant putAndWait(const QNetworkRequest &request, const QVariant ¶ms, const int &expectedStatus = 200); + + void verifyReply(QNetworkReply *reply, const QByteArray &data, const int &expectedStatus); + bool enableNotifications(); bool disableNotifications(); diff --git a/tests/auto/restdeviceclasses/testrestdeviceclasses.cpp b/tests/auto/restdeviceclasses/testrestdeviceclasses.cpp index f1df29a9..63780917 100644 --- a/tests/auto/restdeviceclasses/testrestdeviceclasses.cpp +++ b/tests/auto/restdeviceclasses/testrestdeviceclasses.cpp @@ -58,30 +58,14 @@ private slots: }; - - #include "testrestdeviceclasses.moc" - void TestRestDeviceClasses::getSupportedDevices() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - - // Get all devices - 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 all deviceclasses + QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/deviceclasses"))); + QVariantList deviceClassesList = response.toList(); + QVERIFY2(deviceClassesList.count() > 0, "Not enought deviceclasses."); // Get each of thouse devices individualy foreach (const QVariant &deviceClass, deviceClassesList) { @@ -89,15 +73,10 @@ void TestRestDeviceClasses::getSupportedDevices() QNetworkRequest request; request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); request.setUrl(QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1").arg(deviceClassMap.value("id").toString()))); - 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(); + + response = getAndWait(request); + QVERIFY2(!response.isNull(), "Could not get device"); } - nam->deleteLater(); } void TestRestDeviceClasses::getActionTypes_data() @@ -105,14 +84,15 @@ void TestRestDeviceClasses::getActionTypes_data() QTest::addColumn("deviceClassId"); QTest::addColumn("actionTypeId"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); - QTest::newRow("all ActionTypes") << mockDeviceClassId << ActionTypeId() << 200; - QTest::newRow("ActionType async") << mockDeviceClassId << mockActionIdAsync << 200; - QTest::newRow("ActionType no params") << mockDeviceClassId << mockActionIdNoParams << 200; - QTest::newRow("ActionType failing") << mockDeviceClassId << mockActionIdFailing << 200; - QTest::newRow("ActionType with params") << mockDeviceClassId << mockActionIdWithParams << 200; - QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockActionIdNoParams << 404; - QTest::newRow("invalid ActionTypeId") << mockDeviceClassId << ActionTypeId::createActionTypeId() << 404; + QTest::newRow("all ActionTypes") << mockDeviceClassId << ActionTypeId() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("ActionType async") << mockDeviceClassId << mockActionIdAsync << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("ActionType no params") << mockDeviceClassId << mockActionIdNoParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("ActionType failing") << mockDeviceClassId << mockActionIdFailing << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("ActionType with params") << mockDeviceClassId << mockActionIdWithParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockActionIdNoParams << 404 << DeviceManager::DeviceErrorDeviceClassNotFound; + QTest::newRow("invalid ActionTypeId") << mockDeviceClassId << ActionTypeId::createActionTypeId() << 404 << DeviceManager::DeviceErrorActionTypeNotFound; } void TestRestDeviceClasses::getActionTypes() @@ -120,9 +100,7 @@ void TestRestDeviceClasses::getActionTypes() QFETCH(DeviceClassId, deviceClassId); QFETCH(ActionTypeId, actionTypeId); QFETCH(int, expectedStatusCode); - - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); + QFETCH(DeviceManager::DeviceError, error); QNetworkRequest request; 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()))); } - QNetworkReply *reply = nam->get(request); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + QVariant response = getAndWait(request, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read get action type response"); + if (expectedStatusCode != 200) + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); + } void TestRestDeviceClasses::getStateTypes_data() @@ -145,12 +122,13 @@ void TestRestDeviceClasses::getStateTypes_data() QTest::addColumn("deviceClassId"); QTest::addColumn("stateTypeId"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); - QTest::newRow("all ActionTypes") << mockDeviceClassId << StateTypeId() << 200; - QTest::newRow("StateType bool") << mockDeviceClassId << mockBoolStateId << 200; - QTest::newRow("StateType int") << mockDeviceClassId << mockIntStateId << 200; - QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockBoolStateId << 404; - QTest::newRow("invalid StateTypeId") << mockDeviceClassId << StateTypeId::createStateTypeId() << 404; + QTest::newRow("all ActionTypes") << mockDeviceClassId << StateTypeId() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("StateType bool") << mockDeviceClassId << mockBoolStateId << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("StateType int") << mockDeviceClassId << mockIntStateId << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockBoolStateId << 404 << DeviceManager::DeviceErrorDeviceClassNotFound; + QTest::newRow("invalid StateTypeId") << mockDeviceClassId << StateTypeId::createStateTypeId() << 404 << DeviceManager::DeviceErrorStateTypeNotFound; } void TestRestDeviceClasses::getStateTypes() @@ -158,9 +136,7 @@ void TestRestDeviceClasses::getStateTypes() QFETCH(DeviceClassId, deviceClassId); QFETCH(StateTypeId, stateTypeId); QFETCH(int, expectedStatusCode); - - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); + QFETCH(DeviceManager::DeviceError, error); QNetworkRequest request; 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()))); } - QNetworkReply *reply = nam->get(request); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + QVariant response = getAndWait(request, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read get action type response"); + if (expectedStatusCode != 200) + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); + } void TestRestDeviceClasses::getEventTypes_data() @@ -183,12 +158,13 @@ void TestRestDeviceClasses::getEventTypes_data() QTest::addColumn("deviceClassId"); QTest::addColumn("eventTypeId"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); - QTest::newRow("all ActionTypes") << mockDeviceClassId << EventTypeId() << 200; - QTest::newRow("EventType 1") << mockDeviceClassId << mockEvent1Id << 200; - QTest::newRow("EventType 2") << mockDeviceClassId << mockEvent2Id << 200; - QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockEvent2Id << 404; - QTest::newRow("invalid EventTypeId") << mockDeviceClassId << EventTypeId::createEventTypeId() << 404; + QTest::newRow("all ActionTypes") << mockDeviceClassId << EventTypeId() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("EventType 1") << mockDeviceClassId << mockEvent1Id << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("EventType 2") << mockDeviceClassId << mockEvent2Id << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << mockEvent2Id << 404 << DeviceManager::DeviceErrorDeviceClassNotFound; + QTest::newRow("invalid EventTypeId") << mockDeviceClassId << EventTypeId::createEventTypeId() << 404 << DeviceManager::DeviceErrorEventTypeNotFound; } void TestRestDeviceClasses::getEventTypes() @@ -196,9 +172,7 @@ void TestRestDeviceClasses::getEventTypes() QFETCH(DeviceClassId, deviceClassId); QFETCH(EventTypeId, eventTypeId); QFETCH(int, expectedStatusCode); - - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); + QFETCH(DeviceManager::DeviceError, error); QNetworkRequest request; 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()))); } - QNetworkReply *reply = nam->get(request); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + QVariant response = getAndWait(request, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read get action type response"); + if (expectedStatusCode != 200) + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); + } void TestRestDeviceClasses::discoverDevices_data() @@ -222,6 +195,7 @@ void TestRestDeviceClasses::discoverDevices_data() QTest::addColumn("resultCount"); QTest::addColumn("discoveryParams"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); QVariantList discoveryParams; QVariantMap resultCountParam; @@ -229,9 +203,9 @@ void TestRestDeviceClasses::discoverDevices_data() resultCountParam.insert("value", 1); discoveryParams.append(resultCountParam); - QTest::newRow("valid deviceClassId without params") << mockDeviceClassId << 2 << QVariantList() << 200; - QTest::newRow("valid deviceClassId with params") << mockDeviceClassId << 1 << discoveryParams << 200; - QTest::newRow("invalid deviceClassId") << DeviceClassId::createDeviceClassId() << 0 << QVariantList() << 404; + QTest::newRow("valid deviceClassId without params") << mockDeviceClassId << 2 << QVariantList() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("valid deviceClassId with params") << mockDeviceClassId << 1 << discoveryParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid deviceClassId") << DeviceClassId::createDeviceClassId() << 0 << QVariantList() << 404 << DeviceManager::DeviceErrorDeviceClassNotFound; } void TestRestDeviceClasses::discoverDevices() @@ -240,85 +214,51 @@ void TestRestDeviceClasses::discoverDevices() QFETCH(int, resultCount); QFETCH(QVariantList, discoveryParams); QFETCH(int, expectedStatusCode); + QFETCH(DeviceManager::DeviceError, error); QVariantMap params; params.insert("deviceClassId", deviceClassId); params.insert("discoveryParams", discoveryParams); - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - // DISCOVER QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); - if (!discoveryParams.isEmpty()) { QUrlQuery query; query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); url.setQuery(query); } - QNetworkRequest request(url); - 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, expectedStatusCode); - QByteArray data = reply->readAll(); - reply->deleteLater(); + QVariant response = getAndWait(QNetworkRequest(url), expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read response"); - if (expectedStatusCode != 200) + if (expectedStatusCode != 200) { + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); return; + } // check response - QJsonParseError error; - QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); - QVariantList foundDevices = jsonDoc.toVariant().toList(); + QVariantList foundDevices = response.toList(); QCOMPARE(foundDevices.count(), resultCount); - //qDebug() << jsonDoc.toJson(); - // 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"); DeviceDescriptorId descriptorId = DeviceDescriptorId(foundDevices.first().toMap().value("id").toString()); - //qDebug() << descriptorId; + params.clear(); params.insert("deviceClassId", deviceClassId); params.insert("deviceDescriptorId", descriptorId.toString()); - clientSpy.clear(); - QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); - //qDebug() << payload; - reply = nam->post(request, payload); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - data = reply->readAll(); - //qDebug() << data; + response = postAndWait(request, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read response"); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - 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()); + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); QVERIFY2(!deviceId.isNull(), "got invalid device id"); - // REMOVE added device - request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); - //qDebug() << request.url().toString(); - 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, expectedStatusCode); - nam->deleteLater(); + // REMOVE added device + request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); + response = deleteAndWait(request); + QVERIFY2(!response.isNull(), "Could not delete device"); } QTEST_MAIN(TestRestDeviceClasses) diff --git a/tests/auto/restdevices/testrestdevices.cpp b/tests/auto/restdevices/testrestdevices.cpp index e02a1cfb..7f24f568 100644 --- a/tests/auto/restdevices/testrestdevices.cpp +++ b/tests/auto/restdevices/testrestdevices.cpp @@ -53,6 +53,8 @@ private slots: void addDisplayPinDevices_data(); void addDisplayPinDevices(); + void parentChildDevices(); + void executeAction_data(); void executeAction(); @@ -65,53 +67,23 @@ private slots: void editByDiscovery_data(); void editByDiscovery(); -private: - // for debugging - void printResponse(QNetworkReply *reply, const QByteArray &data); - }; void TestRestDevices::getConfiguredDevices() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - // Get all devices - QNetworkRequest request; - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - request.setUrl(QUrl("http://localhost:3333/api/v1/devices")); - 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(); + QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/devices"))); + QVERIFY2(!response.isNull(), "Could not get device"); + QVariantList deviceList = response.toList(); QVERIFY2(deviceList.count() >= 2, "not enought devices."); // Get each of thouse devices individualy foreach (const QVariant &device, deviceList) { QVariantMap deviceMap = device.toMap(); - QNetworkRequest request; - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceMap.value("id").toString()))); - 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(); + QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceMap.value("id").toString()))); + response = getAndWait(request); + QVERIFY2(!response.isNull(), "Could not get device"); } - nam->deleteLater(); } void TestRestDevices::addConfiguredDevice_data() @@ -179,49 +151,21 @@ void TestRestDevices::addConfiguredDevice() params.insert("deviceClassId", deviceClassId); params.insert("deviceParams", deviceParams); - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - - // Get all devices - QNetworkRequest request; - request.setUrl(QUrl("http://localhost:3333/api/v1/devices")); + QNetworkRequest request(QUrl("http://localhost:3333/api/v1/devices")); request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); - QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); - qDebug() << "sending" << payload; - - 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(); + QVariant response = postAndWait(request, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not add device"); if (expectedStatusCode == 200) { // remove added device - QJsonParseError error; - QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); - QVariantMap response = jsonDoc.toVariant().toMap(); + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); + QVERIFY2(!deviceId.isNull(), "invalid device id for removing"); - DeviceId deviceId = DeviceId(response.value("id").toString()); - QVERIFY2(!deviceId.isNull(),"invalid device id for removing"); - - 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); + QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); + response = deleteAndWait(deleteRequest); + QVERIFY2(!response.isNull(), "Could not delete device"); } - nam->deleteLater(); } void TestRestDevices::addPushButtonDevices_data() @@ -252,31 +196,14 @@ void TestRestDevices::addPushButtonDevices() params.insert("deviceClassId", deviceClassId); params.insert("discoveryParams", discoveryParams); - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - + // create URL QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); - QUrlQuery query; query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); url.setQuery(query); - clientSpy.clear(); - QNetworkRequest request(url); - 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(); + QVariant response = getAndWait(QNetworkRequest(url)); + QVariantList foundDevices = response.toList(); QCOMPARE(foundDevices.count(), 1); 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")); 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 - jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); - PairingTransactionId pairingTransactionId(jsonDoc.toVariant().toMap().value("pairingTransactionId").toString()); - QString displayMessage = jsonDoc.toVariant().toMap().value("displayMessage").toString(); + PairingTransactionId pairingTransactionId(response.toMap().value("pairingTransactionId").toString()); + QString displayMessage = response.toMap().value("displayMessage").toString(); qDebug() << "displayMessage" << displayMessage; @@ -315,32 +233,19 @@ void TestRestDevices::addPushButtonDevices() QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing")); confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - clientSpy.clear(); - reply = nam->post(confirmPairingRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - data = reply->readAll(); - reply->deleteLater(); + + response = postAndWait(confirmPairingRequest, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not confirm pairing device"); if (expectedStatusCode == 200) { - jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); + // remove added device + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); + QVERIFY2(!deviceId.isNull(), "invalid device id for removing"); - DeviceId deviceId(jsonDoc.toVariant().toMap().value("id").toString()); - // delete it - 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(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - reply->deleteLater(); - QCOMPARE(statusCode, 200); + QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); + response = deleteAndWait(deleteRequest); + QVERIFY2(!response.isNull(), "Could not delete device"); } - nam->deleteLater(); } void TestRestDevices::addDisplayPinDevices_data() @@ -371,31 +276,14 @@ void TestRestDevices::addDisplayPinDevices() params.insert("deviceClassId", deviceClassId); params.insert("discoveryParams", discoveryParams); - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - + // create URL QUrl url(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); - QUrlQuery query; query.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); url.setQuery(query); - clientSpy.clear(); - QNetworkRequest request(url); - 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(); + QVariant response = getAndWait(QNetworkRequest(url)); + QVariantList foundDevices = response.toList(); QCOMPARE(foundDevices.count(), 1); 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")); 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 - jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); - PairingTransactionId pairingTransactionId(jsonDoc.toVariant().toMap().value("pairingTransactionId").toString()); - QString displayMessage = jsonDoc.toVariant().toMap().value("displayMessage").toString(); + response = postAndWait(pairRequest, params); + QVERIFY2(!response.isNull(), "Could not pair device"); + + PairingTransactionId pairingTransactionId(response.toMap().value("pairingTransactionId").toString()); + QString displayMessage = response.toMap().value("displayMessage").toString(); qDebug() << "displayMessage" << displayMessage; @@ -431,32 +311,93 @@ void TestRestDevices::addDisplayPinDevices() QNetworkRequest confirmPairingRequest(QUrl("http://localhost:3333/api/v1/devices/confirmpairing")); confirmPairingRequest.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - clientSpy.clear(); - reply = nam->post(confirmPairingRequest, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - data = reply->readAll(); - reply->deleteLater(); + + response = postAndWait(confirmPairingRequest, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not confirm pairing device"); if (expectedStatusCode == 200) { - jsonDoc = QJsonDocument::fromJson(data, &error); - QCOMPARE(error.error, QJsonParseError::NoError); + // remove added device + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); + QVERIFY2(!deviceId.isNull(), "invalid device id for removing"); - DeviceId deviceId(jsonDoc.toVariant().toMap().value("id").toString()); - // delete it - 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(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - reply->deleteLater(); - QCOMPARE(statusCode, 200); + QNetworkRequest deleteRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); + response = deleteAndWait(deleteRequest); + QVERIFY2(!response.isNull(), "Could not delete device"); } - 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() @@ -465,6 +406,7 @@ void TestRestDevices::executeAction_data() QTest::addColumn("actionTypeId"); QTest::addColumn("actionParams"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); QVariantList params; QVariantMap param1; @@ -476,13 +418,13 @@ void TestRestDevices::executeAction_data() param2.insert("value", true); params.append(param2); - QTest::newRow("valid action") << m_mockDeviceId << mockActionIdWithParams << params << 200; - QTest::newRow("invalid deviceId") << DeviceId::createDeviceId() << mockActionIdWithParams << params << 404; - QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << 404; - QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << 500; - QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << 200; - QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << 500; - QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << 500; + QTest::newRow("valid action") << m_mockDeviceId << mockActionIdWithParams << params << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid deviceId") << DeviceId::createDeviceId() << mockActionIdWithParams << params << 404 << DeviceManager::DeviceErrorDeviceNotFound; + QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << 404 << DeviceManager::DeviceErrorActionTypeNotFound; + QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << 500 << DeviceManager::DeviceErrorMissingParameter; + QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << 500 << DeviceManager::DeviceErrorSetupFailed; + QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << 500 << DeviceManager::DeviceErrorSetupFailed; } void TestRestDevices::executeAction() @@ -491,39 +433,39 @@ void TestRestDevices::executeAction() QFETCH(ActionTypeId, actionTypeId); QFETCH(QVariantList, actionParams); QFETCH(int, expectedStatusCode); + QFETCH(DeviceManager::DeviceError, error); // execute action - QNetworkAccessManager nam; - QSignalSpy spy(&nam, SIGNAL(finished(QNetworkReply*))); - - QVariantMap payloadMap; - payloadMap.insert("params", actionParams); + QVariantMap params; + params.insert("params", actionParams); 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"); - spy.clear(); - QNetworkReply *reply = nam.post(request, QJsonDocument::fromVariant(payloadMap).toJson(QJsonDocument::Compact)); - spy.wait(); - QCOMPARE(spy.count(), 1); - - int statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + QVariant response = postAndWait(request, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read execute action response"); + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); // Fetch action execution history from mock device - spy.clear(); - request = QNetworkRequest(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port))); - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - reply = nam.get(request); + QNetworkAccessManager nam; + QSignalSpy spy(&nam, SIGNAL(finished(QNetworkReply*))); + + request.setUrl(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port))); + QNetworkReply *reply = nam.get(request); spy.wait(); QCOMPARE(spy.count(), 1); - QByteArray data = reply->readAll(); 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 spy.clear(); request.setUrl(QUrl(QString("http://localhost:%1/clearactionhistory").arg(m_mockDevice1Port))); - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); reply = nam.get(request); spy.wait(); QCOMPARE(spy.count(), 1); @@ -531,12 +473,12 @@ void TestRestDevices::executeAction() spy.clear(); request.setUrl(QUrl(QString("http://localhost:%1/actionhistory").arg(m_mockDevice1Port))); - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); reply = nam.get(request); spy.wait(); QCOMPARE(spy.count(), 1); reply->deleteLater(); data = reply->readAll(); + qDebug() << "cleared data:" << data; } void TestRestDevices::getStateValue_data() @@ -548,11 +490,12 @@ void TestRestDevices::getStateValue_data() QTest::addColumn("deviceId"); QTest::addColumn("stateTypeId"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); - QTest::newRow("existing state") << device->id() << mockIntStateId << 200; - QTest::newRow("all states") << device->id() << StateTypeId() << 200; - QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << 404; - QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << 404; + QTest::newRow("existing state") << device->id() << mockIntStateId << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("all states") << device->id() << StateTypeId() << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << 404 << DeviceManager::DeviceErrorDeviceNotFound; + QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << 404 << DeviceManager::DeviceErrorStateTypeNotFound; } void TestRestDevices::getStateValue() @@ -560,9 +503,7 @@ void TestRestDevices::getStateValue() QFETCH(DeviceId, deviceId); QFETCH(StateTypeId, stateTypeId); QFETCH(int, expectedStatusCode); - - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); + QFETCH(DeviceManager::DeviceError, error); QNetworkRequest request; request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); @@ -573,16 +514,11 @@ void TestRestDevices::getStateValue() // Get all states 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() @@ -624,12 +560,13 @@ void TestRestDevices::editDevices_data() QTest::addColumn("broken"); QTest::addColumn("newDeviceParams"); QTest::addColumn("expectedStatusCode"); + QTest::addColumn("error"); - QTest::newRow("valid - change async param") << false << asyncChangeDeviceParams << 200; - QTest::newRow("valid - change httpport param") << false << httpportChangeDeviceParams << 200; - QTest::newRow("valid - change httpport and async param") << false << asyncAndPortChangeDeviceParams << 200; - QTest::newRow("invalid - change name param (not writable)") << false << nameChangedDeviceParams << 500; - QTest::newRow("invalid - change all params (except broken)") << false << changeAllWritableDeviceParams << 500; + QTest::newRow("valid - change async param") << false << asyncChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("valid - change httpport param") << false << httpportChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("valid - change httpport and async param") << false << asyncAndPortChangeDeviceParams << 200 << DeviceManager::DeviceErrorNoError; + QTest::newRow("invalid - change name param (not writable)") << false << nameChangedDeviceParams << 500 << DeviceManager::DeviceErrorParameterNotWritable; + QTest::newRow("invalid - change all params (except broken)") << false << changeAllWritableDeviceParams << 500 << DeviceManager::DeviceErrorParameterNotWritable; } void TestRestDevices::editDevices() @@ -637,6 +574,7 @@ void TestRestDevices::editDevices() QFETCH(bool, broken); QFETCH(QVariantList, newDeviceParams); QFETCH(int, expectedStatusCode); + QFETCH(DeviceManager::DeviceError, error); // add device QVariantMap params; @@ -660,29 +598,16 @@ void TestRestDevices::editDevices() deviceParams.append(httpportParam); params.insert("deviceParams", deviceParams); - // add a mockdevice - QNetworkAccessManager *nam = new QNetworkAccessManager(); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - + // ADD a mockdevice QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/devices"))); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - QNetworkReply *reply = nam->post(request, QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact)); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); + QVariant response = postAndWait(request, params); + QVERIFY2(!response.isNull(), "Could not read add device response"); - QByteArray data = reply->readAll(); - 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(); + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); QVERIFY2(deviceId != DeviceId(), "DeviceId not returned"); - // now EDIT the added device QVariantMap editParams; 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.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - clientSpy.clear(); - reply = nam->put(request, QJsonDocument::fromVariant(editParams).toJson(QJsonDocument::Compact)); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + + response = putAndWait(request, editParams, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not read edit device response"); // if the edit should have been successfull if (expectedStatusCode == 200) { request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - clientSpy.clear(); - reply = nam->get(request); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - - QVariantMap deviceMap = QJsonDocument::fromJson(reply->readAll()).toVariant().toMap(); - + response = getAndWait(request); + QVariantMap deviceMap = response.toMap(); verifyParams(newDeviceParams, deviceMap.value("params").toList(), false); - - QCOMPARE(statusCode, 200); - reply->deleteLater(); + } else { + QCOMPARE(JsonTypes::deviceErrorToString(error), response.toMap().value("error").toString()); } // delete it 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(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - reply->deleteLater(); - QCOMPARE(statusCode, 200); - nam->deleteLater(); + response = deleteAndWait(request); + QVERIFY2(!response.isNull(), "Could not delete device"); } void TestRestDevices::editByDiscovery_data() @@ -756,9 +663,6 @@ void TestRestDevices::editByDiscovery() params.insert("deviceClassId", deviceClassId); 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())); if (!discoveryParams.isEmpty()) { @@ -767,22 +671,8 @@ void TestRestDevices::editByDiscovery() url.setQuery(query); } - clientSpy.clear(); QNetworkRequest request(url); - 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, 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(); + QVariantList foundDevices = getAndWait(request).toList(); QCOMPARE(foundDevices.count(), resultCount); // add Discovered Device 1 port 55555 @@ -801,46 +691,25 @@ void TestRestDevices::editByDiscovery() params.insert("deviceClassId", deviceClassId); params.insert("deviceDescriptorId", descriptorId1.toString()); - clientSpy.clear(); - QByteArray payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); - 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(); + QVariant response = postAndWait(request, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not delete device"); - DeviceId deviceId = DeviceId(response.value("id").toString()); + DeviceId deviceId = DeviceId(response.toMap().value("id").toString()); QVERIFY(!deviceId.isNull()); - // and now rediscover, and edit the first device with the second params.clear(); params.insert("deviceClassId", deviceClassId); params.insert("discoveryParams", discoveryParams); - clientSpy.clear(); url = QUrl(QString("http://localhost:3333/api/v1/deviceclasses/%1/discover").arg(deviceClassId.toString())); QUrlQuery query2; query2.addQueryItem("params", QJsonDocument::fromVariant(discoveryParams).toJson(QJsonDocument::Compact)); url.setQuery(query2); - request = QNetworkRequest(url); - request.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - reply = nam->get(request); - clientSpy.wait(); - 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(); + + response = getAndWait(QNetworkRequest(url), expectedStatusCode); + + foundDevices = response.toList(); QCOMPARE(foundDevices.count(), resultCount); // 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.setHeader(QNetworkRequest::ContentTypeHeader, "text/json"); - clientSpy.clear(); - payload = QJsonDocument::fromVariant(params).toJson(QJsonDocument::Compact); - reply = nam->put(request, payload); - clientSpy.wait(); - QCOMPARE(clientSpy.count(), 1); - statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); - QCOMPARE(statusCode, expectedStatusCode); - reply->deleteLater(); + response = putAndWait(request, params, expectedStatusCode); + QVERIFY2(!response.isNull(), "Could not delete device"); // remove added device - request = QNetworkRequest(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); - 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, 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() << "-------------------------------"; - + request.setUrl(QUrl(QString("http://localhost:3333/api/v1/devices/%1").arg(deviceId.toString()))); + response = deleteAndWait(request); + QVERIFY2(!response.isNull(), "Could not delete device"); } #include "testrestdevices.moc" diff --git a/tests/auto/restplugins/testrestplugins.cpp b/tests/auto/restplugins/testrestplugins.cpp index 32dae8fc..94b65b08 100644 --- a/tests/auto/restplugins/testrestplugins.cpp +++ b/tests/auto/restplugins/testrestplugins.cpp @@ -52,63 +52,30 @@ private slots: void TestRestPlugins::getPlugins() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - // Get all plugins - QNetworkRequest request; - request.setUrl(QUrl("http://localhost:3333/api/v1/plugins")); - QNetworkReply *reply = nam->get(request); - clientSpy.wait(); - QVERIFY2(clientSpy.count() == 1, "expected exactly 1 response from webserver"); + QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/plugins"))); + QVariantList pluginList = response.toList(); + QVERIFY2(pluginList.count() > 0, "Not enought plugins."); - QByteArray data = reply->readAll(); - 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 + // Get each of thouse plugins individualy foreach (const QVariant &plugin, pluginList) { QVariantMap pluginMap = plugin.toMap(); - QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1").arg(pluginMap.value("id").toString()))); - 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"); - jsonDoc = QJsonDocument::fromJson(reply->readAll(), &error); - QCOMPARE(error.error, QJsonParseError::NoError); - - reply->deleteLater(); + if (!VendorId(pluginMap.value("id").toString()).isNull()) { + QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1").arg(pluginMap.value("id").toString()))); + response = getAndWait(request); + QVERIFY2(!response.isNull(), "Could not get plugin"); + } } - nam->deleteLater(); } void TestRestPlugins::getPluginConfiguration() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); + // Get plugin config + QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/plugins/%1/configuration").arg(mockPluginId.toString()))); + QVariant response = getAndWait(request); - // Get all plugins - QNetworkRequest request; - 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"); + QVariantList configurations = response.toList(); + QVERIFY2(configurations.count() == 2, "there should be 2 configurations"); } //void TestRestPlugins::setPluginConfiguration_data() diff --git a/tests/auto/restrules/testrestrules.cpp b/tests/auto/restrules/testrestrules.cpp index a4df9e74..8edc3ec9 100644 --- a/tests/auto/restrules/testrestrules.cpp +++ b/tests/auto/restrules/testrestrules.cpp @@ -899,43 +899,19 @@ void TestRestRules::enableDisableRule() void TestRestRules::getRules() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - // Get all rules - QNetworkRequest request; - request.setUrl(QUrl("http://localhost:3333/api/v1/rules")); - 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(); + QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/rules"))); + QVariantList rulesList = response.toList(); QVERIFY2(rulesList.count() == 0, "there should be at least one vendor."); - // Get each of thouse rules individualy foreach (const QVariant &rule, rulesList) { QVariantMap ruleMap = rule.toMap(); QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/rules/%1").arg(ruleMap.value("id").toString()))); 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(); } diff --git a/tests/auto/restvendors/testrestvendors.cpp b/tests/auto/restvendors/testrestvendors.cpp index fedd3ca4..9213dffa 100644 --- a/tests/auto/restvendors/testrestvendors.cpp +++ b/tests/auto/restvendors/testrestvendors.cpp @@ -47,45 +47,20 @@ private slots: void TestRestVendors::getVendors() { - QNetworkAccessManager *nam = new QNetworkAccessManager(this); - QSignalSpy clientSpy(nam, SIGNAL(finished(QNetworkReply*))); - // Get all vendors - QNetworkRequest request; - request.setUrl(QUrl("http://localhost:3333/api/v1/vendors")); - 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 vendorList = jsonDoc.toVariant().toList(); - QVERIFY2(vendorList.count() >= 1, "there should be at least one vendor."); - + QVariant response = getAndWait(QNetworkRequest(QUrl("http://localhost:3333/api/v1/vendors"))); + QVariantList vendorList = response.toList(); + QVERIFY2(vendorList.count() > 0, "Not enought vendors."); // Get each of thouse vendors individualy foreach (const QVariant &vendor, vendorList) { QVariantMap vendorMap = vendor.toMap(); if (!VendorId(vendorMap.value("id").toString()).isNull()) { QNetworkRequest request(QUrl(QString("http://localhost:3333/api/v1/vendors/%1").arg(vendorMap.value("id").toString()))); - 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 vendor"); } } - nam->deleteLater(); }