Merge branch 'suggest/preapre-data-use-old' into feat/unitest-syncmanager

server-sdk

@@ -1 +1 @@
-Subproject commit a818055b75dc0de97e26be44cbbfd2e94516c09e
+Subproject commit 031b6c2535408bce18a5d7bbc5842f9ee4384328

src/app/main.cpp

@@ -45,13 +45,13 @@ int main(int argc, char *argv[])
 
     // Initialize database and colnod API
     if (!syncManager.databaseInitialization()) {
-        qCritical("Not possible to initialize sync application");
+        qCritical() << "Not possible to initialize sync application";
         return -1;
     }
 
     // Synchronizaiton
     if (!syncManager.startSynchronization()) {
-        qCritical("Not possible to start synchronization");
+        qCritical() << "Not possible to start synchronization";
         return -1;
     }
 

src/colnod/colnodapi.cpp

@@ -1,10 +1,12 @@
 #include "colnodapi.h"
 
+#include <utility>
+
 Q_LOGGING_CATEGORY(colnod, "colnod.api");
 
 
-ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, const QString &userName, const QString &password)
+ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, QString userName, QString password)
-    :mReqMan(reqMan), mUserName(userName), mPassword(password), mDryMode(dryMode)
+    :mReqMan(reqMan), mUserName(std::move(userName)), mPassword(std::move(password)), mDryMode(dryMode)
 {
     // -----------------------------------
     mReqMan->setIgnoreSsl(true);
@@ -24,17 +26,29 @@ void ColnodAPI::downloadData(const qint64 &time)
     auto login = requestLogin();
     connect(login.get(), &serversdk::Request::finished, this, [=](){
         // Get login token
-        if (!checkRequest(login)) {
+        if (login->status() != 200) {
             emit downloadDataFinished(nullptr);
             return;
         }
         AuthToken token;
-        token.fromJson(login->responseData());
+        auto responseData = login->responseData();
+        if (responseData.isEmpty()) {
+            qCWarning(colnod) << "empty response data when logging in";
+            emit downloadDataFinished(nullptr);
+            return;
+        }
+
+        token.fromJson(responseData);
         authToken = token.id();
+        if (authToken.isEmpty()) {
+            qCCritical(colnod) << "Token uuid is empty";
+            emit downloadDataFinished(nullptr);
+            return;
+        }
 
         auto data = std::make_shared<Data>();
 
-        auto errorHandler = [=](std::shared_ptr<serversdk::Request> request){
+        auto errorHandler = [=](const std::shared_ptr<serversdk::Request>& request){
             if (!checkRequest(request)) {
                 qWarning(colnod) << "ERROR during calling" << request->url() << ", request unsuccessful";
                 mValid = false;
@@ -218,10 +232,7 @@ std::shared_ptr<serversdk::Request> ColnodAPI::composeRequest(const QString &end
 
 bool ColnodAPI::checkRequest(const std::shared_ptr<serversdk::Request> &request)
 {
-    if (request->status() == 200) {
+    return request->status() == 200;
-        return true;
-    }
-    return false;
 }
 
 bool ColnodAPI::isValid()
@@ -260,7 +271,7 @@ void ColnodAPI::setUserName(const QString &userName)
     mUserName = userName;
 }
 
-void ColnodAPI::areDataReady(std::shared_ptr<Data> data)
+void ColnodAPI::areDataReady(const std::shared_ptr<Data>& data)
 {
     if (++amountData == 4) {
 
@@ -283,12 +294,12 @@ void ColnodAPI::isDataProcessFinished()
     }
 }
 
-void ColnodAPI::saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
+void ColnodAPI::saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
     data->loadTokensFromJson(responseData);
 }
 
-void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData)
+void ColnodAPI::saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();
@@ -297,12 +308,12 @@ void ColnodAPI::saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &
     }
 }
 
-void ColnodAPI::saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
+void ColnodAPI::saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
     data->loadSubjectsFormJson(responseData);
 }
 
-void ColnodAPI::saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData)
+void ColnodAPI::saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData)
 {
     QJsonDocument doc = QJsonDocument::fromJson(responseData);
     QJsonArray items = doc.object()["items"].toArray();

src/colnod/colnodapi.h

@@ -41,7 +41,7 @@ class ColnodAPI: public QObject
     Q_OBJECT
 public:
     ColnodAPI() = default;
-    ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, const QString &userName = "spaceti", const QString &password = "spaceti1");
+    ColnodAPI(serversdk::RequestManager* reqManconst, const bool &dryMode = false, QString userName = "spaceti", QString password = "spaceti1");
 
     void downloadData(const qint64 &time);
     void processData(const std::shared_ptr<Data> &data);
