diff --git a/src/app/main.cpp b/src/app/main.cpp
index f891c95..41eeeab 100644
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -6,7 +6,7 @@
 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);
-    ColnodAPI *api = new ColnodAPI();
+    auto *api = new ColnodAPI();
 
 
     /*api->downloadData(); // this will start downloading data
@@ -31,5 +31,5 @@ int main(int argc, char *argv[])
     api->loadDataFromDB();
 
 
-    return a.exec();
+    return QCoreApplication::exec();
 }
diff --git a/src/colnod/colnodapi.cpp b/src/colnod/colnodapi.cpp
index 87b15c5..739f925 100644
--- a/src/colnod/colnodapi.cpp
+++ b/src/colnod/colnodapi.cpp
@@ -7,33 +7,6 @@ ColnodAPI::ColnodAPI(bool debug)
     debugMode = debug;
 }
 
-
-// PUBLIC FUNCTIONS
-//void ColnodAPI::downloadData()
-//{
-//    Response* resp0 = reqMan->getSubjects();
-//    connect(resp0, &Response::ready, [=](){
-//        dataMan->localSaveSubjects(resp0->getJson());
-//        areDataReady();
-//        resp0->deleteLater();
-//    });
-
-//    Response* resp1 = reqMan->getTokens();
-//    connect(resp1, &Response::ready, [=](){
-//        dataMan->localSaveTokens(resp1->getJson());
-//        areDataReady();
-//        resp1->deleteLater();
-//    });
-
-//    /*
-//    QNetworkReply* reply2 = reqMan->getTokens();
-//    connect(reply2, &QNetworkReply::finished, [=](){
-//        data->saveTokens(reply2->readAll());
-//    });
-//    */
-//}
-
-
 void ColnodAPI::loadDataFromColnod()
 {
     loadTokensFromColnod();
@@ -41,6 +14,7 @@ void ColnodAPI::loadDataFromColnod()
     loadDeletedDataFromColnod();
 }
 
+// download all tokens form colnod for comparing with tokens to update from DB
 void ColnodAPI::loadTokensFromColnod()
 {
     Response* resp = reqMan->getTokens();
@@ -51,24 +25,26 @@ void ColnodAPI::loadTokensFromColnod()
     });
 }
 
+// fill tokens/subjects to update in data manager
 void ColnodAPI::loadUpdatedDataFromColnod()
 {
     uint64_t lastUpdate = dataMan->getLastSync();
     Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate);
     connect(resp0, &Response::ready, [=](){
-        dataMan->fillSubjectsColnod(resp0->getJson());
+        dataMan->fillSubjectsToUpdateColnod(resp0->getJson());
         areChangedDataReady();
         resp0->deleteLater();
     });
 
     Response* resp1 = reqMan->getTokensUpdated(lastUpdate);
     connect(resp1, &Response::ready, [=](){
-        dataMan->fillTokensColnod(resp1->getJson());
+        dataMan->fillTokensToUpdateColnod(resp1->getJson());
         areChangedDataReady();
         resp1->deleteLater();
     });
 }
 
+// fill tokens/subjects to delete in data manager
 void ColnodAPI::loadDeletedDataFromColnod()
 {
     uint64_t lastUpdate = dataMan->getLastSync();
@@ -88,109 +64,82 @@ void ColnodAPI::loadDeletedDataFromColnod()
 
 }
 
+// fill structures in data manager (tokens to updata/to delte)
 void ColnodAPI::loadDataFromDB()
 {
-    dataMan->fillTokensDB();
-
+    dataMan->fillTokensToUpdateDB();
 }
 
-//void ColnodAPI::syncDataFromColnod()
-//{
-//    dataMan->pushTokensToDB();
-//    dataMan->pushSubjectsToDB();
-//    dataMan->updateLastSync();
-//    dataMan->clear();
-//}
-
 void ColnodAPI::syncDataFromColnod()
 {
     dataMan->filterTokensColnod();
-    syncUpdatedDataFromColnod();
+    syncUpdatedDataFromColnodToDB();
     if (dataMan->getLastSync() != 0)
-        syncDeletedDataFromColnod();
-    //dataMan->updateLastSync();
-   // dataMan->clear();
+        syncDeletedDataFromColnodToDB();
 }
 
-void ColnodAPI::syncUpdatedDataFromColnod()
+// push data from colnod to DB
+void ColnodAPI::syncUpdatedDataFromColnodToDB()
 {
     dataMan->pushSubjectsToDB();
     dataMan->pushTokensToDB();
 }
 
-
-void ColnodAPI::syncDeletedDataFromColnod()
+// set deleted tokens from Colnod, delete subject
+void ColnodAPI::syncDeletedDataFromColnodToDB()
 {
     dataMan->deleteSubjectsFromDB();
-    dataMan->deleteTokensFromDB();
+    dataMan->setDeletedToTokensFromDB();
 }
 
-void ColnodAPI::syncDataFromDB()
+// push changes form DB to Colnod
+void ColnodAPI::syncDataFromDBToColnod()
 {
-    // TODO
     dataMan->filterTokensDB();
-    processDataToColnod();
-    connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::clear);
-    connect(this, &ColnodAPI::dataProcessed, dataMan, &DataManager::setLastSync);
-    connect(this, &ColnodAPI::dataProcessed, [=](){
+    if (!dataMan->getTokensToUpdateDB().contains("empty")){
+        syncDeletedDataFromDBToColnod();
+    }
+    if (!dataMan->getTokensToDeleteDB().contains("empty")){
+        syncUpdatedDataFromDBToColnod();
+    }
+    connect(this, &ColnodAPI::dataUpdatedToColnod, dataMan, &DataManager::clear);
+    connect(this, &ColnodAPI::dataUpdatedToColnod, dataMan, &DataManager::setLastSync);
+    connect(this, &ColnodAPI::dataUpdatedToColnod, [=](){
         auto resp = reqMan->getTokensUpdated(dataMan->getActualSync());
         connect(resp, &Response::ready, [=](){
-            dataMan->fillTokensColnod(resp->getJson());
+            dataMan->fillTokensToUpdateColnod(resp->getJson());
             dataMan->setLastUpdate();
             dataMan->clear();
+            dataMan->updateLastSync();
             emit syncFinished();
             resp->deleteLater();
         });
     });
 }
 
-void ColnodAPI::processDataToColnod()
+// add or update tokens to Colnod
+void ColnodAPI::syncUpdatedDataFromDBToColnod()
 {
     auto tokensToUpdate = dataMan->getTokensToUpdateDB();
-
-    if (tokensToUpdate.contains("empty")){
-        qDebug() << "No tokens to be modified.";
-        return;
-    }
-    auto tokensToDelete = dataMan->getTokensToDeleteDB();
-    auto resp0 = reqMan->setTokens(tokensToUpdate);
-    auto resp1 = reqMan->deleteTokens(tokensToDelete);
+    Response* resp0 = reqMan->setTokens(tokensToUpdate);
     connect(resp0, &Response::ready, [=](){
         updateFinished = true;
-        areDataProcessed();
+        areDataUpdatedToColnod();
         resp0->deleteLater();
     });
-    connect(resp1, &Response::ready, [=](){
-        deleteFinished = true;
-        areDataProcessed();
-        resp1->deleteLater();
-    });
 }
 
-// old version
-//void ColnodAPI::processDataToColnod()
-//{
-//    QList<QString>* tokensToDelete = dataMan->getTokensToDelete();
-//    if ((*tokensToDelete)[0] != "empty")
-//    {
-//     Response* resp0 = reqMan->deleteTokens(tokensToDelete);
-//        connect(resp0, &Response::ready, [=](){
-//            isProcessDone();
-//            resp0->deleteLater();
-//        });
-//    }
-//    QHash<QString, QPointer<Token>>* tokens = dataMan->getTokens();
-//    if (!tokens[0].contains("empty"))
-//    {
-//        Response* resp1 = reqMan->setTokens(tokens);
-//        connect(resp1, &Response::ready, [=](){
-//            isProcessDone();
-//            resp1->deleteLater();
-//        });
-//    }
-//    dataMan->clear();
-//    connect(this, &ColnodAPI::dataProcessed, this, &ColnodAPI::loadDataFromColnod);
-//}
+// delete tokens in Colnod
+void ColnodAPI::syncDeletedDataFromDBToColnod()
+{
+    auto tokensToDelete = dataMan->getTokensToDeleteDB();
+    Response* resp1 = reqMan->deleteTokens(tokensToDelete);
+    connect(resp1, &Response::ready, [=](){
+        deleteFinished = true;
+        areDataUpdatedToColnod();
+        resp1->deleteLater();
+    });
+}
 
 // For full sync
 void ColnodAPI::prepareDatabase()
@@ -198,24 +147,19 @@ void ColnodAPI::prepareDatabase()
     dataMan->emptyDatabase();
 }
 
