9 files changed, 110 insertions, 106 deletions

diff --git a/tests/accountstest.cpp b/tests/accountstest.cpp
index 260602c..8216210 100644
--- a/tests/accountstest.cpp
+++ b/tests/accountstest.cpp
@@ -139,7 +139,7 @@ private slots:
             QCOMPARE(account->getStatus(), static_cast<int>(Sink::ApplicationDomain::OfflineStatus));
 
             //Synchronize to connect
-            VERIFYEXEC(Sink::Store::synchronize(Query::ResourceFilter(res)));
+            VERIFYEXEC(Sink::Store::synchronize(Query().resourceFilter(res.identifier())));
 
             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);
         }
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 44eb845..fd3d5f0 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -104,7 +104,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -115,7 +115,7 @@ private slots:
     void testLoadWithoutResource()
     {
         Sink::Query query;
-        query.resources << "nonexisting.resource";
+        query.resourceFilter("nonexisting.resource");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
@@ -129,7 +129,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Folder>(query);
@@ -147,7 +147,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
         query.parentProperty = "parent";
 
@@ -170,7 +170,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
         query.parentProperty = "parent";
 
@@ -193,7 +193,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = true;
         query.parentProperty = "parent";
 
@@ -268,7 +268,7 @@ private slots:
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
 
         Sink::Query query;
-        query.resources << "dummyresource.instance1";
+        query.resourceFilter("dummyresource.instance1");
         query.liveQuery = false;
 
         bool gotValue = false;
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index ffaa8f6..8c6afb4 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -13,6 +13,8 @@
 #include "log.h"
 #include "resourceconfig.h"
 #include "notification_generated.h"
+#include "test.h"
+#include "testutils.h"
 
 #include "hawd/dataset.h"
 #include "hawd/formatter.h"
@@ -98,8 +100,8 @@ private slots:
         // Ensure everything is processed
         {
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            query.resourceFilter("sink.dummy.instance1");
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
         }
         auto allProcessedTime = time.elapsed();
 
@@ -127,7 +129,7 @@ private slots:
         {
             time.start();
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             query.filter("uid", Sink::Query::Comparator("testuid"));
             auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Event>(query);
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index a7a492c..2ff31e5 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -12,6 +12,7 @@
 #include "pipeline.h"
 #include "log.h"
 #include "test.h"
+#include "testutils.h"
 
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
@@ -66,10 +67,10 @@ private slots:
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -88,10 +89,10 @@ private slots:
         event.setProperty("uid", "testuid2");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Uid>("testuid"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -113,10 +114,10 @@ private slots:
         event.setProperty("summary", "summaryValue2");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1") ;
+        auto query = Query().resourceFilter("sink.dummy.instance1") ;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query.filter<Event::Summary>("summaryValue2"));
         QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
@@ -143,11 +144,11 @@ private slots:
 
     void testSyncAndFacade()
     {
-        const auto query = Query::ResourceFilter("sink.dummy.instance1");
+        const auto query = Query().resourceFilter("sink.dummy.instance1");
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -159,12 +160,12 @@ private slots:
 
     void testSyncAndFacadeMail()
     {
-        auto query = Query::ResourceFilter("sink.dummy.instance1");
+        auto query = Query().resourceFilter("sink.dummy.instance1");
         query.request<Mail::Subject>();
 
         // Ensure all local data is processed
         Sink::Store::synchronize(query).exec().waitForFinished();
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -182,10 +183,10 @@ private slots:
         event.setProperty("summary", "summaryValue");
         Sink::Store::create<Event>(event).exec().waitForFinished();
 
-        auto query = Query::ResourceFilter("sink.dummy.instance1").filter<Event::Uid>("testuid");
+        auto query = Query().resourceFilter("sink.dummy.instance1").filter<Event::Uid>("testuid");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test create
         Event event2;
@@ -204,7 +205,7 @@ private slots:
         Sink::Store::modify<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test modify
         {
@@ -219,7 +220,7 @@ private slots:
         Sink::Store::remove<Event>(event2).exec().waitForFinished();
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test remove
         {
@@ -231,7 +232,7 @@ private slots:
 
     void testWriteModifyDeleteLive()
     {
-        auto query = Query::ResourceFilter("sink.dummy.instance1");
+        auto query = Query().resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
         query.filter<Event::Uid>("testuid");
 
diff --git a/tests/mailsynctest.cpp b/tests/mailsynctest.cpp
index 8260978..98ac685 100644
--- a/tests/mailsynctest.cpp
+++ b/tests/mailsynctest.cpp
@@ -81,12 +81,12 @@ void MailSyncTest::testListFolders()
     }
 
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>().request<Folder::SpecialPurpose>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -121,14 +121,14 @@ void MailSyncTest::testListFolders()
 void MailSyncTest::testListNewFolder()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     createFolder(QStringList() << "test2");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -143,17 +143,17 @@ void MailSyncTest::testListNewFolder()
 void MailSyncTest::testListRemovedFolder()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     removeFolder(QStringList() << "test2");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -171,14 +171,14 @@ void MailSyncTest::testListFolderHierarchy()
         QSKIP("Missing capability folder.hierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>().request<Folder::Parent>();
 
     createFolder(QStringList() << "test" << "sub");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([=](const QList<Folder::Ptr> &folders) {
         QHash<QString, Folder::Ptr> map;
@@ -214,14 +214,14 @@ void MailSyncTest::testListNewSubFolder()
         QSKIP("Missing capability mail.folderhierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     createFolder(QStringList() << "test" << "sub1");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -239,17 +239,17 @@ void MailSyncTest::testListRemovedSubFolder()
         QSKIP("Missing capability folder.hierarchy");
     }
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Folder::Name>();
 
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     removeFolder(QStringList() << "test" << "sub1");
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Folder>(query).syncThen<void, QList<Folder::Ptr>>([](const QList<Folder::Ptr> &folders) {
         QStringList names;
@@ -264,12 +264,12 @@ void MailSyncTest::testListRemovedSubFolder()
 void MailSyncTest::testListMails()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
         QCOMPARE(mails.size(), 1);
@@ -290,15 +290,15 @@ void MailSyncTest::testListMails()
 void MailSyncTest::testResyncMails()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
         QCOMPARE(mails.size(), 1);
@@ -309,20 +309,20 @@ void MailSyncTest::testResyncMails()
 void MailSyncTest::testFetchNewRemovedMessages()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>();
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto msg = KMime::Message::Ptr::create();
     msg->subject(true)->fromUnicodeString("Foobar", "utf8");
     msg->assemble();
     auto messageIdentifier = createMessage(QStringList() << "test", msg->encodedContent(true));
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
@@ -333,8 +333,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 
     removeMessage(QStringList() << "test", messageIdentifier);
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
@@ -347,7 +347,8 @@ void MailSyncTest::testFetchNewRemovedMessages()
 void MailSyncTest::testFlagChange()
 {
     Sink::Query query;
-    query.resources << mResourceInstanceIdentifier;
+    query.resourceFilter(mResourceInstanceIdentifier);
+    query.filter<Mail::Important>(true);
     query.request<Mail::Subject>().request<Mail::Important>();
 
     auto msg = KMime::Message::Ptr::create();
@@ -355,13 +356,12 @@ void MailSyncTest::testFlagChange()
     msg->assemble();
     auto messageIdentifier = createMessage(QStringList() << "test", msg->encodedContent(true));
 
-    Store::synchronize(query).exec().waitForFinished();
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(Store::synchronize(query));
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 2);
-            QVERIFY(!mails.at(1)->getImportant());
+            QCOMPARE(mails.size(), 0);
         });
         VERIFYEXEC(job);
     }
@@ -370,12 +370,12 @@ void MailSyncTest::testFlagChange()
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     {
         auto job = Store::fetchAll<Mail>(query).syncThen<void, QList<Mail::Ptr>>([](const QList<Mail::Ptr> &mails) {
-            QCOMPARE(mails.size(), 2);
-            QVERIFY(mails.at(1)->getImportant());
+            QCOMPARE(mails.size(), 1);
+            QVERIFY(mails.first()->getImportant());
         });
         VERIFYEXEC(job);
     }
@@ -389,7 +389,7 @@ void MailSyncTest::testFailingSync()
     VERIFYEXEC(Store::create(resource));
 
     Sink::Query query;
-    query.resources << resource.identifier();
+    query.resourceFilter(resource.identifier());
 
     // Ensure sync fails if resource is misconfigured
     auto future = Store::synchronize(query).exec();
diff --git a/tests/mailtest.cpp b/tests/mailtest.cpp
index ed145d4..3339838 100644
--- a/tests/mailtest.cpp
+++ b/tests/mailtest.cpp
@@ -298,7 +298,7 @@ void MailTest::testMarkMailAsRead()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto job = Store::fetchAll<Mail>(Query()
-                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .resourceFilter(mResourceInstanceIdentifier)
                                         .request<Mail::Folder>()
                                         .request<Mail::Subject>()
                                     )
@@ -315,7 +315,7 @@ void MailTest::testMarkMailAsRead()
 
     // Verify that we can still query for all relevant information
     auto job2 = Store::fetchAll<Mail>(Query()
-                                        .filter(SinkResource(mResourceInstanceIdentifier))
+                                        .resourceFilter(mResourceInstanceIdentifier)
                                         .request<Mail::Folder>()
                                         .request<Mail::Subject>()
                                         .request<Mail::MimeMessage>()
@@ -351,7 +351,7 @@ void MailTest::testCreateDraft()
 
     QByteArray folderIdentifier;
 
-    auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+    auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
     folderIdentifier = createdDraft.getFolder();
     QVERIFY(!folderIdentifier.isEmpty());
 
@@ -370,7 +370,7 @@ void MailTest::testCreateDraft()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier));
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier));
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         VERIFYEXEC(ResourceControl::inspect<ApplicationDomain::Folder>(ResourceControl::Inspection::ExistenceInspection(folder, true)));
@@ -400,7 +400,7 @@ void MailTest::testModifyMailToDraft()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail));
+    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
     modifiedMail.setDraft(true);
     VERIFYEXEC(Store::modify(modifiedMail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -408,7 +408,7 @@ void MailTest::testModifyMailToDraft()
 
     QByteArray folderIdentifier;
     {
-        auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+        auto createdDraft = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
         folderIdentifier = createdDraft.getFolder();
         QVERIFY(!folderIdentifier.isEmpty());
     }
@@ -416,7 +416,7 @@ void MailTest::testModifyMailToDraft()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier).request<Folder::SpecialPurpose>());
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         QVERIFY(folder.getSpecialPurpose().contains("drafts"));
@@ -447,7 +447,7 @@ void MailTest::testModifyMailToTrash()
     VERIFYEXEC(Store::create(mail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
-    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail));
+    auto modifiedMail = Store::readOne<ApplicationDomain::Mail>(Query(mail));
     modifiedMail.setTrash(true);
     VERIFYEXEC(Store::modify(modifiedMail));
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -455,7 +455,7 @@ void MailTest::testModifyMailToTrash()
 
     QByteArray folderIdentifier;
     {
-        auto createdMail = Store::readOne<ApplicationDomain::Mail>(Query::IdentityFilter(mail).request<Mail::Folder>());
+        auto createdMail = Store::readOne<ApplicationDomain::Mail>(Query(mail).request<Mail::Folder>());
         folderIdentifier = createdMail.getFolder();
         QVERIFY(!folderIdentifier.isEmpty());
     }
@@ -463,7 +463,7 @@ void MailTest::testModifyMailToTrash()
     //Ensure the folder is also existing
     {
         ApplicationDomain::Folder folder;
-        auto folders = Store::read<ApplicationDomain::Folder>(Query::IdentityFilter(folderIdentifier).request<Folder::SpecialPurpose>());
+        auto folders = Store::read<ApplicationDomain::Folder>(Query().filter(folderIdentifier).request<Folder::SpecialPurpose>());
         QCOMPARE(folders.size(), 1);
         folder = folders.first();
         QVERIFY(folder.getSpecialPurpose().contains("trash"));
diff --git a/tests/mailthreadtest.cpp b/tests/mailthreadtest.cpp
index 6ba54df..b6b0da2 100644
--- a/tests/mailthreadtest.cpp
+++ b/tests/mailthreadtest.cpp
@@ -66,14 +66,14 @@ void MailThreadTest::init()
 void MailThreadTest::testListThreadLeader()
 {
     Sink::Query query;
-    query.filter(SinkResource(mResourceInstanceIdentifier));
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
     query.sort<Mail::Date>();
     query.reduce<Mail::ThreadId>(Query::Reduce::Selector::max<Mail::Date>());
 
     // Ensure all local data is processed
     VERIFYEXEC(Store::synchronize(query));
-    ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+    VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto mails = Store::read<Mail>(query);
     QCOMPARE(mails.size(), 1);
@@ -125,7 +125,7 @@ void MailThreadTest::testIndexInMixedOrder()
     VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
 
     auto query = Sink::Query::threadLeaders(folder);
-    query.filter(SinkResource(mResourceInstanceIdentifier));
+    query.resourceFilter(mResourceInstanceIdentifier);
     query.request<Mail::Subject>().request<Mail::MimeMessage>().request<Mail::Folder>().request<Mail::Date>();
 
     Mail threadLeader;
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index 1ac0e2d..df0c772 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -11,6 +11,7 @@
 #include "log.h"
 #include "modelresult.h"
 #include "test.h"
+#include "testutils.h"
 
 static int blockingTime;
 
@@ -76,10 +77,10 @@ private slots:
         }
 
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
 
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // Test
         QTime time;
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index db17026..e978787 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -49,7 +49,7 @@ private slots:
     {
         // Test
         Sink::Query query;
-        query.resources << "foobar";
+        query.resourceFilter("foobar");
         query.liveQuery = true;
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -69,7 +69,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("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
@@ -87,11 +87,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = false;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -118,7 +118,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = true;
         query.filter<Mail::Folder>("folder1");
 
@@ -150,7 +150,7 @@ private slots:
             Sink::Store::create<Mail>(mail).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
             Sink::Store::synchronize(query).exec().waitForFinished();
@@ -164,7 +164,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(SinkResource("sink.dummy.instance1"));
+        query.resourceFilter("sink.dummy.instance1");
         query.filter(id);
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -181,7 +181,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("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
@@ -199,10 +199,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -218,11 +218,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.parentProperty = "parent";
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Folder>(query);
@@ -252,12 +252,12 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.liveQuery = false;
         query.filter<Mail::Uid>("test1");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -274,10 +274,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -294,11 +294,11 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -318,10 +318,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -348,12 +348,12 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.resources << "sink.dummy.instance1";
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
         query.filter<Mail::Uid>("test1");
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto model = Sink::Store::loadModel<Mail>(query);
@@ -370,10 +370,10 @@ private slots:
             Sink::Store::create<Folder>(folder).exec().waitForFinished();
 
             Sink::Query query;
-            query.resources << "sink.dummy.instance1";
+            query.resourceFilter("sink.dummy.instance1");
 
             // Ensure all local data is processed
-            Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
             auto model = Sink::Store::loadModel<Folder>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -408,14 +408,14 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(SinkResource("sink.dummy.instance1"));
+        query.resourceFilter("sink.dummy.instance1");
         query.filter<Mail::Folder>(*folderEntity);
         query.sort<Mail::Date>();
         query.limit = 1;
         query.liveQuery = false;
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(query.resources).exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Mail>(query);
         QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
@@ -485,7 +485,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter(account1);
+        query.resourceFilter<SinkResource::Account>(account1);
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto folders = Sink::Store::read<Folder>(query);
@@ -517,7 +517,7 @@ private slots:
         }
 
         // Ensure all local data is processed
-        Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1").exec().waitForFinished();
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         //Setup two folders with a mail each, ensure we only get the mail from the folder that matches the folder filter.
         Query query;
@@ -538,12 +538,12 @@ private slots:
         auto resource1 = ApplicationDomainType::createEntity<SinkResource>();
         resource1.setResourceType("sink.dummy");
         resource1.setCapabilities(QByteArrayList() << "cap1");
-        Store::create(resource1).exec().waitForFinished();
+        VERIFYEXEC(Store::create(resource1));
 
         auto resource2 = ApplicationDomainType::createEntity<SinkResource>();
         resource2.setCapabilities(QByteArrayList() << "cap2");
         resource2.setResourceType("sink.dummy");
-        Store::create(resource2).exec().waitForFinished();
+        VERIFYEXEC(Store::create(resource2));
 
         Folder folder1(resource1.identifier());
         VERIFYEXEC(Sink::Store::create<Folder>(folder1));
@@ -552,7 +552,7 @@ private slots:
 
         // Test
         Sink::Query query;
-        query.filter<Folder::Resource>(Sink::Query().containsFilter<SinkResource::Capabilities>("cap1"));
+        query.resourceContainsFilter<SinkResource::Capabilities>("cap1");
 
         // We fetch before the data is available and rely on the live query mechanism to deliver the actual data
         auto folders = Sink::Store::read<Folder>(query);