@@ -69,14 +69,14 @@ public:
     bool isValid();
 
 private:
-    Q_SLOT void areDataReady(std::shared_ptr<Data> data);
+    Q_SLOT void areDataReady(const std::shared_ptr<Data>& data);
     Q_SLOT void isDataProcessFinished();
 
 private:
-    void saveUpdatedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
+    void saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
+    void saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
+    void saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
-    void saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
+    void saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
 
     void newData();
 

src/colnod/data.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "token.h"
 #include "subject.h"
 
@@ -13,7 +15,7 @@ constexpr auto tab = "\t";
 class Message
 {
 public:
-    static QString massageTemplate(QString action, QString item, QString source, QString itemInfo)
+    static QString massageTemplate(const QString& action, const QString& item, const QString& source, const QString& itemInfo)
     {
         return action + " " + item + " in " + source + ", " + item + ": '" + itemInfo + "'";
     }
@@ -42,11 +44,10 @@ struct PreparedData
 public:
     PreparedData() = default;
     PreparedData(const std::shared_ptr<Data> &database, const std::shared_ptr<Data> &colnod)
-        :databaseData(database), colnodData(colnod)
+        :databaseData(std::move(database)), colnodData(std::move(colnod))
     {
     }
 
-
     // TODO: make unique_ptr ( neeed because of ColnodAPI )
     std::shared_ptr<Data> databaseData;
     std::shared_ptr<Data> colnodData;

src/colnod/databaseapi.cpp

@@ -12,7 +12,7 @@ DatabaseAPI::DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode)
     mDbMan->setDryMode(dryMode);
 }
 
-bool DatabaseAPI::open(QString host, QString name, QString user, QString password)
+bool DatabaseAPI::open(const QString& host, const QString& name, const QString& user, const QString& password)
 {
     return mDbMan->openPostgres(host, name, user, password);
 }
@@ -135,7 +135,8 @@ void DatabaseAPI::reupdateUpdated(const QHash<QString, std::shared_ptr<Token>> &
     qInfo(database) << equals;
 }
 
-void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
+
+void DatabaseAPI::reupdateDeleted(const QList<QString>& ids)
 {
     auto query = mDbMan->createQuery();
     for (const auto &id : ids){
@@ -148,7 +149,6 @@ void DatabaseAPI::reupdateDeleted(const QList<QString> ids)
             }
         }
     }
-
 }
 
 qint64 DatabaseAPI::getNow()
@@ -291,10 +291,7 @@ bool DatabaseAPI::isAlreadyDeleted(const QString &id)
         qWarning(database) << "Token deleted in colnod doesn't exists in db, will be noted as already deleted in stats";
         return true;
     }
-    if (token->deleted())
+    return token->deleted();
-        return true;
-    return false;
-
 }
 
 bool DatabaseAPI::isValid()

src/colnod/databaseapi.h

@@ -20,10 +20,10 @@ class DatabaseAPI : public QObject
 public:
     explicit DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode);
 
-    bool open(QString host = "192.168.1.94",
+    bool open(const QString& host = "192.168.1.94",
-              QString name = "deloitte",
+              const QString& name = "deloitte",
-              QString user = "postgres",
+              const QString& user = "postgres",
-              QString password = "34rjkciea12");
+              const QString& password = "34rjkciea12");
 
     bool executeQuery(QSqlQuery &query, const QString &statement = QString());
 
@@ -32,7 +32,7 @@ public:
     qint64 getLastSync();
     void setLastSync(qint64 timestamp);
     void reupdateUpdated(const QHash<QString, std::shared_ptr<Token> > &tokens);
-    void reupdateDeleted(const QList<QString> ids);
+    void reupdateDeleted(const QList<QString>& ids);
     qint64 getNow();
 
     void initNewTokens();

src/colnod/syncmanager.cpp

@@ -228,8 +228,10 @@ std::unique_ptr<PreparedData> SyncManager::prepareDataNew(const std::shared_ptr<
     return preparedData;
 }
 