-// PRIVATE FUNCTIONS
-void ColnodAPI::areDataReady()
-{
-    if (dataMan->haveData())
-        emit dataDownloaded();
-}
-
+// emit signal when all data is downloaded from Colnod
 void ColnodAPI::areChangedDataReady()
 {
     if (dataMan->haveChangedData())
         emit dataDownloaded();
 }
 
-
-void ColnodAPI::areDataProcessed()
+// emit signal when writing to Colnod is finised
+void ColnodAPI::areDataUpdatedToColnod()
 {
     if (deleteFinished && updateFinished)
     {
-        emit dataProcessed();
+        emit dataUpdatedToColnod();
     }
 }
+
diff --git a/src/colnod/colnodapi.h b/src/colnod/colnodapi.h
index 034e8ce..b5353d8 100644
--- a/src/colnod/colnodapi.h
+++ b/src/colnod/colnodapi.h
@@ -16,7 +16,7 @@ public:
     ColnodAPI(bool debugMode = false);
 
     void syncDataFromColnod();
-    void syncDataFromDB();
+    void syncDataFromDBToColnod();
 
     void prepareDatabase();
 
@@ -24,10 +24,9 @@ public slots:
     void loadDataFromColnod();
     void loadDataFromDB();
 
-
 signals:
     void dataDownloaded();
-    void dataProcessed();
+    void dataUpdatedToColnod();
     void syncFinished();
 
 private slots:
@@ -40,22 +39,21 @@ private:
     void loadUpdatedDataFromDB();
     void loadDeletedDataFromDB();
 
+    void syncUpdatedDataFromColnodToDB();
+    void syncDeletedDataFromColnodToDB();
+
+    void syncUpdatedDataFromDBToColnod();
+    void syncDeletedDataFromDBToColnod();
 
-    void syncUpdatedDataFromColnod();
-    void syncDeletedDataFromColnod();
-    void areDataReady();
     void areChangedDataReady();
-    void areDataProcessed();
-    void processDataToColnod();
-
-
+    void areDataUpdatedToColnod();
 
+private:
     RequestManager* reqMan = nullptr;
     DataManager* dataMan = nullptr;
     bool debugMode = false;
     bool updateFinished = false;
     bool deleteFinished = false;
-
 };
 
 #endif // COLNODAPI_H
diff --git a/src/colnod/databasemanager.cpp b/src/colnod/databasemanager.cpp
index 4874f79..aabd7c7 100644
--- a/src/colnod/databasemanager.cpp
+++ b/src/colnod/databasemanager.cpp
@@ -1,6 +1,6 @@
 #include "databasemanager.h"
 
-DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QString password)
+DatabaseManager::DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password)
 {
 
     db = QSqlDatabase::addDatabase("QPSQL");
@@ -12,15 +12,16 @@ DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QSt
     //db.setPort(80);
     //
     db.setPassword(password);
-    opened = db.open();
-    if (!opened)
+
+    if (!db.open())
     {
         qDebug() << "Opening error" + db.lastError().text();
     }
     query = QSqlQuery("query", db);
 }
 
-void DatabaseManager::saveSubject(Subject* subject, QString table)
+// add or update subject to db
+void DatabaseManager::saveSubject(Subject* subject, const QString& table)
 {
     QString id = subject->idToStringWithoutBraces();
     if (checkIfExists(id, table))
@@ -47,7 +48,8 @@ void DatabaseManager::saveSubject(Subject* subject, QString table)
     }
 }
 
-void DatabaseManager::saveToken(Token* token, QString table)
+// add or update token to DB
+void DatabaseManager::saveToken(Token* token, const QString& table)
 {
     QString id = token->idToStringWithoutBraces();
     if (checkIfExists(id, table))
@@ -91,13 +93,13 @@ void DatabaseManager::saveToken(Token* token, QString table)
     }
 }
 
