24 files changed, 260 insertions, 176 deletions

diff --git a/tests/accountstest.cpp b/tests/accountstest.cpp
index be5e1a0..4be8bd6 100644
--- a/tests/accountstest.cpp
+++ b/tests/accountstest.cpp
@@ -8,6 +8,7 @@
 #include <store.h>
 #include <log.h>
 #include <configstore.h>
+#include "testutils.h"
 
 class AccountsTest : public QObject
 {
@@ -17,7 +18,6 @@ private slots:
     void initTestCase()
     {
         Sink::Test::initTest();
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
     }
 
     void init()
@@ -52,7 +52,7 @@ private slots:
         QString smtpUsername("smtpUsername");
         QString smtpPassword("smtpPassword");
         auto resource = ApplicationDomainType::createEntity<SinkResource>();
-        resource.setProperty("type", "org.kde.mailtransport");
+        resource.setProperty("type", "sink.mailtransport");
         resource.setProperty("account", account.identifier());
         resource.setProperty("server", smtpServer);
         resource.setProperty("username", smtpUsername);
@@ -63,7 +63,7 @@ private slots:
         Store::fetchAll<SinkResource>(Query()).then<void, QList<SinkResource::Ptr>>([&](const QList<SinkResource::Ptr> &resources) {
             QCOMPARE(resources.size(), 1);
             auto resource = resources.first();
-            QCOMPARE(resource->getProperty("type").toString(), QString("org.kde.mailtransport"));
+            QCOMPARE(resource->getProperty("type").toString(), QString("sink.mailtransport"));
             QCOMPARE(resource->getProperty("server").toString(), smtpServer);
         })
         .exec().waitForFinished();
@@ -94,8 +94,8 @@ private slots:
         using namespace Sink::ApplicationDomain;
 
         auto account = ApplicationDomainType::createEntity<SinkAccount>();
-        account.setProperty("type", "maildir");
-        account.setProperty("name", "name");
+        account.setAccountType("maildir");
+        account.setName("name");
         Store::create(account).exec().waitForFinished();
 
         Query query;
@@ -104,18 +104,47 @@ private slots:
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
 
         auto account2 = ApplicationDomainType::createEntity<SinkAccount>();
-        account2.setProperty("type", "maildir");
-        account2.setProperty("name", "name");
+        account2.setAccountType("maildir");
+        account2.setName("name");
         Store::create(account2).exec().waitForFinished();
         QTRY_COMPARE(model->rowCount(QModelIndex()), 2);
 
         //Ensure the notifier only affects one type
         auto resource = ApplicationDomainType::createEntity<SinkResource>();
-        resource.setProperty("type", "org.kde.mailtransport");
+        resource.setResourceType("sink.mailtransport");
         Store::create(resource).exec().waitForFinished();
         QTRY_COMPARE(model->rowCount(QModelIndex()), 2);
     }
 
+    void testLoadAccountStatus()
+    {
+        using namespace Sink;
+        using namespace Sink::ApplicationDomain;
+
+        auto account = ApplicationDomainType::createEntity<SinkAccount>();
+        account.setAccountType("dummy");
+        account.setName("name");
+        VERIFYEXEC(Store::create(account));
+
+        auto res = Sink::ApplicationDomain::DummyResource::create(account.identifier());
+        VERIFYEXEC(Sink::Store::create(res));
+        {
+            Sink::Query query;
+            query.liveQuery = true;
+            query.request<Sink::ApplicationDomain::SinkAccount::Status>();
+
+            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkAccount>(query);
+            QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
+            auto account = model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkAccount::Ptr>();
+            QCOMPARE(account->getStatus(), static_cast<int>(Sink::ApplicationDomain::OfflineStatus));
+
+            //Synchronize to connect
+            VERIFYEXEC(Sink::Store::synchronize(Query::ResourceFilter(res)));
+
+            QTRY_COMPARE_WITH_TIMEOUT(model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkAccount::Ptr>()->getStatus(), static_cast<int>(Sink::ApplicationDomain::ConnectedStatus), 1000);
+        }
+    }
+
 };
 
 QTEST_GUILESS_MAIN(AccountsTest)
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 8c5866d..ed5a9b5 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -9,6 +9,8 @@
 #include "resultprovider.h"
 #include "facadefactory.h"
 
