server-sdk/test/auto/database/tst_databasetable.cpp

#include "serversdk/databasetable.h"

#include <QtTest>

#include <memory>

class BookTable : public serversdk::DatabaseTable
{
    Q_OBJECT
    TABLE_PROPERTY(QString, uuid, setUuid, QString());
    TABLE_PROPERTY(int, id, setId, 0);
    TABLE_PROPERTY(QString, name, setName, "Test");
    TABLE_PROPERTY(QString, author, setAuthor, "Me");
public:
    QByteArray filteredJson() {
        auto variant = this->toVariantMap();
        variant.remove("author");
        QJsonDocument doc = QJsonDocument::fromVariant(variant);
        return doc.toJson(QJsonDocument::Compact);
    }
};


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
{
    Q_OBJECT

public:
    DatabaseTableTest();
    ~DatabaseTableTest();

private slots:
    void constructor_test();
    void qvariant_test();
    void json_test();
    void enum_test();

    void filter_json_test();

};

DatabaseTableTest::DatabaseTableTest()
{
}

DatabaseTableTest::~DatabaseTableTest()
{
}

void DatabaseTableTest::constructor_test()
{
    auto table = std::make_unique<BookTable>();
    QCOMPARE(table->id(), 0);
    QCOMPARE(table->name(), QStringLiteral("Test"));
}

void DatabaseTableTest::qvariant_test()
{
    auto table = std::make_unique<BookTable>();
    QVariantMap map = table->toVariantMap();
    QCOMPARE(map.count(), 4);
}

void DatabaseTableTest::json_test()
{
    auto table = std::make_unique<BookTable>();
    QCOMPARE(table->id(), 0);
    QCOMPARE(table->name(), QStringLiteral("Test"));

    QByteArray expected(R"({"author":"Me","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"));

}

/** Baseclass must not contain property of derived class ( extended class ) */
void DatabaseTableTest::filter_json_test()
{
    auto book = std::make_shared<BookTable>();
    QCOMPARE(book->jsonData(), QByteArray("{\"author\":\"Me\",\"id\":0,\"name\":\"Test\",\"uuid\":\"\"}"));
    QCOMPARE(book->filteredJson(), QByteArray("{\"id\":0,\"name\":\"Test\",\"uuid\":\"\"}"));
}





QTEST_APPLESS_MAIN(DatabaseTableTest)

#include "tst_databasetable.moc"