-void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
+// add of update subject attributes
+void DatabaseManager::saveSubjectAttributes(Subject *subject, const QString& table)
 {
     auto attributes = subject->getAtr();
-    for (auto attribute : attributes){
+    for (const auto& attribute : attributes){
         QString id = subject->idToStringWithoutBraces() + " " + attribute.first;
-        if (checkIfExists(id, table))
-        {
+        if (checkIfExists(id, table)){
             query.prepare(QString("UPDATE %1 SET id = :id, attribute_key = :key, attribute_value = :value, subject_id = :subject_id) "
                                   "WHERE id = :id").arg(table));
             query.bindValue(":id", id);
@@ -106,8 +108,7 @@ void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
             query.bindValue(":subject_id", subject->idToStringWithoutBraces());
             query.exec();
         }
-        else
-        {
+        else{
             query.prepare(QString("INSERT INTO %1 (id, attribute_key, attribute_value, subject_id)"
                                   "VALUES (:id, :key, :value, :subject_id)").arg(table));
             query.bindValue(":id", id);
@@ -119,7 +120,8 @@ void DatabaseManager::saveSubjectAttribute(Subject *subject, QString table)
     }
 }
 
-void DatabaseManager::setDeleted(QString id, QString table)
+// "delete" tokens from DB -> set deleted true
+void DatabaseManager::setDeleted(const QString& id, const QString& table)
 {
     quint64 now = getNow();
     QString nowString = QDateTime::fromMSecsSinceEpoch(now).toString("yyyy-MM-dd hh:mm:ss.zzz");
@@ -129,29 +131,7 @@ void DatabaseManager::setDeleted(QString id, QString table)
     query.exec();
 }
 
-QString DatabaseManager::getTestMessage(int id)
-{
-    query.prepare("SELECT message FROM test WHERE id = :id");
-    query.bindValue(":id", id);
-    query.exec();
-    query.next();
-    return query.value(0).toString();
-}
-
-int DatabaseManager::createTestRecord(QString msg)
-{
-    query.exec("SELECT MAX(id) FROM test");
-    query.next();
-    int id = query.value(0).toInt() + 1;
-    query.prepare("INSERT INTO test (id, message) VALUES (:id, :msg)");
-    query.bindValue(":id", id);
-    query.bindValue(":msg", msg);
-    query.exec();
-    qDebug() << "U inserted new row, id: " << id << "msg: " << getTestMessage(id);
-    return id;
-}
-
-bool DatabaseManager::checkIfExists(QString id, QString table)
+bool DatabaseManager::checkIfExists(const QString& id, const QString& table)
 {
     query.prepare(QString("SELECT EXISTS(SELECT 1 FROM %1 WHERE id = :id)").arg(table));
     query.bindValue(":id", id);
@@ -160,16 +140,23 @@ bool DatabaseManager::checkIfExists(QString id, QString table)
     return query.value(0).toBool();
 }
 
+bool DatabaseManager::executeQuery(QSqlQuery &query) const
+{
+    bool res = query.exec();
+    return res;
+
+}
+
 void DatabaseManager::dropTables()
 {
     query.exec("DROP TABLE IF EXISTS colnod_token, colnod_subject, colnod_subject_attribute");
 }
 
+// create table after deleting, it is used for full sync
 void DatabaseManager::createTables()
 {
     query.exec("CREATE TABLE colnod_subject ("
                "id character(36) primary key NOT NULL,"
-               //"access_pin smallint,"
                "description character varying(255),"
                "last_update timestamp NOT NULL,"
                "name character varying(255),"
@@ -198,6 +185,7 @@ void DatabaseManager::createTables()
                "subject_id CHAR(36))");
 }
 
+// return last_sync time
 uint64_t DatabaseManager::getLastSync()
 {
     query.exec("SELECT last_sync FROM config");
@@ -206,6 +194,7 @@ uint64_t DatabaseManager::getLastSync()
     return temp;
 }
 
+// on the very end of sync set new Last_sync time (begin of this sync)
 void DatabaseManager::updateLastSync(quint64 lastSync)
 {
     query.prepare("UPDATE config SET last_sync = :last_sync");
@@ -213,37 +202,8 @@ void DatabaseManager::updateLastSync(quint64 lastSync)
     query.exec();
 }
 
-void DatabaseManager::makeTestingLast_sync()
-{
-    query.prepare("INSERT INTO last_changes (last_sync) "
-               "VALUES (:time)");
-    query.bindValue(":time", QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz"));
-    query.exec();
-}
-
-QSqlQuery* DatabaseManager::getTokensToAdd()
-{
-    QSqlQuery* qry = new QSqlQuery;
-    qry->exec("SELECT name, token_data FROM changes WHERE status = 'toBeAdd'");
-    return qry;
-}
-
-QSqlQuery* DatabaseManager::getTokensToDelete()
-{
-    QSqlQuery* qry = new QSqlQuery;
-    qry->exec("SELECT id FROM changes WHERE status = 'toBeDeleted'");
-    return qry;
-}
-
-QUuid DatabaseManager::getId(QString name)
-{
-    query.prepare("SELECT id FROM colnod_subject WHERE name = :name");
-    query.bindValue(":name", name);
-    query.exec();
-    query.next();
-    return query.value(0).toUuid();
-}
 
+// return set of tokens to update form DB
 QSqlQuery* DatabaseManager::getUpdatedTokens()
 {
     QSqlQuery* qry = new QSqlQuery;
@@ -252,7 +212,7 @@ QSqlQuery* DatabaseManager::getUpdatedTokens()
     return qry;
 }
 
-QSqlQuery* DatabaseManager::getToken(QString id)
+QSqlQuery* DatabaseManager::getToken(const QString& id)
 {
     QSqlQuery* qry = new QSqlQuery;
     qry->prepare("SELECT SELECT id, auth_errors, description, enabled, last_update, name, no_validity, time_to_live, token_bits, token_data, token_type, subject_id, last_modified, deleted "
@@ -262,9 +222,7 @@ QSqlQuery* DatabaseManager::getToken(QString id)
     if (qry->next()){
         return qry;
     }
-    else {
-        return nullptr;
-    }
+    return nullptr;
 }
 
 quint64 DatabaseManager::getNow()
@@ -274,7 +232,8 @@ quint64 DatabaseManager::getNow()
     return query.value(0).toULongLong();
 }
 
-void DatabaseManager::setLastUpdate(QString id, quint64 lastUpdate)
+// sync last update back to DB from Colnod after changes made to Colnod
+void DatabaseManager::setLastUpdate(const QString& id, quint64 lastUpdate)
 {
     query.prepare("UPDATE colnod_token SET last_update = :lastUpdate WHERE id = :id");
     query.bindValue(":id", id);
diff --git a/src/colnod/databasemanager.h b/src/colnod/databasemanager.h
index cadc248..971f1ca 100644
--- a/src/colnod/databasemanager.h
+++ b/src/colnod/databasemanager.h
@@ -16,53 +16,32 @@ class DatabaseManager : public QObject
 {
     Q_OBJECT
 public:
-    DatabaseManager(QString host, QString dbName, QString user, QString password);
+    DatabaseManager(const QString& host, const QString& dbName, const QString& user, const QString& password);
 
-
-
-    void saveSubject(Subject* subject, QString table);
-    void saveToken(Token* token, QString table);
-    void saveSubjectAttribute(Subject* subject, QString table);
-    void setDeleted(QString id, QString table);
-
-
-    QString getTestMessage(int id);
-    int createTestRecord(QString msg);
-    //
-    void makeTestingLast_sync();
-    //
+    void saveSubject(Subject* subject, const QString& table);
+    void saveToken(Token* token, const QString& table);
+    void saveSubjectAttributes(Subject* subject, const QString& table);
+    void setDeleted(const QString& id, const QString& table);
 
     void dropTables();
     void createTables();
 
-    bool getOpened() {return opened;}
     quint64 getLastSync();
     void updateLastSync(quint64 lastSync);
     quint64 getNow();
 
     QSqlQuery* getUpdatedTokens();
-    QSqlQuery* getToken(QString id);
-
-    // Old version
-    QSqlQuery* getTokensToAdd();
-    QSqlQuery* getTokensToDelete();
-
-    void setLastUpdate(QString id, quint64 lastUpdate);
-
-    QUuid getId(QString name);
+    QSqlQuery* getToken(const QString& id);
 
+    void setLastUpdate(const QString& id, quint64 lastUpdate);
 
 private:
-    bool checkIfExists(QString id, QString table);
-
+    bool checkIfExists(const QString& id, const QString& table);
+    bool executeQuery(QSqlQuery &query) const;
 
 private:
     QSqlDatabase db;
     QSqlQuery query;
-
-    bool opened;
-
-
 };
 
 #endif // DATABASEMANAGER_H
diff --git a/src/colnod/datamanager.cpp b/src/colnod/datamanager.cpp
index 7606ddb..66995c9 100644
--- a/src/colnod/datamanager.cpp
+++ b/src/colnod/datamanager.cpp
@@ -9,113 +9,123 @@ DataManager::DataManager()
     //db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12");
 }
 
-void DataManager::fillFullTokensColnod(QString response)
+// load all tokens from colnod to comparing with working set from DB
+void DataManager::fillFullTokensColnod(const QString& response)
 {
     QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
     QJsonArray items = doc.object()["items"].toArray();
-    if (items.size() > 0)
+    if (!items.empty())
     {
         for (QJsonValueRef item : items)
         {
             auto token = new Token();
             token->fromJSON(item.toObject());
-            fullTokensColnod.insert(token->idToStringWithoutBraces(), token);
+            allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
         }
     }
     else
     {
         auto token = new Token("empty");
-        fullTokensColnod.insert(token->idToStringWithoutBraces(), token);
+        allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
     }
 }
 
-void DataManager::fillTokensColnod(QString response)
+// load working set with updated tokens from Colnod
+void DataManager::fillTokensToUpdateColnod(const QString& response)
 {
     QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
     QJsonArray items = doc.object()["items"].toArray();
-    if (items.size() > 0)
+    if (!items.empty())
     {
         for (QJsonValueRef item : items)
         {
             auto token = new Token();
             token->fromJSON(item.toObject());
             token->setDeleted(false);
-            tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token);
+            tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
         }
     }
     else
     {
         auto token = new Token("empty");
-        tokensToUpdateColnod.insert(token->idToStringWithoutBraces(), token);
+        tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
     }
 }
 
-void DataManager::fillSubjectsColnod(QString response)
+// load working set with updated subjects from Colnod
+void DataManager::fillSubjectsToUpdateColnod(const QString& response)
 {
     QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
     QJsonArray items = doc.object()["items"].toArray();
-    if (items.size() > 0)
+    if (!items.empty())
     {
         for (QJsonValueRef item : items)
         {
             auto subject = new Subject();
             subject->fromJSON(item.toObject());
-            subjectsColnod.insert(subject->idToStringWithoutBraces(), subject);
+            subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
         }
     }
     else
     {
         Subject* subject = new Subject("empty");
-        subjectsColnod.insert(subject->idToStringWithoutBraces(), subject);
+        subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
     }
 }
 
-// fills tokensDB and tokensToDeleteDB
-void DataManager::fillTokensDB()
+// load working sets with updated/deleted tokens from DB
+void DataManager::fillTokensToUpdateDB()
 {
     QSqlQuery* query = db->getUpdatedTokens();
     while (query->next())
     {
         auto token = new Token;
         token->fromSQLRecord(query);
-        tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token);
+        if (token->getDeleted()){                   // sort to delete and to update
+            tokensFromDBToDeleteFromColnod.append(token->idToStringWithoutBraces());
+        }
+        else{
+        tokensToUpdateFromDBToColnod.insert(token->idToStringWithoutBraces(), token);
+        }
     }
-    qDebug() << "Number of tokens to update from DB: "<< tokensToUpdateDB.size();
-    qDebug() << "Number of tokens to delete from DB: "<< tokensToDeleteDB.size();
+    qDebug() << "Number of tokens to update from DB: "<< tokensToUpdateFromDBToColnod.size();
+    qDebug() << "Number of tokens to delete from DB: "<< tokensFromDBToDeleteFromColnod.size();
 }
 
-void DataManager::fillSubjectsDB()
+void DataManager::fillSubjectsToUpdateDB()
 {
    // Not needed yet
 }
 
-void DataManager::fillSubjectsToDeleteColnod(QString json)
+// load working set with subjest to delete from Colnod
+void DataManager::fillSubjectsToDeleteColnod(const QString& json)
 {
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray items = doc.object()["items"].toArray();
-    if (items.size() > 0)
+    if (!items.empty())
     {
         for (QJsonValueRef item : items) {
-            subjectsToDeleteColnod.append(item.toString());
+            subjectsFromColnodToDeleteFromDB.append(item.toString());
         }
     }
     else {
-        subjectsToDeleteColnod.append("empty");
+        subjectsFromColnodToDeleteFromDB.append("empty");
     }
 }
 
-void DataManager::fillTokensToDeleteColnod(QString json)
+// load working set with tokenst to delete from colnod
+void DataManager::fillTokensToDeleteColnod(const QString& json)
 {
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray items = doc.object()["items"].toArray();
-    if (items.size() > 0)
+    if (!items.empty())
     {
         for (QJsonValueRef item : items) {
-            tokensToDeleteColnod.append(item.toString());
+            tokensFromColnodToDeleteFromDB.append(item.toString());
         }
     }
     else {
-        tokensToDeleteColnod.append("empty");
+        tokensFromColnodToDeleteFromDB.append("empty");
     }
 }
 
@@ -124,134 +134,126 @@ void DataManager::fillSubjectsToDeleteDB()
     // Not needed yet
 }
 
+// update subjects from colnod to DB
 void DataManager::pushSubjectsToDB()
 {
-    if (subjectsColnod.contains("empty")) {
+    if (subjectsToUpdateFromColnodToDB.contains("empty")) {
         qDebug() << "All subjects are up to date";
         return;
     }
     //QSqlDatabase::database().transaction();
     qDebug() << "Subjects in progress...";
-    for (auto subject : subjectsColnod)
+    for (const auto& subject : subjectsToUpdateFromColnodToDB)
     {
         db->saveSubject(subject, "colnod_subject");
-        db->saveSubjectAttribute(subject, "colnod_subject_attribute");
+        db->saveSubjectAttributes(subject, "colnod_subject_attribute");
     }
     //QSqlDatabase::database().commit();
-    qDebug() << subjectsColnod.size() << " subjects has been updated";
+    qDebug() << subjectsToUpdateFromColnodToDB.size() << " subjects has been updated";
 
 }
 
+// update tokens from colnod to DB
 void DataManager::pushTokensToDB()
 {
-    if (tokensToUpdateColnod.contains("empty"))
+    if (tokensToUpdateFromColnodToDB.contains("empty"))
     {
         qDebug() << "All tokens are up to date";
         return;
     }
     //QSqlDatabase::database().transaction();
     qDebug() << "Tokens in progress...";
-    for (auto token : tokensToUpdateColnod)
+    for (const auto& token : tokensToUpdateFromColnodToDB)
     {
         db->saveToken(token, "colnod_token");
     }
     //QSqlDatabase::database().commit();
-    qDebug() << tokensToUpdateColnod.size() << " tokens has been updated";
+    qDebug() << tokensToUpdateFromColnodToDB.size() << " tokens has been updated";
 }
 
 void DataManager::deleteSubjectsFromDB()
 {
-    if (subjectsToDeleteColnod[0] == "empty")
+    if (subjectsFromColnodToDeleteFromDB[0] == "empty")
     {
         qDebug() << "No subjects to be deleted";
         return;
     }
     qDebug() << "Deleted subjects in progress...";
-    for (auto subjectId : subjectsToDeleteColnod)
+    for (const auto& subjectId : subjectsFromColnodToDeleteFromDB)
     {
         db->setDeleted(subjectId, "colnod_subject");
     }
-    qDebug() << subjectsToDeleteColnod.size() << "subject has beed deleted";
+    qDebug() << subjectsFromColnodToDeleteFromDB.size() << "subject has beed deleted";
 }
 
-void DataManager::deleteTokensFromDB()
+// "delete" (set deleted true) tokens in DB depends on Colnod
+void DataManager::setDeletedToTokensFromDB()
 {
-    if (tokensToDeleteColnod[0] == "empty")
+    if (tokensFromColnodToDeleteFromDB[0] == "empty")
     {
         qDebug() << "No tokens to be deleted";
         return;
     }
     qDebug() << "Deleted tokens in progress...";
-    for (auto tokenId : tokensToDeleteColnod)
+    for (const auto& tokenId : tokensFromColnodToDeleteFromDB)
     {
         db->setDeleted(tokenId, "colnod_token");
     }
-    qDebug() << tokensToDeleteColnod.size() << "tokens has beed deleted";
-}
-
-bool DataManager::haveData()
-{
-  if ( !subjectsColnod.isEmpty() && !tokensToUpdateColnod.isEmpty() )
-    return true;
-  return false;
+    qDebug() << tokensFromColnodToDeleteFromDB.size() << "tokens has beed deleted";
 }
 
+// do I have loaded all data
 bool DataManager::haveChangedData()
 {
-    if ( !subjectsColnod.isEmpty() &&
-         !tokensToUpdateColnod.isEmpty() &&
-         !subjectsToDeleteColnod.isEmpty() &&
-         !tokensToDeleteColnod.isEmpty() &&
-         !fullTokensColnod.isEmpty() )
-        return true;
-    return false;
-}
-
-bool DataManager::haveProcessData()
-{
-    if ( !tokensToUpdateColnod.isEmpty() && !tokensToDeleteColnod.isEmpty())
-        return true;
-    return false;
+    return !subjectsToUpdateFromColnodToDB.isEmpty() &&
+         !tokensToUpdateFromColnodToDB.isEmpty() &&
+         !subjectsFromColnodToDeleteFromDB.isEmpty() &&
+         !tokensFromColnodToDeleteFromDB.isEmpty() &&
+         !allTokensFromColnod.isEmpty();
 }
 
+// recreate working tables
 void DataManager::emptyDatabase()
 {
     db->dropTables();
     db->createTables();
 }
 
+//clear all structures
 void DataManager::clear()
 {
-    subjectsColnod.clear();
-    subjectsToDeleteColnod.clear();
-    tokensToUpdateColnod.clear();
-    tokensToDeleteColnod.clear();
-    subjectsDB.clear();
-    subjectsToDeleteDB.clear();
-    tokensToUpdateDB.clear();
-    tokensToDeleteDB.clear();
-    fullTokensColnod.clear();
+    subjectsToUpdateFromColnodToDB.clear();
+    subjectsFromColnodToDeleteFromDB.clear();
+    tokensToUpdateFromColnodToDB.clear();
+    tokensFromColnodToDeleteFromDB.clear();
+   //subjectsDB.clear();            // not need yet
+   // subjectsToDeleteDB.clear();   // not need yet
+    tokensToUpdateFromDBToColnod.clear();
+    tokensFromDBToDeleteFromColnod.clear();
+    allTokensFromColnod.clear();
 }
 
+// on the very end of sync update last sync time to begin time of this sync
 void DataManager::updateLastSync()
 {
     db->updateLastSync(nextLastSync);
 }
 
+// these to filter functions solve colision tokens -> remove when change on this token is earlier then change on the same token on the other side (Colnod/DB)
 void DataManager::filterTokensDB()
 {
-    for (auto token : tokensToUpdateDB)
+    for (auto token : tokensToUpdateFromDBToColnod)
     {
         QString id = token->idToStringWithoutBraces();
-        Q_ASSERT(token = fullTokensColnod.value(id));
-        if (fullTokensColnod.contains(id) && token < fullTokensColnod.value(id))
-            tokensToUpdateDB.remove(id);
+        Q_ASSERT(token = allTokensFromColnod.value(id));        // if working sets are loading correctly equels should never happend
+        if (allTokensFromColnod.contains(id) && token < allTokensFromColnod.value(id))
+            tokensToUpdateFromDBToColnod.remove(id);
     }
 }
 
 void DataManager::filterTokensColnod()
 {
-    for (auto token : tokensToUpdateColnod)
+    for (const auto &token : tokensToUpdateFromColnodToDB)
     {
         QString id = token->idToStringWithoutBraces();
         auto record = db->getToken(id);
@@ -261,39 +263,14 @@ void DataManager::filterTokensColnod()
         tokenDB->fromSQLRecord(record);
         Q_ASSERT(tokenDB != token);
         if (tokenDB > token)
-            tokensToUpdateColnod.remove(id);
+            tokensToUpdateFromColnodToDB.remove(id);
     }
 }
 
-// old version
-void DataManager::loadTokensToAdd()
-{
-    QSqlQuery* query = db->getTokensToAdd();
-    while (query->next())
-    {
-        Token* token = new Token(query->value(0).toString(), query->value(1).toString());
-        token->setSubjectId(db->getId(token->getName()));
-        tokensToUpdateDB.insert(token->idToStringWithoutBraces(), token);
-    }
-    if (tokensToUpdateDB.isEmpty())
-        tokensToUpdateDB.insert("empty", nullptr);
-}
-
-void DataManager::loadTokensToDelete()
-{
-    QSqlQuery* query = db->getTokensToDelete();
-    while (query->next())
-    {
-        tokensToDeleteDB.append(query->value(0).toString());
-    }
-    if (tokensToDeleteDB.isEmpty())
-        tokensToDeleteDB.append("empty");
-}
-
-
+// sync last update in colnod and DB
 void DataManager::setLastUpdate()
 {
-    for (auto token : tokensToUpdateColnod){
+    for (const auto &token : tokensToUpdateFromColnodToDB){
         db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
     }
 }
diff --git a/src/colnod/datamanager.h b/src/colnod/datamanager.h
index 7a14373..ebe5eff 100644
--- a/src/colnod/datamanager.h
+++ b/src/colnod/datamanager.h
@@ -17,16 +17,15 @@ class DataManager : public QObject
 public:
     DataManager();
 
-    void getAndSetLastSync();
-    void fillFullTokensColnod(QString jsonResponse);
+    void fillFullTokensColnod(const QString& jsonResponse);
 
-    void fillTokensColnod(QString jsonResponse);
-    void fillSubjectsColnod(QString jsonResponse);
-    void fillSubjectsToDeleteColnod(QString jsonResponse);
-    void fillTokensToDeleteColnod(QString jsonResponse);
+    void fillTokensToUpdateColnod(const QString& jsonResponse);
+    void fillSubjectsToUpdateColnod(const QString& jsonResponse);
+    void fillSubjectsToDeleteColnod(const QString& jsonResponse);
+    void fillTokensToDeleteColnod(const QString& jsonResponse);
 
-    void fillTokensDB();
-    void fillSubjectsDB();
+    void fillTokensToUpdateDB();
+    void fillSubjectsToUpdateDB();
     void fillSubjectsToDeleteDB();
 
     void filterTokensDB();
@@ -35,23 +34,18 @@ public:
     void pushSubjectsToDB();
     void pushTokensToDB();
     void deleteSubjectsFromDB();
-    void deleteTokensFromDB();
+    void setDeletedToTokensFromDB();
 
     void updateLastSync();
 
-    bool haveData();
     bool haveChangedData();
-    bool haveProcessData();
 
     void emptyDatabase();
 
-    void loadTokensToAdd();
-    void loadTokensToDelete();
-
-    QHash<QString, QPointer<Token>> getTokensToUpdateColnod() {return tokensToUpdateColnod;}
-    QList<QString> getTokensToDeleteColnod() {return tokensToDeleteColnod;}
-    QHash<QString, QPointer<Token>> getTokensToUpdateDB() {return tokensToUpdateDB;}
-    QList<QString> getTokensToDeleteDB() {return tokensToDeleteDB;}
+    QHash<QString, QPointer<Token>> getTokensToUpdateColnod() {return tokensToUpdateFromColnodToDB;}
+    QList<QString> getTokensToDeleteColnod() {return tokensFromColnodToDeleteFromDB;}
+    QHash<QString, QPointer<Token>> getTokensToUpdateDB() {return tokensToUpdateFromDBToColnod;}
+    QList<QString> getTokensToDeleteDB() {return tokensFromDBToDeleteFromColnod;}
 
     const quint64 &getLastSync() {return lastSync;}
     const quint64 &getActualSync() {return nextLastSync;}
@@ -64,20 +58,19 @@ public slots:
 private:
     DatabaseManager *db = nullptr;
 
-    quint64 lastSync;
-    quint64 nextLastSync;
+    quint64 lastSync;       // time of last run
+    quint64 nextLastSync;   // time of begin of this run
 
-    QHash<QString, QPointer<Subject>> subjectsColnod;
-    QHash<QString, QPointer<Token>> tokensToUpdateColnod;
-    QHash<QString, QPointer<Token>> fullTokensColnod;
+    QHash<QString, QPointer<Subject>> subjectsToUpdateFromColnodToDB;
+    QHash<QString, QPointer<Token>> tokensToUpdateFromColnodToDB;
+    QHash<QString, QPointer<Token>> allTokensFromColnod;
     QHash<QString, QPointer<Subject>> subjectsDB; // in future
-    QHash<QString, QPointer<Token>> tokensToUpdateDB;
+    QHash<QString, QPointer<Token>> tokensToUpdateFromDBToColnod;
 
-
-    QList<QString> subjectsToDeleteColnod;
-    QList<QString> tokensToDeleteColnod;
+    QList<QString> subjectsFromColnodToDeleteFromDB;
+    QList<QString> tokensFromColnodToDeleteFromDB;
     QList<QString> subjectsToDeleteDB;
-    QList<QString> tokensToDeleteDB;
+    QList<QString> tokensFromDBToDeleteFromColnod;
 
 };
 
diff --git a/src/colnod/entity.h b/src/colnod/entity.h
index de44ca0..97925c2 100644
--- a/src/colnod/entity.h
+++ b/src/colnod/entity.h
@@ -27,11 +27,11 @@ public:
 
     virtual void fromJSON(const QJsonObject &json);
     virtual QJsonObject toJSON() const;
-protected:
+private:
     QUuid id;
     QString name;
     QString description;
-    qint64 lastUpdate;
+    qint64 lastUpdate{};
 };
 
 
diff --git a/src/colnod/requestmanager.cpp b/src/colnod/requestmanager.cpp
index 45733bf..39f9b48 100644
--- a/src/colnod/requestmanager.cpp
+++ b/src/colnod/requestmanager.cpp
@@ -4,15 +4,7 @@ RequestManager::RequestManager()
 {
     manager = new QNetworkAccessManager();
     token = "";
-    loginStatus = false;  //should be false, true for testing request header
-/*
-    QFile configFile(QDir::current().filePath("config.json"));
-       if (!configFile.open(QIODevice::ReadOnly)) {
-           qCritical() << "Couldn't open config file config.json" << QDir::current().filePath("config.json");
-           QCoreApplication::exit(-1);
-           return;
-       }
-    this->config = QJsonDocument::fromJson(configFile.readAll());*/
+    loginStatus = false;
     QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
 }
 
@@ -53,7 +45,7 @@ Response* RequestManager::login()
     return loginResponse;
 }
 
-QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json)
+QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
 {
     QNetworkRequest request;
     request.setUrl(host + endpoint);
@@ -75,26 +67,21 @@ QNetworkReply* RequestManager::postRequest(QString endpoint, QByteArray json)
     return reply;
 }
 
