59 files changed, 1124 insertions, 305 deletions
diff --git a/akonadish/CMakeLists.txt b/akonadish/CMakeLists.txt
index 6761a32..eaedf9a 100644
--- a/akonadish/CMakeLists.txt
+++ b/akonadish/CMakeLists.txt
@@ -18,7 +18,8 @@ set(akonadi2_cli_SRCS
    akonadish_utils.cpp
    repl/repl.cpp
    repl/replStates.cpp
-    state.cpp)
+    state.cpp
+    utils.cpp)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/akonadish/akonadish_utils.cpp b/akonadish/akonadish_utils.cpp
index 070d788..27a863d 100644
--- a/akonadish/akonadish_utils.cpp
+++ b/akonadish/akonadish_utils.cpp
@@ -22,6 +22,8 @@
 #include "common/clientapi.h"
+#include "utils.h"
 namespace AkonadishUtils
 {
@@ -75,8 +77,6 @@ QStringList resourceIds(State &state)
 {
    QStringList resources;
    Akonadi2::Query query;
-    query.syncOnDemand = false;
-    query.processAll = false;
    query.liveQuery = false;
    auto model = AkonadishUtils::loadModel("resource", query);
@@ -98,40 +98,24 @@ QStringList resourceIds(State &state)
    return resources;
 }
-QStringList filtered(const QStringList &list, const QString &fragment)
-{
-    if (fragment.isEmpty()) {
-        return list;
-    }
-    QStringList filtered;
-    for (auto item: list) {
-        if (item.startsWith(fragment)) {
-            filtered << item;
-        }
-    }
-    return filtered;
-}
 QStringList resourceCompleter(const QStringList &, const QString &fragment, State &state)
 {
-    return filtered(resourceIds(state), fragment);
+    return Utils::filteredCompletions(resourceIds(state), fragment);
 }
 QStringList resourceOrTypeCompleter(const QStringList &commands, const QString &fragment, State &state)
 {
    static QStringList types = QStringList() << "resource" << "folder" << "mail" << "event";
    if (commands.count() == 1) {
-        return filtered(s_types, fragment);
+        return Utils::filteredCompletions(s_types, fragment);
    }
-    return filtered(resourceIds(state), fragment);
+    return Utils::filteredCompletions(resourceIds(state), fragment);
 }
 QStringList typeCompleter(const QStringList &commands, const QString &fragment, State &state)
 {
-    return filtered(s_types, fragment);
+    return Utils::filteredCompletions(s_types, fragment);
 }
 QMap<QString, QString> keyValueMapFromArgs(const QStringList &args)
diff --git a/akonadish/main.cpp b/akonadish/main.cpp
index f3cbcac..4c00b9b 100644
--- a/akonadish/main.cpp
+++ b/akonadish/main.cpp
@@ -31,71 +31,82 @@
 /*
 * modes of operation:
 *
- *   1. called with no commands: start the REPL and listen for JSON on stin
+ *   1. called with no commands: start the REPL
- *   2. called with -: listen for JSON on stdin
+ *   2. called with -: listen for commands on stdin
- *   3. called with commands: try to match to syntx
+ *   3. called with a filename: try to run it as a script
+ *   4. called with commands: try to match to syntax and run the result
 */
+int enterRepl()
+{
+    if (State::hasEventLoop()) {
+        return 0;
+    }
+    Repl *repl = new Repl;
+    QObject::connect(repl, &QStateMachine::finished,
+                     repl, &QObject::deleteLater);
+    QObject::connect(repl, &QStateMachine::finished,
+                     QCoreApplication::instance(), &QCoreApplication::quit);
+    State::setHasEventLoop(true);
+    int rv = QCoreApplication::instance()->exec();
+    State::setHasEventLoop(false);
+    return rv;
+}
+bool goInteractive(const QStringList &, State &)
+{
+    enterRepl();
+    return true;
+}
+Syntax::List goInteractiveSyntax()
+{
+    Syntax interactive("go_interactive", QString(), &goInteractive);
+    return Syntax::List() << interactive;
+}
+void processCommandStream(QTextStream &stream)
+{
+    SyntaxTree::self()->registerSyntax(&goInteractiveSyntax);
+    QString line = stream.readLine();
+    while (!line.isEmpty()) {
+        line = line.trimmed();
+        if (!line.isEmpty() && !line.startsWith('#')) {
+            SyntaxTree::self()->run(SyntaxTree::tokenize(line));
+        }
+        line = stream.readLine();
+    }
+}
 int main(int argc, char *argv[])
 {
    const bool interactive = isatty(fileno(stdin));
    const bool startRepl = (argc == 1) && interactive;
    //TODO: make a json command parse cause that would be awesomesauce
-    const bool startJsonListener = !startRepl &&
-                                   (argc == 2 && qstrcmp(argv[1], "-") == 0);
    const bool fromScript = !startRepl && QFile::exists(argv[1]);
-    //qDebug() << "state at startup is" << interactive << startRepl << startJsonListener << fromScript;
+    //qDebug() << "state at startup is" << interactive << startRepl << fromScript;
    QCoreApplication app(argc, argv);
    app.setApplicationName(fromScript ? "interactive-app-shell" : argv[0]);
-    //app.setApplicationName(argv[0]);
-    if (startRepl || startJsonListener) {
-        if (startRepl) {
-            Repl *repl = new Repl;
-            QObject::connect(repl, &QStateMachine::finished,
-                             repl, &QObject::deleteLater);
-            QObject::connect(repl, &QStateMachine::finished,
-                             &app, &QCoreApplication::quit);
-        }
-        if (startJsonListener) {
-//        JsonListener listener(syntax);
-        }
-        State::setHasEventLoop(true);
+    if (startRepl) {
-        return app.exec();
+        return enterRepl();
    } else if (fromScript) {
        QFile f(argv[1]);
        if (!f.open(QIODevice::ReadOnly)) { 
            return 1;
        }
-        QString line = f.readLine();
+        QTextStream inputStream(&f);
-        while (!line.isEmpty()) {
+        processCommandStream(inputStream);
-            line = line.trimmed();
-            if (!line.isEmpty() && !line.startsWith('#')) {
-                SyntaxTree::self()->run(SyntaxTree::tokenize(line));
-            }
-            line = f.readLine();
-        }
-        exit(0);
    } else if (!interactive) {
        QTextStream inputStream(stdin);
+        processCommandStream(inputStream);
-        QString line = inputStream.readLine();
-        while (!line.isEmpty()) {
-            line = line.trimmed();
-            if (!line.isEmpty() && !line.startsWith('#')) {
-                SyntaxTree::self()->run(SyntaxTree::tokenize(line));
-            }
-            line = inputStream.readLine();
-        }
    } else {
        QStringList commands = app.arguments();
        commands.removeFirst();
diff --git a/akonadish/state.cpp b/akonadish/state.cpp
index f3f5975..9fb5bcc 100644
--- a/akonadish/state.cpp
+++ b/akonadish/state.cpp
@@ -24,6 +24,8 @@
 #include <QEventLoop>
 #include <QTextStream>
+#include "common/log.h"
 static bool s_hasEventLoop = false;
 class State::Private
@@ -112,6 +114,11 @@ void State::setHasEventLoop(bool evented)
    s_hasEventLoop = evented;
 }
+bool State::hasEventLoop()
+{
+    return s_hasEventLoop;
+}
 void State::setCommandTiming(bool time)
 {
    d->timing = time;
@@ -122,4 +129,16 @@ bool State::commandTiming() const
    return d->timing;
 }
+void State::setLoggingLevel(const QString &level) const
+{
+    Akonadi2::Log::setDebugOutputLevel(Akonadi2::Log::debugLevelFromName(level.toLatin1()));
+}
+QString State::loggingLevel() const
+{
+    // do not turn this into a single line return: that core dumps due to allocation of
+    // the byte array in Akonadi2::Log
+    QByteArray rv = Akonadi2::Log::debugLevelName(Akonadi2::Log::debugOutputLevel());
+    return rv.toLower();
+}
diff --git a/akonadish/state.h b/akonadish/state.h
index 9c1ab6f..3c4c2c7 100644
--- a/akonadish/state.h
+++ b/akonadish/state.h
@@ -39,7 +39,11 @@ public:
    int commandStarted() const;
    void commandFinished(int returnCode = 0) const;
+    void setLoggingLevel(const QString &level) const;
+    QString loggingLevel() const;
    static void setHasEventLoop(bool evented);
+    static bool hasEventLoop();
 private:
    class Private;
diff --git a/akonadish/syntax_modules/akonadi_count.cpp b/akonadish/syntax_modules/akonadi_count.cpp
index 5acdcdd..bb1cd19 100644
--- a/akonadish/syntax_modules/akonadi_count.cpp
+++ b/akonadish/syntax_modules/akonadi_count.cpp
@@ -53,8 +53,6 @@ bool count(const QStringList &args, State &state)
    for (const auto &res : resources) {
        query.resources << res.toLatin1();
    }
-    query.syncOnDemand = false;
-    query.processAll = false;
    query.liveQuery = false;
    auto model = AkonadishUtils::loadModel(type, query);
diff --git a/akonadish/syntax_modules/akonadi_list.cpp b/akonadish/syntax_modules/akonadi_list.cpp
index 82f13b5..7709d3b 100644
--- a/akonadish/syntax_modules/akonadi_list.cpp
+++ b/akonadish/syntax_modules/akonadi_list.cpp
@@ -58,8 +58,6 @@ bool list(const QStringList &args, State &state)
    for (const auto &res : resources) {
        query.resources << res.toLatin1();
    }
-    query.syncOnDemand = false;
-    query.processAll = false;
    query.liveQuery = false;
    QTime time;
diff --git a/akonadish/syntax_modules/akonadi_stat.cpp b/akonadish/syntax_modules/akonadi_stat.cpp
index 9270f9d..d10556f 100644
--- a/akonadish/syntax_modules/akonadi_stat.cpp
+++ b/akonadish/syntax_modules/akonadi_stat.cpp
@@ -69,8 +69,6 @@ void statResources(const QStringList &resources, const State &state)
 bool statAllResources(State &state)
 {
    Akonadi2::Query query;
-    query.syncOnDemand = false;
-    query.processAll = false;
    query.liveQuery = false;
    auto model = AkonadishUtils::loadModel("resource", query);
diff --git a/akonadish/syntax_modules/akonadi_sync.cpp b/akonadish/syntax_modules/akonadi_sync.cpp
index 03abbb4..0c994d0 100644
--- a/akonadish/syntax_modules/akonadi_sync.cpp
+++ b/akonadish/syntax_modules/akonadi_sync.cpp
@@ -43,8 +43,6 @@ bool sync(const QStringList &args, State &state)
    for (const auto &res : args) {
        query.resources << res.toLatin1();
    }
-    query.syncOnDemand = true;
-    query.processAll = true;
    QTimer::singleShot(0, [query, state]() {
    Akonadi2::Store::synchronize(query).then<void>([state]() {
diff --git a/akonadish/syntax_modules/core_syntax.cpp b/akonadish/syntax_modules/core_syntax.cpp
index b4812df..ccf96c1 100644
--- a/akonadish/syntax_modules/core_syntax.cpp
+++ b/akonadish/syntax_modules/core_syntax.cpp
@@ -24,6 +24,7 @@
 #include "state.h"
 #include "syntaxtree.h"
+#include "utils.h"
 namespace CoreSyntax
 {
@@ -145,6 +146,24 @@ bool printSyntaxTree(const QStringList &, State &state)
    return true;
 }
+bool setLoggingLevel(const QStringList &commands, State &state)
+{
+    if (commands.count() != 1) {
+        state.printError(QObject::tr("Wrong number of arguments; expected 1 got %1").arg(commands.count()));
+        return false;
+    }
+    state.setLoggingLevel(commands.at(0));
+    return true;
+}
+bool printLoggingLevel(const QStringList &commands, State &state)
+{
+    const QString level = state.loggingLevel();
+    state.printLine(level);
+    return true;
+}
 Syntax::List syntax()
 {
    Syntax::List syntax;
@@ -158,15 +177,22 @@ Syntax::List syntax()
    Syntax set("set", QObject::tr("Sets settings for the session"));
    set.children << Syntax("debug", QObject::tr("Set the debug level from 0 to 6"), &CoreSyntax::setDebugLevel);
    Syntax setTiming = Syntax("timing", QObject::tr("Whether or not to print the time commands take to complete"));
    setTiming.children << Syntax("on", QString(), [](const QStringList &, State &state) -> bool { state.setCommandTiming(true); return true; });
    setTiming.children << Syntax("off", QString(), [](const QStringList &, State &state) -> bool { state.setCommandTiming(false); return true; });
    set.children << setTiming;
+    Syntax logging("logging", QObject::tr("Set the logging level to one of Trace, Log, Warning or Error"), &CoreSyntax::setLoggingLevel);
+    logging.completer = [](const QStringList &, const QString &fragment, State &state) -> QStringList { return Utils::filteredCompletions(QStringList() << "trace" << "log" << "warning" << "error", fragment, Qt::CaseInsensitive); };
+    set.children << logging;
    syntax << set;
    Syntax get("get", QObject::tr("Gets settings for the session"));
    get.children << Syntax("debug", QObject::tr("The current debug level from 0 to 6"), &CoreSyntax::printDebugLevel);
    get.children << Syntax("timing", QObject::tr("Whether or not to print the time commands take to complete"), &CoreSyntax::printCommandTiming);
+    get.children << Syntax("logging", QObject::tr("The current logging level"), &CoreSyntax::printLoggingLevel);
    syntax << get;
    return syntax;
diff --git a/akonadish/utils.cpp b/akonadish/utils.cpp
new file mode 100644
index 0000000..d2a28ed
--- /dev/null
+++ b/akonadish/utils.cpp
@@ -0,0 +1,42 @@
+/*
+ *   Copyright (C) 2016 Aaron Seigo <aseigo@kde.org>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#include "utils.h"
+namespace Utils
+{
+QStringList filteredCompletions(const QStringList &possibleCompletions, const QString &commandFragment, Qt::CaseSensitivity cs)
+{
+    if (commandFragment.isEmpty()) {
+        return possibleCompletions;
+    }
+    QStringList filtered;
+    for (auto item: possibleCompletions) {
+        if (item.startsWith(commandFragment, cs)) {
+            filtered << item;
+        }
+    }
+    return filtered;
+}
+} // namespace Utils
diff --git a/akonadish/utils.h b/akonadish/utils.h
new file mode 100644
index 0000000..82be8d5
--- /dev/null
+++ b/akonadish/utils.h
@@ -0,0 +1,30 @@
+/*
+ *   Copyright (C) 2016 Aaron Seigo <aseigo@kde.org>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#pragma once
+#include <QStringList>
+namespace Utils
+{
+QStringList filteredCompletions(const QStringList &possibleCompletions, const QString &commandFragment, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+} // namespace Utils
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 87f4898..85cd621 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -75,6 +75,7 @@ generate_flatbuffers(
    commands/synchronize
    commands/notification
    commands/revisionreplayed
+    commands/inspection
    domain/event
    domain/mail
    domain/folder
diff --git a/common/bufferutils.h b/common/bufferutils.h
new file mode 100644
index 0000000..b0fb75a
--- /dev/null
+++ b/common/bufferutils.h
@@ -0,0 +1,26 @@
+#pragma once
+#include <flatbuffers/flatbuffers.h>
+#include <QByteArray>
+namespace Akonadi2 {
+namespace BufferUtils {
+    template<typename T>
+    static QByteArray extractBuffer(const T *data)
+    {
+        return QByteArray::fromRawData(reinterpret_cast<char const *>(data->Data()), data->size());
+    }
+    template<typename T>
+    static QByteArray extractBufferCopy(const T *data)
+    {
+        return QByteArray(reinterpret_cast<char const *>(data->Data()), data->size());
+    }
+    static QByteArray extractBuffer(const flatbuffers::FlatBufferBuilder &fbb)
+    {
+        return QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize());
+    }
+}
+}
diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index e7ca99d..824ef19 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -25,6 +25,7 @@
 #include <QEventLoop>
 #include <QAbstractItemModel>
 #include <QDir>
+#include <QUuid>
 #include <functional>
 #include <memory>
@@ -204,7 +205,7 @@ KAsync::Job<void> Store::synchronize(const Akonadi2::Query &query)
        Trace() << "Synchronizing " << resource;
        auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
        resourceAccess->open();
-        resourceAccess->synchronizeResource(query.syncOnDemand, query.processAll).then<void>([&future, resourceAccess]() {
+        resourceAccess->synchronizeResource(true, false).then<void>([&future, resourceAccess]() {
            future.setFinished();
        }).exec();
    })
@@ -212,10 +213,148 @@ KAsync::Job<void> Store::synchronize(const Akonadi2::Query &query)
    .template then<void>([](){});
 }
+KAsync::Job<void> Store::flushMessageQueue(const QByteArrayList &resourceIdentifier)
+{
+    Trace() << "flushMessageQueue" << resourceIdentifier;
+    return KAsync::iterate(resourceIdentifier)
+    .template each<void, QByteArray>([](const QByteArray &resource, KAsync::Future<void> &future) {
+        Trace() << "Flushing message queue " << resource;
+        auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
+        resourceAccess->open();
+        resourceAccess->synchronizeResource(false, true).then<void>([&future, resourceAccess]() {
+            future.setFinished();
+        }).exec();
+    })
+    //FIXME JOBAPI this is only required because we don't care about the return value of each (and each shouldn't even have a return value)
+    .template then<void>([](){});
+}
+KAsync::Job<void> Store::flushReplayQueue(const QByteArrayList &resourceIdentifier)
+{
+    return flushMessageQueue(resourceIdentifier);
+}
+template <class DomainType>
+KAsync::Job<DomainType> Store::fetchOne(const Akonadi2::Query &query)
+{
+    return KAsync::start<DomainType>([query](KAsync::Future<DomainType> &future) {
+        //FIXME We could do this more elegantly if composed jobs would have the correct type (In that case we'd simply return the value from then continuation, and could avoid the outer job entirely)
+        fetch<DomainType>(query, 1)
+            .template then<void, QList<typename DomainType::Ptr> >([&future](const QList<typename DomainType::Ptr> &list){
+                future.setValue(*list.first());
+                future.setFinished();
+            }, [&future](int errorCode, const QString &errorMessage) {
+                future.setError(errorCode, errorMessage);
+                future.setFinished();
+            }).exec();
+    });
+}
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > Store::fetchAll(const Akonadi2::Query &query)
+{
+    return fetch<DomainType>(query);
+}
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > Store::fetch(const Akonadi2::Query &query, int minimumAmount)
+{
+    auto model = loadModel<DomainType>(query);
+    auto list = QSharedPointer<QList<typename DomainType::Ptr> >::create();
+    auto context = QSharedPointer<QObject>::create();
+    return KAsync::start<QList<typename DomainType::Ptr> >([model, list, context, minimumAmount](KAsync::Future<QList<typename DomainType::Ptr> > &future) {
+        if (model->rowCount() >= 1) {
+            for (int i = 0; i < model->rowCount(); i++) {
+                list->append(model->index(i, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).template value<typename DomainType::Ptr>());
+            }
+        } else {
+            QObject::connect(model.data(), &QAbstractItemModel::rowsInserted, context.data(), [model, &future, list](const QModelIndex &index, int start, int end) {
+                for (int i = start; i <= end; i++) {
+                    list->append(model->index(i, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).template value<typename DomainType::Ptr>());
+                }
+            });
+            QObject::connect(model.data(), &QAbstractItemModel::dataChanged, context.data(), [model, &future, list, minimumAmount](const QModelIndex &, const QModelIndex &, const QVector<int> &roles) {
+                if (roles.contains(ModelResult<DomainType, typename DomainType::Ptr>::ChildrenFetchedRole)) {
+                    if (list->size() < minimumAmount) {
+                        future.setError(1, "Not enough values.");
+                    } else {
+                        future.setValue(*list);
+                    }
+                    future.setFinished();
+                }
+            });
+        }
+        if (model->data(QModelIndex(), ModelResult<DomainType, typename DomainType::Ptr>::ChildrenFetchedRole).toBool()) {
+            if (list->size() < minimumAmount) {
+                future.setError(1, "Not enough values.");
+            } else {
+                future.setValue(*list);
+            }
+            future.setFinished();
+        }
+    });
+}
+template <class DomainType>
+KAsync::Job<void> Resources::inspect(const Inspection &inspectionCommand)
+{
+    auto resource = inspectionCommand.resourceIdentifier;
+    Trace() << "Sending inspection " << resource;
+    auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
+    resourceAccess->open();
+    auto notifier = QSharedPointer<Akonadi2::Notifier>::create(resourceAccess);
+    auto id = QUuid::createUuid().toByteArray();
+    return resourceAccess->sendInspectionCommand(id, ApplicationDomain::getTypeName<DomainType>(), inspectionCommand.entityIdentifier, inspectionCommand.property, inspectionCommand.expectedValue)
+        .template then<void>([resourceAccess, notifier, id](KAsync::Future<void> &future) {
+            notifier->registerHandler([&future, id](const Notification &notification) {
+                if (notification.id == id) {
+                    if (notification.code) {
+                        future.setError(-1, "Inspection returned an error: " + notification.message);
+                    } else {
+                        future.setFinished();
+                    }
+                }
+            });
+        });
+}
+class Akonadi2::Notifier::Private {
+public:
+    Private()
+        : context(new QObject)
+    {
+    }
+    QList<QSharedPointer<ResourceAccess> > resourceAccess;
+    QList<std::function<void(const Notification &)> > handler;
+    QSharedPointer<QObject> context;
+};
+Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess)
+    : d(new Akonadi2::Notifier::Private)
+{
+    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+        for (const auto &handler : d->handler) {
+            handler(notification);
+        }
+    });
+    d->resourceAccess << resourceAccess;
+}
+void Notifier::registerHandler(std::function<void(const Notification &)> handler)
+{
+    d->handler << handler;
+}
 #define REGISTER_TYPE(T) template KAsync::Job<void> Store::remove<T>(const T &domainObject); \
    template KAsync::Job<void> Store::create<T>(const T &domainObject); \
    template KAsync::Job<void> Store::modify<T>(const T &domainObject); \
    template QSharedPointer<QAbstractItemModel> Store::loadModel<T>(Query query); \
+    template KAsync::Job<void> Resources::inspect<T>(const Inspection &); \
+    template KAsync::Job<T> Store::fetchOne<T>(const Query &); \
+    template KAsync::Job<QList<T::Ptr> > Store::fetchAll<T>(const Query &); \
+    template KAsync::Job<QList<T::Ptr> > Store::fetch<T>(const Query &, int); \
 REGISTER_TYPE(ApplicationDomain::Event);
 REGISTER_TYPE(ApplicationDomain::Mail);
diff --git a/common/clientapi.h b/common/clientapi.h
index 4e55432..06376c2 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -26,11 +26,14 @@
 #include <Async/Async>
 #include "query.h"
+#include "inspection.h"
 #include "applicationdomaintype.h"
 class QAbstractItemModel;
 namespace Akonadi2 {
+class ResourceAccess;
+class Notification;
 /**
 * Store interface used in the client API.
@@ -73,6 +76,11 @@ public:
    static KAsync::Job<void> remove(const DomainType &domainObject);
    /**
+     * Synchronize data to local cache.
+     */
+    static KAsync::Job<void> synchronize(const Akonadi2::Query &query);
+    /**
     * Shutdown resource.
     */
    static KAsync::Job<void> shutdown(const QByteArray &resourceIdentifier);
@@ -87,16 +95,46 @@ public:
    static KAsync::Job<void> start(const QByteArray &resourceIdentifier);
    /**
-     * Synchronize data to local cache.
+     * Flushes any pending messages to disk
     */
-    static KAsync::Job<void> synchronize(const Akonadi2::Query &query);
+    static KAsync::Job<void> flushMessageQueue(const QByteArrayList &resourceIdentifier);
+    /**
+     * Flushes any pending messages that haven't been replayed to the source.
+     */
+    static KAsync::Job<void> flushReplayQueue(const QByteArrayList &resourceIdentifier);
    /**
     * Removes a resource from disk.
     */
    static void removeFromDisk(const QByteArray &resourceIdentifier);
+    template <class DomainType>
+    static KAsync::Job<DomainType> fetchOne(const Akonadi2::Query &query);
+    template <class DomainType>
+    static KAsync::Job<QList<typename DomainType::Ptr> > fetchAll(const Akonadi2::Query &query);
+    template <class DomainType>
+    static KAsync::Job<QList<typename DomainType::Ptr> > fetch(const Akonadi2::Query &query, int minimumAmount = 0);
 };
+namespace Resources {
+    template <class DomainType>
+    KAsync::Job<void> inspect(const Inspection &inspectionCommand);
+}
+class Notifier {
+public:
+    Notifier(const QSharedPointer<ResourceAccess> &resourceAccess);
+    // Notifier(const QByteArray &resource);
+    // Notifier(const QByteArrayList &resource);
+    void registerHandler(std::function<void(const Notification &)>);
+private:
+    class Private;
+    QScopedPointer<Private> d;
+};
 }
diff --git a/common/commands.cpp b/common/commands.cpp
index 7a0ae23..35dfb13 100644
--- a/common/commands.cpp
+++ b/common/commands.cpp
@@ -33,7 +33,7 @@ QByteArray name(int commandId)
    switch(commandId) {
        case UnknownCommand:
            return "Unknown";
-        case CommandCompletion:
+        case CommandCompletionCommand:
            return "Completion";
        case HandshakeCommand:
            return "Handshake";
@@ -59,6 +59,8 @@ QByteArray name(int commandId)
            return "Ping";
        case RevisionReplayedCommand:
            return "RevisionReplayed";
+        case InspectionCommand:
+            return "Inspection";
        case CustomCommand:
            return "Custom";
    };
diff --git a/common/commands.h b/common/commands.h
index c68ef90..33d5cd7 100644
--- a/common/commands.h
+++ b/common/commands.h
@@ -34,7 +34,7 @@ namespace Commands
 enum CommandIds {
    UnknownCommand = 0,
-    CommandCompletion,
+    CommandCompletionCommand,
    HandshakeCommand,
    RevisionUpdateCommand,
    SynchronizeCommand,
@@ -47,6 +47,7 @@ enum CommandIds {
    NotificationCommand,
    PingCommand,
    RevisionReplayedCommand,
+    InspectionCommand,
    CustomCommand = 0xffff
 };
diff --git a/common/commands/commandcompletion.fbs b/common/commands/commandcompletion.fbs
index 5330b4f..de7ec14 100644
--- a/common/commands/commandcompletion.fbs
+++ b/common/commands/commandcompletion.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
 table CommandCompletion {
    id: ulong;
diff --git a/common/commands/fetchentity.fbs b/common/commands/fetchentity.fbs
index ddca275..7a1d74d 100644
--- a/common/commands/fetchentity.fbs
+++ b/common/commands/fetchentity.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
 table FetchEntity {
    revision: ulong;
diff --git a/common/commands/handshake.fbs b/common/commands/handshake.fbs
index 52a883a..e824715 100644
--- a/common/commands/handshake.fbs
+++ b/common/commands/handshake.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
 table Handshake {
    name: string;
diff --git a/common/commands/inspection.fbs b/common/commands/inspection.fbs
new file mode 100644
index 0000000..aaae1ae
--- /dev/null
+++ b/common/commands/inspection.fbs
@@ -0,0 +1,12 @@
+namespace Akonadi2.Commands;
+table Inspection {
+    id: string;
+    type: int;
+    entityId: string;
+    domainType: string;
+    property: string;
+    expectedValue: string;
+}
+root_type Inspection;
diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index 6684472..89687cf 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -1,9 +1,13 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
-enum NotificationType : byte { Shutdown = 1, Status, Warning, Progress }
+enum NotificationType : byte { Shutdown = 1, Status, Warning, Progress, Inspection }
+enum NotificationCode : byte { Success = 0, Failure = 1, UserCode }
 table Notification {
    type: NotificationType = Status;
+    identifier: string; //An identifier that links back to the something related to the notification (e.g. an entity id or a command id)
+    message: string;
+    code: int = 0; //Of type NotificationCode
 }
 root_type Notification;
diff --git a/common/commands/revisionupdate.fbs b/common/commands/revisionupdate.fbs
index 634bcd0..93fbe34 100644
--- a/common/commands/revisionupdate.fbs
+++ b/common/commands/revisionupdate.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
 table RevisionUpdate {
    revision: ulong;
diff --git a/common/commands/synchronize.fbs b/common/commands/synchronize.fbs
index d2d0364..7c3ae9a 100644
--- a/common/commands/synchronize.fbs
+++ b/common/commands/synchronize.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2;
+namespace Akonadi2.Commands;
 table Synchronize {
    sourceSync: bool; //Synchronize with source
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index cff0172..44d8743 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -82,29 +82,34 @@ inline bool operator==(const ApplicationDomainType& lhs, const ApplicationDomain
            && lhs.resourceInstanceIdentifier() == rhs.resourceInstanceIdentifier();
 }
-struct Event : public ApplicationDomainType {
+struct Entity : public ApplicationDomainType {
-    typedef QSharedPointer<Event> Ptr;
+    typedef QSharedPointer<Entity> Ptr;
    using ApplicationDomainType::ApplicationDomainType;
 };
-struct Todo : public ApplicationDomainType {
+struct Event : public Entity {
+    typedef QSharedPointer<Event> Ptr;
+    using Entity::Entity;
+};
+struct Todo : public Entity {
    typedef QSharedPointer<Todo> Ptr;
-    using ApplicationDomainType::ApplicationDomainType;
+    using Entity::Entity;
 };
-struct Calendar : public ApplicationDomainType {
+struct Calendar : public Entity {
    typedef QSharedPointer<Calendar> Ptr;
-    using ApplicationDomainType::ApplicationDomainType;
+    using Entity::Entity;
 };
-struct Mail : public ApplicationDomainType {
+struct Mail : public Entity {
    typedef QSharedPointer<Mail> Ptr;
-    using ApplicationDomainType::ApplicationDomainType;
+    using Entity::Entity;
 };
-struct Folder : public ApplicationDomainType {
+struct Folder : public Entity {
    typedef QSharedPointer<Folder> Ptr;
-    using ApplicationDomainType::ApplicationDomainType;
+    using Entity::Entity;
 };
 /**
@@ -155,6 +160,8 @@ class TypeImplementation;
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::ApplicationDomainType)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr)
+Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Entity)
+Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Entity::Ptr)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Event)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Event::Ptr)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Mail)
diff --git a/common/facade.cpp b/common/facade.cpp
index 22ef84a..91021db 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -25,6 +25,7 @@
 #include "definitions.h"
 #include "domainadaptor.h"
 #include "queryrunner.h"
+#include "bufferutils.h"
 using namespace Akonadi2;
@@ -113,7 +114,7 @@ KAsync::Job<void> GenericFacade<DomainType>::create(const DomainType &domainObje
    }
    flatbuffers::FlatBufferBuilder entityFbb;
    mDomainTypeAdaptorFactory->createBuffer(domainObject, entityFbb);
-    return mResourceAccess->sendCreateCommand(bufferTypeForDomainType(), QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
+    return mResourceAccess->sendCreateCommand(bufferTypeForDomainType(), BufferUtils::extractBuffer(entityFbb));
 }
 template<class DomainType>
@@ -125,7 +126,7 @@ KAsync::Job<void> GenericFacade<DomainType>::modify(const DomainType &domainObje
    }
    flatbuffers::FlatBufferBuilder entityFbb;
    mDomainTypeAdaptorFactory->createBuffer(domainObject, entityFbb);
-    return mResourceAccess->sendModifyCommand(domainObject.identifier(), domainObject.revision(), bufferTypeForDomainType(), QByteArrayList(), QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
+    return mResourceAccess->sendModifyCommand(domainObject.identifier(), domainObject.revision(), bufferTypeForDomainType(), QByteArrayList(), BufferUtils::extractBuffer(entityFbb));
 }
 template<class DomainType>
diff --git a/common/genericresource.cpp b/common/genericresource.cpp
index 29acce4..c7f323a 100644
--- a/common/genericresource.cpp
+++ b/common/genericresource.cpp
@@ -6,13 +6,17 @@
 #include "createentity_generated.h"
 #include "modifyentity_generated.h"
 #include "deleteentity_generated.h"
+#include "inspection_generated.h"
+#include "notification_generated.h"
 #include "domainadaptor.h"
 #include "commands.h"
 #include "index.h"
 #include "log.h"
 #include "definitions.h"
+#include "bufferutils.h"
 #include <QUuid>
+#include <QDataStream>
 static int sBatchSize = 100;
@@ -112,6 +116,7 @@ private:
 class CommandProcessor : public QObject
 {
    Q_OBJECT
+    typedef std::function<KAsync::Job<void>(void const *, size_t)> InspectionFunction;
 public:
    CommandProcessor(Akonadi2::Pipeline *pipeline, QList<MessageQueue*> commandQueues)
        : QObject(),
@@ -135,6 +140,11 @@ public:
        mLowerBoundRevision = revision;
    }
+    void setInspectionCommand(const InspectionFunction &f)
+    {
+        mInspect = f;
+    }
 signals:
    void error(int errorCode, const QString &errorMessage);
@@ -176,6 +186,14 @@ private slots:
                return mPipeline->modifiedEntity(queuedCommand->command()->Data(), queuedCommand->command()->size());
            case Akonadi2::Commands::CreateEntityCommand:
                return mPipeline->newEntity(queuedCommand->command()->Data(), queuedCommand->command()->size());
+            case Akonadi2::Commands::InspectionCommand:
+                if (mInspect) {
+                    return mInspect(queuedCommand->command()->Data(), queuedCommand->command()->size()).then<qint64>([]() {
+                        return -1;
+                    });
+                } else {
+                    return KAsync::error<qint64>(-1, "Missing inspection command.");
+                }
            default:
                return KAsync::error<qint64>(-1, "Unhandled command");
        }
@@ -266,6 +284,7 @@ private:
    bool mProcessingLock;
    //The lowest revision we no longer need
    qint64 mLowerBoundRevision;
+    InspectionFunction mInspect;
 };
@@ -279,6 +298,38 @@ GenericResource::GenericResource(const QByteArray &resourceInstanceIdentifier, c
    mClientLowerBoundRevision(std::numeric_limits<qint64>::max())
 {
    mProcessor = new CommandProcessor(mPipeline.data(), QList<MessageQueue*>() << &mUserQueue << &mSynchronizerQueue);
+    mProcessor->setInspectionCommand([this](void const *command, size_t size) {
+        flatbuffers::Verifier verifier((const uint8_t *)command, size);
+        if (Akonadi2::Commands::VerifyInspectionBuffer(verifier)) {
+            auto buffer = Akonadi2::Commands::GetInspection(command);
+            int inspectionType = buffer->type();
+            QByteArray inspectionId = BufferUtils::extractBuffer(buffer->id());
+            QByteArray entityId = BufferUtils::extractBuffer(buffer->entityId());
+            QByteArray domainType = BufferUtils::extractBuffer(buffer->domainType());
+            QByteArray property = BufferUtils::extractBuffer(buffer->property());
+            QByteArray expectedValueString = BufferUtils::extractBuffer(buffer->expectedValue());
+            QDataStream s(expectedValueString);
+            QVariant expectedValue;
+            s >> expectedValue;
+            inspect(inspectionType, inspectionId, domainType, entityId, property, expectedValue).then<void>([=]() {
+                Akonadi2::Notification n;
+                n.type = Akonadi2::Commands::NotificationType_Inspection;
+                n.id = inspectionId;
+                n.code = Akonadi2::Commands::NotificationCode_Success;
+                emit notify(n);
+            }, [=](int code, const QString &message) {
+                Akonadi2::Notification n;
+                n.type = Akonadi2::Commands::NotificationType_Inspection;
+                n.message = message;
+                n.id = inspectionId;
+                n.code = Akonadi2::Commands::NotificationCode_Failure;
+                emit notify(n);
+            }).exec();
+            return KAsync::null<void>();
+        }
+        return KAsync::error<void>(-1, "Invalid inspection command.");
+    });
    QObject::connect(mProcessor, &CommandProcessor::error, [this](int errorCode, const QString &msg) { onProcessorError(errorCode, msg); });
    QObject::connect(mPipeline.data(), &Pipeline::revisionUpdated, this, &Resource::revisionUpdated);
    mSourceChangeReplay = new ChangeReplay(resourceInstanceIdentifier, [this](const QByteArray &type, const QByteArray &key, const QByteArray &value) {
@@ -301,6 +352,12 @@ GenericResource::~GenericResource()
    delete mSourceChangeReplay;
 }
+KAsync::Job<void> GenericResource::inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue)
+{
+    Warning() << "Inspection not implemented";
+    return KAsync::null<void>();
+}
 void GenericResource::enableChangeReplay(bool enable)
 {
    if (enable) {
@@ -464,7 +521,7 @@ void GenericResource::createEntity(const QByteArray &akonadiId, const QByteArray
    auto delta = Akonadi2::EntityBuffer::appendAsVector(fbb, entityFbb.GetBufferPointer(), entityFbb.GetSize());
    auto location = Akonadi2::Commands::CreateCreateEntity(fbb, entityId, type, delta, replayToSource);
    Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
-    callback(QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
+    callback(BufferUtils::extractBuffer(fbb));
 }
 void GenericResource::modifyEntity(const QByteArray &akonadiId, qint64 revision, const QByteArray &bufferType, const Akonadi2::ApplicationDomain::ApplicationDomainType &domainObject, DomainTypeAdaptorFactoryInterface &adaptorFactory, std::function<void(const QByteArray &)> callback)
@@ -481,7 +538,7 @@ void GenericResource::modifyEntity(const QByteArray &akonadiId, qint64 revision,
    //TODO removals
    auto location = Akonadi2::Commands::CreateModifyEntity(fbb, revision, entityId, 0, type, delta, replayToSource);
    Akonadi2::Commands::FinishModifyEntityBuffer(fbb, location);
-    callback(QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
+    callback(BufferUtils::extractBuffer(fbb));
 }
 void GenericResource::deleteEntity(const QByteArray &akonadiId, qint64 revision, const QByteArray &bufferType, std::function<void(const QByteArray &)> callback)
@@ -494,7 +551,7 @@ void GenericResource::deleteEntity(const QByteArray &akonadiId, qint64 revision,
    auto type = fbb.CreateString(bufferType.toStdString());
    auto location = Akonadi2::Commands::CreateDeleteEntity(fbb, revision, entityId, type, replayToSource);
    Akonadi2::Commands::FinishDeleteEntityBuffer(fbb, location);
-    callback(QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()));
+    callback(BufferUtils::extractBuffer(fbb));
 }
 void GenericResource::recordRemoteId(const QByteArray &bufferType, const QByteArray &localId, const QByteArray &remoteId, Akonadi2::Storage::Transaction &transaction)
diff --git a/common/genericresource.h b/common/genericresource.h
index f47c6f8..d71061c 100644
--- a/common/genericresource.h
+++ b/common/genericresource.h
@@ -48,6 +48,7 @@ public:
    virtual KAsync::Job<void> synchronizeWithSource(Akonadi2::Storage &mainStore, Akonadi2::Storage &synchronizationStore);
    virtual KAsync::Job<void> processAllMessages() Q_DECL_OVERRIDE;
    virtual void setLowerBoundRevision(qint64 revision) Q_DECL_OVERRIDE;
+    virtual KAsync::Job<void> inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue);
    int error() const;
diff --git a/common/inspection.h b/common/inspection.h
new file mode 100644
index 0000000..ecf5b3d
--- /dev/null
+++ b/common/inspection.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <QByteArray>
+#include <QVariant>
+#include "applicationdomaintype.h"
+namespace Akonadi2 {
+    namespace Resources {
+struct Inspection {
+    static Inspection PropertyInspection(const Akonadi2::ApplicationDomain::Entity &entity, const QByteArray &property, const QVariant &expectedValue)
+    {
+        Inspection inspection;
+        inspection.resourceIdentifier = entity.resourceInstanceIdentifier();
+        inspection.entityIdentifier = entity.identifier();
+        inspection.property = property;
+        inspection.expectedValue = expectedValue;
+        return inspection;
+    }
+    static Inspection ExistenceInspection(const Akonadi2::ApplicationDomain::Entity &entity, bool exists)
+    {
+        Inspection inspection;
+        inspection.resourceIdentifier = entity.resourceInstanceIdentifier();
+        inspection.entityIdentifier = entity.identifier();
+        inspection.expectedValue = exists;
+        return inspection;
+    }
+    enum Type {
+        PropertyInspectionType,
+        ExistenceInspectionType
+    };
+    QByteArray resourceIdentifier;
+    QByteArray entityIdentifier;
+    QByteArray property;
+    QVariant expectedValue;
+};
+    }
+}
diff --git a/common/listener.cpp b/common/listener.cpp
index 1b78f01..fa08472 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -31,11 +31,13 @@
 #include "common/synchronize_generated.h"
 #include "common/notification_generated.h"
 #include "common/revisionreplayed_generated.h"
+#include "common/inspection_generated.h"
 #include <QLocalServer>
 #include <QLocalSocket>
 #include <QTimer>
 #include <QTime>
+#include <QDataStream>
 Listener::Listener(const QByteArray &resourceInstanceIdentifier, QObject *parent)
    : QObject(parent),
@@ -203,13 +205,14 @@ void Listener::processClientBuffers()
    }
 }
-void Listener::processCommand(int commandId, uint messageId, const QByteArray &commandBuffer, Client &client, const std::function<void()> &callback)
+void Listener::processCommand(int commandId, uint messageId, const QByteArray &commandBuffer, Client &client, const std::function<void(bool)> &callback)
 {
+    bool success = true;
    switch (commandId) {
        case Akonadi2::Commands::HandshakeCommand: {
            flatbuffers::Verifier verifier((const uint8_t *)commandBuffer.constData(), commandBuffer.size());
-            if (Akonadi2::VerifyHandshakeBuffer(verifier)) {
+            if (Akonadi2::Commands::VerifyHandshakeBuffer(verifier)) {
-                auto buffer = Akonadi2::GetHandshake(commandBuffer.constData());
+                auto buffer = Akonadi2::Commands::GetHandshake(commandBuffer.constData());
                client.name = buffer->name()->c_str();
            } else {
                Warning() << "received invalid command";
@@ -218,8 +221,8 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
        }
        case Akonadi2::Commands::SynchronizeCommand: {
            flatbuffers::Verifier verifier((const uint8_t *)commandBuffer.constData(), commandBuffer.size());
-            if (Akonadi2::VerifySynchronizeBuffer(verifier)) {
+            if (Akonadi2::Commands::VerifySynchronizeBuffer(verifier)) {
-                auto buffer = Akonadi2::GetSynchronize(commandBuffer.constData());
+                auto buffer = Akonadi2::Commands::GetSynchronize(commandBuffer.constData());
                Log() << QString("\tSynchronize request (id %1) from %2").arg(messageId).arg(client.name);
                auto timer = QSharedPointer<QTime>::create();
                timer->start();
@@ -232,7 +235,7 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
                }
                job.then<void>([callback, timer]() {
                    Trace() << "Sync took " << timer->elapsed();
-                    callback();
+                    callback(true);
                }).exec();
                return;
            } else {
@@ -240,6 +243,7 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
            }
            break;
        }
+        case Akonadi2::Commands::InspectionCommand:
        case Akonadi2::Commands::FetchEntityCommand:
        case Akonadi2::Commands::DeleteEntityCommand:
        case Akonadi2::Commands::ModifyEntityCommand:
@@ -273,11 +277,12 @@ void Listener::processCommand(int commandId, uint messageId, const QByteArray &c
                Log() << QString("\tReceived custom command from %1: ").arg(client.name) << commandId;
                loadResource()->processCommand(commandId, commandBuffer);
            } else {
+                success = false;
                ErrorMsg() << QString("\tReceived invalid command from %1: ").arg(client.name) << commandId;
            }
            break;
    }
-    callback();
+    callback(success);
 }
 qint64 Listener::lowerBoundRevision()
@@ -298,8 +303,8 @@ qint64 Listener::lowerBoundRevision()
 void Listener::quit()
 {
    //Broadcast shutdown notifications to open clients, so they don't try to restart the resource
-    auto command = Akonadi2::CreateNotification(m_fbb, Akonadi2::NotificationType::NotificationType_Shutdown);
+    auto command = Akonadi2::Commands::CreateNotification(m_fbb, Akonadi2::Commands::NotificationType::NotificationType_Shutdown);
-    Akonadi2::FinishNotificationBuffer(m_fbb, command);
+    Akonadi2::Commands::FinishNotificationBuffer(m_fbb, command);
    for (Client &client : m_connections) {
        if (client.socket && client.socket->isOpen()) {
            Akonadi2::Commands::write(client.socket, ++m_messageId, Akonadi2::Commands::NotificationCommand, m_fbb);
@@ -333,10 +338,10 @@ bool Listener::processClientBuffer(Client &client)
        auto clientName = client.name;
        const QByteArray commandBuffer = client.commandBuffer.left(size);
        client.commandBuffer.remove(0, size);
-        processCommand(commandId, messageId, commandBuffer, client, [this, messageId, commandId, socket, clientName]() {
+        processCommand(commandId, messageId, commandBuffer, client, [this, messageId, commandId, socket, clientName](bool success) {
            Log() << QString("\tCompleted command messageid %1 of type \"%2\" from %3").arg(messageId).arg(QString(Akonadi2::Commands::name(commandId))).arg(clientName);
            if (socket) {
-                sendCommandCompleted(socket.data(), messageId);
+                sendCommandCompleted(socket.data(), messageId, success);
            } else {
                Log() << QString("Socket became invalid before we could send a response. client: %1").arg(clientName);
            }
@@ -348,15 +353,15 @@ bool Listener::processClientBuffer(Client &client)
    return false;
 }
-void Listener::sendCommandCompleted(QLocalSocket *socket, uint messageId)
+void Listener::sendCommandCompleted(QLocalSocket *socket, uint messageId, bool success)
 {
    if (!socket || !socket->isValid()) {
        return;
    }
-    auto command = Akonadi2::CreateCommandCompletion(m_fbb, messageId);
+    auto command = Akonadi2::Commands::CreateCommandCompletion(m_fbb, messageId, success);
-    Akonadi2::FinishCommandCompletionBuffer(m_fbb, command);
+    Akonadi2::Commands::FinishCommandCompletionBuffer(m_fbb, command);
-    Akonadi2::Commands::write(socket, ++m_messageId, Akonadi2::Commands::CommandCompletion, m_fbb);
+    Akonadi2::Commands::write(socket, ++m_messageId, Akonadi2::Commands::CommandCompletionCommand, m_fbb);
    m_fbb.Clear();
 }
@@ -367,8 +372,8 @@ void Listener::refreshRevision(qint64 revision)
 void Listener::updateClientsWithRevision(qint64 revision)
 {
-    auto command = Akonadi2::CreateRevisionUpdate(m_fbb, revision);
+    auto command = Akonadi2::Commands::CreateRevisionUpdate(m_fbb, revision);
-    Akonadi2::FinishRevisionUpdateBuffer(m_fbb, command);
+    Akonadi2::Commands::FinishRevisionUpdateBuffer(m_fbb, command);
    for (const Client &client: m_connections) {
        if (!client.socket || !client.socket->isValid()) {
@@ -381,6 +386,25 @@ void Listener::updateClientsWithRevision(qint64 revision)
    m_fbb.Clear();
 }
+void Listener::notify(const Akonadi2::Notification &notification)
+{
+    auto messageString = m_fbb.CreateString(notification.message.toUtf8().constData(), notification.message.toUtf8().size());
+    auto idString = m_fbb.CreateString(notification.id.constData(), notification.id.size());
+    Akonadi2::Commands::NotificationBuilder builder(m_fbb);
+    builder.add_type(static_cast<Akonadi2::Commands::NotificationType>(notification.type));
+    builder.add_code(notification.code);
+    builder.add_identifier(idString);
+    builder.add_message(messageString);
+    auto command = builder.Finish();
+    Akonadi2::Commands::FinishNotificationBuffer(m_fbb, command);
+    for (Client &client : m_connections) {
+        if (client.socket && client.socket->isOpen()) {
+            Akonadi2::Commands::write(client.socket, ++m_messageId, Akonadi2::Commands::NotificationCommand, m_fbb);
+        }
+    }
+    m_fbb.Clear();
+}
 Akonadi2::Resource *Listener::loadResource()
 {
    if (!m_resource) {
@@ -390,6 +414,8 @@ Akonadi2::Resource *Listener::loadResource()
            Trace() << QString("\tResource: %1").arg((qlonglong)m_resource);
            connect(m_resource, &Akonadi2::Resource::revisionUpdated,
                this, &Listener::refreshRevision);
+            connect(m_resource, &Akonadi2::Resource::notify,
+                this, &Listener::notify);
        } else {
            ErrorMsg() << "Failed to load resource " << m_resourceName;
            m_resource = new Akonadi2::Resource;
diff --git a/common/listener.h b/common/listener.h
index 248a190..4112a6a 100644
--- a/common/listener.h
+++ b/common/listener.h
@@ -28,6 +28,7 @@
 namespace Akonadi2
 {
    class Resource;
+    class Notification;
 }
 class QTimer;
@@ -76,12 +77,13 @@ private Q_SLOTS:
    void onDataAvailable();
    void processClientBuffers();
    void refreshRevision(qint64);
+    void notify(const Akonadi2::Notification &);
    void quit();
 private:
-    void processCommand(int commandId, uint messageId, const QByteArray &commandBuffer, Client &client, const std::function<void()> &callback);
+    void processCommand(int commandId, uint messageId, const QByteArray &commandBuffer, Client &client, const std::function<void(bool)> &callback);
    bool processClientBuffer(Client &client);
-    void sendCommandCompleted(QLocalSocket *socket, uint messageId);
+    void sendCommandCompleted(QLocalSocket *socket, uint messageId, bool success);
    void updateClientsWithRevision(qint64);
    Akonadi2::Resource *loadResource();
    void readFromSocket(QLocalSocket *socket);
diff --git a/common/log.cpp b/common/log.cpp
index c33c700..489e1bd 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -96,7 +96,7 @@ static QString colorCommand(QList<int> colorCodes)
    return string;
 }
-QByteArray debugLevelName(DebugLevel debugLevel)
+QByteArray Akonadi2::Log::debugLevelName(DebugLevel debugLevel)
 {
    switch (debugLevel) {
        case DebugLevel::Trace:
@@ -114,15 +114,16 @@ QByteArray debugLevelName(DebugLevel debugLevel)
    return QByteArray();
 }
-DebugLevel debugLevelFromName(const QByteArray &name)
+DebugLevel Akonadi2::Log::debugLevelFromName(const QByteArray &name)
 {
-    if (name.toLower() == "trace")
+    const QByteArray lowercaseName = name.toLower();
+    if (lowercaseName == "trace")
        return DebugLevel::Trace;
-    if (name.toLower() == "log")
+    if (lowercaseName == "log")
        return DebugLevel::Log;
-    if (name.toLower() == "warning")
+    if (lowercaseName == "warning")
        return DebugLevel::Warning;
-    if (name.toLower() == "error")
+    if (lowercaseName == "error")
        return DebugLevel::Error;
    return DebugLevel::Log;
 }
@@ -132,6 +133,11 @@ void Akonadi2::Log::setDebugOutputLevel(DebugLevel debugLevel)
    qputenv("AKONADI2DEBUGLEVEL", debugLevelName(debugLevel));
 }
+Akonadi2::Log::DebugLevel Akonadi2::Log::debugOutputLevel()
+{
+    return debugLevelFromName(qgetenv("AKONADI2DEBUGLEVEL"));
+}
 QDebug Akonadi2::Log::debugStream(DebugLevel debugLevel, int line, const char* file, const char* function, const char* debugArea)
 {
    DebugLevel debugOutputLevel = debugLevelFromName(qgetenv("AKONADI2DEBUGLEVEL"));
diff --git a/common/log.h b/common/log.h
index 9db9e8e..e531348 100644
--- a/common/log.h
+++ b/common/log.h
@@ -12,7 +12,11 @@ enum DebugLevel {
    Error
 };
+QByteArray debugLevelName(DebugLevel debugLevel);
+DebugLevel debugLevelFromName(const QByteArray &name);
 void setDebugOutputLevel(DebugLevel);
+DebugLevel debugOutputLevel();
 QDebug debugStream(DebugLevel debugLevel, int line, const char* file, const char* function, const char* debugArea = 0);
diff --git a/common/notification.h b/common/notification.h
new file mode 100644
index 0000000..e1b5bff
--- /dev/null
+++ b/common/notification.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2016 Christian Mollekopf <mollekopf@kolabsys.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <akonadi2common_export.h>
+#include <QString>
+namespace Akonadi2
+{
+/**
+ * A notification
+ */
+class AKONADI2COMMON_EXPORT Notification
+{
+public:
+    QByteArray id;
+    int type;
+    QString message;
+    int code;
+};
+}
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index 06d8114..a087def 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -34,6 +34,7 @@
 #include "log.h"
 #include "domain/applicationdomaintype.h"
 #include "definitions.h"
+#include "bufferutils.h"
 namespace Akonadi2
 {
@@ -119,7 +120,7 @@ Storage &Pipeline::storage() const
 void Pipeline::storeNewRevision(qint64 newRevision, const flatbuffers::FlatBufferBuilder &fbb, const QByteArray &bufferType, const QByteArray &uid)
 {
-    d->transaction.openDatabase(bufferType + ".main").write(Akonadi2::Storage::assembleKey(uid, newRevision), QByteArray::fromRawData(reinterpret_cast<char const *>(fbb.GetBufferPointer()), fbb.GetSize()),
+    d->transaction.openDatabase(bufferType + ".main").write(Akonadi2::Storage::assembleKey(uid, newRevision), BufferUtils::extractBuffer(fbb),
        [](const Akonadi2::Storage::Error &error) {
            Warning() << "Failed to write entity";
        }
@@ -285,7 +286,7 @@ KAsync::Job<qint64> Pipeline::modifiedEntity(void const *command, size_t size)
    //Remove deletions
    if (modifyEntity->deletions()) {
        for (const auto &property : *modifyEntity->deletions()) {
-            newObject->setProperty(QByteArray::fromRawData(property->data(), property->size()), QVariant());
+            newObject->setProperty(BufferUtils::extractBuffer(property), QVariant());
        }
    }
diff --git a/common/query.h b/common/query.h
index 0d0f382..1df32da 100644
--- a/common/query.h
+++ b/common/query.h
@@ -22,42 +22,120 @@
 #include <QByteArrayList>
 #include <QHash>
 #include <QSet>
+#include "applicationdomaintype.h"
 namespace Akonadi2 {
 /**
- * A query that matches a set of objects
+ * A query that matches a set of entities.
- * 
- * The query will have to be updated regularly similary to the domain objects.
- * It probably also makes sense to have a domain specific part of the query,
- * such as what properties we're interested in (necessary information for on-demand
- * loading of data).
- *
- * The query defines:
- * * what resources to search
- * * filters on various properties (parent collection, startDate range, ....)
- * * properties we need (for on-demand querying)
- * 
- * syncOnDemand: Execute a source sync before executing the query
- * processAll: Ensure all local messages are processed before querying to guarantee an up-to date dataset.
 */
 class Query
 {
 public:
-    Query() : syncOnDemand(true), processAll(false), liveQuery(false) {}
+    enum Flag {
-    //Could also be a propertyFilter
+        /** Leave the query running an contiously update the result set. */
+        LiveQuery
+    };
+    Q_DECLARE_FLAGS(Flags, Flag)
+    static Query PropertyFilter(const QByteArray &key, const QVariant &value)
+    {
+        Query query;
+        query.propertyFilter.insert(key, value);
+        return query;
+    }
+    static Query PropertyFilter(const QByteArray &key, const ApplicationDomain::Entity &entity)
+    {
+        return PropertyFilter(key, QVariant::fromValue(entity.identifier()));
+    }
+    static Query ResourceFilter(const QByteArray &identifier)
+    {
+        Query query;
+        query.resources.append(identifier);
+        return query;
+    }
+    static Query ResourceFilter(const QByteArrayList &identifier)
+    {
+        Query query;
+        query.resources = identifier;
+        return query;
+    }
+    static Query ResourceFilter(const ApplicationDomain::AkonadiResource &entity)
+    {
+        return ResourceFilter(entity.identifier());
+    }
+    static Query IdentityFilter(const QByteArray &identifier)
+    {
+        Query query;
+        query.ids << identifier;
+        return query;
+    }
+    static Query IdentityFilter(const QByteArrayList &identifier)
+    {
+        Query query;
+        query.ids = identifier;
+        return query;
+    }
+    static Query IdentityFilter(const ApplicationDomain::Entity &entity)
+    {
+        return IdentityFilter(entity.identifier());
+    }
+    static Query RequestedProperties(const QByteArrayList &properties)
+    {
+        Query query;
+        query.requestedProperties = properties;
+        return query;
+    }
+    static Query RequestTree(const QByteArray &parentProperty)
+    {
+        Query query;
+        query.parentProperty = parentProperty;
+        return query;
+    }
+    Query(Flags flags = Flags())
+    {}
+    Query& operator+=(const Query& rhs)
+    {
+        resources += rhs.resources;
+        ids += rhs.ids;
+        for (auto it = rhs.propertyFilter.constBegin(); it != rhs.propertyFilter.constEnd(); it++) {
+            propertyFilter.insert(it.key(), it.value());
+        }
+        requestedProperties += rhs.requestedProperties;
+        parentProperty = rhs.parentProperty;
+        liveQuery = rhs.liveQuery;
+        syncOnDemand = rhs.syncOnDemand;
+        processAll = rhs.processAll;
+        return *this;
+    }
+    friend Query operator+(Query lhs, const Query& rhs)
+    {
+        lhs += rhs;
+        return lhs;
+    }
    QByteArrayList resources;
-    //Could also be a propertyFilter
    QByteArrayList ids;
-    //Filters to apply
    QHash<QByteArray, QVariant> propertyFilter;
-    //Properties to retrieve
    QByteArrayList requestedProperties;
    QByteArray parentProperty;
+    bool liveQuery;
    bool syncOnDemand;
    bool processAll;
-    //If live query is false, this query will not continuously be updated
-    bool liveQuery;
 };
 }
+Q_DECLARE_OPERATORS_FOR_FLAGS(Akonadi2::Query::Flags)
diff --git a/common/resource.h b/common/resource.h
index 4ed21b5..2ae71a0 100644
--- a/common/resource.h
+++ b/common/resource.h
@@ -17,10 +17,12 @@
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
+#pragma once
 #include <akonadi2common_export.h>
 #include <Async/Async>
+#include "notification.h"
 namespace Akonadi2
 {
@@ -55,6 +57,7 @@ public:
 Q_SIGNALS:
    void revisionUpdated(qint64);
+    void notify(Notification);
 private:
    class Private;
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 7be1259..6592699 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -30,19 +30,33 @@
 #include "common/modifyentity_generated.h"
 #include "common/deleteentity_generated.h"
 #include "common/revisionreplayed_generated.h"
+#include "common/inspection_generated.h"
 #include "common/entitybuffer.h"
+#include "common/bufferutils.h"
 #include "log.h"
 #include <QCoreApplication>
 #include <QDebug>
 #include <QDir>
 #include <QProcess>
+#include <QDataStream>
+#include <QBuffer>
 #undef Trace
 #define Trace() Akonadi2::Log::debugStream(Akonadi2::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess")
 #undef Log
 #define Log(IDENTIFIER) Akonadi2::Log::debugStream(Akonadi2::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess("+IDENTIFIER+")")
+static void queuedInvoke(const std::function<void()> &f, QObject *context = 0)
+{
+    auto timer = QSharedPointer<QTimer>::create();
+    timer->setSingleShot(true);
+    QObject::connect(timer.data(), &QTimer::timeout, context, [f, timer]() {
+        f();
+    });
+    timer->start(0);
+}
 namespace Akonadi2
 {
@@ -284,8 +298,8 @@ KAsync::Job<void> ResourceAccess::synchronizeResource(bool sourceSync, bool loca
 {
    Trace() << "Sending synchronize command: " << sourceSync << localSync;
    flatbuffers::FlatBufferBuilder fbb;
-    auto command = Akonadi2::CreateSynchronize(fbb, sourceSync, localSync);
+    auto command = Akonadi2::Commands::CreateSynchronize(fbb, sourceSync, localSync);
-    Akonadi2::FinishSynchronizeBuffer(fbb, command);
+    Akonadi2::Commands::FinishSynchronizeBuffer(fbb, command);
    open();
    return sendCommand(Commands::SynchronizeCommand, fbb);
 }
@@ -338,6 +352,25 @@ KAsync::Job<void> ResourceAccess::sendRevisionReplayedCommand(qint64 revision)
    return sendCommand(Akonadi2::Commands::RevisionReplayedCommand, fbb);
 }
+KAsync::Job<void> ResourceAccess::sendInspectionCommand(const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue)
+{
+    flatbuffers::FlatBufferBuilder fbb;
+    auto id = fbb.CreateString(inspectionId.toStdString());
+    auto domain = fbb.CreateString(domainType.toStdString());
+    auto entity = fbb.CreateString(entityId.toStdString());
+    auto prop = fbb.CreateString(property.toStdString());
+    QByteArray array;
+    QDataStream s(&array, QIODevice::WriteOnly);
+    s << expectedValue;
+    auto expected = fbb.CreateString(array.toStdString());
+    auto location = Akonadi2::Commands::CreateInspection (fbb, id, 0, entity, domain, prop, expected);
+    Akonadi2::Commands::FinishInspectionBuffer(fbb, location);
+    open();
+    return sendCommand(Akonadi2::Commands::InspectionCommand, fbb);
+}
 void ResourceAccess::open()
 {
    if (d->socket && d->socket->isValid()) {
@@ -424,8 +457,8 @@ void ResourceAccess::connected()
    {
        flatbuffers::FlatBufferBuilder fbb;
        auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1());
-        auto command = Akonadi2::CreateHandshake(fbb, name);
+        auto command = Akonadi2::Commands::CreateHandshake(fbb, name);
-        Akonadi2::FinishHandshakeBuffer(fbb, command);
+        Akonadi2::Commands::FinishHandshakeBuffer(fbb, command);
        Commands::write(d->socket.data(), ++d->messageId, Commands::HandshakeCommand, fbb);
    }
@@ -490,28 +523,49 @@ bool ResourceAccess::processMessageBuffer()
    switch (commandId) {
        case Commands::RevisionUpdateCommand: {
-            auto buffer = GetRevisionUpdate(d->partialMessageBuffer.constData() + headerSize);
+            auto buffer = Commands::GetRevisionUpdate(d->partialMessageBuffer.constData() + headerSize);
            log(QString("Revision updated to: %1").arg(buffer->revision()));
            emit revisionChanged(buffer->revision());
            break;
        }
-        case Commands::CommandCompletion: {
+        case Commands::CommandCompletionCommand: {
-            auto buffer = GetCommandCompletion(d->partialMessageBuffer.constData() + headerSize);
+            auto buffer = Commands::GetCommandCompletion(d->partialMessageBuffer.constData() + headerSize);
            log(QString("Command with messageId %1 completed %2").arg(buffer->id()).arg(buffer->success() ? "sucessfully" : "unsuccessfully"));
            d->completeCommands << buffer->id();
            //The callbacks can result in this object getting destroyed directly, so we need to ensure we finish our work first
-            QMetaObject::invokeMethod(this, "callCallbacks", Qt::QueuedConnection);
+            queuedInvoke([=]() {
+                d->callCallbacks();
+            }, this);
            break;
        }
        case Commands::NotificationCommand: {
-            auto buffer = GetNotification(d->partialMessageBuffer.constData() + headerSize);
+            auto buffer = Commands::GetNotification(d->partialMessageBuffer.constData() + headerSize);
            switch (buffer->type()) {
-                case Akonadi2::NotificationType::NotificationType_Shutdown:
+                case Akonadi2::Commands::NotificationType::NotificationType_Shutdown:
                    Log(d->resourceInstanceIdentifier) << "Received shutdown notification.";
                    close();
                    break;
+                case Akonadi2::Commands::NotificationType::NotificationType_Inspection: {
+                    Log(d->resourceInstanceIdentifier) << "Received inspection notification.";
+                    Notification n;
+                    if (buffer->identifier()) {
+                        //Don't use fromRawData, the buffer is gone once we invoke emit notification
+                        n.id = BufferUtils::extractBufferCopy(buffer->identifier());
+                    }
+                    if (buffer->message()) {
+                        //Don't use fromRawData, the buffer is gone once we invoke emit notification
+                        n.message = BufferUtils::extractBufferCopy(buffer->message());
+                    }
+                    n.type = buffer->type();
+                    n.code = buffer->code();
+                    //The callbacks can result in this object getting destroyed directly, so we need to ensure we finish our work first
+                    queuedInvoke([=]() {
+                        emit notification(n);
+                    }, this);
+                }
+                    break;
                default:
                    Warning() << "Received unknown notification: " << buffer->type();
                    break;
@@ -526,11 +580,6 @@ bool ResourceAccess::processMessageBuffer()
    return d->partialMessageBuffer.size() >= headerSize;
 }
-void ResourceAccess::callCallbacks()
-{
-    d->callCallbacks();
-}
 void ResourceAccess::log(const QString &message)
 {
    Log(d->resourceInstanceIdentifier) << this << message;
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index 7f61b30..2fe83ed 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -27,6 +27,7 @@
 #include <Async/Async>
 #include <flatbuffers/flatbuffers.h>
+#include "notification.h"
 namespace Akonadi2
 {
@@ -49,10 +50,12 @@ public:
    virtual KAsync::Job<void> sendModifyCommand(const QByteArray &uid, qint64 revision, const QByteArray &resourceBufferType, const QByteArrayList &deletedProperties, const QByteArray &buffer) { return KAsync::null<void>(); };
    virtual KAsync::Job<void> sendDeleteCommand(const QByteArray &uid, qint64 revision, const QByteArray &resourceBufferType) { return KAsync::null<void>(); };
    virtual KAsync::Job<void> sendRevisionReplayedCommand(qint64 revision) {return KAsync::null<void>(); };
+    virtual KAsync::Job<void> sendInspectionCommand(const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expecedValue) {return KAsync::null<void>(); };
 Q_SIGNALS:
    void ready(bool isReady);
    void revisionChanged(qint64 revision);
+    void notification(Notification revision);
 public Q_SLOTS:
    virtual void open() = 0;
@@ -78,6 +81,7 @@ public:
    KAsync::Job<void> sendModifyCommand(const QByteArray &uid, qint64 revision, const QByteArray &resourceBufferType, const QByteArrayList &deletedProperties, const QByteArray &buffer) Q_DECL_OVERRIDE;
    KAsync::Job<void> sendDeleteCommand(const QByteArray &uid, qint64 revision, const QByteArray &resourceBufferType) Q_DECL_OVERRIDE;
    KAsync::Job<void> sendRevisionReplayedCommand(qint64 revision) Q_DECL_OVERRIDE;
+    KAsync::Job<void> sendInspectionCommand(const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expecedValue) Q_DECL_OVERRIDE;
    /**
     * Tries to connect to server, and returns a connected socket on success.
     */
@@ -93,7 +97,6 @@ private Q_SLOTS:
    void connectionError(QLocalSocket::LocalSocketError error);
    void readResourceMessage();
    bool processMessageBuffer();
-    void callCallbacks();
 private:
    void connected();
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index 38e0c0e..ae3037a 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -27,6 +27,7 @@
 namespace Akonadi2 {
    class Query;
+    class Inspection;
 }
 class ResourceFacade : public Akonadi2::StoreFacade<Akonadi2::ApplicationDomain::AkonadiResource>
@@ -38,5 +39,9 @@ public:
    KAsync::Job<void> modify(const Akonadi2::ApplicationDomain::AkonadiResource &resource) Q_DECL_OVERRIDE;
    KAsync::Job<void> remove(const Akonadi2::ApplicationDomain::AkonadiResource &resource) Q_DECL_OVERRIDE;
    QPair<KAsync::Job<void>, typename Akonadi2::ResultEmitter<Akonadi2::ApplicationDomain::AkonadiResource::Ptr>::Ptr > load(const Akonadi2::Query &query) Q_DECL_OVERRIDE;
+    KAsync::Job<void> inspect(const Akonadi2::Inspection &domainObject) Q_DECL_OVERRIDE
+    {
+        return KAsync::error<void>(-1, "Failed to inspect.");
+    }
 };
diff --git a/common/resultprovider.h b/common/resultprovider.h
index 7f090e9..a064ab5 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -346,8 +346,14 @@ public:
        emitter->onRemoved([this](const DomainType &value) {
            this->remove(value);
        });
-        emitter->onInitialResultSetComplete([this](const DomainType &value) {
+        auto ptr = emitter.data();
-            this->initialResultSetComplete(value);
+        emitter->onInitialResultSetComplete([this, ptr](const DomainType &parent) {
+            auto hashValue = qHash(parent);
+            mInitialResultSetInProgress.remove(hashValue, ptr);
+            //Normally a parent is only in a single resource, except the toplevel (invalid) parent
+            if (!mInitialResultSetInProgress.contains(hashValue)) {
+                this->initialResultSetComplete(parent);
+            }
        });
        emitter->onComplete([this]() {
            this->complete();
@@ -365,6 +371,7 @@ public:
            this->initialResultSetComplete(parent);
        } else {
            for (const auto &emitter : mEmitter) {
+                mInitialResultSetInProgress.insert(qHash(parent), emitter.data());
                emitter->fetch(parent);
            }
        }
@@ -372,6 +379,7 @@ public:
 private:
    QList<typename ResultEmitter<DomainType>::Ptr> mEmitter;
+    QMultiMap<qint64, ResultEmitter<DomainType>*> mInitialResultSetInProgress;
 };
diff --git a/docs/resource.md b/docs/resource.md
index c8f58e9..0988535 100644
--- a/docs/resource.md
+++ b/docs/resource.md
@@ -141,3 +141,10 @@ The remoteid mapping has to be updated in two places:
 * New entities that are synchronized immediately get a localid assinged, that is then recorded together with the remoteid. This is required to be able to reference other entities directly in the command queue (i.e. for parent folders).
 * Entities created by clients get a remoteid assigned during change replay, so the entity can be recognized during the next sync.
+# Testing / Inspection
+Resources new to be tested, which often requires inspections into the current state of the resource. This is difficult in an asynchronous system where the whole backend logic is encapsulated in a separate process without running tests in a vastly different setup from how it will be run in production.
+To alleviate this inspection commands are introduced. Inspection commands are special commands that the resource processes just like all other commands, and that have the sole purpose of inspecting the current resource state. Because the command is processed with the same mechanism as other commands we can rely on ordering of commands in a way that a prior command is guaranteed to be executed once the inspection command is processed.
+A typical inspection command could i.e. verify that a file has been created in the expected path after a create command.
diff --git a/examples/client/main.cpp b/examples/client/main.cpp
index 127fd2f..6660f86 100644
--- a/examples/client/main.cpp
+++ b/examples/client/main.cpp
@@ -120,7 +120,6 @@ public:
        QObject::connect(syncButton, &QPushButton::pressed, []() {
            Akonadi2::Query query;
            query.resources << "org.kde.dummy.instance1";
-            query.syncOnDemand = true;
            Akonadi2::Store::synchronize(query).exec();
        });
@@ -198,8 +197,6 @@ int main(int argc, char *argv[])
    for (const auto &res : resources) {
        query.resources << res.toLatin1();
    }
-    query.syncOnDemand = false;
-    query.processAll = false;
    query.liveQuery = true;
    if (type == "folder") {
        query.parentProperty = "parent";
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index a984097..c43b5e6 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -134,6 +134,22 @@ void DummyResource::removeFromDisk(const QByteArray &instanceIdentifier)
    Akonadi2::Storage(Akonadi2::storageLocation(), instanceIdentifier + ".synchronization", Akonadi2::Storage::ReadWrite).removeFromDisk();
 }
+KAsync::Job<void> DummyResource::inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue)
+{
+    Trace() << "Inspecting " << inspectionType << domainType << entityId << property << expectedValue;
+    if (property == "testInspection") {
+        if (expectedValue.toBool()) {
+            //Success
+            return KAsync::null<void>();
+        } else {
+            //Failure
+            return KAsync::error<void>(1, "Failed.");
+        }
+    }
+    return KAsync::null<void>();
+}
 DummyResourceFactory::DummyResourceFactory(QObject *parent)
    : Akonadi2::ResourceFactory(parent)
 {
diff --git a/examples/dummyresource/resourcefactory.h b/examples/dummyresource/resourcefactory.h
index 2ed4c5d..634829e 100644
--- a/examples/dummyresource/resourcefactory.h
+++ b/examples/dummyresource/resourcefactory.h
@@ -40,6 +40,7 @@ public:
    KAsync::Job<void> synchronizeWithSource(Akonadi2::Storage &mainStore, Akonadi2::Storage &synchronizationStore) Q_DECL_OVERRIDE;
    using GenericResource::synchronizeWithSource;
    static void removeFromDisk(const QByteArray &instanceIdentifier);
+    KAsync::Job<void> inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue) Q_DECL_OVERRIDE;
 private:
    KAsync::Job<void> replay(Akonadi2::Storage &synchronizationStore, const QByteArray &type, const QByteArray &key, const QByteArray &value) Q_DECL_OVERRIDE;
    Akonadi2::ApplicationDomain::Event::Ptr createEvent(const QByteArray &rid, const QMap<QString, QVariant> &data, Akonadi2::Storage::Transaction &);
diff --git a/examples/maildirresource/libmaildir/maildir.cpp b/examples/maildirresource/libmaildir/maildir.cpp
index 94363b8..28cf46e 100644
--- a/examples/maildirresource/libmaildir/maildir.cpp
+++ b/examples/maildirresource/libmaildir/maildir.cpp
@@ -770,7 +770,7 @@ bool Maildir::removeEntry(const QString& key)
 //     return newUniqueKey;
 // }
 //
-Maildir::Flags Maildir::readEntryFlags(const QString& key) const
+Maildir::Flags Maildir::readEntryFlags(const QString& key)
 {
    Flags flags;
    const QRegExp rx = *(statusSeparatorRx());
diff --git a/examples/maildirresource/libmaildir/maildir.h b/examples/maildirresource/libmaildir/maildir.h
index f80ba5d..fefd5a7 100644
--- a/examples/maildirresource/libmaildir/maildir.h
+++ b/examples/maildirresource/libmaildir/maildir.h
@@ -178,7 +178,7 @@ public:
    /**
     * Return the flags encoded in the maildir file name for an entry
     **/
-    Flags readEntryFlags( const QString& key ) const;
+    static Flags readEntryFlags( const QString& key );
    /**
     * Return the contents of the headers section of the file the maildir with the given @p file, that
diff --git a/examples/maildirresource/maildirresource.cpp b/examples/maildirresource/maildirresource.cpp
index 70f6ae5..9280bdc 100644
--- a/examples/maildirresource/maildirresource.cpp
+++ b/examples/maildirresource/maildirresource.cpp
@@ -35,6 +35,7 @@
 #include "facadefactory.h"
 #include "indexupdater.h"
 #include "libmaildir/maildir.h"
+#include "inspection.h"
 #include <QDate>
 #include <QUuid>
 #include <QDir>
@@ -292,6 +293,35 @@ void MaildirResource::removeFromDisk(const QByteArray &instanceIdentifier)
    Akonadi2::Storage(Akonadi2::storageLocation(), instanceIdentifier + ".synchronization", Akonadi2::Storage::ReadWrite).removeFromDisk();
 }
+KAsync::Job<void> MaildirResource::inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue)
+{
+    auto synchronizationStore = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::storageLocation(), mResourceInstanceIdentifier + ".synchronization", Akonadi2::Storage::ReadOnly);
+    auto synchronizationTransaction = synchronizationStore->createTransaction(Akonadi2::Storage::ReadOnly);
+    Trace() << "Inspecting " << inspectionType << domainType << entityId << property << expectedValue;
+    if (domainType == ENTITY_TYPE_MAIL) {
+        if (inspectionType == Akonadi2::Resources::Inspection::PropertyInspectionType) {
+            if (property == "unread") {
+                const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, entityId, synchronizationTransaction);
+                const auto flags = KPIM::Maildir::readEntryFlags(remoteId.split('/').last());
+                if (expectedValue.toBool() && !(flags & KPIM::Maildir::Seen)) {
+                    return KAsync::error<void>(1, "Expected seen but couldn't find it.");
+                }
+                if (!expectedValue.toBool() && (flags & KPIM::Maildir::Seen)) {
+                    return KAsync::error<void>(1, "Expected seen but couldn't find it.");
+                }
+                return KAsync::null<void>();
+            }
+        }
+        if (inspectionType == Akonadi2::Resources::Inspection::ExistenceInspectionType) {
+            const auto remoteId = resolveLocalId(ENTITY_TYPE_MAIL, entityId, synchronizationTransaction);
+            if (QFileInfo(remoteId).exists() != expectedValue.toBool()) {
+                return KAsync::error<void>(1, "Wrong file existence: " + remoteId);
+            }
+        }
+    }
+    return KAsync::null<void>();
+}
 MaildirResourceFactory::MaildirResourceFactory(QObject *parent)
    : Akonadi2::ResourceFactory(parent)
 {
diff --git a/examples/maildirresource/maildirresource.h b/examples/maildirresource/maildirresource.h
index 21ee637..5f7795b 100644
--- a/examples/maildirresource/maildirresource.h
+++ b/examples/maildirresource/maildirresource.h
@@ -44,6 +44,7 @@ class MaildirResource : public Akonadi2::GenericResource
 public:
    MaildirResource(const QByteArray &instanceIdentifier, const QSharedPointer<Akonadi2::Pipeline> &pipeline = QSharedPointer<Akonadi2::Pipeline>());
    KAsync::Job<void> synchronizeWithSource(Akonadi2::Storage &mainStore, Akonadi2::Storage &synchronizationStore) Q_DECL_OVERRIDE;
+    KAsync::Job<void> inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue) Q_DECL_OVERRIDE;
    static void removeFromDisk(const QByteArray &instanceIdentifier);
 private:
    KAsync::Job<void> replay(Akonadi2::Storage &synchronizationStore, const QByteArray &type, const QByteArray &key, const QByteArray &value) Q_DECL_OVERRIDE;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1e0f6b5..38e5512 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -51,12 +51,14 @@ auto_tests (
    databasepopulationandfacadequerybenchmark
    dummyresourcewritebenchmark
    modelinteractivitytest
+    inspectiontest
 )
 target_link_libraries(dummyresourcetest akonadi2_resource_dummy)
 target_link_libraries(dummyresourcebenchmark akonadi2_resource_dummy)
 target_link_libraries(dummyresourcewritebenchmark akonadi2_resource_dummy)
 target_link_libraries(querytest akonadi2_resource_dummy)
 target_link_libraries(modelinteractivitytest akonadi2_resource_dummy)
+target_link_libraries(inspectiontest akonadi2_resource_dummy)
 if (BUILD_MAILDIR)
    auto_tests (
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 78e1d1e..86150ee 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -33,6 +33,7 @@ public:
    KAsync::Job<void> create(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
    KAsync::Job<void> modify(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
    KAsync::Job<void> remove(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
+    KAsync::Job<void> inspect(const Akonadi2::Inspection &) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
    QPair<KAsync::Job<void>, typename Akonadi2::ResultEmitter<typename T::Ptr>::Ptr > load(const Akonadi2::Query &query) Q_DECL_OVERRIDE
    {
        auto resultProvider = new Akonadi2::ResultProvider<typename T::Ptr>();
@@ -265,9 +266,38 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.liveQuery = false;
+        int childrenFetchedCount = 0;
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Event>(query);
+        QObject::connect(model.data(), &QAbstractItemModel::dataChanged, [&childrenFetchedCount](const QModelIndex &, const QModelIndex &, const QVector<int> &roles) {
+            if (roles.contains(Akonadi2::Store::ChildrenFetchedRole)) {
+                childrenFetchedCount++;
+            }
+        });
        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
        QCOMPARE(model->rowCount(QModelIndex()), 2);
+        //Ensure children fetched is only emitted once (when all resources are done)
+        QTest::qWait(50);
+        QCOMPARE(childrenFetchedCount, 1);
+    }
+    void testImperativeLoad()
+    {
+        auto facade = DummyResourceFacade<Akonadi2::ApplicationDomain::Event>::registerFacade();
+        facade->results << QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("resource", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
+        ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
+        Akonadi2::Query query;
+        query.resources << "dummyresource.instance1";
+        query.liveQuery = false;
+        bool gotValue = false;
+        auto result = Akonadi2::Store::fetchOne<Akonadi2::ApplicationDomain::Event>(query)
+            .then<void, Akonadi2::ApplicationDomain::Event>([&gotValue](const Akonadi2::ApplicationDomain::Event &event) {
+                gotValue = true;
+            }).exec();
+        result.waitForFinished();
+        QVERIFY(!result.errorCode());
+        QVERIFY(gotValue);
    }
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index aad86c0..c52eee3 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -92,9 +92,7 @@ private Q_SLOTS:
        {
            Akonadi2::Query query;
            query.resources << "org.kde.dummy.instance1";
-            query.syncOnDemand = false;
+            Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
-            query.processAll = true;
-            Akonadi2::Store::synchronize(query).exec().waitForFinished();
        }
        auto allProcessedTime = time.elapsed();
@@ -123,8 +121,6 @@ private Q_SLOTS:
            time.start();
            Akonadi2::Query query;
            query.resources << "org.kde.dummy.instance1";
-            query.syncOnDemand = false;
-            query.processAll = false;
            query.propertyFilter.insert("uid", "testuid");
            auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Event>(query);
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index 0e1f382..72a24b6 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -62,11 +62,9 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("uid", "testuid");
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Event>(query);
@@ -88,11 +86,9 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("uid", "testuid");
@@ -118,11 +114,9 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        query.propertyFilter.insert("summary", "summaryValue2");
@@ -153,11 +147,10 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Event>(query);
        QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -171,11 +164,10 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(model->rowCount(QModelIndex()) >= 1);
@@ -195,12 +187,10 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.propertyFilter.insert("uid", "testuid");
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test create
        Akonadi2::ApplicationDomain::Event event2;
@@ -219,7 +209,7 @@ private Q_SLOTS:
        Akonadi2::Store::modify<Akonadi2::ApplicationDomain::Event>(event2).exec().waitForFinished();
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test modify
        {
@@ -234,7 +224,7 @@ private Q_SLOTS:
        Akonadi2::Store::remove<Akonadi2::ApplicationDomain::Event>(event2).exec().waitForFinished();
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test remove
        {
@@ -249,8 +239,6 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.liveQuery = true;
        query.propertyFilter.insert("uid", "testuid");
diff --git a/tests/inspectiontest.cpp b/tests/inspectiontest.cpp
new file mode 100644
index 0000000..29cce6c
--- /dev/null
+++ b/tests/inspectiontest.cpp
@@ -0,0 +1,65 @@
+#include <QtTest>
+#include <QString>
+#include "dummyresource/resourcefactory.h"
+#include "clientapi.h"
+#include "resourceconfig.h"
+#include "log.h"
+/**
+ * Test of inspection system using the dummy resource.
+ *
+ * This test requires the dummy resource installed.
+ */
+class InspectionTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase()
+    {
+        Akonadi2::Log::setDebugOutputLevel(Akonadi2::Log::Trace);
+        auto factory = Akonadi2::ResourceFactory::load("org.kde.dummy");
+        QVERIFY(factory);
+        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        ResourceConfig::addResource("org.kde.dummy.instance1", "org.kde.dummy");
+    }
+    void cleanup()
+    {
+        Akonadi2::Store::shutdown(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+        DummyResource::removeFromDisk("org.kde.dummy.instance1");
+        auto factory = Akonadi2::ResourceFactory::load("org.kde.dummy");
+        QVERIFY(factory);
+        Akonadi2::Store::start(QByteArray("org.kde.dummy.instance1")).exec().waitForFinished();
+    }
+    void testInspection_data()
+    {
+        QTest::addColumn<bool>("success");
+        QTest::newRow("success") << true;
+        QTest::newRow("fail") << false;
+    }
+    void testInspection()
+    {
+        QFETCH(bool, success);
+        using namespace Akonadi2;
+        using namespace Akonadi2::ApplicationDomain;
+        Mail mail(QByteArray("org.kde.dummy.instance1"), QByteArray("identifier"), 0, QSharedPointer<MemoryBufferAdaptor::MemoryBufferAdaptor>::create());
+        //testInspection is a magic property that the dummyresource supports
+        auto inspectionCommand = Resources::Inspection::PropertyInspection(mail, "testInspection", success);
+        auto result = Resources::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/maildirresourcetest.cpp b/tests/maildirresourcetest.cpp
index 6e7818a..ec4f6a4 100644
--- a/tests/maildirresourcetest.cpp
+++ b/tests/maildirresourcetest.cpp
@@ -87,11 +87,10 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -102,12 +101,11 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        query.parentProperty = "parent";
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -120,34 +118,27 @@ private Q_SLOTS:
    void testListMailsOfFolder()
    {
-        {
+        using namespace Akonadi2;
-            Akonadi2::Query query;
+        using namespace Akonadi2::ApplicationDomain;
-            query.resources << "org.kde.maildir.instance1";
+        //Ensure all local data is processed
-            query.syncOnDemand = true;
+        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
-            query.processAll = true;
+        Store::synchronize(query).exec().waitForFinished();
+        Store::flushMessageQueue(query.resources).exec().waitForFinished();
-            //Ensure all local data is processed
+        auto result = Store::fetchOne<Folder>(
-            Akonadi2::Store::synchronize(query).exec().waitForFinished();
+                Query::ResourceFilter("org.kde.maildir.instance1") + Query::RequestedProperties(QByteArrayList() << "name")
-        }
+            )
-        QByteArray folderIdentifier;
+            .then<QList<Mail::Ptr>, Folder>([](const Folder &folder) {
-        {
+                Trace() << "Found a folder" << folder.identifier();
-            Akonadi2::Query query;
+                return Store::fetchAll<Mail>(
-            query.resources << "org.kde.maildir.instance1";
+                    Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
-            query.requestedProperties << "folder" << "name";
+                );
+            })
-            auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
+            .then<void, QList<Mail::Ptr> >([](const QList<Mail::Ptr> &mails) {
-            QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
+                QVERIFY(mails.size() >= 1);
-            QVERIFY(model->rowCount(QModelIndex()) > 1);
+            })
-            folderIdentifier = model->index(1, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).value<Akonadi2::ApplicationDomain::Folder::Ptr>()->identifier();
+            .exec();
-        }
+        result.waitForFinished();
+        QVERIFY(!result.errorCode());
-        Akonadi2::Query query;
-        query.resources << "org.kde.maildir.instance1";
-        query.requestedProperties << "folder" << "subject";
-        query.propertyFilter.insert("folder", folderIdentifier);
-        auto mailModel = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
-        QTRY_VERIFY(mailModel->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
-        QVERIFY(mailModel->rowCount(QModelIndex()) >= 1);
    }
    void testMailContent()
@@ -155,11 +146,10 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
        query.requestedProperties << "folder" << "subject" << "mimeMessage" << "date";
-        query.syncOnDemand = true;
-        query.processAll = true;
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -175,12 +165,11 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        query.requestedProperties << "name";
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/";
        QDir dir(targetPath);
@@ -188,6 +177,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -199,15 +189,15 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        query.requestedProperties << "folder" << "subject";
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -218,12 +208,11 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = true;
-        query.processAll = true;
        query.requestedProperties << "folder" << "subject";
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/cur/1365777830.R28.localhost.localdomain:2,S";
        QFile file(targetPath);
@@ -231,6 +220,7 @@ private Q_SLOTS:
        //Ensure all local data is processed
        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto mailModel = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
        QTRY_VERIFY(mailModel->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -241,11 +231,9 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        Akonadi2::ApplicationDomain::Folder folder("org.kde.maildir.instance1");
        folder.setProperty("name", "testCreateFolder");
@@ -253,7 +241,7 @@ private Q_SLOTS:
        Akonadi2::Store::create(folder).exec().waitForFinished();
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/testCreateFolder";
        QFileInfo file(targetPath);
@@ -265,15 +253,13 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        auto targetPath = tempDir.path() + "/maildir1/testCreateFolder";
        Akonadi2::ApplicationDomain::Folder folder("org.kde.maildir.instance1");
        folder.setProperty("name", "testCreateFolder");
        Akonadi2::Store::create(folder).exec().waitForFinished();
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        QTRY_VERIFY(QFileInfo(targetPath).exists());
        Akonadi2::Query folderQuery;
@@ -285,7 +271,7 @@ private Q_SLOTS:
        auto createdFolder = model->index(0, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).value<Akonadi2::ApplicationDomain::Folder::Ptr>();
        Akonadi2::Store::remove(*createdFolder).exec().waitForFinished();
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        QTRY_VERIFY(!QFileInfo(targetPath).exists());
    }
@@ -293,11 +279,9 @@ private Q_SLOTS:
    {
        Akonadi2::Query query;
        query.resources << "org.kde.maildir.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        Akonadi2::ApplicationDomain::Mail mail("org.kde.maildir.instance1");
        mail.setProperty("name", "testCreateMail");
@@ -305,7 +289,7 @@ private Q_SLOTS:
        Akonadi2::Store::create(mail).exec().waitForFinished();
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        auto targetPath = tempDir.path() + "/maildir1/new";
        QDir dir(targetPath);
@@ -315,32 +299,72 @@ private Q_SLOTS:
    void testRemoveMail()
    {
-        Akonadi2::Query query;
+        using namespace Akonadi2;
-        query.resources << "org.kde.maildir.instance1";
+        using namespace Akonadi2::ApplicationDomain;
-        query.syncOnDemand = true;
-        query.processAll = true;
+        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Store::synchronize(query).exec().waitForFinished();
+        Store::flushMessageQueue(query.resources).exec().waitForFinished();
-        Akonadi2::Query folderQuery;
-        folderQuery.resources << "org.kde.maildir.instance1";
+        auto result = Store::fetchOne<Folder>(
-        folderQuery.propertyFilter.insert("name", "maildir1");
+                Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
-        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(folderQuery);
+            )
-        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
+            .then<void, KAsync::Job<void>, Folder>([query](const Folder &folder) {
-        QCOMPARE(model->rowCount(QModelIndex()), 1);
+                return Store::fetchAll<Mail>(
-        auto folder = model->index(0, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).value<Akonadi2::ApplicationDomain::Folder::Ptr>();
+                    Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
+                )
-        Akonadi2::Query mailQuery;
+                .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
-        mailQuery.resources << "org.kde.maildir.instance1";
+                    //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
-        mailQuery.propertyFilter.insert("folder", folder->identifier());
+                    if (mails.size() != 1) {
-        auto mailModel = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(mailQuery);
+                        return KAsync::error<void>(1, "Wrong number of mails.");
-        QTRY_VERIFY(mailModel->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
+                    }
-        QCOMPARE(mailModel->rowCount(QModelIndex()), 1);
+                    auto mail = mails.first();
-        auto mail = mailModel->index(0, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).value<Akonadi2::ApplicationDomain::Mail::Ptr>();
+                    return Store::remove(*mail)
-        Akonadi2::Store::remove(*mail).exec().waitForFinished();
+                        .then(Store::flushReplayQueue(query.resources)) //The change needs to be replayed already
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+                        .then(Resources::inspect<Mail>(Resources::Inspection::ExistenceInspection(*mail, false)));
+                })
+                .then<void>([](){});
+            })
+            .exec();
+        result.waitForFinished();
+        QVERIFY(!result.errorCode());
+    }
-        QTRY_COMPARE(QDir(tempDir.path() + "/maildir1/cur", QString(), QDir::NoSort, QDir::Files).count(), static_cast<unsigned int>(0));
+    void testMarkMailAsRead()
+    {
+        using namespace Akonadi2;
+        using namespace Akonadi2::ApplicationDomain;
+        auto query = Query::ResourceFilter("org.kde.maildir.instance1");
+        Store::synchronize(query).exec().waitForFinished();
+        Store::flushMessageQueue(query.resources).exec().waitForFinished();
+        auto result = Store::fetchOne<Folder>(
+                Query::ResourceFilter("org.kde.maildir.instance1") + Query::PropertyFilter("name", "maildir1") + Query::RequestedProperties(QByteArrayList() << "name")
+            )
+            .then<void, KAsync::Job<void>, Folder>([query](const Folder &folder) {
+                Trace() << "Found a folder" << folder.identifier();
+                return Store::fetchAll<Mail>(
+                    Query::PropertyFilter("folder", folder) + Query::RequestedProperties(QByteArrayList() << "folder" << "subject")
+                )
+                .then<void, KAsync::Job<void>, QList<Mail::Ptr> >([query](const QList<Mail::Ptr> &mails) {
+                    //Can't use QCOMPARE because it tries to return FIXME Implement ASYNCCOMPARE
+                    if (mails.size() != 1) {
+                        return KAsync::error<void>(1, "Wrong number of mails.");
+                    }
+                    auto mail = mails.first();
+                    mail->setProperty("unread", true);
+                    auto inspectionCommand = Resources::Inspection::PropertyInspection(*mail, "unread", true);
+                    return Store::modify(*mail)
+                        .then<void>(Store::flushReplayQueue(query.resources)) //The change needs to be replayed already
+                        .then(Resources::inspect<Mail>(inspectionCommand));
+                })
+                .then<void>([](){});
+            })
+            .exec();
+        result.waitForFinished();
+        QVERIFY(!result.errorCode());
    }
 };
diff --git a/tests/modelinteractivitytest.cpp b/tests/modelinteractivitytest.cpp
index 52db932..59c2c6f 100644
--- a/tests/modelinteractivitytest.cpp
+++ b/tests/modelinteractivitytest.cpp
@@ -73,11 +73,9 @@ private Q_SLOTS:
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.liveQuery = true;
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //Test
        QTime time;
diff --git a/tests/querytest.cpp b/tests/querytest.cpp
index e09f7a4..f9344cd 100644
--- a/tests/querytest.cpp
+++ b/tests/querytest.cpp
@@ -48,8 +48,6 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "foobar";
-        query.syncOnDemand = false;
-        query.processAll = false;
        query.liveQuery = true;
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -70,8 +68,6 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = false;
        query.liveQuery = true;
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -91,12 +87,10 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.liveQuery = false;
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
@@ -150,8 +144,6 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = false;
        query.liveQuery = true;
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
@@ -171,11 +163,9 @@ private Q_SLOTS:
            Akonadi2::Query query;
            query.resources << "org.kde.dummy.instance1";
-            query.syncOnDemand = false;
-            query.processAll = true;
            //Ensure all local data is processed
-            Akonadi2::Store::synchronize(query).exec().waitForFinished();
+            Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
            auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
            QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -192,12 +182,10 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.parentProperty = "parent";
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch after the data is available and don't rely on the live query mechanism to deliver the actual data
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
@@ -222,13 +210,11 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
        query.liveQuery = false;
        query.propertyFilter.insert("uid", "test1");
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
@@ -246,11 +232,9 @@ private Q_SLOTS:
            Akonadi2::Query query;
            query.resources << "org.kde.dummy.instance1";
-            query.syncOnDemand = false;
-            query.processAll = true;
            //Ensure all local data is processed
-            Akonadi2::Store::synchronize(query).exec().waitForFinished();
+            Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
            auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Folder>(query);
            QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
@@ -268,13 +252,10 @@ private Q_SLOTS:
        //Test
        Akonadi2::Query query;
        query.resources << "org.kde.dummy.instance1";
-        query.syncOnDemand = false;
-        query.processAll = true;
-        query.liveQuery = false;
        query.propertyFilter.insert("folder", folderEntity->identifier());
        //Ensure all local data is processed
-        Akonadi2::Store::synchronize(query).exec().waitForFinished();
+        Akonadi2::Store::flushMessageQueue(query.resources).exec().waitForFinished();
        //We fetch before the data is available and rely on the live query mechanism to deliver the actual data
        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Mail>(query);
diff --git a/tests/resourcecommunicationtest.cpp b/tests/resourcecommunicationtest.cpp
index 18e9223..1b09c5f 100644
--- a/tests/resourcecommunicationtest.cpp
+++ b/tests/resourcecommunicationtest.cpp
@@ -32,8 +32,8 @@ private Q_SLOTS:
        flatbuffers::FlatBufferBuilder fbb;
        auto name = fbb.CreateString("test");
-        auto command = Akonadi2::CreateHandshake(fbb, name);
+        auto command = Akonadi2::Commands::CreateHandshake(fbb, name);
-        Akonadi2::FinishHandshakeBuffer(fbb, command);
+        Akonadi2::Commands::FinishHandshakeBuffer(fbb, command);
        auto result = resourceAccess.sendCommand(Akonadi2::Commands::HandshakeCommand, fbb).exec();
        result.waitForFinished();
        QVERIFY(!result.errorCode());