4 files changed, 196 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);
diff --git a/common/test.h b/common/test.h
index 146b4ac..e2bd1ea 100644
--- a/common/test.h
+++ b/common/test.h
@@ -21,6 +21,9 @@
 #pragma once
 
 #include "sink_export.h"
+#include "applicationdomaintype.h"
+
+#include <memory>
 
 namespace Sink {
 namespace Test {
@@ -31,5 +34,28 @@ namespace Test {
  * and clears all data directories.
  */
 void SINK_EXPORT initTest();
+
+class SINK_EXPORT TestAccount {
+public:
+    QByteArray identifier;
+    static TestAccount registerAccount();
+
+    template<typename DomainType>
+    void addEntity(const ApplicationDomain::ApplicationDomainType::Ptr &domainObject);
+
+    template<typename DomainType>
+    typename DomainType::Ptr createEntity();
+
+    template<typename DomainType>
+    QList<ApplicationDomain::ApplicationDomainType::Ptr> entities() const;
+
+private:
+    TestAccount(){};
+    TestAccount(const TestAccount &);
+    TestAccount &operator=(const TestAccount &);
+    QHash<QByteArray, QList<ApplicationDomain::ApplicationDomainType::Ptr> > mEntities;
+    QHash<QByteArray, std::shared_ptr<void> > mFacades;
+};
+
 }
 }
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b25e7bc..b97596a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -55,6 +55,7 @@ auto_tests (
     modelinteractivitytest
     inspectiontest
     accountstest
+    testaccounttest
 )
 target_link_libraries(dummyresourcetest sink_resource_dummy)
 target_link_libraries(dummyresourcebenchmark sink_resource_dummy)
diff --git a/tests/testaccounttest.cpp b/tests/testaccounttest.cpp
new file mode 100644
index 0000000..c630846
--- /dev/null
+++ b/tests/testaccounttest.cpp
@@ -0,0 +1,45 @@
+#include <QtTest>
+#include <QDebug>
+#include <functional>
+
+#include "store.h"
+#include "test.h"
+#include "log.h"
+
+using namespace Sink;
+
+/**
+ * Test of the test account.
+ */
+class TestAccountTest : public QObject
+{
+    Q_OBJECT
+private slots:
+
+    void initTestCase()
+    {
+        // Sink::FacadeFactory::instance().resetFactory();
+        // ResourceConfig::clear();
+        Log::setDebugOutputLevel(Sink::Log::Trace);
+        Test::initTest();
+    }
+
+    void testLoad()
+    {
+        auto &&account = Test::TestAccount::registerAccount();
+        auto folder = ApplicationDomain::Folder::Ptr::create(ApplicationDomain::ApplicationDomainType::createEntity<ApplicationDomain::Folder>());
+        account.addEntity<ApplicationDomain::Folder>(folder);
+
+        auto folders = account.entities<ApplicationDomain::Folder>();
+        QCOMPARE(folders.size(), 1);
+        QCOMPARE(account.entities<ApplicationDomain::Mail>().size(), 0);
+
+        auto mail = ApplicationDomain::ApplicationDomainType::createEntity<ApplicationDomain::Mail>();
+        Sink::Store::create(ApplicationDomain::Mail(account.identifier)).exec();
+        QCOMPARE(account.entities<ApplicationDomain::Mail>().size(), 1);
+    }
+
+};
+
+QTEST_MAIN(TestAccountTest)
+#include "testaccounttest.moc"