16 files changed, 290 insertions, 37 deletions

diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index c82fad3..517111c 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -2,9 +2,10 @@ namespace Sink.Commands;
 
 table Notification {
     type: int = 0; //See notification.h
-    identifier: string; //An identifier that links back to the something related to the notification (e.g. an entity id or a command id)
+    identifier: string; //An identifier that links back to the something related to the notification (e.g. a command id)
     message: string;
     code: int = 0; //See notification.h
+    entities: [string]; //A list of entities this applies to
 }
 
 root_type Notification;
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index ef38d58..6fd2b90 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -93,7 +93,7 @@
 namespace Sink {
 namespace ApplicationDomain {
 
-enum ErrorCode {
+enum SINK_EXPORT ErrorCode {
     NoError = 0,
     UnknownError,
     NoServerError,
@@ -101,10 +101,33 @@ enum ErrorCode {
     TransmissionError,
 };
 
-enum SuccessCode {
+enum SINK_EXPORT SuccessCode {
     TransmissionSuccess
 };
 
+enum SINK_EXPORT SyncStatus {
+    NoSyncStatus,
+    SyncInProgress,
+    SyncError,
+    SyncSuccess
+};
+
+/**
+ * The status of an account or resource.
+ *
+ * It is set as follows:
+ * * By default the status is offline.
+ * * If a connection to the server could be established the status is Connected.
+ * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
+ * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
+ */
+enum SINK_EXPORT Status {
+    OfflineStatus,
+    ConnectedStatus,
+    BusyStatus,
+    ErrorStatus
+};
+
 struct SINK_EXPORT Error {
 
 };
@@ -113,6 +136,11 @@ struct SINK_EXPORT Progress {
 
 };
 
+/**
+ * Internal type.
+ *
+ * Represents a BLOB property.
+ */
 struct BLOB {
     BLOB() = default;
     BLOB(const BLOB &) = default;
@@ -410,22 +438,6 @@ struct SINK_EXPORT Mail : public Entity {
 
 SINK_EXPORT QDebug operator<< (QDebug d, const Mail::Contact &c);
 
-/**
- * The status of an account or resource.
- *
- * It is set as follows:
- * * By default the status is offline.
- * * If a connection to the server could be established the status is Connected.
- * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
- * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
- */
-enum SINK_EXPORT Status {
-    OfflineStatus,
-    ConnectedStatus,
-    BusyStatus,
-    ErrorStatus
-};
-
 struct SINK_EXPORT Identity : public ApplicationDomainType {
     static constexpr const char *name = "identity";
     typedef QSharedPointer<Identity> Ptr;
diff --git a/common/listener.cpp b/common/listener.cpp
index f18fe1d..96806ad 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -25,6 +25,7 @@
 #include "common/definitions.h"
 #include "common/resourcecontext.h"
 #include "common/adaptorfactoryregistry.h"
+#include "common/bufferutils.h"
 
 // commands
 #include "common/commandcompletion_generated.h"
@@ -406,11 +407,13 @@ void Listener::notify(const Sink::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());
+    auto entities = Sink::BufferUtils::toVector(m_fbb, notification.entities);
     Sink::Commands::NotificationBuilder builder(m_fbb);
     builder.add_type(notification.type);
     builder.add_code(notification.code);
     builder.add_identifier(idString);
     builder.add_message(messageString);
+    builder.add_entities(entities);
     auto command = builder.Finish();
     Sink::Commands::FinishNotificationBuffer(m_fbb, command);
     for (Client &client : m_connections) {
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index 904766d..3edbec7 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -24,12 +24,20 @@
 #include <QPointer>
 
 #include "log.h"
+#include "notifier.h"
+#include "notification.h"
+
+using namespace Sink;
+
+static uint getInternalIdentifer(const QByteArray &resourceId, const QByteArray &entityId)
+{
+    return qHash(resourceId + entityId);
+}
 
 static uint qHash(const Sink::ApplicationDomain::ApplicationDomainType &type)
 {
-    // Q_ASSERT(!type.resourceInstanceIdentifier().isEmpty());
     Q_ASSERT(!type.identifier().isEmpty());
-    return qHash(type.resourceInstanceIdentifier() + type.identifier());
+    return getInternalIdentifer(type.resourceInstanceIdentifier(), type.identifier());
 }
 
 static qint64 getIdentifier(const QModelIndex &idx)
@@ -44,6 +52,79 @@ template <class T, class Ptr>
 ModelResult<T, Ptr>::ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &ctx)
     : QAbstractItemModel(), mLogCtx(ctx.subContext("modelresult")), mPropertyColumns(propertyColumns), mQuery(query)
 {
+    if (query.flags().testFlag(Sink::Query::UpdateStatus)) {
+        mNotifier.reset(new Sink::Notifier{query});
+        mNotifier->registerHandler([this](const Notification &notification) {
+            switch (notification.type) {
+                case Notification::Status:
+                case Notification::Warning:
+                case Notification::Error:
+                case Notification::Info:
+                case Notification::Progress:
+                    //These are the notifications we care about
+                    break;
+                default:
+                    //We're not interested
+                    return;
+            };
+            if (notification.resource.isEmpty()|| notification.entities.isEmpty()) {
+                return;
+            }
+
+            QVector<qint64> idList;
+            for (const auto &entity : notification.entities) {
+                auto id = getInternalIdentifer(notification.resource, entity);
+                if (mEntities.contains(id)) {
+                    idList << id;
+                }
+            }
+
+            if (idList.isEmpty()) {
+                //We don't have this entity in our model
+                return;
+            }
+            const int newStatus = [&] {
+                if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    return ApplicationDomain::SyncStatus::SyncError;
+                }
+                if (notification.type == Notification::Info) {
+                    switch (notification.code) {
+                        case ApplicationDomain::SyncInProgress:
+                            return ApplicationDomain::SyncInProgress;
+                        case ApplicationDomain::SyncSuccess:
+                            return ApplicationDomain::SyncSuccess;
+                        case ApplicationDomain::SyncError:
+                            return ApplicationDomain::SyncError;
+                        case ApplicationDomain::NoSyncStatus:
+                            break;
+                    }
+                    return ApplicationDomain::NoSyncStatus;
+                }
+                if (notification.type == Notification::Progress) {
+                    return ApplicationDomain::SyncStatus::SyncInProgress;
+                }
+                return ApplicationDomain::NoSyncStatus;
+            }();
+
+            for (const auto id : idList) {
+                const auto oldStatus = mEntityStatus.value(id);
+                QVector<int> changedRoles;
+                if (oldStatus != newStatus) {
+                    mEntityStatus.insert(id, newStatus);
+                    changedRoles << StatusRole;
+                }
+
+                if (notification.type == Notification::Progress) {
+                    changedRoles << ProgressRole;
+                } else if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    changedRoles << WarningRole;
+                }
+
+                const auto idx = createIndexFromId(id);
+                emit dataChanged(idx, idx, changedRoles);
+            }
+        });
+    }
 }
 
 template <class T, class Ptr>
@@ -60,7 +141,7 @@ qint64 ModelResult<T, Ptr>::parentId(const Ptr &value)
     if (!mQuery.parentProperty().isEmpty()) {
         const auto identifier = value->getProperty(mQuery.parentProperty()).toByteArray();
         if (!identifier.isEmpty()) {
-            return qHash(T(value->resourceInstanceIdentifier(), identifier, 0, QSharedPointer<Sink::ApplicationDomain::BufferAdaptor>()));
+            return getInternalIdentifer(value->resourceInstanceIdentifier(), identifier);
         }
     }
     return 0;
@@ -106,6 +187,9 @@ QVariant ModelResult<T, Ptr>::data(const QModelIndex &index, int role) const
     if (role == ChildrenFetchedRole) {
         return childrenFetched(index);
     }
+    if (role == StatusRole) {
+        return mEntityStatus.value(index.internalId());
+    }
     if (role == Qt::DisplayRole && index.isValid()) {
         if (index.column() < mPropertyColumns.size()) {
             Q_ASSERT(mEntities.contains(index.internalId()));
diff --git a/common/modelresult.h b/common/modelresult.h
index f30a8e1..cc263cf 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -30,15 +30,23 @@
 #include "resultprovider.h"
 #include "threadboundary.h"
 
+namespace Sink {
+class Notifier;
+}
+
 template <class T, class Ptr>
 class ModelResult : public QAbstractItemModel
 {
 public:
+    //Update the copy in store.h as well if you modify this
     enum Roles
     {
         DomainObjectRole = Qt::UserRole + 1,
         ChildrenFetchedRole,
-        DomainObjectBaseRole
+        DomainObjectBaseRole,
+        StatusRole, //ApplicationDomain::SyncStatus
+        WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+        ProgressRole //ApplicationDomain::Progress
     };
 
     ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &);
@@ -77,9 +85,11 @@ private:
     QSet<qint64 /* entity id */> mEntityChildrenFetched;
     QSet<qint64 /* entity id */> mEntityChildrenFetchComplete;
     QSet<qint64 /* entity id */> mEntityAllChildrenFetched;
+    QMap<qint64 /* entity id */, int /* Status */> mEntityStatus;
     QList<QByteArray> mPropertyColumns;
     Sink::Query mQuery;
     std::function<void(const Ptr &)> loadEntities;
     typename Sink::ResultEmitter<Ptr>::Ptr mEmitter;
     async::ThreadBoundary threadBoundary;
+    QScopedPointer<Sink::Notifier> mNotifier;
 };
diff --git a/common/notification.cpp b/common/notification.cpp
index b399d50..806d04a 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -21,6 +21,6 @@
 
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Id: " << n.id << ", Type: " << n.type  << ", Code: " << n.code << ", Message: " << n.message << ")";
+    dbg << "Notification(Type: " << n.type << "Id, : " << n.id  << ", Code: " << n.code << ", Message: " << n.message << ", Entities: " << n.entities << ")";
     return dbg.space();
 }
diff --git a/common/notification.h b/common/notification.h
index 4b52274..f5379fd 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -51,6 +51,7 @@ public:
     };
 
     QByteArray id;
+    QByteArrayList entities;
     int type = 0;
     QString message;
     //A return code. Zero typically indicates success.
diff --git a/common/query.h b/common/query.h
index 49c8d5e..5b37cdd 100644
--- a/common/query.h
+++ b/common/query.h
@@ -300,7 +300,9 @@ public:
         /** Leave the query running and continuously update the result set. */
         LiveQuery = 1,
         /** Run the query synchronously. */
-        SynchronousQuery = 2
+        SynchronousQuery = 2,
+        /** Include status updates via notifications */
+        UpdateStatus = 4
     };
     Q_DECLARE_FLAGS(Flags, Flag)
 
@@ -410,6 +412,11 @@ public:
         mFlags = flags;
     }
 
+    Flags flags() const
+    {
+        return mFlags;
+    }
+
     bool liveQuery() const
     {
         return mFlags.testFlag(LiveQuery);
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index e48b624..9f4f14c 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -547,6 +547,7 @@ static Sink::Notification getNotification(const Sink::Commands::Notification *bu
     }
     n.type = buffer->type();
     n.code = buffer->code();
+    n.entities = BufferUtils::fromVector(*buffer->entities());
     return n;
 }
 
@@ -608,13 +609,17 @@ bool ResourceAccess::processMessageBuffer()
                     mResourceStatus = buffer->code();
                     SinkTrace() << "Updated status: " << mResourceStatus;
                     [[clang::fallthrough]];
+                case Sink::Notification::Info:
+                    [[clang::fallthrough]];
                 case Sink::Notification::Warning:
                     [[clang::fallthrough]];
+                case Sink::Notification::Error:
+                    [[clang::fallthrough]];
                 case Sink::Notification::FlushCompletion:
                     [[clang::fallthrough]];
                 case Sink::Notification::Progress: {
                     auto n = getNotification(buffer);
-                    SinkTrace() << "Received notification: Type:" << n.type  << "Message: " << n.message << "Code: " << n.code;
+                    SinkTrace() << "Received notification: " << n;
                     n.resource = d->resourceInstanceIdentifier;
                     emit notification(n);
                 } break;
diff --git a/common/store.h b/common/store.h
index 86e4d20..fae76e5 100644
--- a/common/store.h
+++ b/common/store.h
@@ -48,11 +48,15 @@ QString SINK_EXPORT storageLocation();
  */
 QString SINK_EXPORT getTemporaryFilePath();
 
+// Must be the same as in ModelResult
 enum Roles
 {
-    DomainObjectRole = Qt::UserRole + 1, // Must be the same as in ModelResult
+    DomainObjectRole = Qt::UserRole + 1,
     ChildrenFetchedRole,
-    DomainObjectBaseRole
+    DomainObjectBaseRole,
+    StatusRole, //ApplicationDomain::SyncStatus
+    WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+    ProgressRole //ApplicationDomain::Progress
 };
 
 /**
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index 4ed6e3a..ec896ed 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -292,13 +292,14 @@ void Synchronizer::flushComplete(const QByteArray &flushId)
     }
 }
 
-void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id)
+void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id, const QByteArrayList &entities)
 {
     Sink::Notification n;
     n.id = id;
     n.type = type;
     n.message = message;
     n.code = code;
+    n.entities = entities;
     emit notify(n);
 }
 
@@ -328,6 +329,7 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
         return KAsync::start([this, request] {
             SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
             emitNotification(Notification::Status, ApplicationDomain::BusyStatus, "Synchronization has started.", request.requestId);
+            emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, request.query.ids());
         }).then(synchronizeWithSource(request.query)).then([this] {
             //Commit after every request, so implementations only have to commit more if they add a lot of data.
             commit();
@@ -335,10 +337,12 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
             if (error) {
                 //Emit notification with error
                 SinkWarningCtx(mLogCtx) << "Synchronization failed: " << error.errorMessage;
+                emitNotification(Notification::Warning, ApplicationDomain::SyncError, {}, {}, request.query.ids());
                 emitNotification(Notification::Status, ApplicationDomain::ErrorStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::error(error);
             } else {
                 SinkLogCtx(mLogCtx) << "Done Synchronizing";
+                emitNotification(Notification::Info, ApplicationDomain::SyncSuccess, {}, {}, request.query.ids());
                 emitNotification(Notification::Status, ApplicationDomain::ConnectedStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::null();
             }
diff --git a/common/synchronizer.h b/common/synchronizer.h
index 28fe645..e3dbddc 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -180,7 +180,7 @@ protected:
      */
     virtual void mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue);
 
-    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{});
+    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{}, const QByteArrayList &entiteis = QByteArrayList{});
 
 protected:
     Sink::Log::Context mLogCtx;
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index e89edde..ece3440 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -69,6 +69,7 @@ class DummySynchronizer : public Sink::Synchronizer {
     Sink::ApplicationDomain::Mail::Ptr createMail(const QByteArray &ridBuffer, const QMap<QString, QVariant> &data)
     {
         auto mail = Sink::ApplicationDomain::Mail::Ptr::create();
+        mail->setExtractedMessageId(ridBuffer);
         mail->setExtractedSubject(data.value("subject").toString());
         mail->setExtractedSender(Sink::ApplicationDomain::Mail::Contact{data.value("senderName").toString(), data.value("senderEmail").toString()});
         mail->setExtractedDate(data.value("date").toDateTime());
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7144d41..fef76bd 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -44,6 +44,7 @@ auto_tests (
     testaccounttest
     dummyresourcemailtest
     interresourcemovetest
+    notificationtest
 )
 generate_flatbuffers(dummyresourcetest calendar)
 target_link_libraries(dummyresourcetest sink_resource_dummy)
@@ -52,3 +53,4 @@ target_link_libraries(dummyresourcewritebenchmark sink_resource_dummy)
 target_link_libraries(querytest sink_resource_dummy)
 target_link_libraries(modelinteractivitytest sink_resource_dummy)
 target_link_libraries(inspectiontest sink_resource_dummy)
+target_link_libraries(notificationtest sink_resource_dummy)
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index eea63c0..17df160 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -136,12 +136,7 @@ private slots:
     void testResourceSync()
     {
         ::DummyResource resource(getContext());
-        auto job = resource.synchronizeWithSource(Sink::QueryBase());
-        // TODO pass in optional timeout?
-        auto future = job.exec();
-        future.waitForFinished();
-        QVERIFY(!future.errorCode());
-        QVERIFY(future.isFinished());
+        VERIFYEXEC(resource.synchronizeWithSource(Sink::QueryBase()));
         QVERIFY(!resource.error());
         auto processAllMessagesFuture = resource.processAllMessages().exec();
         processAllMessagesFuture.waitForFinished();
@@ -152,7 +147,7 @@ private slots:
         const auto query = Query().resourceFilter("sink.dummy.instance1");
 
         // Ensure all local data is processed
-        Sink::Store::synchronize(query).exec().waitForFinished();
+        VERIFYEXEC(Sink::Store::synchronize(query));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
 
         auto model = Sink::Store::loadModel<Event>(query);
diff --git a/tests/notificationtest.cpp b/tests/notificationtest.cpp
new file mode 100644
index 0000000..9433586
--- /dev/null
+++ b/tests/notificationtest.cpp
@@ -0,0 +1,124 @@
+#include <QtTest>
+
+#include <QString>
+#include <QSignalSpy>
+
+#include "store.h"
+#include "resourceconfig.h"
+#include "resourcecontrol.h"
+#include "modelresult.h"
+#include "log.h"
+#include "test.h"
+#include "testutils.h"
+#include "notifier.h"
+#include "notification.h"
+
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
+
+/**
+ * Test of complete system using the dummy resource.
+ *
+ * This test requires the dummy resource installed.
+ */
+class NotificationTest : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase()
+    {
+        Sink::Test::initTest();
+        ResourceConfig::addResource("sink.dummy.instance1", "sink.dummy");
+    }
+
+    void cleanup()
+    {
+        VERIFYEXEC(Sink::Store::removeDataFromDisk(QByteArray("sink.dummy.instance1")));
+    }
+
+    void testSyncNotifications()
+    {
+        auto query = Query().resourceFilter("sink.dummy.instance1");
+        query.setType<ApplicationDomain::Mail>();
+        query.filter("id1");
+        query.filter("id2");
+
+        QList<Sink::Notification> statusNotifications;
+        QList<Sink::Notification> infoNotifications;
+        Sink::Notifier notifier("sink.dummy.instance1");
+        notifier.registerHandler([&] (const Sink::Notification &n){
+            SinkLogCtx(Sink::Log::Context{"dummyresourcetest"}) << "Received notification " << n;
+            if (n.type == Notification::Status) {
+                statusNotifications << n;
+            }
+            if (n.type == Notification::Info) {
+                infoNotifications << n;
+            }
+        });
+
+        // Ensure all local data is processed
+        VERIFYEXEC(Sink::Store::synchronize(query));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
+
+        //FIXME it can happen that we get a changereplay notification pair first.
+        QTRY_COMPARE(statusNotifications.size(), 5);
+        //Sync
+        QCOMPARE(statusNotifications.at(0).code, static_cast<int>(ApplicationDomain::Status::ConnectedStatus));
+        QCOMPARE(statusNotifications.at(1).code, static_cast<int>(Sink::ApplicationDomain::Status::BusyStatus));
+        QCOMPARE(statusNotifications.at(2).code, static_cast<int>(Sink::ApplicationDomain::Status::ConnectedStatus));
+        //Changereplay
+        QCOMPARE(statusNotifications.at(3).code, static_cast<int>(Sink::ApplicationDomain::Status::BusyStatus));
+        QCOMPARE(statusNotifications.at(4).code, static_cast<int>(Sink::ApplicationDomain::Status::ConnectedStatus));
+
+        QTRY_COMPARE(infoNotifications.size(), 2);
+        QCOMPARE(infoNotifications.at(0).code, static_cast<int>(ApplicationDomain::SyncStatus::SyncInProgress));
+        QCOMPARE(infoNotifications.at(0).entities, QList<QByteArray>{} << "id1" << "id2");
+        QCOMPARE(infoNotifications.at(1).code, static_cast<int>(ApplicationDomain::SyncStatus::SyncSuccess));
+        QCOMPARE(infoNotifications.at(1).entities, QList<QByteArray>{} << "id1" << "id2");
+
+        QCOMPARE(infoNotifications.at(1).code, static_cast<int>(ApplicationDomain::SyncStatus::SyncSuccess));
+    }
+
+    void testModelNotifications()
+    {
+        auto query = Query().resourceFilter("sink.dummy.instance1");
+        query.setType<ApplicationDomain::Mail>();
+        query.setFlags(Query::LiveQuery | Query::UpdateStatus);
+
+        VERIFYEXEC(Sink::Store::synchronize(query));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
+
+        auto model = Sink::Store::loadModel<Sink::ApplicationDomain::Mail>(query);
+        QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
+        QVERIFY(model->rowCount() >= 1);
+
+        QSignalSpy changedSpy(model.data(), &QAbstractItemModel::dataChanged);
+        auto mail = model->index(0, 0, QModelIndex()).data(Sink::Store::DomainObjectRole).value<Mail::Ptr>();
+        auto newQuery = query;
+        newQuery.filter(mail->identifier());
+
+        QList<int> status;
+        QObject::connect(model.data(), &QAbstractItemModel::dataChanged, [&] (const QModelIndex &begin, const QModelIndex &end, const QVector<int> &roles) {
+            QVERIFY(begin.row() == end.row());
+            if (begin.row() == 0) {
+                status << model->data(begin, Store::StatusRole).value<int>();
+                // qWarning() << "New status: " << status.last() << roles;
+            }
+        });
+
+        //This will trigger a modification of all previous items as well.
+        VERIFYEXEC(Sink::Store::synchronize(newQuery));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(QByteArrayList() << "sink.dummy.instance1"));
+
+        QCOMPARE(status.size(), 3);
+        //Sync progress of item
+        QCOMPARE(status.at(0), static_cast<int>(ApplicationDomain::SyncStatus::SyncInProgress));
+        QCOMPARE(status.at(1), static_cast<int>(ApplicationDomain::SyncStatus::SyncSuccess));
+        //Modification triggered during sync
+        QCOMPARE(status.at(2), static_cast<int>(ApplicationDomain::SyncStatus::SyncSuccess));
+    }
+};
+
+QTEST_MAIN(NotificationTest)
+#include "notificationtest.moc"