found source of bug: getTokens were not finished leaving dangling QNetworkReply

Adding check to RequestManager::processRequest ( void -> bool )
Nothing helped at alll -> same bug appears ( could be connected to Qt itself )

server-sdk

@@ -1 +1 @@
-Subproject commit b643f25421757703b930d48a3c0175b7e9de1c72
+Subproject commit 3640c0db5d1e24b314b00cc2b0dd61915080381b

src/colnod/colnodapi.cpp

@@ -15,27 +15,32 @@ ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, QSt
 
 /**
  * @brief Downloads new data from Colnod -> emits downloadDataFinished signal
- * @param time
+ * @param time - timestamp -> ms from 1970
  *
- * @return signal with nullptr when something went wrong
+ * @return emits signal with data when ok, or nullptr, when error
- * @return signal with data when valid data returned
  */
-void ColnodAPI::downloadData(const qint64 &time)
+bool ColnodAPI::downloadData(const qint64 &time)
 {
     // Have to get Login
     auto login = requestLogin();
+    Q_ASSERT(login);
+    if (login->networkReply() == nullptr) {
+        qCCritical(colnod) << "Not possible to create login request";
+        return false;
+    }
+
     connect(login.get(), &serversdk::Request::finished, this, [=](){
         // Get login token
         if (login->status() != 200) {
             emit downloadDataFinished(nullptr);
-            return;
+            return false;
         }
         AuthToken token;
         auto responseData = login->responseData();
         if (responseData.isEmpty()) {
             qCWarning(colnod) << "empty response data when logging in";
             emit downloadDataFinished(nullptr);
-            return;
+            return false;
         }
 
         token.fromJson(responseData);
@@ -43,58 +48,89 @@ void ColnodAPI::downloadData(const qint64 &time)
         if (authToken.isEmpty()) {
             qCCritical(colnod) << "Token uuid is empty";
             emit downloadDataFinished(nullptr);
-            return;
+            return false;
         }
 
-        auto data = std::make_shared<Data>();
-
-        auto errorHandler = [=](const std::shared_ptr<serversdk::Request>& request){
-            if (!checkRequest(request)) {
-                qWarning(colnod) << "ERROR during calling" << request->url() << ", request unsuccessful";
-                mValid = false;
-                emit downloadDataFinished(nullptr);  // TODO: think about it, will the other if passed?
-            }
-            else if (!checkResponse(request->responseData())) {
-                qWarning(colnod) << "Data from" << request->url() << "are invalid";
-                mValid = false;
-            }
-        };
-
 
         // if I have all data emit downloadDataFinished
-        connect(this, &ColnodAPI::partOfDataReady, this, &ColnodAPI::areDataReady);
+        //connect(this, &ColnodAPI::partOfDataReady, this, &ColnodAPI::areDataReady);
 
         Timestamp timestamp;
         timestamp.setTimestamp(time);
 
+        auto data = std::make_shared<Data>();
+        int dataCount = 0;
+
+        auto checkData = [=]() {
+            qDebug() << "check data" << dataCount;
+            // VALIDATE: problem was in unitest getTokens
+            // -> no tests -> destroying QNetworkRequest when QNetworkReply was running
+            // FIXME: Problem with ASSERT: "dataCount < 5" -> datacount sometime -> 32677 ( bad memory allocation )
+            // Not possible to pinpoint memory problem.
+            // Possible sources:
+            // 0) Bad code -> dataCount -> &dataCount -> ++ what it does. Increase dataCount or increment address?
+            //    - have to double check this problem
+            // 1) ColnodAPI
+            // 2) RequestManager ( serversdk )
+            // 3) Problem with testing QtTest logic
+            //    - try to change stack allocation to heap ( std::unique_ptr )
+            //    - reason: Does not make sence but something else could appear
+            // 4) Lambda slots
+            if (dataCount > 5) {
+                qCCritical(colnod) << "check data cannnot be higher then 4";
+            }
+            Q_ASSERT(dataCount < 5);
+            if (dataCount == 4)
+                emit downloadDataFinished(data);
+        };
+
+        // Getting tokens from ColnodAPI
         auto tokensRequest = getTokensUpdated(timestamp);
-        connect(tokensRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(tokensRequest.get(), &serversdk::Request::finished, [=](){
-            saveUpdatedTokens(data, tokensRequest->responseData());
+            qDebug(colnod) << "tokens finished";
-            emit partOfDataReady(data);
+
+            // false when not possible to load request data
+            if (!saveUpdatedTokens(data, tokensRequest->responseData())) {
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+
+            checkData();
         });
 
         auto deletedTokensRequest = getTokensDeleted(timestamp);
-        connect(deletedTokensRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(deletedTokensRequest.get(), &serversdk::Request::finished, [=](){
-            saveDeletedTokens(data, deletedTokensRequest->responseData());
+            qDebug(colnod) << "tokens finished";
-            emit partOfDataReady(data);
+            if (!saveDeletedTokens(data, deletedTokensRequest->responseData())) {
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
 
         auto subjectsRequest = getSubjectsUpdated(timestamp);
-        connect(subjectsRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(subjectsRequest.get(), &serversdk::Request::finished, [=](){
-            saveUpdatedSubjects(data, subjectsRequest->responseData());
+            qDebug(colnod) << "tokens finished";
-            emit partOfDataReady(data);
+            if (!saveUpdatedSubjects(data, subjectsRequest->responseData())) {
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
 
         auto deletedSubjectsRequest = getSubjectsDeleted(timestamp);
-        connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, errorHandler);
         connect(deletedSubjectsRequest.get(), &serversdk::Request::finished, [=](){
-            saveDeletedSubjects(data, deletedSubjectsRequest->responseData());
+            qDebug(colnod) << "tokens finished";
-            emit partOfDataReady(data);
+            if (!saveDeletedSubjects(data, deletedSubjectsRequest->responseData())) {
+                emit downloadDataFinished(nullptr);
+                return;
+            }
+            checkData();
         });
+        return true;
     });
+
+    return true;
 }
 
 void ColnodAPI::processData(const std::shared_ptr<Data> &data)
@@ -148,6 +184,11 @@ std::shared_ptr<serversdk::Request> ColnodAPI::requestLogin()
     return loginRequest;
 }
 
+/**
+ * @return sucess  :
+ * @return fail    :
+ * @return no data :
+ */
 std::shared_ptr<serversdk::Request> ColnodAPI::getTokensUpdated(const Timestamp &time)
 {
     auto request = composeRequest("/TokenManager/getTokensUpdated", time.jsonData());
@@ -156,6 +197,11 @@ std::shared_ptr<serversdk::Request> ColnodAPI::getTokensUpdated(const Timestamp
     return request;
 }
 
+/**
+ * @return sucess  :
+ * @return fail    :
+ * @return no data :
+ */
 std::shared_ptr<serversdk::Request> ColnodAPI::getTokensDeleted(const Timestamp &time)
 {
     auto request = composeRequest("/TokenManager/getTokensDeleted", time.jsonData());
@@ -164,6 +210,11 @@ std::shared_ptr<serversdk::Request> ColnodAPI::getTokensDeleted(const Timestamp
     return request;
 }
 
+/**
+ * @return sucess  :
+ * @return fail    :
+ * @return no data :
+ */
 std::shared_ptr<serversdk::Request> ColnodAPI::getSubjectsUpdated(const Timestamp &time)
 {
     auto request = composeRequest("/SubjectManager/getSubjectsUpdated", time.jsonData());
@@ -172,6 +223,11 @@ std::shared_ptr<serversdk::Request> ColnodAPI::getSubjectsUpdated(const Timestam
     return request;
 }
 
+/**
+ * @return sucess  :
+ * @return fail    :
+ * @return no data :
+ */
 std::shared_ptr<serversdk::Request> ColnodAPI::getSubjectsDeleted(const Timestamp &time)
 {
     auto request = composeRequest("/SubjectManager/getSubjectsDeleted", time.jsonData());
@@ -180,6 +236,10 @@ std::shared_ptr<serversdk::Request> ColnodAPI::getSubjectsDeleted(const Timestam
     return request;
 }
 
+/**
+ * @return sucess  :
+ * @return fail    :
+ */
 std::shared_ptr<serversdk::Request> ColnodAPI::setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
 {
     auto request = composeRequest("/TokenManager/setTokens", Token::tokensToColnodJson(tokens));
@@ -294,32 +354,42 @@ void ColnodAPI::isDataProcessFinished()
     }
 }
 
-void ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
+bool ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
-    data->loadTokensFromJson(responseData);
+    Q_ASSERT(data);
+    return data->loadTokensFromJson(responseData);
 }
 
-void ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
+bool ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
+    Q_ASSERT(data);
+    if (responseData.isEmpty())
+        return false;
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();
     for (QJsonValueRef item : items) {
         data->deletedTokens.append(item.toString());
     }
+    return true;
 }
 
-void ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
+bool ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
-    data->loadSubjectsFormJson(responseData);
+    Q_ASSERT(data);
+    return data->loadSubjectsFormJson(responseData);
 }
 
-void ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
+bool ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
+    Q_ASSERT(data);
+    if (responseData.isEmpty())
+        return false;
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();
     for (QJsonValueRef item : items) {
         data->deletedSubjects.append(item.toString());
     }
+    return true;
 }
 
 void ColnodAPI::newData()

src/colnod/colnodapi.h

@@ -39,11 +39,12 @@ public:
 class ColnodAPI: public QObject
 {
     Q_OBJECT
+    friend class ColnodTest;
 public:
-    ColnodAPI() = default;
+//    ColnodAPI() = default;
     ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, QString userName = "spaceti", QString password = "spaceti1");
 
-    void downloadData(const qint64 &time);
+    bool downloadData(const qint64 &time);
     void processData(const std::shared_ptr<Data> &data);
 
     // New approach
@@ -73,10 +74,10 @@ private:
     Q_SLOT void isDataProcessFinished();
 
 private:
-    void saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
+    bool saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
+    bool saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
+    bool saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
+    bool saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
 
     void newData();
 
@@ -90,7 +91,7 @@ private:
 
 signals:
     void downloadDataFinished(std::shared_ptr<Data> = std::shared_ptr<Data>());
-    void partOfDataReady(std::shared_ptr<Data> = std::shared_ptr<Data>());
+//    void partOfDataReady(std::shared_ptr<Data> = std::shared_ptr<Data>());
     void partOfDataProcessFinished();
     void dataProcessFinished();
 
@@ -103,7 +104,7 @@ private:
     QString mPassword;
     Timestamp mLastSync;
     bool mDryMode = false;
-    bool mValid = true;
+    bool mValid = false;
 
     std::shared_ptr<Data> mData;
 

src/colnod/data.cpp

@@ -9,8 +9,11 @@ void Data::clear()
     deletedSubjects.clear();
 }
 
-void Data::loadTokensFromJson(const QByteArray &data)
+bool Data::loadTokensFromJson(const QByteArray &data)
 {
+    if (data.isEmpty())
+        return false;
+
     auto doc = QJsonDocument::fromJson(data);
     auto items = doc.object()["items"].toArray();
     for (auto item : items) {
@@ -19,10 +22,14 @@ void Data::loadTokensFromJson(const QByteArray &data)
         token->fromJson(doc.toJson());
         updatedTokens.insert(token->id(), token);
     }
+    return true;
 }
 
-void Data::loadSubjectsFormJson(const QByteArray &data)
+bool Data::loadSubjectsFormJson(const QByteArray &data)
 {
+    if (!data.isEmpty())
+        return false;
+
     auto doc = QJsonDocument::fromJson(data);
     auto items = doc.object()["items"].toArray();
     for (auto item : items) {
@@ -31,4 +38,5 @@ void Data::loadSubjectsFormJson(const QByteArray &data)
         subject->fromJson(doc.toJson());
         updatedSubjects.insert(subject->id(), subject);
     }
+    return true;
 }

src/colnod/data.h

@@ -30,8 +30,8 @@ public:
 
     void clear();
 
-    void loadTokensFromJson(const QByteArray &data);
+    bool loadTokensFromJson(const QByteArray &data);
-    void loadSubjectsFormJson(const QByteArray &data);
+    bool loadSubjectsFormJson(const QByteArray &data);
 
     QHash<QString, std::shared_ptr<Token>> updatedTokens;
     QList<QString> deletedTokens;
@@ -44,7 +44,7 @@ struct PreparedData
 public:
     PreparedData() = default;
     PreparedData(const std::shared_ptr<Data> &database, const std::shared_ptr<Data> &colnod)
-        :databaseData(std::move(database)), colnodData(std::move(colnod))
+        :databaseData(database), colnodData(colnod)
     {
     }
 

src/colnod/databaseapi.cpp

@@ -46,9 +46,6 @@ std::shared_ptr<Data> DatabaseAPI::downloadData()
     }
 
     return composeData(updatedQuery, deletedQuery);
-    // TODO: why emiting signal??
-    // this can return Strucutre
-    //emit downloadDataFinished(composeData(updatedQuery, deletedQuery));
 }
 
 bool DatabaseAPI::processData(const std::shared_ptr<Data> &data)

src/colnod/syncmanager.cpp

@@ -36,6 +36,7 @@ bool SyncManager::databaseInitialization()
 
 bool SyncManager::startSynchronization()
 {
+    Q_ASSERT(database);
     // I have to current time from database
     qint64 syncBegin = database->getNow();
     if (syncBegin == -1) {
@@ -61,7 +62,7 @@ bool SyncManager::startSynchronization()
     // NOW I HAVE DATA FROM DATABASE
 
     colnod->downloadData(mlastSync.timestamp());
-    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](std::shared_ptr<Data> colnodData) {
+    connect(colnod.get(), &ColnodAPI::downloadDataFinished, [=](const std::shared_ptr<Data> &colnodData) {
         qInfo(syncmanager) << "DOWNLOADING DATA -> FINISHED";
         qInfo(syncmanager) << equals;
 
@@ -263,8 +264,6 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataUsindOld(const std::shared
     Q_ASSERT(colnodData);
     Q_ASSERT(databaseData);
 
-
-    // TODO: why copy data?
     std::shared_ptr<Data> cloneColnodDataToProcess = std::make_shared<Data>(*colnodData);
     std::shared_ptr<Data> cloneDatabaseDataToProcess = std::make_shared<Data>(*databaseData);
 

test/auto/colnod/tst_colnodapi.cpp

@@ -18,12 +18,12 @@ public:
         qRegisterMetaType<std::shared_ptr<serversdk::Request>>("std::shared_ptr<Request>");
     }
 
-private slots:
+private :
+    Q_SLOT void getTokens();
+    Q_SLOT void download_test();
+    Q_SLOT void download_data_test_now();
+    Q_SLOT void download_data_fail_test();
     void login();
-    void getTokens();
-    void download_data_test();
-    void download_data_test_now();
-    void download_data_fail_test();
 
 private:
     QString getLoginToken(ColnodAPI &colnod);
@@ -34,38 +34,61 @@ void ColnodTest::login()
     serversdk::RequestManager reqMan;
     ColnodAPI colnod(&reqMan);
     auto login = colnod.requestLogin();
+    QVERIFY(login);
+    QVERIFY(login->networkReply());
     QSignalSpy spy(login.get(), &serversdk::Request::finished);
     QCOMPARE(spy.count(), 0);
     QVERIFY(spy.wait());
     QCOMPARE(spy.count(), 1);
     QVERIFY(login->responseData().contains("id"));
+
 }
 
+
 void ColnodTest::getTokens()
 {
+    // FIXME: finish this -> must be valid test testing something
+    // FIXME: Was not testing anything only causing bug
     serversdk::RequestManager reqMan;
     ColnodAPI colnod(&reqMan);
 
     // get login token
+    // FIXME: calling login request two times
     auto login = colnod.requestLogin();
     QSignalSpy spy(login.get(), &serversdk::Request::finished);
-    spy.wait();
+    QVERIFY(spy.isValid());
-    QString token = getLoginToken(colnod);
+    QVERIFY(spy.wait());
+    //login->responseData().mid(7,36);
+    // NOTE: second calling of loging request
+    //QString token = getLoginToken(colnod);
     Timestamp time;
     time.setTimestamp(QDateTime::currentMSecsSinceEpoch());
-    colnod.getTokensUpdated(time);
+    auto request = colnod.getTokensUpdated(time);
+
+    // FIXING BUG: creating request not waiting for it immediatelly destroying request
+    //  immediatelly reqMan goes out of scope destroying QNetworkRequestManager with QNetworkReply running.
+    QSignalSpy requestSpy(request.get(), &serversdk::Request::finished);
+    QVERIFY(requestSpy.wait()); // <-- have to wait here for request!!!!
+    // FIXME: check request and finish test!!
 }
 
-void ColnodTest::download_data_test()
+void ColnodTest::download_test()
 {
     serversdk::RequestManager reqMan;
-    //reqMan.setIgnoreSsl(true);
+    reqMan.setIgnoreSsl(true);
     ColnodAPI colnod(&reqMan);
 
+    QVERIFY(!colnod.mData);
+    QVERIFY(!colnod.mValid);
+    QVERIFY(!colnod.amountData);
+    QVERIFY(!colnod.amountProccessesFinished);
+
     QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
     QVERIFY(spy.isValid());
-    colnod.downloadData(1570190399259);
+    QVERIFY(colnod.downloadData(1570190399259));
     QVERIFY(spy.wait());
+    QVERIFY(colnod.amountData == 0);
+
 
     auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
     QVERIFY(data);
@@ -83,11 +106,12 @@ void ColnodTest::download_data_test_now()
     QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
     QVERIFY(spy.wait());
     auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
+    // No latest data
     QVERIFY(data);
-
     QVERIFY(data->updatedTokens.isEmpty());
 }
 
+
 void ColnodTest::download_data_fail_test()
 {
     serversdk::RequestManager reqMan;
@@ -98,6 +122,7 @@ void ColnodTest::download_data_fail_test()
 
     QVERIFY(spy.wait());
 
+    // FIXME: problem with returning data
     auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
 
     QVERIFY(!data);

test/auto/database/tst_databaseapi.cpp

@@ -23,12 +23,6 @@ void DatabaseTest::open_database_test()
     serversdk::DatabaseManager dbManager;
     DatabaseAPI db(&dbManager, false);
     QVERIFY(db.open());
-
-    // TODO: fix -> databaseAPI must be able to add credentials to check for wrong one or test wrong IP
-    //db.open(user, password, url, etc );
-    // then test with wrong credentials
-    // QVERIFY(!db.open(worng usernae));
-    // QVERIFY(!db.open(worng ip));
 }
 
 void DatabaseTest::open_database_ip_fail_test()