11 files changed, 184 insertions, 69 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 6f8fee3..3d3a2b7 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -32,6 +32,7 @@ set(command_SRCS
     storage_common.cpp
     threadboundary.cpp
     messagequeue.cpp
+    index.cpp
     ${storage_SRCS})
 
 add_library(${PROJECT_NAME} SHARED ${command_SRCS})
diff --git a/common/clientapi.h b/common/clientapi.h
index 546f210..659ae91 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -228,7 +228,7 @@ public:
     }
 
     virtual QVariant getProperty(const QString &key) const { return mAdaptor->getProperty(key); }
-    virtual void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); }
+    virtual void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
 
 private:
     QSharedPointer<BufferAdaptor> mAdaptor;
diff --git a/common/commands/modifyentity.fbs b/common/commands/modifyentity.fbs
index b4edb12..d26051e 100644
--- a/common/commands/modifyentity.fbs
+++ b/common/commands/modifyentity.fbs
@@ -3,9 +3,9 @@ namespace Akonadi2;
 table ModifyEntity {
     revision: ulong;
     entityId: string;
-    deletions: [string];
+    deletions: [string]; //A list of deleted properties
     domainType: string;
-    delta: [ubyte];
+    delta: [ubyte]; //Contains an entity buffer with all changed properties set
 }
 
 root_type ModifyEntity;
diff --git a/common/entitybuffer.cpp b/common/entitybuffer.cpp
index 4af84ef..5ba4afe 100644
--- a/common/entitybuffer.cpp
+++ b/common/entitybuffer.cpp
@@ -58,7 +58,6 @@ void EntityBuffer::extractResourceBuffer(void *dataValue, int dataSize, const st
 
 void EntityBuffer::assembleEntityBuffer(flatbuffers::FlatBufferBuilder &fbb, void const *metadataData, size_t metadataSize, void const *resourceData, size_t resourceSize, void const *localData, size_t localSize)
 {
-    qDebug() << "res size: " << resourceSize;
     auto metadata = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(metadataData), metadataSize);
     auto resource = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(resourceData), resourceSize);
     auto local = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(localData), localSize);
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 5f04db8..73a01ca 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -298,6 +298,7 @@ bool ResourceAccess::processMessageBuffer()
 {
     static const int headerSize = Commands::headerSize();
     if (d->partialMessageBuffer.size() < headerSize) {
+        qWarning() << "command too small";
         return false;
     }
 
@@ -306,6 +307,7 @@ bool ResourceAccess::processMessageBuffer()
     const uint size = *(int*)(d->partialMessageBuffer.constData() + sizeof(int) + sizeof(uint));
 
     if (size > (uint)(d->partialMessageBuffer.size() - headerSize)) {
+        qWarning() << "command too small";
         return false;
     }
 
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index bede6aa..b7fbfed 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -218,6 +218,11 @@ bool Storage::write(void const *keyPtr, size_t keySize, void const *valuePtr, si
         return false;
     }
 
+    if (!keyPtr || keySize == 0) {
+        std::cerr << "tried to write empty key." << std::endl;
+        return false;
+    }
+
     const bool implicitTransaction = !d->transaction || d->readTransaction;
     if (implicitTransaction) {
         if (!startTransaction()) {
diff --git a/dummyresource/domainadaptor.cpp b/dummyresource/domainadaptor.cpp
index ec5e2be..d902052 100644
--- a/dummyresource/domainadaptor.cpp
+++ b/dummyresource/domainadaptor.cpp
@@ -40,9 +40,10 @@ public:
     {
         if (mResourceBuffer && mResourceMapper->mReadAccessors.contains(key)) {
             return mResourceMapper->getProperty(key, mResourceBuffer);
-        } else if (mLocalBuffer) {
+        } else if (mLocalBuffer && mLocalMapper->mReadAccessors.contains(key)) {
             return mLocalMapper->getProperty(key, mLocalBuffer);
         }
+        qWarning() << "no mapping available for key " << key;
         return QVariant();
     }
 
@@ -67,14 +68,23 @@ DummyEventAdaptorFactory::DummyEventAdaptorFactory()
 {
     mResourceMapper = QSharedPointer<PropertyMapper<DummyEvent> >::create();
     mResourceMapper->mReadAccessors.insert("summary", [](DummyEvent const *buffer) -> QVariant {
-        return QString::fromStdString(buffer->summary()->c_str());
+        if (buffer->summary()) {
+            return QString::fromStdString(buffer->summary()->c_str());
+        }
+        return QVariant();
     });
     mLocalMapper = QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> >::create();
     mLocalMapper->mReadAccessors.insert("summary", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
-        return QString::fromStdString(buffer->summary()->c_str());
+        if (buffer->summary()) {
+            return QString::fromStdString(buffer->summary()->c_str());
+        }
+        return QVariant();
     });
     mLocalMapper->mReadAccessors.insert("uid", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
-        return QString::fromStdString(buffer->uid()->c_str());
+        if (buffer->uid()) {
+            return QString::fromStdString(buffer->uid()->c_str());
+        }
+        return QVariant();
     });
 
 }
@@ -94,7 +104,7 @@ QSharedPointer<Akonadi2::Domain::BufferAdaptor> DummyEventAdaptorFactory::create
     if (auto metadataData = entity.metadata()) {
         flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
         if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
-            metadataBuffer = Akonadi2::GetMetadata(metadataData);
+            metadataBuffer = Akonadi2::GetMetadata(metadataData->Data());
         }
     }
 