+SINK_DEBUG_AREA("clientapitest")
+
 template <typename T>
 class TestDummyResourceFacade : public Sink::StoreFacade<T>
 {
@@ -44,7 +46,7 @@ public:
     {
         auto resultProvider = new Sink::ResultProvider<typename T::Ptr>();
         resultProvider->onDone([resultProvider]() {
-            Trace() << "Result provider is done";
+            SinkTrace() << "Result provider is done";
             delete resultProvider;
         });
         // We have to do it this way, otherwise we're not setting the fetcher right
@@ -52,11 +54,11 @@ public:
 
         resultProvider->setFetcher([query, resultProvider, this](const typename T::Ptr &parent) {
             if (parent) {
-                Trace() << "Running the fetcher " << parent->identifier();
+                SinkTrace() << "Running the fetcher " << parent->identifier();
             } else {
-                Trace() << "Running the fetcher.";
+                SinkTrace() << "Running the fetcher.";
             }
-            Trace() << "-------------------------.";
+            SinkTrace() << "-------------------------.";
             for (const auto &res : results) {
                 qDebug() << "Parent filter " << query.propertyFilter.value("parent").value.toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
                 auto parentProperty = res->getProperty("parent").toByteArray();
@@ -91,7 +93,6 @@ private slots:
     {
         Sink::FacadeFactory::instance().resetFactory();
         ResourceConfig::clear();
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
     }
 
     void testLoad()
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index d5f98c3..72562c3 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -34,9 +34,9 @@ private slots:
     void initTestCase()
     {
         Sink::Log::setDebugOutputLevel(Sink::Log::Warning);
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
+        auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
-        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
         num = 5000;
     }
 
@@ -76,21 +76,21 @@ private slots:
     void testCommandResponsiveness()
     {
         // Test responsiveness including starting the process.
-        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
+        Sink::Store::removeDataFromDisk("sink.dummy.instance1").exec().waitForFinished();
 
         QTime time;
         time.start();
 
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
 
-        auto notifier = QSharedPointer<Sink::Notifier>::create("org.kde.dummy.instance1", "org.kde.dummy");
+        auto notifier = QSharedPointer<Sink::Notifier>::create("sink.dummy.instance1", "sink.dummy");
         bool gotNotification = false;
         int duration = 0;
         notifier->registerHandler([&gotNotification, &duration, &time](const Sink::Notification &notification) {
-            if (notification.type == Sink::Commands::NotificationType::NotificationType_RevisionUpdate) {
+            if (notification.type == Sink::Notification::RevisionUpdate) {
                 gotNotification = true;
                 duration = time.elapsed();
             }
@@ -102,19 +102,19 @@ private slots:
         QTRY_VERIFY(gotNotification);
 
         QVERIFY2(duration < 100, QString::fromLatin1("Processing a create command took more than 100ms: %1").arg(duration).toLatin1());
-        Sink::ResourceControl::shutdown("org.kde.dummy.instance1").exec().waitForFinished();
+        Sink::ResourceControl::shutdown("sink.dummy.instance1").exec().waitForFinished();
         qDebug() << "Single command took [ms]: " << duration;
     }
 
     void testWriteToFacade()
     {
-        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
+        Sink::Store::removeDataFromDisk("sink.dummy.instance1").exec().waitForFinished();
 
         QTime time;
         time.start();
         QList<KAsync::Future<void>> waitCondition;
         for (int i = 0; i < num; i++) {
-            Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Event event("sink.dummy.instance1");
             event.setProperty("uid", "testuid");
             QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
             event.setProperty("summary", "summaryValue");
@@ -126,7 +126,7 @@ private slots:
         // Ensure everything is processed
         {
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
         }
         auto allProcessedTime = time.elapsed();
@@ -140,7 +140,7 @@ private slots:
         dataset.insertRow(row);
         HAWD::Formatter::print(dataset);
 
-        auto diskUsage = DummyResource::diskUsage("org.kde.dummy.instance1");
+        auto diskUsage = DummyResource::diskUsage("sink.dummy.instance1");
         qDebug() << "Database size [kb]: " << diskUsage / 1024;
 
         // Print memory layout, RSS is what is in memory
@@ -155,7 +155,7 @@ private slots:
         {
             time.start();
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
 
             query.propertyFilter.insert("uid", Sink::Query::Comparator("testuid"));
             auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -173,12 +173,12 @@ private slots:
 
     void testWriteInProcess()
     {
-        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
+        Sink::Store::removeDataFromDisk("sink.dummy.instance1").exec().waitForFinished();
         QTime time;
         time.start();
 
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.dummy.instance1");
-        DummyResource resource("org.kde.dummy.instance1", pipeline);
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.dummy.instance1");
+        DummyResource resource("sink.dummy.instance1", pipeline);
 
         flatbuffers::FlatBufferBuilder eventFbb;
         eventFbb.Clear();
@@ -261,7 +261,7 @@ private slots:
     // This allows to run individual parts without doing a cleanup, but still cleaning up normally
     void testCleanupForCompleteTest()
     {
-        Sink::Store::removeDataFromDisk("org.kde.dummy.instance1").exec().waitForFinished();
+        Sink::Store::removeDataFromDisk("sink.dummy.instance1").exec().waitForFinished();
     }
 
 private:
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index d41f235..687a33b 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -30,11 +30,10 @@ private slots:
     void initTestCase()
     {
         Sink::Test::initTest();
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
+        auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
-        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
+        DummyResource::removeFromDisk("sink.dummy.instance1");
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
     }
 
     void init()
@@ -48,7 +47,7 @@ private slots:
     void cleanup()
     {
         qDebug() << "Test took " << time.elapsed();
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void testProperty()
@@ -60,13 +59,13 @@ private slots:
 
     void testWriteToFacadeAndQueryByUid()
     {
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
 
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1") ;
+        const auto query = Query::ResourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -79,7 +78,7 @@ private slots:
 
     void testWriteToFacadeAndQueryByUid2()
     {
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
         event.setProperty("summary", "summaryValue");
 
         event.setProperty("uid", "testuid");
@@ -88,7 +87,7 @@ private slots:
         event.setProperty("uid", "testuid2");
         Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
 
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1") ;
+        const auto query = Query::ResourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -103,7 +102,7 @@ private slots:
 
     void testWriteToFacadeAndQueryBySummary()
     {
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
 
         event.setProperty("uid", "testuid");
         event.setProperty("summary", "summaryValue1");
@@ -113,7 +112,7 @@ private slots:
         event.setProperty("summary", "summaryValue2");
         Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
 
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1") ;
+        const auto query = Query::ResourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -128,8 +127,8 @@ private slots:
 
     void testResourceSync()
     {
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.dummy.instance1");
-        DummyResource resource("org.kde.dummy.instance1", pipeline);
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.dummy.instance1");
+        DummyResource resource("sink.dummy.instance1", pipeline);
         auto job = resource.synchronizeWithSource();
         // TODO pass in optional timeout?
         auto future = job.exec();
@@ -143,7 +142,7 @@ private slots:
 
     void testSyncAndFacade()
     {
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1");
+        const auto query = Query::ResourceFilter("sink.dummy.instance1");
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
@@ -159,7 +158,7 @@ private slots:
 
     void testSyncAndFacadeMail()
     {
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1");
+        const auto query = Query::ResourceFilter("sink.dummy.instance1");
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
@@ -175,13 +174,13 @@ private slots:
 
     void testWriteModifyDelete()
     {
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
 
-        const auto query = Query::ResourceFilter("org.kde.dummy.instance1") + Query::PropertyFilter("uid", "testuid");
+        const auto query = Query::ResourceFilter("sink.dummy.instance1") + Query::PropertyFilter("uid", "testuid");
 
         // Ensure all local data is processed
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -230,14 +229,14 @@ private slots:
 
     void testWriteModifyDeleteLive()
     {
-        auto query = Query::ResourceFilter("org.kde.dummy.instance1");
+        auto query = Query::ResourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
         query += Query::PropertyFilter("uid", "testuid");
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
 
-        Sink::ApplicationDomain::Event event("org.kde.dummy.instance1");
+        Sink::ApplicationDomain::Event event("sink.dummy.instance1");
         event.setProperty("uid", "testuid");
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
diff --git a/tests/dummyresourcewritebenchmark.cpp b/tests/dummyresourcewritebenchmark.cpp
index b4ab438..5cd7007 100644
--- a/tests/dummyresourcewritebenchmark.cpp
+++ b/tests/dummyresourcewritebenchmark.cpp
@@ -103,14 +103,14 @@ class DummyResourceWriteBenchmark : public QObject
 
     void writeInProcess(int num)
     {
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        DummyResource::removeFromDisk("sink.dummy.instance1");
 
 
         QTime time;
         time.start();
 
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.dummy.instance1");
-        DummyResource resource("org.kde.dummy.instance1", pipeline);
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.dummy.instance1");
+        DummyResource resource("sink.dummy.instance1", pipeline);
 
         int bufferSize = 0;
         auto command = createEntityBuffer(bufferSize);
@@ -131,7 +131,7 @@ class DummyResourceWriteBenchmark : public QObject
         const auto finalRss = getCurrentRSS();
         const auto rssGrowth = finalRss - startingRss;
         // Since the database is memory mapped it is attributted to the resident set size.
-        const auto rssWithoutDb = finalRss - DummyResource::diskUsage("org.kde.dummy.instance1");
+        const auto rssWithoutDb = finalRss - DummyResource::diskUsage("sink.dummy.instance1");
         const auto peakRss = getPeakRSS();
         // How much peak deviates from final rss in percent
         const auto percentageRssError = static_cast<double>(peakRss - finalRss) * 100.0 / static_cast<double>(finalRss);
@@ -143,7 +143,7 @@ class DummyResourceWriteBenchmark : public QObject
         std::cout << "Rss without db [kb]: " << rssWithoutDb / 1024 << std::endl;
         std::cout << "Percentage peak rss error: " << percentageRssError << std::endl;
 
-        auto onDisk = DummyResource::diskUsage("org.kde.dummy.instance1");
+        auto onDisk = DummyResource::diskUsage("sink.dummy.instance1");
         auto writeAmplification = static_cast<double>(onDisk) / static_cast<double>(bufferSizeTotal);
         std::cout << "On disk [kb]: " << onDisk / 1024 << std::endl;
         std::cout << "Buffer size total [kb]: " << bufferSizeTotal / 1024 << std::endl;
@@ -216,13 +216,13 @@ private slots:
 
     void getFreePages()
     {
-        std::system(QString("mdb_stat %1/%2 -ff").arg(Sink::storageLocation()).arg("org.kde.dummy.instance1").toLatin1().constData());
+        std::system(QString("mdb_stat %1/%2 -ff").arg(Sink::storageLocation()).arg("sink.dummy.instance1").toLatin1().constData());
     }
 
     // This allows to run individual parts without doing a cleanup, but still cleaning up normally
     void testCleanupForCompleteTest()
     {
-        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        DummyResource::removeFromDisk("sink.dummy.instance1");
     }
 
 private:
diff --git a/tests/genericfacadetest.cpp b/tests/genericfacadetest.cpp
index 8336875..0267dac 100644
--- a/tests/genericfacadetest.cpp
+++ b/tests/genericfacadetest.cpp
@@ -8,6 +8,7 @@
 #include <common/domainadaptor.h>
 #include <common/resultprovider.h>
 #include <common/synclistresult.h>
+#include <common/test.h>
 
 // Replace with something different
 #include "event_generated.h"
@@ -23,10 +24,9 @@ class GenericFacadeTest : public QObject
 {
     Q_OBJECT
 private slots:
-
-    void init()
+    void initTestCase()
     {
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
+        Sink::Test::initTest();
     }
 
     void testLoad()
diff --git a/tests/genericresourcebenchmark.cpp b/tests/genericresourcebenchmark.cpp
index a0a368c..2315d0b 100644
--- a/tests/genericresourcebenchmark.cpp
+++ b/tests/genericresourcebenchmark.cpp
@@ -96,9 +96,9 @@ private slots:
 
     void initTestCase()
     {
-        removeFromDisk("org.kde.test.instance1");
-        removeFromDisk("org.kde.test.instance1.userqueue");
-        removeFromDisk("org.kde.test.instance1.synchronizerqueue");
+        removeFromDisk("sink.test.instance1");
+        removeFromDisk("sink.test.instance1.userqueue");
+        removeFromDisk("sink.test.instance1.synchronizerqueue");
     }
 
 
@@ -106,8 +106,8 @@ private slots:
     {
         int num = 10000;
 
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.test.instance1");
-        TestResource resource("org.kde.test.instance1", pipeline);
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.test.instance1");
+        TestResource resource("sink.test.instance1", pipeline);
 
         auto command = createEntityBuffer();
 
@@ -141,16 +141,16 @@ private slots:
     {
         int num = 50000;
 
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.test.instance1");
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.test.instance1");
 
         auto eventFactory = QSharedPointer<TestEventAdaptorFactory>::create();
-        const QByteArray resourceIdentifier = "org.kde.test.instance1";
+        const QByteArray resourceIdentifier = "sink.test.instance1";
         auto indexer = QSharedPointer<IndexUpdater>::create();
 
         pipeline->setPreprocessors("event", QVector<Sink::Preprocessor *>() << indexer.data());
         pipeline->setAdaptorFactory("event", eventFactory);
 
-        TestResource resource("org.kde.test.instance1", pipeline);
+        TestResource resource("sink.test.instance1", pipeline);
 
         auto command = createEntityBuffer();
 
diff --git a/tests/genericresourcetest.cpp b/tests/genericresourcetest.cpp
index 7474cbf..77a901d 100644
--- a/tests/genericresourcetest.cpp
+++ b/tests/genericresourcetest.cpp
@@ -26,8 +26,7 @@ private slots:
 
     void init()
     {
-        Sink::GenericResource::removeFromDisk("org.kde.test.instance1");
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
+        Sink::GenericResource::removeFromDisk("sink.test.instance1");
     }
 
     /// Ensure the resource can process messages
@@ -71,10 +70,10 @@ private slots:
         }
 
         // Actual test
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.test.instance1");
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.test.instance1");
         QSignalSpy revisionSpy(pipeline.data(), SIGNAL(revisionUpdated(qint64)));
         QVERIFY(revisionSpy.isValid());
-        TestResource resource("org.kde.test.instance1", pipeline);
+        TestResource resource("sink.test.instance1", pipeline);
         resource.processCommand(Sink::Commands::CreateEntityCommand, command);
         resource.processCommand(Sink::Commands::CreateEntityCommand, command);
         resource.processAllMessages().exec().waitForFinished();
diff --git a/tests/indextest.cpp b/tests/indextest.cpp
index fa3ace4..8566803 100644
--- a/tests/indextest.cpp
+++ b/tests/indextest.cpp
@@ -16,19 +16,19 @@ class IndexTest : public QObject
 private slots:
     void initTestCase()
     {
-        Sink::Storage store("./testindex", "org.kde.dummy.testindex", Sink::Storage::ReadWrite);
+        Sink::Storage store("./testindex", "sink.dummy.testindex", Sink::Storage::ReadWrite);
         store.removeFromDisk();
     }
 
     void cleanup()
     {
-        Sink::Storage store("./testindex", "org.kde.dummy.testindex", Sink::Storage::ReadWrite);
+        Sink::Storage store("./testindex", "sink.dummy.testindex", Sink::Storage::ReadWrite);
         store.removeFromDisk();
     }
 
     void testIndex()
     {
-        Index index("./testindex", "org.kde.dummy.testindex", Sink::Storage::ReadWrite);
+        Index index("./testindex", "sink.dummy.testindex", Sink::Storage::ReadWrite);
         // The first key is specifically a substring of the second key
         index.add("key", "value1");
         index.add("keyFoo", "value2");
diff --git a/tests/inspectiontest.cpp b/tests/inspectiontest.cpp
index 38bf23d..3e8a103 100644
--- a/tests/inspectiontest.cpp
+++ b/tests/inspectiontest.cpp
@@ -19,11 +19,10 @@ class InspectionTest : public QObject
 private slots:
     void initTestCase()
     {
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
+        auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
-        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void testInspection_data()
@@ -39,7 +38,7 @@ private slots:
         using namespace Sink;
         using namespace Sink::ApplicationDomain;
 
-        Mail mail(QByteArray("org.kde.dummy.instance1"), QByteArray("identifier"), 0, QSharedPointer<MemoryBufferAdaptor::MemoryBufferAdaptor>::create());
+        Mail mail(QByteArray("sink.dummy.instance1"), QByteArray("identifier"), 0, QSharedPointer<MemoryBufferAdaptor::MemoryBufferAdaptor>::create());
 
         // testInspection is a magic property that the dummyresource supports
         auto inspectionCommand = ResourceControl::Inspection::PropertyInspection(mail, "testInspection", success);
diff --git a/tests/maildirsyncbenchmark.cpp b/tests/maildirsyncbenchmark.cpp
index 06c5ab1..d84c758 100644
--- a/tests/maildirsyncbenchmark.cpp
+++ b/tests/maildirsyncbenchmark.cpp
@@ -61,18 +61,17 @@ private slots:
     {
         targetPath = tempDir.path() + "/maildir1";
 
-        Sink::Log::setDebugOutputLevel(Sink::Log::Log);
-        MaildirResource::removeFromDisk("org.kde.maildir.test1");
+        MaildirResource::removeFromDisk("sink.maildir.test1");
         Sink::ApplicationDomain::SinkResource resource;
-        resource.setProperty("identifier", "org.kde.maildir.test1");
-        resource.setProperty("type", "org.kde.maildir");
+        resource.setProperty("identifier", "sink.maildir.test1");
+        resource.setProperty("type", "sink.maildir");
         resource.setProperty("path", targetPath);
         Sink::Store::create(resource).exec().waitForFinished();
     }
 
     void cleanup()
     {
-        MaildirResource::removeFromDisk("org.kde.maildir.test1");
+        MaildirResource::removeFromDisk("sink.maildir.test1");
         QDir dir(targetPath);
         dir.removeRecursively();
     }
@@ -84,8 +83,8 @@ private slots:
 
     void testbench()
     {
-        auto pipeline = QSharedPointer<Sink::Pipeline>::create("org.kde.maildir.test1");
-        MaildirResource resource("org.kde.maildir.test1", pipeline);
+        auto pipeline = QSharedPointer<Sink::Pipeline>::create("sink.maildir.test1");
+        MaildirResource resource("sink.maildir.test1", pipeline);
         QTime time;
         time.start();
         resource.Sink::GenericResource::synchronizeWithSource().exec().waitForFinished();
diff --git a/tests/mailquerybenchmark.cpp b/tests/mailquerybenchmark.cpp
index 4e58899..450955f 100644
--- a/tests/mailquerybenchmark.cpp
+++ b/tests/mailquerybenchmark.cpp
@@ -148,7 +148,7 @@ private slots:
 
     void init()
     {
-        resourceIdentifier = "org.kde.test.instance1";
+        resourceIdentifier = "sink.test.instance1";
         Sink::AdaptorFactoryRegistry::instance().registerFactory<Sink::ApplicationDomain::Mail, TestMailAdaptorFactory>("test");
     }
 
diff --git a/tests/mailsynctest.cpp b/tests/mailsynctest.cpp
index e70e34e..4b797c8 100644
--- a/tests/mailsynctest.cpp
+++ b/tests/mailsynctest.cpp
@@ -31,10 +31,12 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
+SINK_DEBUG_AREA("mailsynctest")
+
 void MailSyncTest::initTestCase()
 {
     Test::initTest();
-    Log::setDebugOutputLevel(Sink::Log::Trace);
+    QVERIFY(isBackendAvailable());
     resetTestEnvironment();
     auto resource = createResource();
     QVERIFY(!resource.identifier().isEmpty());
@@ -72,7 +74,7 @@ void MailSyncTest::testListFolders()
                 for (const auto &folder : folders) {
                     names << folder->getName();
                 }
-                Trace() << "base folder: " << names;
+                SinkTrace() << "base folder: " << names;
                 baseCount = folders.size();
             });
         VERIFYEXEC(job);
@@ -196,6 +198,10 @@ void MailSyncTest::testListFolderHierarchy()
             QVERIFY(names.contains("Drafts"));
             names.removeAll("Drafts");
         }
+        if (mCapabilities.contains(ResourceCapabilities::Mail::trash)) {
+            QVERIFY(names.contains("Trash"));
+            names.removeAll("Trash");
+        }
         QCOMPARE(names.size(), 3);
         QCOMPARE(map.value("sub")->getParent(), map.value("test")->identifier());
     });
diff --git a/tests/mailsynctest.h b/tests/mailsynctest.h
index a21335b..31d3f03 100644
--- a/tests/mailsynctest.h
+++ b/tests/mailsynctest.h
@@ -41,6 +41,7 @@ protected:
     QByteArray mResourceInstanceIdentifier;
     QByteArrayList mCapabilities;
 
+    virtual bool isBackendAvailable() { return true; }
     virtual void resetTestEnvironment() = 0;
     virtual Sink::ApplicationDomain::SinkResource createResource() = 0;
     virtual Sink::ApplicationDomain::SinkResource createFaultyResource() = 0;
diff --git a/tests/mailtest.cpp b/tests/mailtest.cpp
index b9d496d..2547536 100644
--- a/tests/mailtest.cpp
+++ b/tests/mailtest.cpp
@@ -31,10 +31,12 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
+SINK_DEBUG_AREA("mailtest")
+
 void MailTest::initTestCase()
 {
     Test::initTest();
-    Log::setDebugOutputLevel(Sink::Log::Trace);
+    QVERIFY(isBackendAvailable());
     resetTestEnvironment();
     auto resource = createResource();
     QVERIFY(!resource.identifier().isEmpty());
@@ -250,7 +252,7 @@ void MailTest::testMoveMail()
                 auto mail = *mails.first();
                 modifiedMail = mail;
                 QCOMPARE(mail.getFolder(), folder.identifier());
-                Warning() << "path: " << mail.getMimeMessagePath();
+                SinkWarning() << "path: " << mail.getMimeMessagePath();
                 QVERIFY(QFile(mail.getMimeMessagePath()).exists());
             });
         VERIFYEXEC(job);
@@ -269,7 +271,7 @@ void MailTest::testMoveMail()
                 auto mail = *mails.first();
                 QCOMPARE(mail.getFolder(), folder1.identifier());
                 QVERIFY(QFile(mail.getMimeMessagePath()).exists());
-                Trace() << "Mime message path: " << mail.getMimeMessagePath();
+                SinkTrace() << "Mime message path: " << mail.getMimeMessagePath();
             });
         VERIFYEXEC(job);
     }
diff --git a/tests/mailtest.h b/tests/mailtest.h
index 2144bf1..cba623d 100644
--- a/tests/mailtest.h
+++ b/tests/mailtest.h
@@ -34,6 +34,7 @@ protected:
     QByteArray mResourceInstanceIdentifier;
     QByteArrayList mCapabilities;
 
+    virtual bool isBackendAvailable() { return true; }
     virtual void resetTestEnvironment() = 0;
     virtual Sink::ApplicationDomain::SinkResource createResource() = 0;
 
diff --git a/tests/messagequeuetest.cpp b/tests/messagequeuetest.cpp
index 484ff86..e79bba2 100644
--- a/tests/messagequeuetest.cpp
+++ b/tests/messagequeuetest.cpp
@@ -7,6 +7,9 @@
 #include "storage.h"
 #include "messagequeue.h"
 #include "log.h"
+#include "test.h"
+
+SINK_DEBUG_AREA("messagequeuetest")
 
 /**
  * Test of the messagequeue implementation.
@@ -17,8 +20,8 @@ class MessageQueueTest : public QObject
 private slots:
     void initTestCase()
     {
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
-        Sink::Storage store(Sink::Store::storageLocation(), "org.kde.dummy.testqueue", Sink::Storage::ReadWrite);
+        Sink::Test::initTest();
+        Sink::Storage store(Sink::Store::storageLocation(), "sink.dummy.testqueue", Sink::Storage::ReadWrite);
         store.removeFromDisk();
     }
 
@@ -28,13 +31,13 @@ private slots:
 
     void cleanup()
     {
-        Sink::Storage store(Sink::Store::storageLocation(), "org.kde.dummy.testqueue", Sink::Storage::ReadWrite);
+        Sink::Storage store(Sink::Store::storageLocation(), "sink.dummy.testqueue", Sink::Storage::ReadWrite);
         store.removeFromDisk();
     }
 
     void testEmpty()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         QVERIFY(queue.isEmpty());
         queue.enqueue("value");
         QVERIFY(!queue.isEmpty());
@@ -42,7 +45,7 @@ private slots:
 
     void testDequeueEmpty()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         bool gotValue = false;
         bool gotError = false;
         queue.dequeue([&](void *ptr, int size, std::function<void(bool success)> callback) { gotValue = true; }, [&](const MessageQueue::Error &error) { gotError = true; });
@@ -52,7 +55,7 @@ private slots:
 
     void testEnqueue()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         QSignalSpy spy(&queue, SIGNAL(messageReady()));
         queue.enqueue("value1");
         QCOMPARE(spy.size(), 1);
@@ -60,7 +63,7 @@ private slots:
 
     void testDrained()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         QSignalSpy spy(&queue, SIGNAL(drained()));
         queue.enqueue("value1");
 
@@ -74,13 +77,13 @@ private slots:
         values << "value1";
         values << "value2";
 
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         for (const QByteArray &value : values) {
             queue.enqueue(value);
         }
 
         while (!queue.isEmpty()) {
-            Log() << "start";
+            SinkLog() << "start";
             const auto expected = values.dequeue();
             bool gotValue = false;
             bool gotError = false;
@@ -104,7 +107,7 @@ private slots:
         values << "value1";
         values << "value2";
 
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         for (const QByteArray &value : values) {
             queue.enqueue(value);
         }
@@ -142,7 +145,7 @@ private slots:
      */
     void testNestedEnqueue()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         queue.enqueue("value1");
 
         bool gotError = false;
@@ -157,7 +160,7 @@ private slots:
 
     void testBatchDequeue()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         queue.enqueue("value1");
         queue.enqueue("value2");
         queue.enqueue("value3");
@@ -178,7 +181,7 @@ private slots:
 
     void testBatchEnqueue()
     {
-        MessageQueue queue(Sink::Store::storageLocation(), "org.kde.dummy.testqueue");
+        MessageQueue queue(Sink::Store::storageLocation(), "sink.dummy.testqueue");
         QSignalSpy spy(&queue, SIGNAL(messageReady()));
         queue.startTransaction();
         queue.enqueue("value1");
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index d0a0920..1ac0e2d 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -10,6 +10,7 @@
 #include "resourceconfig.h"
 #include "log.h"
 #include "modelresult.h"
+#include "test.h"
 
 static int blockingTime;
 
@@ -29,10 +30,11 @@ public:
     {
         t.start();
         const bool ret = QCoreApplication::notify(receiver, event);
-        if (t.elapsed() > 1)
+        if (t.elapsed() > 1) {
             std::cout
-                << QString("processing event type %1 for object %2 took %3ms").arg((int)event->type()).arg("" /* receiver->objectName().toLocal8Bit().data()*/).arg((int)t.elapsed()).toStdString()
+                << QString("processing event type %1 for object %2 took %3ms").arg((int)event->type()).arg(receiver->metaObject()->className()).arg((int)t.elapsed()).toStdString()
                 << std::endl;
+        }
         blockingTime += t.elapsed();
         return ret;
     }
@@ -49,14 +51,14 @@ class ModelinteractivityTest : public QObject
 private slots:
     void initTestCase()
     {
-        Sink::Log::setDebugOutputLevel(Sink::Log::Warning);
-        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Test::initTest();
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void cleanup()
     {
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void init()
@@ -67,14 +69,14 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             for (int i = 0; i < 1000; i++) {
                 Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
             }
         }
 
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.liveQuery = true;
 
         Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
diff --git a/tests/pipelinebenchmark.cpp b/tests/pipelinebenchmark.cpp
index 51481fd..0c0b9e6 100644
--- a/tests/pipelinebenchmark.cpp
+++ b/tests/pipelinebenchmark.cpp
@@ -131,7 +131,7 @@ private slots:
     {
         Sink::Log::setDebugOutputLevel(Sink::Log::Warning);
         Sink::AdaptorFactoryRegistry::instance().registerFactory<Sink::ApplicationDomain::Mail, TestMailAdaptorFactory>("test");
-        resourceIdentifier = "org.kde.test.instance1";
+        resourceIdentifier = "sink.test.instance1";
     }
 
     void testWithoutIndex()
diff --git a/tests/pipelinetest.cpp b/tests/pipelinetest.cpp
index c6ee9ab..7216f62 100644
--- a/tests/pipelinetest.cpp
+++ b/tests/pipelinetest.cpp
@@ -190,13 +190,12 @@ class PipelineTest : public QObject
 private slots:
     void initTestCase()
     {
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
         Sink::AdaptorFactoryRegistry::instance().registerFactory<Sink::ApplicationDomain::Event, TestEventAdaptorFactory>("test");
     }
 
     void init()
     {
-        removeFromDisk("org.kde.pipelinetest.instance1");
+        removeFromDisk("sink.pipelinetest.instance1");
     }
 
     void testCreate()
@@ -204,14 +203,14 @@ private slots:
         flatbuffers::FlatBufferBuilder entityFbb;
         auto command = createEntityCommand(createEvent(entityFbb));
 
-        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
+        Sink::Pipeline pipeline("sink.pipelinetest.instance1");
         pipeline.setResourceType("test");
 
         pipeline.startTransaction();
         pipeline.newEntity(command.constData(), command.size());
         pipeline.commit();
 
-        auto result = getKeys("org.kde.pipelinetest.instance1", "event.main");
+        auto result = getKeys("sink.pipelinetest.instance1", "event.main");
         qDebug() << result;
         QCOMPARE(result.size(), 1);
     }
@@ -221,7 +220,7 @@ private slots:
         flatbuffers::FlatBufferBuilder entityFbb;
         auto command = createEntityCommand(createEvent(entityFbb, "summary", "description"));
 
-        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
+        Sink::Pipeline pipeline("sink.pipelinetest.instance1");
         pipeline.setResourceType("test");
 
         auto adaptorFactory = QSharedPointer<TestEventAdaptorFactory>::create();
@@ -232,7 +231,7 @@ private slots:
         pipeline.commit();
 
         // Get uid of written entity
-        auto keys = getKeys("org.kde.pipelinetest.instance1", "event.main");
+        auto keys = getKeys("sink.pipelinetest.instance1", "event.main");
         QCOMPARE(keys.size(), 1);
         const auto key = keys.first();
         const auto uid = Sink::Storage::uidFromKey(key);
@@ -245,7 +244,7 @@ private slots:
         pipeline.commit();
 
         // Ensure we've got the new revision with the modification
-        auto buffer = getEntity("org.kde.pipelinetest.instance1", "event.main", Sink::Storage::assembleKey(uid, 2));
+        auto buffer = getEntity("sink.pipelinetest.instance1", "event.main", Sink::Storage::assembleKey(uid, 2));
         QVERIFY(!buffer.isEmpty());
         Sink::EntityBuffer entityBuffer(buffer.data(), buffer.size());
         auto adaptor = adaptorFactory->createAdaptor(entityBuffer.entity());
@@ -254,7 +253,7 @@ private slots:
         QVERIFY2(adaptor->getProperty("description").toString() == QString("description"), "The modification has sideeffects.");
 
         // Both revisions are in the store at this point
-        QCOMPARE(getKeys("org.kde.pipelinetest.instance1", "event.main").size(), 2);
+        QCOMPARE(getKeys("sink.pipelinetest.instance1", "event.main").size(), 2);
 
         // Cleanup old revisions
         pipeline.startTransaction();
@@ -262,7 +261,7 @@ private slots:
         pipeline.commit();
 
         // And now only the latest revision is left
-        QCOMPARE(getKeys("org.kde.pipelinetest.instance1", "event.main").size(), 1);
+        QCOMPARE(getKeys("sink.pipelinetest.instance1", "event.main").size(), 1);
     }
 
     void testModifyWithUnrelatedOperationInbetween()
@@ -270,7 +269,7 @@ private slots:
         flatbuffers::FlatBufferBuilder entityFbb;
         auto command = createEntityCommand(createEvent(entityFbb));
 
-        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
+        Sink::Pipeline pipeline("sink.pipelinetest.instance1");
         pipeline.setResourceType("test");
 
         auto adaptorFactory = QSharedPointer<TestEventAdaptorFactory>::create();
@@ -281,7 +280,7 @@ private slots:
         pipeline.commit();
 
         // Get uid of written entity
-        auto keys = getKeys("org.kde.pipelinetest.instance1", "event.main");
+        auto keys = getKeys("sink.pipelinetest.instance1", "event.main");
         QCOMPARE(keys.size(), 1);
         const auto uid = Sink::Storage::uidFromKey(keys.first());
 
@@ -303,7 +302,7 @@ private slots:
         pipeline.commit();
 
         // Ensure we've got the new revision with the modification
-        auto buffer = getEntity("org.kde.pipelinetest.instance1", "event.main", Sink::Storage::assembleKey(uid, 3));
+        auto buffer = getEntity("sink.pipelinetest.instance1", "event.main", Sink::Storage::assembleKey(uid, 3));
         QVERIFY(!buffer.isEmpty());
         Sink::EntityBuffer entityBuffer(buffer.data(), buffer.size());
         auto adaptor = adaptorFactory->createAdaptor(entityBuffer.entity());
@@ -314,7 +313,7 @@ private slots:
     {
         flatbuffers::FlatBufferBuilder entityFbb;
         auto command = createEntityCommand(createEvent(entityFbb));
-        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
+        Sink::Pipeline pipeline("sink.pipelinetest.instance1");
         pipeline.setResourceType("test");
 
         // Create the initial revision
@@ -322,7 +321,7 @@ private slots:
         pipeline.newEntity(command.constData(), command.size());
         pipeline.commit();
 
-        auto result = getKeys("org.kde.pipelinetest.instance1", "event.main");
+        auto result = getKeys("sink.pipelinetest.instance1", "event.main");
         QCOMPARE(result.size(), 1);
 
         const auto uid = Sink::Storage::uidFromKey(result.first());
@@ -334,7 +333,7 @@ private slots:
         pipeline.commit();
 
         // We have a new revision that indicates the deletion
-        QCOMPARE(getKeys("org.kde.pipelinetest.instance1", "event.main").size(), 2);
+        QCOMPARE(getKeys("sink.pipelinetest.instance1", "event.main").size(), 2);
 
         // Cleanup old revisions
         pipeline.startTransaction();
@@ -342,18 +341,18 @@ private slots:
         pipeline.commit();
 
         // And all revisions are gone
-        QCOMPARE(getKeys("org.kde.pipelinetest.instance1", "event.main").size(), 0);
+        QCOMPARE(getKeys("sink.pipelinetest.instance1", "event.main").size(), 0);
     }
 
     void testPreprocessor()
     {
         flatbuffers::FlatBufferBuilder entityFbb;
 
-        TestProcessor testProcessor;
+        auto testProcessor = new TestProcessor;
 
-        Sink::Pipeline pipeline("org.kde.pipelinetest.instance1");
+        Sink::Pipeline pipeline("sink.pipelinetest.instance1");
         pipeline.setResourceType("test");
-        pipeline.setPreprocessors("event", QVector<Sink::Preprocessor *>() << &testProcessor);
+        pipeline.setPreprocessors("event", QVector<Sink::Preprocessor *>() << testProcessor);
         pipeline.startTransaction();
         // pipeline.setAdaptorFactory("event", QSharedPointer<TestEventAdaptorFactory>::create());
 
@@ -361,24 +360,24 @@ private slots:
         {
             auto command = createEntityCommand(createEvent(entityFbb));
             pipeline.newEntity(command.constData(), command.size());
-            QCOMPARE(testProcessor.newUids.size(), 1);
-            QCOMPARE(testProcessor.newRevisions.size(), 1);
+            QCOMPARE(testProcessor->newUids.size(), 1);
+            QCOMPARE(testProcessor->newRevisions.size(), 1);
             // Key doesn't contain revision and is just the uid
-            QCOMPARE(testProcessor.newUids.at(0), Sink::Storage::uidFromKey(testProcessor.newUids.at(0)));
+            QCOMPARE(testProcessor->newUids.at(0), Sink::Storage::uidFromKey(testProcessor->newUids.at(0)));
         }
         pipeline.commit();
         entityFbb.Clear();
         pipeline.startTransaction();
-        auto keys = getKeys("org.kde.pipelinetest.instance1", "event.main");
+        auto keys = getKeys("sink.pipelinetest.instance1", "event.main");
         QCOMPARE(keys.size(), 1);
         const auto uid = Sink::Storage::uidFromKey(keys.first());
         {
             auto modifyCommand = modifyEntityCommand(createEvent(entityFbb, "summary2"), uid, 1);
             pipeline.modifiedEntity(modifyCommand.constData(), modifyCommand.size());
-            QCOMPARE(testProcessor.modifiedUids.size(), 1);
-            QCOMPARE(testProcessor.modifiedRevisions.size(), 1);
+            QCOMPARE(testProcessor->modifiedUids.size(), 1);
+            QCOMPARE(testProcessor->modifiedRevisions.size(), 1);
             // Key doesn't contain revision and is just the uid
-            QCOMPARE(testProcessor.modifiedUids.at(0), Sink::Storage::uidFromKey(testProcessor.modifiedUids.at(0)));
+            QCOMPARE(testProcessor->modifiedUids.at(0), Sink::Storage::uidFromKey(testProcessor->modifiedUids.at(0)));
         }
         pipeline.commit();
         entityFbb.Clear();
@@ -386,12 +385,12 @@ private slots:
         {
             auto deleteCommand = deleteEntityCommand(uid, 1);
             pipeline.deletedEntity(deleteCommand.constData(), deleteCommand.size());
-            QCOMPARE(testProcessor.deletedUids.size(), 1);
-            QCOMPARE(testProcessor.deletedUids.size(), 1);
-            QCOMPARE(testProcessor.deletedSummaries.size(), 1);
+            QCOMPARE(testProcessor->deletedUids.size(), 1);
+            QCOMPARE(testProcessor->deletedUids.size(), 1);
+            QCOMPARE(testProcessor->deletedSummaries.size(), 1);
             // Key doesn't contain revision and is just the uid
-            QCOMPARE(testProcessor.deletedUids.at(0), Sink::Storage::uidFromKey(testProcessor.deletedUids.at(0)));
-            QCOMPARE(testProcessor.deletedSummaries.at(0), QByteArray("summary2"));
+            QCOMPARE(testProcessor->deletedUids.at(0), Sink::Storage::uidFromKey(testProcessor->deletedUids.at(0)));
+            QCOMPARE(testProcessor->deletedSummaries.at(0), QByteArray("summary2"));
         }
     }
 };
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index 6d7746e..d3a97f6 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -23,16 +23,15 @@ private slots:
     void initTestCase()
     {
         Sink::Test::initTest();
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
-        auto factory = Sink::ResourceFactory::load("org.kde.dummy");
+        auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
-        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void cleanup()
     {
-        Sink::Store::removeDataFromDisk(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")).exec().waitForFinished();
     }
 
     void init()
@@ -60,13 +59,13 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -78,13 +77,13 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.liveQuery = false;
 
         // Ensure all local data is processed
@@ -102,12 +101,12 @@ private slots:
         QByteArray id;
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
 
             // Ensure all local data is processed
             Sink::Store::synchronize(query).exec().waitForFinished();
@@ -121,7 +120,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.ids << id;
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -132,13 +131,13 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Folder folder("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -152,11 +151,11 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Folder folder("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
 
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -168,14 +167,14 @@ private slots:
             auto folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
-            Sink::ApplicationDomain::Folder subfolder("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Folder subfolder("sink.dummy.instance1");
             subfolder.setProperty("parent", folderEntity->identifier());
             Sink::Store::create<Sink::ApplicationDomain::Folder>(subfolder).exec().waitForFinished();
         }
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.parentProperty = "parent";
 
         // Ensure all local data is processed
@@ -194,7 +193,7 @@ private slots:
     {
         // Setup
         {
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             mail.setProperty("uid", "test1");
             mail.setProperty("sender", "doe@example.org");
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
@@ -202,7 +201,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query.liveQuery = false;
         query += Sink::Query::PropertyFilter("uid", "test1");
 
@@ -220,11 +219,11 @@ private slots:
         // Setup
         Sink::ApplicationDomain::Folder::Ptr folderEntity;
         {
-            Sink::ApplicationDomain::Folder folder("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
 
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -236,7 +235,7 @@ private slots:
             folderEntity = model->index(0, 0).data(Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::Folder::Ptr>();
             QVERIFY(!folderEntity->identifier().isEmpty());
 
-            Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
             mail.setProperty("uid", "test1");
             mail.setProperty("folder", folderEntity->identifier());
             Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
@@ -244,7 +243,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query += Sink::Query::PropertyFilter("folder", *folderEntity);
 
         // Ensure all local data is processed
@@ -261,11 +260,11 @@ private slots:
         // Setup
         Sink::ApplicationDomain::Folder::Ptr folderEntity;
         {
-            Sink::ApplicationDomain::Folder folder("org.kde.dummy.instance1");
+            Sink::ApplicationDomain::Folder folder("sink.dummy.instance1");
             Sink::Store::create<Sink::ApplicationDomain::Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "org.kde.dummy.instance1";
+            query.resources << "sink.dummy.instance1";
 
             // Ensure all local data is processed
             Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
@@ -279,21 +278,21 @@ private slots:
 
             const auto date = QDateTime(QDate(2015, 7, 7), QTime(12, 0));
             {
-                Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testSecond");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date.addDays(-1));
                 Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
             }
             {
-                Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testLatest");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date);
                 Sink::Store::create<Sink::ApplicationDomain::Mail>(mail).exec().waitForFinished();
             }
             {
-                Sink::ApplicationDomain::Mail mail("org.kde.dummy.instance1");
+                Sink::ApplicationDomain::Mail mail("sink.dummy.instance1");
                 mail.setProperty("uid", "testLast");
                 mail.setProperty("folder", folderEntity->identifier());
                 mail.setProperty("date", date.addDays(-2));
@@ -303,7 +302,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "org.kde.dummy.instance1";
+        query.resources << "sink.dummy.instance1";
         query += Sink::Query::PropertyFilter("folder", *folderEntity);
         query.sortProperty = "date";
         query.limit = 1;
diff --git a/tests/resourcecommunicationtest.cpp b/tests/resourcecommunicationtest.cpp
index 2874457..1530f63 100644
--- a/tests/resourcecommunicationtest.cpp
+++ b/tests/resourcecommunicationtest.cpp
@@ -92,6 +92,26 @@ private slots:
         QTRY_COMPARE(complete, count);
         QVERIFY(!errors);
     }
+
+    void testAccessFactory()
+    {
+        const QByteArray resourceIdentifier("test");
+        Listener listener(resourceIdentifier, "");
+        QWeakPointer<Sink::ResourceAccess> weakRef;
+        QTime time;
+        time.start();
+        {
+            auto resourceAccess = Sink::ResourceAccessFactory::instance().getAccess(resourceIdentifier, "");
+            weakRef = resourceAccess.toWeakRef();
+            resourceAccess->open();
+            resourceAccess->sendCommand(Sink::Commands::PingCommand).then<void>([resourceAccess]() { qDebug() << "Pind complete";  }).exec();
+        }
+        QVERIFY(weakRef.toStrongRef());
+        QTRY_VERIFY(!weakRef.toStrongRef());
+        qDebug() << "time.elapsed " << time.elapsed();
+        QVERIFY(time.elapsed() < 3500);
+        QVERIFY(time.elapsed() > 2500);
+    }
 };
 
 QTEST_MAIN(ResourceCommunicationTest)
diff --git a/tests/resourceconfigtest.cpp b/tests/resourceconfigtest.cpp
index bebff50..021d042 100644
--- a/tests/resourceconfigtest.cpp
+++ b/tests/resourceconfigtest.cpp
@@ -8,6 +8,8 @@
 #include "modelresult.h"
 #include "resultprovider.h"
 #include "facadefactory.h"
+#include "test.h"
+#include "testutils.h"
 
 /**
  * Test of the resource configuration.
@@ -19,9 +21,9 @@ private slots:
 
     void initTestCase()
     {
+        Sink::Test::initTest();
         Sink::FacadeFactory::instance().resetFactory();
         ResourceConfig::clear();
-        Sink::Log::setDebugOutputLevel(Sink::Log::Trace);
     }
 
     void resourceManagement()
@@ -72,6 +74,30 @@ private slots:
         Sink::Store::remove(res).exec().waitForFinished();
     }
 
+    void testLoadResourceStatus()
+    {
+        ResourceConfig::clear();
+        Sink::FacadeFactory::instance().registerStaticFacades();
+
+        auto res = Sink::ApplicationDomain::DummyResource::create("");
+        VERIFYEXEC(Sink::Store::create(res));
+        {
+            Sink::Query query;
+            query.liveQuery = true;
+            query.request<Sink::ApplicationDomain::SinkResource::Status>();
+            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkResource>(query);
+            QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
+            auto resource = model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkResource::Ptr>();
+            QCOMPARE(resource->getStatus(), static_cast<int>(Sink::ApplicationDomain::OfflineStatus));
+
+            //Synchronize to connect
+            VERIFYEXEC(Sink::Store::synchronize(query));
+            QTRY_COMPARE(model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkResource::Ptr>()->getStatus(), static_cast<int>(Sink::ApplicationDomain::ConnectedStatus));
+        }
+
+        VERIFYEXEC(Sink::Store::remove(res));
+    }
+
 };
 
 QTEST_MAIN(ResourceConfigTest)
diff --git a/tests/testaccounttest.cpp b/tests/testaccounttest.cpp
index c630846..078e7a0 100644
--- a/tests/testaccounttest.cpp
+++ b/tests/testaccounttest.cpp
@@ -20,7 +20,6 @@ private slots:
     {
         // Sink::FacadeFactory::instance().resetFactory();
         // ResourceConfig::clear();
-        Log::setDebugOutputLevel(Sink::Log::Trace);
         Test::initTest();
     }