An in memory testaccount that can be used for application testing.

1 files changed, 124 insertions, 0 deletions

diff --git a/common/test.cpp b/common/test.cpp
index 0864f1a..c4dac89 100644
--- a/common/test.cpp
+++ b/common/test.cpp
@@ -23,6 +23,12 @@
 #include <QStandardPaths>
 #include <QDir>
 #include <QDebug>
+#include "facade.h"
+#include "facadefactory.h"
+#include "query.h"
+#include "resourceconfig.h"
+
+using namespace Sink;
 
 void Sink::Test::initTest()
 {
@@ -40,3 +46,121 @@ void Sink::Test::initTest()
     // qDebug() << "Removing " << QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
     QDir(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation)).removeRecursively();
 }
+
+
+template <typename T>
+class TestFacade : public Sink::StoreFacade<T>
+{
+public:
+    static std::shared_ptr<TestFacade<T>> registerFacade(Test::TestAccount *testAccount, const QByteArray &instanceIdentifier = QByteArray())
+    {
+        static QMap<QByteArray, std::shared_ptr<TestFacade<T>>> map;
+        auto facade = std::make_shared<TestFacade<T>>();
+        facade->mTestAccount = testAccount;
+        map.insert(instanceIdentifier, facade);
+        bool alwaysReturnFacade = instanceIdentifier.isEmpty();
+        Sink::FacadeFactory::instance().registerFacade<T, TestFacade<T>>("testresource", [alwaysReturnFacade](const QByteArray &instanceIdentifier) {
+            if (alwaysReturnFacade) {
+                return map.value(QByteArray());
+            }
+            return map.value(instanceIdentifier);
+        });
+        return facade;
+    }
+    ~TestFacade(){};
+    KAsync::Job<void> create(const T &domainObject) Q_DECL_OVERRIDE
+    {
+        mTestAccount->addEntity<T>(T::Ptr::create(domainObject));
+        return KAsync::null<void>();
+    };
+    KAsync::Job<void> modify(const T &domainObject) Q_DECL_OVERRIDE
+    {
+        // mTestAccount->modifyEntity<T>(domainObject);
+        return KAsync::null<void>();
+    };
+    KAsync::Job<void> remove(const T &domainObject) Q_DECL_OVERRIDE
+    {
+        //FIXME
+        // mTestAccount->removeEntity<T>(domainObject);
+        return KAsync::null<void>();
+    };
+    QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename T::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE
+    {
+        auto resultProvider = new Sink::ResultProvider<typename T::Ptr>();
+        resultProvider->onDone([resultProvider]() {
+            Trace() << "Result provider is done";
+            delete resultProvider;
+        });
+        // We have to do it this way, otherwise we're not setting the fetcher right
+        auto emitter = resultProvider->emitter();
+
+        resultProvider->setFetcher([query, resultProvider, this](const typename T::Ptr &parent) {
+            if (parent) {
+                Trace() << "Running the fetcher " << parent->identifier();
+            } else {
+                Trace() << "Running the fetcher.";
+            }
+            Trace() << "-------------------------.";
+            for (const auto &res : mTestAccount->entities<T>()) {
+                qDebug() << "Parent filter " << query.propertyFilter.value("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
+                auto parentProperty = res->getProperty("parent").toByteArray();
+                if ((!parent && parentProperty.isEmpty()) || (parent && parentProperty == parent->identifier()) || query.parentProperty.isEmpty()) {
+                    qDebug() << "Found a match" << res->identifier();
+                    resultProvider->add(res.template staticCast<T>());
+                }
+            }
+            resultProvider->initialResultSetComplete(parent);
+        });
+        auto job = KAsync::start<void>([query, resultProvider]() {});
+        return qMakePair(job, emitter);
+    }
+
+    Test::TestAccount *mTestAccount;
+};
+
+Test::TestAccount Sink::Test::TestAccount::registerAccount()
+{
+    Test::TestAccount account;
+    account.mFacades.insert(ApplicationDomain::getTypeName<ApplicationDomain::Folder>(), TestFacade<ApplicationDomain::Folder>::registerFacade(&account));
+    account.mFacades.insert(ApplicationDomain::getTypeName<ApplicationDomain::Mail>(), TestFacade<ApplicationDomain::Mail>::registerFacade(&account));
+    account.identifier = "testresource.instance1";
+    ResourceConfig::addResource(account.identifier, "testresource");
+    QMap<QByteArray, QVariant> configuration;
+    configuration.insert("account", account.identifier);
+    ResourceConfig::configureResource(account.identifier, configuration);
+    return account;
+}
+
+template<typename DomainType>
+void Sink::Test::TestAccount::addEntity(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)
+{
+    mEntities[ApplicationDomain::getTypeName<DomainType>()].append(domainObject);
+}
+
+template<typename DomainType>
+typename DomainType::Ptr Sink::Test::TestAccount::createEntity()
+{
+    auto entity = DomainType::Ptr::create(ApplicationDomain::ApplicationDomainType::createEntity<DomainType>(identifier));
+    addEntity<DomainType>(entity);
+    return entity;
+}
+
+template<typename DomainType>
+QList<Sink::ApplicationDomain::ApplicationDomainType::Ptr> Sink::Test::TestAccount::entities() const
+{
+    return mEntities.value(ApplicationDomain::getTypeName<DomainType>());
+}
+
+
+#define REGISTER_TYPE(T)                                                          \
+    template QList<Sink::ApplicationDomain::ApplicationDomainType::Ptr> Sink::Test::TestAccount::entities<T>() const;           \
+    template void Sink::Test::TestAccount::addEntity<T>(const ApplicationDomain::ApplicationDomainType::Ptr &);           \
+    template typename T::Ptr Sink::Test::TestAccount::createEntity<T>();
+
+
+REGISTER_TYPE(ApplicationDomain::Event);
+REGISTER_TYPE(ApplicationDomain::Mail);
+REGISTER_TYPE(ApplicationDomain::Folder);
+REGISTER_TYPE(ApplicationDomain::SinkResource);
+REGISTER_TYPE(ApplicationDomain::SinkAccount);
+REGISTER_TYPE(ApplicationDomain::Identity);