@@ -102,15 +112,15 @@ QSharedPointer<Akonadi2::Domain::BufferAdaptor> DummyEventAdaptorFactory::create
     if (auto localData = entity.local()) {
         flatbuffers::Verifier verifyer(localData->Data(), localData->size());
         if (Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
-            localBuffer = Akonadi2::Domain::Buffer::GetEvent(localData);
+            localBuffer = Akonadi2::Domain::Buffer::GetEvent(localData->Data());
         }
     }
 
     auto adaptor = QSharedPointer<DummyEventAdaptor>::create();
     adaptor->mLocalBuffer = localBuffer;
+    adaptor->mLocalMapper = mLocalMapper;
     adaptor->mResourceBuffer = resourceBuffer;
     adaptor->mResourceMapper = mResourceMapper;
-    adaptor->mLocalMapper = mLocalMapper;
     return adaptor;
 }
 
@@ -135,6 +145,6 @@ void DummyEventAdaptorFactory::createBuffer(const Akonadi2::Domain::Event &event
         Akonadi2::Domain::Buffer::FinishEventBuffer(localFbb, location);
     }
 
-    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, localFbb.GetBufferPointer(), localFbb.GetSize(), eventFbb.GetBufferPointer(), eventFbb.GetSize(), 0, 0);
+    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
 }
 
diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index cd930f6..1aaec68 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -31,6 +31,7 @@
 #include "createentity_generated.h"
 #include "domainadaptor.h"
 #include <common/entitybuffer.h>
+#include <common/index.h>
 
 using namespace DummyCalendar;
 using namespace flatbuffers;
@@ -73,11 +74,11 @@ Async::Job<void> DummyResourceFacade::remove(const Akonadi2::Domain::Event &doma
     return Async::null<void>();
 }
 
