diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 8cc34b7c..6cd46d9d 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,68 +1,65 @@
 add_subdirectory(hawd)
 
 set(CMAKE_AUTOMOC ON)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}/hawd
     ${CMAKE_CURRENT_BINARY_DIR}/../examples/dummyresource
     ${CMAKE_CURRENT_SOURCE_DIR}/../examples/
     )
 
 add_definitions(-DTESTDATAPATH="${CMAKE_CURRENT_SOURCE_DIR}/data")
 add_definitions(-DTHREADTESTDATAPATH="${CMAKE_CURRENT_SOURCE_DIR}/threaddata")
 
 find_package(KF5 COMPONENTS REQUIRED Mime)
 
 add_library(sink_test SHARED testimplementations.cpp getrssusage.cpp mailtest.cpp mailsynctest.cpp mailthreadtest.cpp utils.cpp)
 generate_export_header(sink_test BASE_NAME SinkTest EXPORT_FILE_NAME sinktest_export.h)
 target_link_libraries(sink_test
     sink
     libhawd
     Qt5::Core
     Qt5::Concurrent
     Qt5::Test
     KF5::Mime
 )
 
 add_executable(dbwriter dbwriter.cpp)
 target_link_libraries(dbwriter sink)
 
 include(SinkTest)
 
 manual_tests (
     storagebenchmark
     dummyresourcebenchmark
     mailquerybenchmark
     pipelinebenchmark
     dummyresourcewritebenchmark
     databasepopulationandfacadequerybenchmark
 )
 
 auto_tests (
     clientapitest
     resourceconfigtest
     storagetest
     dummyresourcetest
     domainadaptortest
     messagequeuetest
     indextest
     resourcecommunicationtest
     pipelinetest
     querytest
     modelinteractivitytest
     inspectiontest
     accountstest
     testaccounttest
     dummyresourcemailtest
     interresourcemovetest
     notificationtest
     entitystoretest
     upgradetest
 )
 target_link_libraries(dummyresourcetest sink_resource_dummy)
 target_link_libraries(dummyresourcebenchmark sink_resource_dummy)
 target_link_libraries(dummyresourcewritebenchmark sink_resource_dummy)
-target_link_libraries(querytest sink_resource_dummy)
-target_link_libraries(modelinteractivitytest sink_resource_dummy)
-target_link_libraries(inspectiontest sink_resource_dummy)
-target_link_libraries(notificationtest sink_resource_dummy)
+
diff --git a/tests/inspectiontest.cpp b/tests/inspectiontest.cpp
index b03f2771..4e177853 100644
--- a/tests/inspectiontest.cpp
+++ b/tests/inspectiontest.cpp
@@ -1,57 +1,57 @@
 #include <QtTest>
 
 #include <QString>
 
-#include "dummyresource/resourcefactory.h"
 #include "store.h"
 #include "resourcecontrol.h"
 #include "resourceconfig.h"
+#include "resource.h"
 #include "log.h"
 #include "testutils.h"
 
 /**
  * Test of inspection system using the dummy resource.
  *
  * This test requires the dummy resource installed.
  */
 class InspectionTest : public QObject
 {
     Q_OBJECT
 private slots:
     void initTestCase()
     {
         auto factory = Sink::ResourceFactory::load("sink.dummy");
         QVERIFY(factory);
         ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
         VERIFYEXEC(Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")));
     }
 
     void testInspection_data()
     {
         QTest::addColumn<bool>("success");
         QTest::newRow("success") << true;
         QTest::newRow("fail") << false;
     }
 
     void testInspection()
     {
         QFETCH(bool, success);
         using namespace Sink;
         using namespace Sink::ApplicationDomain;
 
         Mail mail(QByteArray("sink.dummy.instance1"), QByteArray("identifier"), 0, QSharedPointer<MemoryBufferAdaptor>::create());
 
         // testInspection is a magic property that the dummyresource supports
         auto inspectionCommand = ResourceControl::Inspection::PropertyInspection(mail, "testInspection", success);
         auto result = ResourceControl::inspect<Mail>(inspectionCommand).exec();
         result.waitForFinished();
         if (success) {
             QVERIFY(!result.errorCode());
         } else {
             QVERIFY(result.errorCode());
         }
     }
 };
 
 QTEST_MAIN(InspectionTest)
 #include "inspectiontest.moc"
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index da643a84..2939323a 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -1,105 +1,104 @@
 #include <QtTest>
 
 #include <QString>
 #include <iostream>
 
-#include "dummyresource/resourcefactory.h"
 #include "store.h"
 #include "resourcecontrol.h"
 #include "commands.h"
 #include "resourceconfig.h"
 #include "log.h"
 #include "modelresult.h"
 #include "test.h"
 #include "testutils.h"
 
 static int blockingTime;
 
 class TimeMeasuringApplication : public QCoreApplication
 {
     QElapsedTimer t;
 
 public:
     TimeMeasuringApplication(int &argc, char **argv) : QCoreApplication(argc, argv)
     {
     }
     virtual ~TimeMeasuringApplication()
     {
     }
 
     virtual bool notify(QObject *receiver, QEvent *event)
     {
         t.start();
         auto receiverName = receiver->metaObject()->className();
         const bool ret = QCoreApplication::notify(receiver, event);
         if (t.elapsed() > 1) {
             std::cout
                 << QString("processing event type %1 for object %2 took %3ms").arg((int)event->type()).arg(receiverName).arg((int)t.elapsed()).toStdString()
                 << std::endl;
         }
         blockingTime += t.elapsed();
         return ret;
     }
 };
 
 /**
  * Ensure that queries don't block the system for an extended period of time.
  *
  * This is done by ensuring that the event loop is never blocked.
  */
 class ModelinteractivityTest : public QObject
 {
     Q_OBJECT
 private slots:
     void initTestCase()
     {
         Sink::Test::initTest();
         ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
         VERIFYEXEC(Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")));
     }
 
     void cleanup()
     {
         VERIFYEXEC(Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")));
     }
 
     void init()
     {
     }
 
     void testSingle()
     {
         // Setup
         {
             Sink::ApplicationDomain::Event event("sink.dummy.instance1");
             for (int i = 0; i < 1000; i++) {
                 Sink::Store::create<Sink::ApplicationDomain::Event>(event).exec().waitForFinished();
             }
         }
 
         Sink::Query query;
         query.resourceFilter("sink.dummy.instance1");
         query.setFlags(Sink::Query::LiveQuery);
 
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test
         QTime time;
         time.start();
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
         blockingTime += time.elapsed();
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
         // Never block longer than 10 ms
         QVERIFY2(blockingTime < 10, QString("Total blocking time: %1").arg(blockingTime).toLatin1().data());
     }
 };
 
 int main(int argc, char *argv[])
 {
     blockingTime = 0;
     TimeMeasuringApplication app(argc, argv);
     ModelinteractivityTest tc;
     return QTest::qExec(&tc, argc, argv);
 }
 
 #include "modelinteractivitytest.moc"