-void SyncManager::initNewToken(std::shared_ptr<Token> token)
+void SyncManager::initNewToken(const std::shared_ptr<Token>& token)
 {
+    Q_ASSERT(database);
+    Q_ASSERT(token);
     qint16 num = database->getNumOfTokensOfSubject(token->subjectId());
     token->setName(database->getSubjectNameByTokenId(token->id()) + "_mobile_" + QString::number(num + 1));
     token->setDescription("mobile");
@@ -240,9 +242,6 @@ void SyncManager::initNewToken(std::shared_ptr<Token> token)
 
 std::unique_ptr<PreparedData> SyncManager::prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData)
 {
-    Q_UNUSED(databaseData)
-    Q_UNUSED(colnodData)
-
     qInfo(syncmanager) << equals;
     qInfo(syncmanager) << "PREPARING DATA -> BEGIN";
     qInfo(syncmanager) << dash;

src/colnod/syncmanager.h

@@ -29,7 +29,7 @@ private:
     std::unique_ptr<PreparedData> prepareDataUsindOld(const std::shared_ptr<Data> &databaseData, const std::shared_ptr<Data> &colnodData);
 
 private:
-    void initNewToken(std::shared_ptr<Token> token);
+    void initNewToken(const std::shared_ptr<Token>& token);
 
     void updateLastUpdate(qint64 syncBegin);
 

test/auto/colnod/tst_colnodapi.cpp

@@ -7,6 +7,7 @@
 Q_DECLARE_METATYPE(std::shared_ptr<Data>)
 Q_DECLARE_METATYPE(std::shared_ptr<serversdk::Request>);
 
+
 class ColnodTest : public QObject
 {
     Q_OBJECT
@@ -14,13 +15,14 @@ public:
     ColnodTest()
     {
         qRegisterMetaType<std::shared_ptr<Data>>();
-        qRegisterMetaType<std::shared_ptr<serversdk::Request>>();
+        qRegisterMetaType<std::shared_ptr<serversdk::Request>>("std::shared_ptr<Request>");
     }
 
 private slots:
     void login();
     void getTokens();
     void download_data_test();
+    void download_data_test_now();
     void download_data_fail_test();
 
 private:
@@ -57,27 +59,33 @@ void ColnodTest::getTokens()
 void ColnodTest::download_data_test()
 {
     serversdk::RequestManager reqMan;
+    //reqMan.setIgnoreSsl(true);
     ColnodAPI colnod(&reqMan);
-    {
-        QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
-        colnod.downloadData(1570190399259);
-        QVERIFY(spy.wait());
 
-        auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
+    QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
-        QVERIFY(data);
+    QVERIFY(spy.isValid());
+    colnod.downloadData(1570190399259);
+    QVERIFY(spy.wait());
 
-        QVERIFY(data->updatedTokens.size() > 0);
+    auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
-        QVERIFY(data->updatedTokens.contains("5e2f1260-da1c-441f-9644-24dfe3b97b2a"));
+    QVERIFY(data);
-    }
-    {
-        colnod.downloadData(QDateTime::currentMSecsSinceEpoch());
-        QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
-        QVERIFY(spy.wait());
-        auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
-        QVERIFY(data);
 
-        QVERIFY(data->updatedTokens.isEmpty());
+    QVERIFY(! data->updatedTokens.isEmpty());
-    }
+    QVERIFY(data->updatedTokens.contains("5e2f1260-da1c-441f-9644-24dfe3b97b2a"));
+}
+
+void ColnodTest::download_data_test_now()
+{
+    serversdk::RequestManager reqMan;
+    ColnodAPI colnod(&reqMan);
+
+    colnod.downloadData(QDateTime::currentMSecsSinceEpoch());
+    QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
+    QVERIFY(spy.wait());
+    auto data = qvariant_cast<std::shared_ptr<Data>>(spy.at(0).at(0));
+    QVERIFY(data);
+
+    QVERIFY(data->updatedTokens.isEmpty());
 }
 
 void ColnodTest::download_data_fail_test()

test/auto/syncmanager/tst_syncmanager.cpp

@@ -6,29 +6,147 @@
 class SyncManagerTest : public QObject
 {
     Q_OBJECT
+private:
+    std::shared_ptr<Token> tokenFromString(const QString &text);
 private slots:
+    void tokenFromString_test();
     void sync_init_test();
     void prepareData_test();
+    void prepareData_tokens();
+    void prepareData_tokens_data();
 
 };
 
+std::shared_ptr<Token> SyncManagerTest::tokenFromString(const QString &text)
+{
+    auto split = text.split(",");
+    if (split.count() != 2)
+        return nullptr;
+
+    auto token = std::make_shared<Token>();
+    token->setId(split.first());
+    token->setDescription("mobile");
+    token->setLastUpdate(QDateTime::fromString(split.last(), "yyyyMMdd:HHmmss"));
+    return token;
+}
+
+void SyncManagerTest::tokenFromString_test()
+{
+    auto token = tokenFromString("id1,20191010:232300");
+    QCOMPARE(token->id(), QStringLiteral("id1"));
+    QCOMPARE(token->lastUpdate(), QDateTime::fromString("20191010:232300", "yyyyMMdd:HHmmss"));
+}
+
 void SyncManagerTest::sync_init_test()
 {
     SyncManager sync(true);
     QVERIFY(sync.databaseInitialization());
 }
 
+
 void SyncManagerTest::prepareData_test()
 {
     SyncManager sync(true);
+    QVERIFY(sync.databaseInitialization());
     auto dbData = std::make_shared<Data>();
     auto colnodData = std::make_shared<Data>();
 
+    auto token = std::make_shared<Token>();
+    token->setDescription("mobile");
+    token->setId("id1");
+    dbData->updatedTokens.insert("id1", token);
+
+    auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
+    auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
+    QVERIFY(oldPreparedData->databaseData->updatedTokens.contains("id1"));
+    QVERIFY(newPreparedData->databaseData->updatedTokens.contains("id1"));
+    QVERIFY(oldPreparedData->databaseData->updatedSubjects.isEmpty());
+    QVERIFY(newPreparedData->databaseData->updatedSubjects.isEmpty());
+    QVERIFY(oldPreparedData->databaseData->deletedTokens.isEmpty());
+    QVERIFY(newPreparedData->databaseData->deletedTokens.isEmpty());
+    QVERIFY(oldPreparedData->databaseData->deletedSubjects.isEmpty());
+    QVERIFY(newPreparedData->databaseData->deletedSubjects.isEmpty());
+}
+
+void SyncManagerTest::prepareData_tokens()
+{
+    SyncManager sync(true);
+    QVERIFY(sync.databaseInitialization());
+
+
+
+    QFETCH(QString, db_token_updated);
+    QFETCH(QString, db_token_deleted);
+    QFETCH(QString, colnod_token_updated);
+    QFETCH(QString, colnod_token_deleted);
+    QFETCH(QString, expected_db_tokens_toupdate);
+    QFETCH(QString, expected_db_tokens_todelete);
+    QFETCH(QString, expected_colnod_tokens_toupdate);
+    QFETCH(QString, expected_colnod_tokens_todelete);
+
+    // fake data
+    auto dbData = std::make_shared<Data>();
+    auto colnodData = std::make_shared<Data>();
+
+    // Database
+    auto utoken = tokenFromString(db_token_updated);
+    if ( utoken )
+        dbData->updatedTokens.insert(utoken->id(), utoken);
+    auto dtoken = tokenFromString(db_token_deleted);
+    if ( dtoken )
+        dbData->deletedTokens.append(dtoken->id());
+
+    // Colnod
+    auto colnod_utoken = tokenFromString(colnod_token_updated);
+    if ( colnod_utoken )
+        colnodData->updatedTokens.insert(colnod_utoken->id(), colnod_utoken);
+    auto colnod_dtoken = tokenFromString(colnod_token_deleted);
+    if ( colnod_dtoken )
+        colnodData->deletedTokens.append(colnod_dtoken->id());
+
     auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
     auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
 
-    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
+    QVERIFY(newPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
-    QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
+    QVERIFY(newPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
+    QVERIFY(newPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
+    QVERIFY(newPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));
+
+    QVERIFY(oldPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
+    QVERIFY(oldPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
+    QVERIFY(oldPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
+    QVERIFY(oldPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));
+
+}
+
+void SyncManagerTest::prepareData_tokens_data()
+{
+    QTest::addColumn<QString>("db_token_updated");
+    QTest::addColumn<QString>("db_token_deleted");
+    QTest::addColumn<QString>("colnod_token_updated");
+    QTest::addColumn<QString>("colnod_token_deleted");
+    QTest::addColumn<QString>("expected_db_tokens_toupdate");
+    QTest::addColumn<QString>("expected_db_tokens_todelete");
+    QTest::addColumn<QString>("expected_colnod_tokens_toupdate");
+    QTest::addColumn<QString>("expected_colnod_tokens_todelete");
+
+    // in: db 1 new token
+    // out: 1 db token must be updated in colnod
+    QTest::newRow("db 1 update") << "id1,20191010:23:23:00" << ""
+                             << "" << ""
+                             // expected database: toupdate << todelete
+                             << "id1" << ""
+                             // expected colnod: toupdate << todelete
+                             << "" << "";
+    // in: id1 in database new/updated
+    // in: id1 deleted in colnod
+    // out: 1 colnod token must be deleted from database
+    QTest::newRow("delete 1 existing token in database") << "id1,20191010:23:23:00" << ""
+                             << "" << "id1,20191010:23:23:00"
+                             // expected database: toupdate << todelete
+                             << "" << "id1"
+                             // expected colnod: toupdate << todelete
+                             << "" << "";
 }
 
 QTEST_MAIN(SyncManagerTest)