-static std::function<bool(const std::string &key, DummyEvent const *buffer)> prepareQuery(const Akonadi2::Query &query)
+static std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> prepareQuery(const Akonadi2::Query &query)
 {
     //Compose some functions to make query matching fast.
     //This way we can process the query once, and convert all values into something that can be compared quickly
-    std::function<bool(const std::string &key, DummyEvent const *buffer)> preparedQuery;
+    std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> preparedQuery;
     if (!query.ids.isEmpty()) {
         //Match by id
         //TODO: for id's a direct lookup would be way faster
@@ -88,15 +89,26 @@ static std::function<bool(const std::string &key, DummyEvent const *buffer)> pre
         for (const auto &id : query.ids) {
             ids << id.toStdString();
         }
-        preparedQuery = [ids](const std::string &key, DummyEvent const *buffer) {
+        preparedQuery = [ids](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
             if (ids.contains(key)) {
                 return true;
             }
             return false;
         };
+    } else if (!query.propertyFilter.isEmpty()) {
+        if (query.propertyFilter.contains("uid")) {
+            const QByteArray uid = query.propertyFilter.value("uid").toByteArray();
+            preparedQuery = [uid](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
+                if (local && local->uid() && (QByteArray::fromRawData(local->uid()->c_str(), local->uid()->size()) == uid)) {
+                    qDebug() << "uid match";
+                    return true;
+                }
+                return false;
+            };
+        }
     } else {
         //Match everything
-        preparedQuery = [](const std::string &key, DummyEvent const *buffer) {
+        preparedQuery = [](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
             return true;
         };
     }
@@ -121,65 +133,96 @@ Async::Job<void> DummyResourceFacade::synchronizeResource(bool sync)
     return Async::null<void>();
 }
 
-Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
+void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> preparedQuery)
 {
-    qDebug() << "load called";
+    storage->scan(key.data(), key.size(), [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
 
-    return synchronizeResource(query.syncOnDemand).then<void>([=](Async::Future<void> &future) {
-        qDebug() << "sync complete";
-        //Now that the sync is complete we can execute the query
-        const auto preparedQuery = prepareQuery(query);
-
-        auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
+        //Skip internals
+        if (QByteArray::fromRawData(static_cast<char*>(keyValue), keySize).startsWith("__internal")) {
+            return true;
+        }
 
-        qDebug() << "executing query";
-        //We start a transaction explicitly that we'll leave open so the values can be read.
-        //The transaction will be closed automatically once the storage object is destroyed.
-        storage->startTransaction(Akonadi2::Storage::ReadOnly);
-        //Because we have no indexes yet, we always do a full scan
-        storage->scan("", [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
+        //Extract buffers
+        Akonadi2::EntityBuffer buffer(dataValue, dataSize);
 
-            //Skip internals
-            if (QByteArray::fromRawData(static_cast<char*>(keyValue), keySize).startsWith("__internal")) {
-                return true;
+        DummyEvent const *resourceBuffer = 0;
+        if (auto resourceData = buffer.entity().resource()) {
+            flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
+            if (VerifyDummyEventBuffer(verifyer)) {
+                resourceBuffer = GetDummyEvent(resourceData->Data());
             }
+        }
 
-            //Extract buffers
-            Akonadi2::EntityBuffer buffer(dataValue, dataSize);
-
-            DummyEvent const *resourceBuffer = 0;
-            if (auto resourceData = buffer.entity().resource()) {
-                flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
-                if (VerifyDummyEventBuffer(verifyer)) {
-                    resourceBuffer = GetDummyEvent(resourceData);
-                }
+        Akonadi2::Domain::Buffer::Event const *localBuffer = 0;
+        if (auto localData = buffer.entity().local()) {
+            flatbuffers::Verifier verifyer(localData->Data(), localData->size());
+            if (Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
+                localBuffer = Akonadi2::Domain::Buffer::GetEvent(localData->Data());
             }
+        }
 
-            Akonadi2::Metadata const *metadataBuffer = 0;
-            if (auto metadataData = buffer.entity().metadata()) {
-                flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
-                if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
-                    metadataBuffer = Akonadi2::GetMetadata(metadataData);
-                }
+        Akonadi2::Metadata const *metadataBuffer = 0;
+        if (auto metadataData = buffer.entity().metadata()) {
+            flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
+            if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
+                metadataBuffer = Akonadi2::GetMetadata(metadataData->Data());
             }
+        }
 
-            if (!resourceBuffer || !metadataBuffer) {
-                qWarning() << "invalid buffer " << QString::fromStdString(std::string(static_cast<char*>(keyValue), keySize));
-                return true;
-            }
+        if (!resourceBuffer || !metadataBuffer) {
+            qWarning() << "invalid buffer " << QString::fromStdString(std::string(static_cast<char*>(keyValue), keySize));
+            return true;
+        }
+
+        //We probably only want to create all buffers after the scan
+        //TODO use adapter for query and scan?
+        if (preparedQuery && preparedQuery(std::string(static_cast<char*>(keyValue), keySize), resourceBuffer, localBuffer)) {
+            qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
+            //This only works for a 1:1 mapping of resource to domain types.
+            //Not i.e. for tags that are stored as flags in each entity of an imap store.
+            auto adaptor = mFactory->createAdaptor(buffer.entity());
+            //TODO only copy requested properties
+            auto memoryAdaptor = QSharedPointer<Akonadi2::Domain::MemoryBufferAdaptor>::create(*adaptor);
+            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
+            resultCallback(event);
+        }
+        return true;
+    },
+    [](const Akonadi2::Storage::Error &error) {
+        qDebug() << QString::fromStdString(error.message);
+    });
+}
+
+Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
+{
+    return synchronizeResource(query.syncOnDemand).then<void>([=](Async::Future<void> &future) {
+        //Now that the sync is complete we can execute the query
+        const auto preparedQuery = prepareQuery(query);
+
+        auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
 
-            //We probably only want to create all buffers after the scan
-            //TODO use adapter for query and scan?
-            if (preparedQuery && preparedQuery(std::string(static_cast<char*>(keyValue), keySize), resourceBuffer)) {
-                qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
-                auto adaptor = mFactory->createAdaptor(buffer.entity());
-                //TODO only copy requested properties
-                auto memoryAdaptor = QSharedPointer<Akonadi2::Domain::MemoryBufferAdaptor>::create(*adaptor);
-                auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
-                resultCallback(event);
+        QVector<QByteArray> keys;
+        if (query.propertyFilter.contains("uid")) {
+            static Index uidIndex(Akonadi2::Store::storageLocation(), "org.kde.dummy.index.uid", Akonadi2::Storage::ReadOnly);
+            uidIndex.lookup(query.propertyFilter.value("uid").toByteArray(), [&](const QByteArray &value) {
+                keys << value;
+            },
+            [](const Index::Error &error) {
+                qWarning() << "Error in index: " <<  QString::fromStdString(error.message);
+            });
+        }
+
+        //We start a transaction explicitly that we'll leave open so the values can be read.
+        //The transaction will be closed automatically once the storage object is destroyed.
+        storage->startTransaction(Akonadi2::Storage::ReadOnly);
+        if (keys.isEmpty()) {
+            qDebug() << "full scan";
+            readValue(storage, QByteArray(), resultCallback, preparedQuery);
+        } else {
+            for (const auto &key : keys) {
+                readValue(storage, key, resultCallback, preparedQuery);
             }
-            return true;
-        });
+        }
         future.setFinished();
     });
 }
diff --git a/dummyresource/facade.h b/dummyresource/facade.h
index da0b1d6..c9c8047 100644
--- a/dummyresource/facade.h
+++ b/dummyresource/facade.h
@@ -43,6 +43,7 @@ public:
     virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback);
 
 private:
+    void readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyCalendar::DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)>);
     Async::Job<void> synchronizeResource(bool sync);
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
     QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, DummyCalendar::DummyEvent> > mFactory;
diff --git a/dummyresource/resourcefactory.cpp b/dummyresource/resourcefactory.cpp
index 60a9cf6..18083cb 100644
--- a/dummyresource/resourcefactory.cpp
+++ b/dummyresource/resourcefactory.cpp
@@ -28,6 +28,7 @@
 #include "domainadaptor.h"
 #include "commands.h"
 #include "clientapi.h"
+#include "index.h"
 #include <QUuid>
 #include <assert.h>
 
@@ -261,8 +262,31 @@ void DummyResource::configurePipeline(Akonadi2::Pipeline *pipeline)
         auto adaptor = eventFactory->createAdaptor(entity);
         qDebug() << "Summary preprocessor: " << adaptor->getProperty("summary").toString();
     });