-
+// This will ensure login is called only once
 Response* RequestManager::getLoginResponse() {
     if (!loginResponse){
         loginResponse = login();
-
-
     }
     return loginResponse;
 }
 
-Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray data)
+Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
 {
     auto loginResponse = getLoginResponse();
-    // This will ensure login is called only once
-
     Q_ASSERT(loginResponse);
-    Response* response = new Response;
+    auto* response = new Response;
 
     if (!loginStatus){
-
         connect(this, &RequestManager::successLogin, [=](){
             response->setReply(postRequest(endpoint, data));
             connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
@@ -108,9 +95,10 @@ Response* RequestManager::postRequestReturnLogic(QString endpoint, QByteArray da
     return response;
 }
 
-QString RequestManager::getFromJson(QString json, const QString &member)
+// get value of member in json
+QString RequestManager::getFromJson(const QString& json, const QString &member)
 {
-    QJsonParseError err;
+    QJsonParseError err{};
     QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
     if (err.error != 0)
     {
@@ -119,12 +107,12 @@ QString RequestManager::getFromJson(QString json, const QString &member)
     return document.object().value(member).toString();
 }
 
-QString RequestManager::encryptedPassword(QString password)
+QString RequestManager::encryptedPassword(const QString& password)
 {
      return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
 }
 
-QString RequestManager::getLoginHeader(QString username, QString hash)
+QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
 {
     QString authValue = username + ":" + hash;
     return "Basic " + authValue.toLocal8Bit().toBase64();
@@ -150,7 +138,7 @@ void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &er
 
 }
 
-QByteArray RequestManager::makeTimeStampJson(uint64_t time)
+QByteArray RequestManager::makeTimestampJson(uint64_t time)
 {
     QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }};
     QJsonDocument doc;
@@ -162,7 +150,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
 {
     QJsonObject items;
     QJsonArray jsonTokens;
-    for (auto token : tokens)
+    for (const auto& token : tokens)
     {
         jsonTokens.push_back(token->toJSON());
     }
@@ -175,7 +163,7 @@ QByteArray RequestManager::makeTokensJson(const QHash<QString, QPointer<Token> >
 QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
 {
     QJsonArray jsonIds;
-    for (auto id : ids)
+    for (const auto& id : ids)
     {
         jsonIds.push_back(id);
     }
@@ -203,22 +191,22 @@ Response* RequestManager::getTokenSubject()
 
 Response* RequestManager::getSubjectsUpdated(uint64_t time)
 {
-    return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimeStampJson(time));
+    return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(time));
 }
 
 Response* RequestManager::getSubjectsDeleted(uint64_t time)
 {
-    return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimeStampJson(time));
+    return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimestampJson(time));
 }
 
 Response* RequestManager::getTokensUpdated(uint64_t time)
 {
-    return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimeStampJson(time));
+    return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
 }
 
 Response* RequestManager::getTokensDeleted(uint64_t time)
 {
-    return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimeStampJson(time));
+    return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
 }
 
 Response* RequestManager::getAccessGroups()
@@ -228,12 +216,12 @@ Response* RequestManager::getAccessGroups()
 
 Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
 {
-    return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimeStampJson(time));
+    return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
 }
 
 Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
 {
-    return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimeStampJson(time));
+    return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
 }
 
 Response* RequestManager::getAccessGroupMembership()
