Merge branch 'update-unittest' into 'master'

Update unittest

See merge request spaceti-app/integrations/common/server-sdk!7

src/serversdk/databasemanager.cpp

@@ -116,6 +116,12 @@ QSqlQuery DatabaseManager::executeQuery(QSqlQuery &query, const QString &sqlText
     return query;
 }
 
+QSqlQuery DatabaseManager::createQuery()
+{
+    QSqlQuery query(mDatabase);
+    return query;
+}
+
 QSqlQuery DatabaseManager::processResult(int res, const QSqlQuery &query) const
 {
     if ( !res ) {

src/serversdk/databasemanager.h

@@ -25,7 +25,6 @@ public:
     bool dryMode() const;
     void setDryMode(bool dryMode);
 
-
     bool openSQLite(const QString &path, const QString &connectionName = QStringLiteral("qt_sql_default_connection"));
     bool openPostgres(const QString& host, const QString& dbName, const QString& user, const QString& password, const QString &connectionName = QStringLiteral("qt_sql_default_connection"));
     bool isValid() const;
@@ -35,6 +34,7 @@ public:
     // SQL handling
     QSqlQuery execPlainSql(const QString &sqlText);
     QSqlQuery executeQuery(QSqlQuery &query, const QString &sqlText = QString());
+    QSqlQuery createQuery();
     QSqlDatabase database() const;
 
 

src/serversdk/databasetable.cpp

@@ -19,6 +19,16 @@ QByteArray DatabaseTable::jsonData() const
     return doc.toJson(QJsonDocument::Compact);
 }
 
+bool DatabaseTable::fromJson(const QByteArray &data)
+{
+    // in: JSON ( e.g. {"id": 300} )
+    QJsonDocument doc = QJsonDocument::fromJson(data);
+    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
+
+    // Populate this object data
+    bool res = fromVariantMap(variant);
+    return res;
+}
 
 /** Creates universal variant structure to hold key / value pairs */
 QVariantMap DatabaseTable::toVariantMap() const
@@ -76,16 +86,6 @@ QList<std::shared_ptr<DatabaseTable> > DatabaseTable::fromListVariantMap(const Q
     return list;
 }
 
-bool DatabaseTable::fromJson(const QByteArray &data)
-{
-    // in: JSON ( e.g. {"id": 300} )
-    QJsonDocument doc = QJsonDocument::fromJson(data);
-    QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
-
-    // Populate this object data
-    bool res = fromVariantMap(variant);
-    return res;
-}
 
 QString DatabaseTable::textSQLIteType(QVariant::Type type) const
 {

src/serversdk/databasetable.h

@@ -84,13 +84,13 @@ public:
      * @brief Creates JSON from QMetaObject data ( Q_PROPERTY ) -> TABLE_PROPERTY
      * @return text json e.g. { "id": 00344 }
      */
-    QByteArray jsonData() const;
+    virtual QByteArray jsonData() const;
 
     /**
      * @brief Populates object with JSON {"id": 300} )
      * @return true if success TODO: not implemented corrrectly
      */
-    bool fromJson(const QByteArray &data);
+    virtual bool fromJson(const QByteArray &data);
 
     /**
      * @brief Creates VariantMap from QMetaObject data ( Q_PROPERTY )

src/serversdk/databaseutils.cpp

@@ -56,7 +56,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
         if (!prop.isUser())
             continue;
 
-        QString name = prop.name();
+        QString name = fromCamelCase(prop.name());
         QVariant::Type type = prop.type();
         QString textType;
 
@@ -79,7 +79,7 @@ QString DatabaseUtils::createTableText(const DatabaseTable *table, const QString
         // in: PRIMARY KEY
         // out: "CREATE TABLE colnod_subject ( id TEXT PRIMARY KEY"
         if (first) { // first row
-            sql += " PRIMARY KEY";
+            sql += " PRIMARY KEY NOT NULL";
             first = false;
         }
 
@@ -105,6 +105,7 @@ QSqlQuery DatabaseUtils::createTable(const DatabaseTable *table, const QString t
 {
     // CREATE TABLE ...
     QString sql = createTableText(table, tableName);
+    qCDebug(sdkdb) << "SQL:" << sql;
     return mDatabaseManager->execPlainSql(sql);
 }
 
@@ -116,9 +117,12 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri
 
     QVariantMap valueMap = table->toVariantMap();
 
-
+    // in: id / 23233
+    // out: columns: id
+    // out: values: :id
     auto keys = valueMap.keys();
-    for (auto key : keys) {
+    for (auto _key : keys) {
+        QString key = fromCamelCase(_key);
         if (!columns.isEmpty()) {
             columns += ", ";
             values += ", ";
@@ -131,8 +135,45 @@ QSqlQuery DatabaseUtils::insertIntoTable(const DatabaseTable *table, const QStri
     QString queryText = QString("INSERT INTO %1 ( %2 ) VALUES ( %3 );").arg(table_name).arg(columns).arg(values);
     query.prepare(queryText);
 
-    for (auto key : keys ) {
+    for (auto _key : keys ) {
-        auto value = valueMap.value(key);
+        QString key = fromCamelCase(_key);
+        auto value = valueMap.value(_key);
+        query.bindValue(":"+key, value);
+    }
+
+    QSqlQuery res = mDatabaseManager->executeQuery(query);
+    return res;
+}
+
+QSqlQuery DatabaseUtils::updateTable(const DatabaseTable *table, const QString table_name) const
+{
+    QString columnsAndValues;
+    QString primaryKeyCondition;
+
+    QVariantMap valueMap = table->toVariantMap();
+    auto keys = valueMap.keys();
+
+    Q_ASSERT(!keys.isEmpty());
+    // Primary key is first user property ( first VariantMap item )
+    // in ( primary key ): id
+    // out: id = :id
+    primaryKeyCondition = keys.at(0) + " = :" + keys.at(0);
+
+    for (auto _key : keys) {
+        QString key = fromCamelCase(_key);
+        if (!columnsAndValues.isEmpty()) {
+            columnsAndValues += ", ";
+        }
+        columnsAndValues += key + " = :" + key;
+    }
+
+    QSqlQuery query(mDatabaseManager->database());
+    QString queryText = QString("UPDATE %1 SET %2 WHERE %3;").arg(table_name).arg(columnsAndValues).arg(primaryKeyCondition);
+    query.prepare(queryText);
+
+    for (auto _key : keys ) {
+        QString key = fromCamelCase(_key);
+        auto value = valueMap.value(_key);
         query.bindValue(":"+key, value);
     }
 
@@ -152,6 +193,27 @@ void DatabaseUtils::setSqlType(const QString &sqlType)
     mSqlType = sqlType;
 }
 
+QString DatabaseUtils::fromCamelCase(const QString &s)
+{
+    static QRegularExpression regExp1 {"(.)([A-Z][a-z]+)"};
+    static QRegularExpression regExp2 {"([a-z0-9])([A-Z])"};
+
+    QString result = s;
+    result.replace(regExp1, "\\1_\\2");
+    result.replace(regExp2, "\\1_\\2");
+
+    return result.toLower();
+}
+
+QString serversdk::DatabaseUtils::toCamelCase(const QString &s)
+{
+    QStringList parts = s.split('_', QString::SkipEmptyParts);
+    for (int i=1; i<parts.size(); ++i)
+        parts[i].replace(0, 1, parts[i][0].toUpper());
+
+    return parts.join("");
+}
+
 
 
 } // namespace serversdk

src/serversdk/databaseutils.h

@@ -3,6 +3,7 @@
 #include "databasetable.h"
 
 #include <QObject>
+#include <QRegularExpression>
 #include <QSqlQuery>
 #include <QSqlRecord>
 
@@ -24,6 +25,8 @@ public:
 
     QSqlQuery insertIntoTable(const DatabaseTable *table, const QString table_name) const;
 
+    QSqlQuery updateTable(const DatabaseTable *table, const QString table_name) const;
+
     template <class T>
     QList<std::shared_ptr<T>> tableFromQuery(QSqlQuery query) const {
         QList<std::shared_ptr<T>> list;
@@ -32,7 +35,9 @@ public:
             int total = rec.count();
             QMap<QString, QVariant> map;
             for (int column = 0; column < total; ++column) {
-                map.insert(rec.fieldName(column), query.value(column));
+                QString columnName = rec.fieldName(column);
+                QString propertyName = toCamelCase(columnName);
+                map.insert(propertyName, query.value(column));
             }
 
             auto data = std::make_shared<T>();
@@ -46,6 +51,9 @@ public:
     QString sqlType() const;
     void setSqlType(const QString &sqlType);
 
+    static QString fromCamelCase(const QString &s);
+    static QString toCamelCase(const QString& s);
+
 private:
     QString createTableText(const DatabaseTable *table, const QString table_name) const;
 
@@ -54,5 +62,6 @@ private:
     QString mSqlType;
 };
 
+
 } // namespace serversdk
 

test/auto/database/tst_databasetable.cpp

@@ -7,12 +7,64 @@
 class BookTable : public serversdk::DatabaseTable
 {
     Q_OBJECT
-    TABLE_PROPERTY(QUuid, uuid, setUuid, QUuid());
+    TABLE_PROPERTY(QString, uuid, setUuid, QString());
     TABLE_PROPERTY(int, id, setId, 0);
     TABLE_PROPERTY(QString, name, setName, "Test");
 };
 
 
+QString enumjson = R"({"authErrors":255,"flags":["Enabled","NoValidity"],"subjectId":"1438aade-3aa6-4885-8e0f-138dedae727a"})";
+
+
+class EnumTest : public serversdk::DatabaseTable
+{
+    Q_OBJECT
+    TABLE_PROPERTY(int, authErrors, setAuthErrors, 0);
+    TABLE_PROPERTY(bool, enabled, setEnabled, false);
+    TABLE_PROPERTY(bool, noValidity, setNoValidity, false);
+    TABLE_PROPERTY(QString, subjectId, setSubjectId, QString());
+public:
+    QByteArray jsonData() const override
+    {
+        auto variantMap = this->toVariantMap();
+        auto enabled = variantMap["enabled"].toBool();
+        auto noValidity = variantMap["noValidity"].toBool();
+        variantMap.remove("enabled");
+        variantMap.remove("noValidity");
+        QVariantList flags;
+        if ( enabled ) {
+            flags << "Enabled";
+        }
+        if ( noValidity ) {
+            flags << "NoValidity";
+        }
+        variantMap.insert("flags", flags);
+
+        QJsonDocument doc = QJsonDocument::fromVariant(variantMap);
+        return doc.toJson(QJsonDocument::Compact);
+    }
+    bool fromJson(const QByteArray &data) override
+    {
+        QJsonDocument doc = QJsonDocument::fromJson(data);
+        QVariantMap variant = qvariant_cast<QVariantMap>(doc.toVariant());
+
+        QVariantList flags = variant["flags"].toList();
+        for (auto value : flags) {
+            if ( value.toString() == "Enabled") {
+                variant.insert("enabled", true);
+            }
+            if ( value.toString() == "NoValidity") {
+                variant.insert("noValidity", true);
+            }
+        }
+        variant.remove("flags");
+
+        // Populate this object data
+        bool res = fromVariantMap(variant);
+        return res;
+    }
+};
+
 
 class DatabaseTableTest : public QObject
 {
@@ -26,6 +78,7 @@ private slots:
     void constructor_test();
     void qvariant_test();
     void json_test();
+    void enum_test();
 
 };
 
@@ -57,10 +110,39 @@ void DatabaseTableTest::json_test()
     QCOMPARE(table->id(), 0);
     QCOMPARE(table->name(), QStringLiteral("Test"));
 
-    QByteArray expected(R"({"id":0,"name":"Test","uuid":"{00000000-0000-0000-0000-000000000000}"})");
+    QByteArray expected(R"({"id":0,"name":"Test","uuid":""})");
     QCOMPARE(table->jsonData(), expected);
 }
 
+void DatabaseTableTest::enum_test()
+{
+    auto table = std::make_unique<EnumTest>();
+    table->setAuthErrors(255);
+    table->setNoValidity(true);
+    table->setEnabled(true);
+    table->setSubjectId("1438aade-3aa6-4885-8e0f-138dedae727a");
+
+    QCOMPARE(table->jsonData(), enumjson.toUtf8());
+
+    EnumTest jsonTest;
+
+    jsonTest.fromJson(enumjson.toUtf8());
+
+    QCOMPARE(jsonTest.authErrors(), 255);
+    QCOMPARE(jsonTest.noValidity(), true);
+    QCOMPARE(jsonTest.enabled(), true);
+    QCOMPARE(jsonTest.subjectId(), QStringLiteral("1438aade-3aa6-4885-8e0f-138dedae727a"));
+
+}
+
+
+
+
+
+
+
+
+
 QTEST_APPLESS_MAIN(DatabaseTableTest)
 
 #include "tst_databasetable.moc"

test/auto/database/tst_databaseutils.cpp

@@ -33,6 +33,8 @@ public:
 
 private slots:
     void createTable_test();
+    void toCamelCase_test();
+    void fromCamelCase_test();
 
 };
 
@@ -53,7 +55,7 @@ void DatabaseUtilsTest::createTable_test()
     QString sql = utils.createTableText(table.get(), "subjects");
 
     QString expected = "CREATE TABLE subjects ( "
-                       "id TEXT PRIMARY KEY, "
+                       "id TEXT PRIMARY KEY NOT NULL, "
                        "description TEXT, "
                        "last_update INTEGER, "
                        "name TEXT, "
@@ -64,6 +66,18 @@ void DatabaseUtilsTest::createTable_test()
     QCOMPARE(sql, expected);
 }
 
+void DatabaseUtilsTest::toCamelCase_test()
+{
+    QString test1 = "id_name";
+    QCOMPARE(serversdk::DatabaseUtils::toCamelCase(test1), QStringLiteral("idName"));
+}
+
+void DatabaseUtilsTest::fromCamelCase_test()
+{
+    QString test1 = "idName";
+    QCOMPARE(serversdk::DatabaseUtils::fromCamelCase(test1), QStringLiteral("id_name"));
+}
+
 
 
 QTEST_APPLESS_MAIN(DatabaseUtilsTest)

test/auto/database/tst_postgresql.cpp

@@ -6,7 +6,7 @@
 // add necessary includes here
 
 
-class Names : public serversdk::DatabaseTable {
+class Name : public serversdk::DatabaseTable {
     Q_OBJECT
     TABLE_PROPERTY(int, id, set_id, 0);
     TABLE_PROPERTY(QString, name, set_name, 0);
@@ -68,7 +68,7 @@ void PostgresqlTest::createTable_test()
     QVERIFY(db.isValid());
     QVERIFY(db.isOpen());
 
-    Names names;
+    Name names;
 
     //Have to drop tabel
     QSqlQuery dropQuery = db.execPlainSql("DROP TABLE names");
@@ -87,13 +87,13 @@ void PostgresqlTest::createTable_test()
 
     // SELECT FROM TABLE
     QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
-    auto list = utils.tableFromQuery<Names>(selectSQL);
+    auto list = utils.tableFromQuery<Name>(selectSQL);
 
     // ENSURE SAME
     auto first = list.first();
     // Problem is that fromListvariantMap returns shared_ptr of class DataTable
     // Must subclass.
-    auto names_tab = std::dynamic_pointer_cast<Names>(first);
+    auto names_tab = std::dynamic_pointer_cast<Name>(first);
     QCOMPARE(list.count(), 1);
     QCOMPARE(names_tab->name(), QStringLiteral("Testname"));
 

test/auto/database/tst_sqlite.cpp

@@ -6,10 +6,12 @@
 // add necessary includes here
 
 
-class Names : public serversdk::DatabaseTable {
+class Name : public serversdk::DatabaseTable {
     Q_OBJECT
+    TABLE_PROPERTY(QString, uuid, set_uuid, QString());
     TABLE_PROPERTY(int, id, set_id, 0);
-    TABLE_PROPERTY(QString, name, set_name, 0);
+    TABLE_PROPERTY(QString, name, set_name, "");
+    TABLE_PROPERTY(QString, vehicleName, set_vehicle_name, "Škodouliňkaťoučký");
 };
 
 
@@ -18,24 +20,14 @@ class SqliteTest : public QObject
     Q_OBJECT
 
 public:
-    SqliteTest();
+    SqliteTest() = default;
-    ~SqliteTest();
 
 private slots:
     void createDb_test();
     void createTable_test();
-
+    void updateTable_test();
 };
 
-SqliteTest::SqliteTest()
-{
-
-}
-
-SqliteTest::~SqliteTest()
-{
-
-}
 
 void SqliteTest::createDb_test()
 {
@@ -72,29 +64,76 @@ void SqliteTest::createTable_test()
     db.openSQLite(dbpath);
     QVERIFY(db.isOpen());
 
-    Names names;
+    Name name_A, name_B;
+
+    // CREATE TABLE
+    serversdk::DatabaseUtils utils(&db);
+    QSqlQuery query = utils.createTable(&name_A, "names");
+
+    // INSERT INTO TABLE
+    const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6";
+    const QString uuidB = "d70143ab-8c14-4ee0-85cb-f0d1b72df104";
+    name_A.set_uuid(uuidA);
+    name_A.set_id(2);
+    name_A.set_name("TestnameA");
+    name_B.set_uuid(uuidB);
+    name_B.set_id(2);
+    name_B.set_name("TestnameB");
+
+    utils.insertIntoTable(&name_A, "names");
+    utils.insertIntoTable(&name_B, "names");
+
+    // SELECT FROM TABLE
+    QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
+    auto list = utils.tableFromQuery<Name>(selectSQL);
+
+
+    // ENSURE SAME
+    QCOMPARE(list.count(), 2);
+    auto names_tab = list.first();
+    qDebug() << "Uuid" << names_tab->uuid();
+    QVERIFY(names_tab);
+    QCOMPARE(names_tab->name(), QStringLiteral("TestnameA"));
+
+    QCOMPARE(list.first()->jsonData(), name_A.jsonData());
+}
+
+void SqliteTest::updateTable_test()
+{
+    // Prepare temporary path for database
+    QTemporaryDir dir;
+    QString dbpath = dir.path() + "/testdb.sqlite";
+    serversdk::DatabaseManager db;
+    db.openSQLite(dbpath);
+    QVERIFY(db.isOpen());
+
+    Name names;
 
     // CREATE TABLE
     serversdk::DatabaseUtils utils(&db);
     QSqlQuery query = utils.createTable(&names, "names");
 
     // INSERT INTO TABLE
+    const QString uuidA = "48f64fab-ba2a-40b5-8fbb-75361099dfb6";
+    names.set_uuid(uuidA);
     names.set_id(2);
     names.set_name("Testname");
 
     utils.insertIntoTable(&names, "names");
 
+    // NOW UPDATING TABLE WITH name: NewName
+    names.set_name("NewName");
+    utils.updateTable(&names, "names");
+
     // SELECT FROM TABLE
     QSqlQuery selectSQL = db.execPlainSql("SELECT * FROM names");
-    auto list = utils.tableFromQuery<Names>(selectSQL);
+    auto list = utils.tableFromQuery<Name>(selectSQL);
 
     // ENSURE SAME
     QCOMPARE(list.count(), 1);
-    auto first = list.first();
+    auto names_tab = list.first();
-    QVERIFY(first);
-    auto names_tab = std::dynamic_pointer_cast<Names>(first);
     QVERIFY(names_tab);
-    QCOMPARE(names_tab->name(), QStringLiteral("Testname"));
+    QCOMPARE(names_tab->name(), QStringLiteral("NewName"));
 
     QCOMPARE(list.first()->jsonData(), names.jsonData());
 }