+
+    auto uidIndexer = new SimpleProcessor("uidIndexer", [eventFactory](const Akonadi2::PipelineState &state, const Akonadi2::Entity &entity) {
+        static Index uidIndex(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/akonadi2/storage", "org.kde.dummy.index.uid", Akonadi2::Storage::ReadWrite);
+
+        auto adaptor = eventFactory->createAdaptor(entity);
+        const auto uid = adaptor->getProperty("uid");
+        if (uid.isValid()) {
+            uidIndex.add(uid.toByteArray(), state.key());
+        }
+
+        //TODO would this be worthwhile for performance reasons?
+        // flatbuffers::Verifier verifyer(entity.local()->Data(), entity.local()->size());
+        // if (!Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
+        //     qWarning() << "invalid local buffer";
+        //     return;
+        // }
+        // auto localEvent = Akonadi2::Domain::Buffer::GetEvent(entity.local()->Data());
+        // if (localEvent && localEvent->uid()) {
+        //     qDebug() << "got uid: " << QByteArray::fromRawData(reinterpret_cast<const char *>(localEvent->uid()->Data()), localEvent->uid()->size());
+        //     uidIndex.add(QByteArray::fromRawData(reinterpret_cast<const char *>(localEvent->uid()->Data()), localEvent->uid()->size()), state.key());
+        // }
+    });
+
     //event is the entitytype and not the domain type
-    pipeline->setPreprocessors("event", Akonadi2::Pipeline::NewPipeline, QVector<Akonadi2::Preprocessor*>() << eventIndexer);
+    pipeline->setPreprocessors("event", Akonadi2::Pipeline::NewPipeline, QVector<Akonadi2::Preprocessor*>() << eventIndexer << uidIndexer);
     mProcessor = new Processor(pipeline, QList<MessageQueue*>() << &mUserQueue << &mSynchronizerQueue);
     QObject::connect(mProcessor, &Processor::error, [this](int errorCode, const QString &msg) { onProcessorError(errorCode, msg); });
 }
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index 56e5513..4e9d0a5 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -29,6 +29,7 @@ private Q_SLOTS:
         removeFromDisk("org.kde.dummy");
         removeFromDisk("org.kde.dummy.userqueue");
         removeFromDisk("org.kde.dummy.synchronizerqueue");
