ondra/colnod-connector
1
0
Fork 1
mirror of https://gitlab.com/spaceti-app/integrations/acs/colnod-connector.git synced 2026-07-12 12:00:37 +02:00
Code Issues Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Filip Bucek 2019-12-02 16:03:56 +01:00
commit 8cb0f3b01d
11 changed files with 197 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server-sdk

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

4
src/app/main.cpp
View File

@ -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;
}

39
src/colnod/colnodapi.cpp
View File

@ -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)
:mReqMan(reqMan), mUserName(userName), mPassword(password), mDryMode(dryMode)
ColnodAPI::ColnodAPI(serversdk::RequestManager* reqMan, const bool &dryMode, QString userName, QString password)
: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 true;
}
return false;
return request->status() == 200;
}
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();

12
src/colnod/colnodapi.h
View File

@ -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 saveUpdatedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
void saveDeletedTokens(std::shared_ptr<Data> data, const QByteArray &responseData);
void saveDeletedSubjects(std::shared_ptr<Data> data, const QByteArray &responseData);
void saveUpdatedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
void saveUpdatedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
void saveDeletedTokens(const std::shared_ptr<Data>& data, const QByteArray &responseData);
void saveDeletedSubjects(const std::shared_ptr<Data>& data, const QByteArray &responseData);
void newData();

7
src/colnod/data.h
View File

@ -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;

11
src/colnod/databaseapi.cpp
View File

@ -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 true;
return false;
return token->deleted();
}
bool DatabaseAPI::isValid()

10
src/colnod/databaseapi.h
View File

@ -20,10 +20,10 @@ class DatabaseAPI : public QObject
public:
explicit DatabaseAPI(serversdk::DatabaseManager *dbMan, bool dryMode);
bool open(QString host = "192.168.1.94",
QString name = "deloitte",
QString user = "postgres",
QString password = "34rjkciea12");
bool open(const QString& host = "192.168.1.94",
const QString& name = "deloitte",
const QString& user = "postgres",
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();

7
src/colnod/syncmanager.cpp
View File

@ -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;

2
src/colnod/syncmanager.h
View File

@ -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);

44
test/auto/colnod/tst_colnodapi.cpp
View File

@ -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));
QVERIFY(data);
QSignalSpy spy(&colnod, &ColnodAPI::downloadDataFinished);
QVERIFY(spy.isValid());
colnod.downloadData(1570190399259);
QVERIFY(spy.wait());
QVERIFY(data->updatedTokens.size() > 0);
QVERIFY(data->updatedTokens.contains("5e2f1260-da1c-441f-9644-24dfe3b97b2a"));
}
{
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);
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()

122
test/auto/syncmanager/tst_syncmanager.cpp
View File

@ -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());
QCOMPARE(newPreparedData->databaseData->updatedTokens.size(), oldPreparedData->databaseData->updatedTokens.size());
QVERIFY(newPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
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)