@@ -243,12 +231,12 @@ Response* RequestManager::getAccessGroupMembership()
 
 Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
 {
-    return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimeStampJson(time));
+    return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(time));
 }
 
 Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time)
 {
-     return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimeStampJson(time));
+     return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimestampJson(time));
 }
 
 Response* RequestManager::setTokens(const QHash<QString, QPointer<Token> > &tokens)
diff --git a/src/colnod/requestmanager.h b/src/colnod/requestmanager.h
index e169b58..375499e 100644
--- a/src/colnod/requestmanager.h
+++ b/src/colnod/requestmanager.h
@@ -58,13 +58,13 @@ public:
     const QString &getResponse() const {return jsonResponse;}
 
 private:
-    QNetworkReply* postRequest(QString endpoint, QByteArray json = QByteArray());
-    Response* postRequestReturnLogic(QString endpoint, QByteArray data = QByteArray());
-    QString getFromJson(QString json, const QString &member);
-    QString encryptedPassword(QString password);
-    QString getLoginHeader(QString username, QString hash);
+    QNetworkReply* postRequest(const QString& endpoint, const QByteArray& json = QByteArray());
+    Response* postRequestReturnLogic(const QString& endpoint, const QByteArray& data = QByteArray());
+    QString getFromJson(const QString& json, const QString &member);
+    QString encryptedPassword(const QString& password);
+    QString getLoginHeader(const QString& username, const QString& hash);
 