+        removeFromDisk("org.kde.dummy.index.uid");
     }
 
     void cleanup()
@@ -36,6 +37,7 @@ private Q_SLOTS:
         removeFromDisk("org.kde.dummy");
         removeFromDisk("org.kde.dummy.userqueue");
         removeFromDisk("org.kde.dummy.synchronizerqueue");
+        removeFromDisk("org.kde.dummy.index.uid");
     }
 
     void testProcessCommand()
@@ -50,8 +52,17 @@ private Q_SLOTS:
             Akonadi2::Domain::Buffer::FinishEventBuffer(eventFbb, eventLocation);
         }
 
+        flatbuffers::FlatBufferBuilder localFbb;
+        {
+            auto uid = localFbb.CreateString("testuid");
+            auto localBuilder = Akonadi2::Domain::Buffer::EventBuilder(localFbb);
+            localBuilder.add_uid(uid);
+            auto location = localBuilder.Finish();
+            Akonadi2::Domain::Buffer::FinishEventBuffer(localFbb, location);
+        }
+
         flatbuffers::FlatBufferBuilder entityFbb;
-        Akonadi2::EntityBuffer::assembleEntityBuffer(entityFbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), 0, 0);
+        Akonadi2::EntityBuffer::assembleEntityBuffer(entityFbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
 
         flatbuffers::FlatBufferBuilder fbb;
         auto type = fbb.CreateString(Akonadi2::Domain::getTypeName<Akonadi2::Domain::Event>().toStdString().data());
@@ -82,15 +93,34 @@ private Q_SLOTS:
         QCOMPARE(revisionSpy.count(), 2);
     }
 
-    void testWriteToFacade()
+    void testProperty()
+    {
+        Akonadi2::Domain::Event event;
+        event.setProperty("uid", "testuid");
+        QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
+    }
+
+    void testWriteToFacadeAndQueryByUid()
     {
-        Akonadi2::Query query;
         Akonadi2::Domain::Event event;
+        event.setProperty("uid", "testuid");
+        QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
         Akonadi2::Store::create<Akonadi2::Domain::Event>(event, "org.kde.dummy");
 
-        QTest::qWait(1000);
-        //TODO wait for success response
+        //TODO required to ensure all messages have been processed. The query should ensure this.
+        QTest::qWait(300);
+
+        Akonadi2::Query query;
+        query.resources << "org.kde.dummy";
+        query.syncOnDemand = false;
+
+        query.propertyFilter.insert("uid", "testuid");
+        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        result.exec();
+        QCOMPARE(result.size(), 1);
+        auto value = result.first();
+        QCOMPARE(value->getProperty("uid").toByteArray(), QByteArray("testuid"));
     }
 
     void testResourceSync()