-    QByteArray makeTimeStampJson(uint64_t time);
+    QByteArray makeTimestampJson(uint64_t time);
     QByteArray makeTokensJson(const QHash<QString, QPointer<Token>> &tokens);
     QByteArray makeIdsJson(const QList<QString> &ids);
     Response* getLoginResponse();
diff --git a/src/colnod/subject.cpp b/src/colnod/subject.cpp
index 1cfb763..6556cf6 100644
--- a/src/colnod/subject.cpp
+++ b/src/colnod/subject.cpp
@@ -4,9 +4,9 @@
 
 #include <QJsonArray>
 
-Subject::Subject(QString namee)
+Subject::Subject(QString name)
 {
-    this->name = namee;
+    setName(std::move(name));
 }
 
 QString Subject::getEmail() const {
@@ -17,10 +17,10 @@ void Subject::fromJSON(const QJsonObject &json) {
     Entity::fromJSON(json);
 
     attributes = json.value("attributes").toObject().value("items").toObject();
-    for (int i = 0; i < attributeTypes->length(); i++)
+    for (const auto & attributeType : attributeTypes)
     {
-        if (!attributes[attributeTypes[i]].toString().isEmpty()){
-            atr.append(qMakePair(attributeTypes[i], attributes[attributeTypes[i]].toString()));
+        if (!attributes[attributeType].toString().isEmpty()){
+            atr.append(qMakePair(attributeType, attributes[attributeType].toString()));
         }
     }
     const auto &tokenFlagsArray = json.value("tokenFlags").toArray();
diff --git a/src/colnod/subject.h b/src/colnod/subject.h
index 1377c50..dd587eb 100644
--- a/src/colnod/subject.h
+++ b/src/colnod/subject.h
@@ -12,7 +12,7 @@ class Subject : public Entity {
 
 public:
     using Entity::Entity;
-
+    Subject() = default;
     Subject(QString name);
 
     QString getEmail() const;
@@ -33,14 +33,14 @@ public:
 
     void fromJSON(const QJsonObject &json) override;
     QJsonObject toJSON() const override;
-protected:
+private:
     QJsonObject attributes;
     QSet<QString> tokenFlags;
     QString pin;
     QSet<QString> pinFlags;
     //QList<QPointer<Attribute>> atr;
     QList<QPair<QString, QString>> atr;
-    const QString attributeTypes[6] = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"};
+    const std::array<QString, 6> attributeTypes = {"Jmeno", "Prijmeni", "ProfilParking", "Spolecnost", "Profil", "spz"};
 
 };
 
diff --git a/src/colnod/token.cpp b/src/colnod/token.cpp
index 2b48e1e..6f24b9b 100644
--- a/src/colnod/token.cpp
+++ b/src/colnod/token.cpp
@@ -1,13 +1,14 @@
 #include "token.h"
 
 #include <QJsonArray>
+#include <utility>
 
-Token::Token(QString namee, QString tokenData, QString decription)
+Token::Token(QString name, QString tokenData, QString decription)
 {
-    this->name = namee;
-    this->tokenData = tokenData;
-    this->description = decription;
-    this->id = QUuid::createUuid();
+    this->setName(std::move(name));
+    this->tokenData = std::move(tokenData);
+    this->setDescription(std::move(decription));
+    this->setId(QUuid::createUuid());
     this->tokenType = "Token";
     this->tokenBits = 32;
     this->timeToLive = 255;
@@ -16,9 +17,9 @@ Token::Token(QString namee, QString tokenData, QString decription)
 
 }
 
-Token::Token(QString namee)
+Token::Token(QString name)
 {
-    this->name = namee;
+    this->setName(std::move(name));
 }
 
 
@@ -57,17 +58,17 @@ QJsonObject Token::toJSON() const {
 
 void Token::fromSQLRecord(QSqlQuery *query)
 {
-    id = query->value(0).toUuid();
+    setId(query->value(0).toUuid());
     authErrors = query->value(1).toInt();
-    description = query->value(2).toString();
+    setDescription(query->value(2).toString());
     QSet<QString> flags;
     if (query->value(6).toBool())
         flags.insert("NoValidity");
     if (query->value(3).toBool())
         flags.insert("Enabled");
     this->flags = flags;
-    lastUpdate = query->value(4).toUInt();
-    name = query->value(5).toString();
+    setLastUpdate(query->value(4).toUInt());
+    setName(query->value(5).toString());
     timeToLive = query->value(7).toInt();
     tokenBits = query->value(8).toInt();
     tokenData = query->value(9).toString();
diff --git a/src/colnod/token.h b/src/colnod/token.h
index c06dcdc..5d58eff 100644
--- a/src/colnod/token.h
+++ b/src/colnod/token.h
@@ -51,18 +51,19 @@ public:
     void fromSQLRecord(QSqlQuery* query);
     void fromJSON(const QJsonObject &json) override;
     QJsonObject toJSON() const override;
-protected:
+
+private:
     QString tokenType;
-    int tokenBits;
+    int tokenBits{};
     QString tokenData;
-    quint64 validFrom;
-    quint64 validTo;
-    int timeToLive;
-    int authErrors;
+    qint64 validFrom{};
+    qint64 validTo{};
+    int timeToLive{};
+    int authErrors{};
     QSet<QString> flags;
     QUuid subjectId;
-    quint64 lastModified;
-    bool deleted;
+    quint64 lastModified{};
+    bool deleted{};
 };
 
 
diff --git a/test/unitTests/UnitTest.cpp b/test/unitTests/UnitTest.cpp
index d907b5e..f442bbd 100644
--- a/test/unitTests/UnitTest.cpp
+++ b/test/unitTests/UnitTest.cpp
@@ -7,12 +7,11 @@ void UnitTest::initTestCase()
 
 void UnitTest::loginSuccessfully()
 {
-    RequestManager* testAccess = new RequestManager();
-    QJsonDocument config = testAccess->getConfig();
+    auto testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(successLogin()));
     QVERIFY(spy.isValid());
     testAccess->login();
-    spy.wait(15000);
+    spy.wait(timeout);
 
     QCOMPARE(spy.count(), 1);
     QString json = testAccess->getResponse();
@@ -24,13 +23,13 @@ void UnitTest::loginSuccessfully()
 //POST request w/o datas
 void UnitTest::getSubjects()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     QVERIFY(spy.isValid());
     Response* response = testAccess->getSubjects();
     QSignalSpy spy1(response, &Response::ready);
 
-    spy.wait(15000);
+    spy.wait(timeout);
 
     QCOMPARE(spy.count(), 1);
     QCOMPARE(spy1.count(), 1);
@@ -45,11 +44,11 @@ void UnitTest::getSubjects()
 
 void UnitTest::getTokens()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     Response* response = testAccess->getTokens();
     QSignalSpy spy(response, &Response::ready);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -62,11 +61,11 @@ void UnitTest::getTokens()
 
 void UnitTest::getTokenSubject()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->getTokenSubject();
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -75,11 +74,11 @@ void UnitTest::getTokenSubject()
 
 void UnitTest::getSubjectsUpdated()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getSubjectsUpdated(1568646217767);
+    Response* response = testAccess->getSubjectsUpdated(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -88,11 +87,11 @@ void UnitTest::getSubjectsUpdated()
 
 void UnitTest::getSubjectsDeleted()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getSubjectsDeleted(1568646217767);
+    Response* response = testAccess->getSubjectsDeleted(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -101,11 +100,11 @@ void UnitTest::getSubjectsDeleted()
 
 void UnitTest::getTokensUpdated()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getTokensUpdated(1570109859681);
+    Response* response = testAccess->getTokensUpdated(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -114,11 +113,11 @@ void UnitTest::getTokensUpdated()
 
 void UnitTest::getTokensDeleted()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getTokensDeleted(1570109859681);
+    Response* response = testAccess->getTokensDeleted(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -127,11 +126,11 @@ void UnitTest::getTokensDeleted()
 
 void UnitTest::getAccessGroups()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->getAccessGroups();
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -140,11 +139,11 @@ void UnitTest::getAccessGroups()
 
 void UnitTest::getAccessGroupsUpdated()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getAccessGroupsUpdated(1568646217767);
+    Response* response = testAccess->getAccessGroupsUpdated(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -153,11 +152,11 @@ void UnitTest::getAccessGroupsUpdated()
 
 void UnitTest::getAccessGroupsDeleted()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getAccessGroupsDeleted(1568646217767);
+    Response* response = testAccess->getAccessGroupsDeleted(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -166,11 +165,11 @@ void UnitTest::getAccessGroupsDeleted()
 
 void UnitTest::getAccessGroupMembership()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->getAccessGroupMembership();
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -179,11 +178,11 @@ void UnitTest::getAccessGroupMembership()
 
 void UnitTest::getAccessGroupMembershipUpdated()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getAccessGroupMembershipUpdated(1568646217767);
+    Response* response = testAccess->getAccessGroupMembershipUpdated(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -192,11 +191,11 @@ void UnitTest::getAccessGroupMembershipUpdated()
 
 void UnitTest::getAccessGroupMembershipDeleted()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
-    Response* response = testAccess->getAccessGroupMembershipDeleted(1568646217767);
+    Response* response = testAccess->getAccessGroupMembershipDeleted(epochMS);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -220,11 +219,11 @@ void UnitTest::setTokens()
         qDebug() << token;
         tokens.insert(token->idToStringWithoutBraces(), token);
     }
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->setTokens(tokens);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -233,14 +232,14 @@ void UnitTest::setTokens()
 
 void UnitTest::deleteTokens()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     QList<QString> ids;
     ids.append("582c982d-6fd7-4856-8548-7ce542791c7a");
     ids.append("3ff23b41-3da3-4b33-82ce-d8e2d8c9a546");
     Response* response = testAccess->deleteTokens(ids);
     QCOMPARE(spy.count(), 0);
-    spy.wait(15000);
+    spy.wait(timeout);
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = response->getJson();
@@ -262,10 +261,10 @@ void UnitTest::subjectJSONParser()
     QJsonObject obj = doc.object();
     QJsonArray arr = obj["items"].toArray();
     */
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->getSubjects();
-    spy.wait(15000);
+    spy.wait(timeout);
     QString json = response->getJson();
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray arr = doc.object()["items"].toArray();
@@ -277,10 +276,10 @@ void UnitTest::subjectJSONParser()
 
 void UnitTest::tokenJSONParser()
 {
-    RequestManager* testAccess = new RequestManager();
+    auto* testAccess = new RequestManager();
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     Response* response = testAccess->getTokens();
-    spy.wait(15000);
+    spy.wait(timeout);
     QString json = response->getJson();
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QJsonArray arr = doc.object()["items"].toArray();
@@ -290,15 +289,15 @@ void UnitTest::tokenJSONParser()
     QVERIFY(!testToken->getName().isEmpty());
 }
 
-void UnitTest::connectToDB()
-{
-    DatabaseManager *db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
-    QVERIFY(db->getOpened());
-    qDebug() << db->getTestMessage(1);
-    QVERIFY(true);
-    QCOMPARE(db->getTestMessage(1), QStringLiteral("Hello world"));
-    QCOMPARE(db->getTestMessage(db->createTestRecord("Now it's diffrent")), QStringLiteral("Now it's diffrent"));
-}
+//void UnitTest::connectToDB()
+//{
+//    DatabaseManager *db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
+//    QVERIFY(db->getOpened());
+//    qDebug() << db->getTestMessage(1);
+//    QVERIFY(true);
+//    QCOMPARE(db->getTestMessage(1), QStringLiteral("Hello world"));
+//    QCOMPARE(db->getTestMessage(db->createTestRecord("Now it's diffrent")), QStringLiteral("Now it's diffrent"));
+//}
 
 /*
 void UnitTest::debugConnection()
diff --git a/test/unitTests/complextest.cpp b/test/unitTests/complextest.cpp
index cbe31d5..a2ea479 100644
--- a/test/unitTests/complextest.cpp
+++ b/test/unitTests/complextest.cpp
@@ -9,7 +9,7 @@ void ComplexTest::initTestCase()
     Response* deleteTokensResp = reqMan1->deleteTokens(ids);
     QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
     QCOMPARE(deleteTokensRespSpy.count(), 0);
-    deleteTokensRespSpy.wait(10000);
+    deleteTokensRespSpy.wait(timeout);
     QTest::qWait(2500);
     start = QDateTime::currentMSecsSinceEpoch()-2000;
     api = new ColnodAPI;
@@ -26,7 +26,7 @@ void ComplexTest::cleanupTestCase()
     Response* deleteTokensResp = reqMan->deleteTokens(ids);
     QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
     QCOMPARE(deleteTokensRespSpy.count(), 0);
-    deleteTokensRespSpy.wait(10000);
+    deleteTokensRespSpy.wait(timeout);
     QCOMPARE(deleteTokensRespSpy.count(), 1);
 }
 
@@ -39,7 +39,7 @@ void ComplexTest::complexTest()
     QSignalSpy loginRespSpy(loginResp, &Response::ready);
     QCOMPARE(loginSpy.count(), 0);
     QCOMPARE(loginRespSpy.count(), 0);
-    loginSpy.wait(10000);
+    loginSpy.wait(timeout);
     QCOMPARE(loginResp->getStatusCode(), 200); // HTTP status code check
     QCOMPARE(loginSpy.count(), 1); // Checking multiple calls
     QCOMPARE(loginRespSpy.count(), 1);
@@ -62,7 +62,7 @@ void ComplexTest::complexTest()
     Response* setTokensResp = reqMan->setTokens(tokens);
     QSignalSpy setTokensRespSpy(setTokensResp, &Response::ready);
     QCOMPARE(setTokensRespSpy.count(), 0);
-    setTokensRespSpy.wait(10000);
+    setTokensRespSpy.wait(timeout);
     QCOMPARE(setTokensRespSpy.count(), 1);
     QCOMPARE(setTokensResp->getStatusCode(), 200);
     QCOMPARE(getNumOfTokens(), numOfTokens + 1);
@@ -73,7 +73,7 @@ void ComplexTest::complexTest()
     //start = QDateTime::currentMSecsSinceEpoch();
     QSignalSpy getTokensUpdatedRespSpy(getTokensUpdatedResp, &Response::ready);
     QCOMPARE(getTokensUpdatedRespSpy.count(), 0);
-    getTokensUpdatedRespSpy.wait(10000);
+    getTokensUpdatedRespSpy.wait(timeout);
     QCOMPARE(getTokensUpdatedResp->getStatusCode(), 200);
     QCOMPARE(getTokensUpdatedRespSpy.count(), 1);
     auto doc1 = getJsonDoc(getTokensUpdatedResp->getJson());
@@ -86,7 +86,7 @@ void ComplexTest::complexTest()
     Response* deleteTokensResp = reqMan->deleteTokens(ids);
     QSignalSpy deleteTokensRespSpy(deleteTokensResp, &Response::ready);
     QCOMPARE(deleteTokensRespSpy.count(), 0);
-    deleteTokensRespSpy.wait(10000);
+    deleteTokensRespSpy.wait(timeout);
     QCOMPARE(deleteTokensRespSpy.count(), 1);
     QCOMPARE(deleteTokensResp->getStatusCode(), 200);
     // DELETE_TOKENS_CHECK_END
@@ -96,7 +96,7 @@ void ComplexTest::complexTest()
     start = QDateTime::currentMSecsSinceEpoch();
     QSignalSpy getTokensDeletedRespSpy(getTokensDeletedResp, &Response::ready);
     QCOMPARE(getTokensDeletedRespSpy.count(), 0);
-    getTokensDeletedRespSpy.wait(10000);
+    getTokensDeletedRespSpy.wait(timeout);
     QCOMPARE(getTokensDeletedResp->getStatusCode(), 200);
     QCOMPARE(getTokensDeletedRespSpy.count(), 1);
     auto doc2 = getJsonDoc(getTokensDeletedResp->getJson());
@@ -119,7 +119,7 @@ void ComplexTest::fullSync()
     api->prepareDatabase();
     api->loadDataFromColnod();
     QSignalSpy spy(api, &ColnodAPI::dataDownloaded);
-    spy.wait(10000);
+    spy.wait(timeout);
     api->syncDataFromColnod();
    // api->syncDataToColnod();
 }
@@ -128,12 +128,14 @@ void ComplexTest::syncLastUpdated()
 {
     api->loadDataFromColnod();
     QSignalSpy spy(api, &ColnodAPI::dataDownloaded);
-    spy.wait(10000);
+    spy.wait(timeout);
     api->loadDataFromDB();
     api->syncDataFromColnod();
-    api->syncDataFromDB();
-    QSignalSpy processSpy(api, &ColnodAPI::dataProcessed);
-    processSpy.wait(10000);
+    api->syncDataFromDBToColnod();
+    QSignalSpy processSpy(api, &ColnodAPI::dataUpdatedToColnod);
+    processSpy.wait(timeout);
+    QSignalSpy finish(api, &ColnodAPI::syncFinished);
+    finish.wait(timeout);
     qDebug() << "All right, at least should be.";
 
 }
@@ -150,7 +152,7 @@ int ComplexTest::getNumOfSubjects()
 {
     Response* subjectsResp = reqMan->getSubjects();
     QSignalSpy subjectsRespSpy(subjectsResp, &Response::ready);
-    subjectsRespSpy.wait(10000);
+    subjectsRespSpy.wait(timeout);
     auto doc = getJsonDoc(subjectsResp->getJson());
     return doc.object()["items"].toArray().size();
 }
@@ -159,17 +161,17 @@ int ComplexTest::getNumOfTokens()
 {
     Response* tokensResp = reqMan->getTokens();
     QSignalSpy tokensRespSpy(tokensResp, &Response::ready);
-    tokensRespSpy.wait(10000);
+    tokensRespSpy.wait(timeout);
     auto doc = getJsonDoc(tokensResp->getJson());
     return doc.object()["items"].toArray().size();
 }
 
-QJsonDocument ComplexTest::getJsonDoc(QString json)
+QJsonDocument ComplexTest::getJsonDoc(const QString &json)
 {
     return QJsonDocument::fromJson(json.toUtf8());
 }
 
-Token* ComplexTest::getTestToken()
+QPointer<Token> ComplexTest::getTestToken()
 {
     QJsonObject jsonToken;
     jsonToken.insert("id", "582c982d-6fd7-4856-8548-7ce542791c7a");
@@ -185,7 +187,7 @@ Token* ComplexTest::getTestToken()
     flags.push_back("NoValidity");
     jsonToken.insert("flags", flags);
     jsonToken.insert("subjectId", "72b37f7e-5761-4e6c-8e87-20c0bed0d904");
-    Token* token = new Token;
+    QPointer<Token> token = new Token;
     token->fromJSON(jsonToken);
     return token;
 }
diff --git a/test/unitTests/complextest.h b/test/unitTests/complextest.h
index ed34fe5..0aa1c74 100644
--- a/test/unitTests/complextest.h
+++ b/test/unitTests/complextest.h
@@ -23,8 +23,8 @@ private:
     // FUNCTIONS
     int getNumOfSubjects();
     int getNumOfTokens();
-    QJsonDocument getJsonDoc(QString json);
-    Token* getTestToken();
+    QJsonDocument getJsonDoc(const QString &json);
+    QPointer<Token> getTestToken();
 
 
     // VARIABLES
@@ -34,5 +34,7 @@ private:
     RequestManager* reqMan = nullptr;
     uint64_t start = 0;
     ColnodAPI* api = nullptr;
+
+    static constexpr qint16 timeout = 10000;
 };
 
diff --git a/test/unitTests/unittest.h b/test/unitTests/unittest.h
index 2fabad0..3e414e5 100644
--- a/test/unitTests/unittest.h
+++ b/test/unitTests/unittest.h
@@ -37,7 +37,7 @@ private slots:
     void deleteTokens();
     void subjectJSONParser();
     void tokenJSONParser();
-    void connectToDB();
+    //void connectToDB();
     //void debugConnection();
     void saveDataToDB();
     void getUuid();
@@ -48,4 +48,7 @@ private:
      QString host = "https://192.168.1.3:8443"; //local testing server
      QString password = "spaceti1";
      QString email = "spaceti";
-};  
+
+     static constexpr int timeout = 10000;
+     static constexpr qint64 epochMS = 1568646217767;
+};