15 files changed, 349 insertions, 235 deletions

diff --git a/common/domain/typeimplementations.cpp b/common/domain/typeimplementations.cpp
index c74701d..6e14501 100644
--- a/common/domain/typeimplementations.cpp
+++ b/common/domain/typeimplementations.cpp
@@ -56,7 +56,8 @@ typedef IndexConfig<Folder,
     > FolderIndexConfig;
 
 typedef IndexConfig<Contact,
-        ValueIndex<Contact::Uid>
+        ValueIndex<Contact::Uid>,
+        ValueIndex<Contact::Addressbook>
     > ContactIndexConfig;
 
 typedef IndexConfig<Addressbook,
@@ -65,12 +66,14 @@ typedef IndexConfig<Addressbook,
 
 typedef IndexConfig<Event,
         ValueIndex<Event::Uid>,
+        ValueIndex<Event::Calendar>,
         SortedIndex<Event::StartTime>,
         SampledPeriodIndex<Event::StartTime, Event::EndTime>
     > EventIndexConfig;
 
 typedef IndexConfig<Todo,
-        ValueIndex<Todo::Uid>
+        ValueIndex<Todo::Uid>,
+        ValueIndex<Todo::Calendar>
     > TodoIndexConfig;
 
 typedef IndexConfig<Calendar,
diff --git a/common/log.cpp b/common/log.cpp
index 5156a23..e5ed29b 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -253,14 +253,22 @@ class DebugAreaCollector {
 public:
     DebugAreaCollector()
     {
-        QMutexLocker locker(&mutex);
-        mDebugAreas = debugAreasConfig()->value("areas").value<QString>().split(';').toSet();
+        //This call can potentially print a log message (if we fail to remove the qsettings lockfile), which would result in a deadlock if we locked over all of it.
+        const auto areas = debugAreasConfig()->value("areas").value<QString>().split(';').toSet();
+        {
+            QMutexLocker locker(&mutex);
+            mDebugAreas = areas;
+        }
     }
 
     ~DebugAreaCollector()
     {
-        QMutexLocker locker(&mutex);
-        mDebugAreas += debugAreasConfig()->value("areas").value<QString>().split(';').toSet();
+        //This call can potentially print a log message (if we fail to remove the qsettings lockfile), which would result in a deadlock if we locked over all of it.
+        const auto areas = debugAreasConfig()->value("areas").value<QString>().split(';').toSet();
+        {
+            QMutexLocker locker(&mutex);
+            mDebugAreas += areas;
+        }
         debugAreasConfig()->setValue("areas", QVariant::fromValue(mDebugAreas.toList().join(';')));
     }
 
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index c11f49c..daabf1f 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -458,7 +458,7 @@ QVector<Identifier> EntityStore::fullScan(const QByteArray &type)
                 const auto identifier = Sink::Storage::Identifier::fromDisplayByteArray(uid);
                 if (keys.contains(identifier)) {
                     //Not something that should persist if the replay works, so we keep a message for now.
-                    SinkTraceCtx(d->logCtx) << "Multiple revisions for key: " << key;
+                    SinkTraceCtx(d->logCtx) << "Multiple revisions for uid: " << Sink::Storage::Key::fromInternalByteArray(key) << ". This is normal if changereplay has not completed yet.";
                 }
                 keys << identifier;
                 return true;
diff --git a/examples/caldavresource/CMakeLists.txt b/examples/caldavresource/CMakeLists.txt
index d6e8408..00d1eb8 100644
--- a/examples/caldavresource/CMakeLists.txt
+++ b/examples/caldavresource/CMakeLists.txt
@@ -2,7 +2,7 @@ project(sink_resource_caldav)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KPimKDAV2 REQUIRED)
+find_package(KPimKDAV2 REQUIRED 0.2.0)
 find_package(KF5CalendarCore REQUIRED)
 
 add_library(${PROJECT_NAME} SHARED caldavresource.cpp)
diff --git a/examples/caldavresource/tests/caldavtest.cpp b/examples/caldavresource/tests/caldavtest.cpp
index daa890d..d62616f 100644
--- a/examples/caldavresource/tests/caldavtest.cpp
+++ b/examples/caldavresource/tests/caldavtest.cpp
@@ -1,8 +1,10 @@
 #include <QtTest>
 
 #include <KDAV2/DavCollectionsFetchJob>
+#include <KDAV2/DavCollectionCreateJob>
 #include <KDAV2/DavItemFetchJob>
 #include <KDAV2/DavItemModifyJob>
+#include <KDAV2/DavItemCreateJob>
 #include <KDAV2/DavItemsListJob>
 #include <KDAV2/EtagCache>
 
@@ -41,20 +43,82 @@ class CalDavTest : public QObject
         resource.setProperty("server", baseUrl);
         resource.setProperty("username", username);
         Sink::SecretStore::instance().insert(resource.identifier(), password);
-        resource.setProperty("testmode", true);
         return resource;
     }
 
     QByteArray mResourceInstanceIdentifier;
 
-    QString addedEventUid;
-    QString addedTodoUid;
+    QByteArray createEvent(const QString &subject, const QString &collectionName)
+    {
+        QUrl mainUrl{"http://localhost/dav/calendars/user/doe"};
+        mainUrl.setUserName(QStringLiteral("doe"));
+        mainUrl.setPassword(QStringLiteral("doe"));
+
+        KDAV2::DavUrl davUrl(mainUrl, KDAV2::CalDav);
+
+        auto *job = new KDAV2::DavCollectionsFetchJob(davUrl);
+        job->exec();
+
+        const auto collectionUrl = [&] {
+            for (const auto &col : job->collections()) {
+                // qWarning() << "Looking for " << collectionName << col.displayName();
+                if (col.displayName() == collectionName) {
+                    return col.url().url();
+                }
+            }
+            return QUrl{};
+        }();
+
+        QUrl url{collectionUrl.toString() + subject + ".ical"};
+        url.setUserInfo(mainUrl.userInfo());
+
+        KDAV2::DavUrl testItemUrl(url, KDAV2::CardDav);
+
+        auto event = QSharedPointer<KCalCore::Event>::create();
+        event->setSummary(subject);
+        event->setDtStart(QDateTime::currentDateTime());
+        event->setDtEnd(QDateTime::currentDateTime().addSecs(3600));
+        event->setCreated(QDateTime::currentDateTime());
+        event->setUid(subject);
+
+        auto data = KCalCore::ICalFormat().toICalString(event).toUtf8();
+
+        KDAV2::DavItem item(testItemUrl, QStringLiteral("text/calendar"), data, QString());
+        auto createJob = new KDAV2::DavItemCreateJob(item);
+        createJob->exec();
+        if (createJob->error()) {
+            qWarning() << createJob->errorString();
+        }
+        return event->uid().toUtf8();
+    }
+
+    void createCollection(const QString &name)
+    {
+        QUrl mainUrl(QStringLiteral("http://localhost/dav/calendars/user/doe/") + name);
+        mainUrl.setUserName(QStringLiteral("doe"));
+        mainUrl.setPassword(QStringLiteral("doe"));
+
+        KDAV2::DavUrl davUrl(mainUrl, KDAV2::CalDav);
+        KDAV2::DavCollection collection{davUrl, name, KDAV2::DavCollection::Events};
+
+        auto createJob = new KDAV2::DavCollectionCreateJob(collection);
+        createJob->exec();
+        if (createJob->error()) {
+            qWarning() << createJob->errorString();
+        }
+    }
+
+    void resetTestEnvironment()
+    {
+        system("resetmailbox.sh");
+    }
 
 private slots:
 
     void initTestCase()
     {
         Sink::Test::initTest();
+        resetTestEnvironment();
         auto resource = createResource();
         QVERIFY(!resource.identifier().isEmpty());
         VERIFYEXEC(Sink::Store::create(resource));
@@ -76,42 +140,73 @@ private slots:
         VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        auto eventJob = Sink::Store::fetchAll<Event>(Sink::Query().request<Event::Uid>())
-                            .then([](const QList<Event::Ptr> &events) { QCOMPARE(events.size(), 0); });
-        auto todoJob = Sink::Store::fetchAll<Todo>(Sink::Query().request<Todo::Uid>())
-                            .then([](const QList<Todo::Ptr> &todos) { QCOMPARE(todos.size(), 0); });
+        QCOMPARE(Sink::Store::read<Event>({}).size(), 0);
+        QCOMPARE(Sink::Store::read<Todo>({}).size(), 0);
+
+        const auto calendars = Sink::Store::read<Calendar>(Sink::Query().request<Calendar::Name>());
+        QCOMPARE(calendars.size(), 1);
+        QCOMPARE(calendars.first().getName(), {"personal"});
+    }
+
+    void testSyncCalendars()
+    {
+        createCollection("calendar2");
+
+        Sink::SyncScope scope;
+        scope.setType<Calendar>();
+        scope.resourceFilter(mResourceInstanceIdentifier);
+
+        VERIFYEXEC(Sink::Store::synchronize(scope));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+        const auto calendars = Sink::Store::read<Calendar>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+        QCOMPARE(calendars.size(), 2);
+    }
 
-        VERIFYEXEC(eventJob);
-        VERIFYEXEC(todoJob);
+    void testSyncEvents()
+    {
+        createEvent("event1", "personal");
+        createEvent("event2", "personal");
+        createEvent("event3", "calendar2");
+        Sink::SyncScope scope;
+        scope.setType<Event>();
+        scope.resourceFilter(mResourceInstanceIdentifier);
+
+        VERIFYEXEC(Sink::Store::synchronize(scope));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+        const auto events = Sink::Store::read<Event>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+        QCOMPARE(events.size(), 3);
 
-        auto calendarJob = Sink::Store::fetchAll<Calendar>(Sink::Query().request<Calendar::Name>())
-                               .then([](const QList<Calendar::Ptr> &calendars) {
-                                   QCOMPARE(calendars.size(), 1);
-                                   for (const auto &calendar : calendars) {
-                                       QVERIFY(calendar->getName() == "personal");
-                                   }
-                               });
-        VERIFYEXEC(calendarJob);
+        //Ensure a resync works
+        {
+            VERIFYEXEC(Sink::Store::synchronize(scope));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            const auto events = Sink::Store::read<Event>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+            QCOMPARE(events.size(), 3);
+        }
 
-        SinkLog() << "Finished";
+        //Ensure a resync after another creation works
+        createEvent("event4", "calendar2");
+        {
+            VERIFYEXEC(Sink::Store::synchronize(scope));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            const auto events = Sink::Store::read<Event>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+            QCOMPARE(events.size(), 4);
+        }
     }
 
-    void testAddEvent()
+    void testCreateModifyDeleteEvent()
     {
         VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        auto future = Sink::Store::fetchOne<Calendar>({}).exec();
-        future.waitForFinished();
-        QVERIFY2(!future.errorCode(), "Fetching Calendar failed");
-        auto calendar = future.value();
+        auto calendar = Sink::Store::readOne<Calendar>(Sink::Query{}.filter<Calendar::Name>("personal"));
 
         auto event = QSharedPointer<KCalCore::Event>::create();
         event->setSummary("Hello");
         event->setDtStart(QDateTime::currentDateTime());
         event->setDtEnd(QDateTime::currentDateTime().addSecs(3600));
         event->setCreated(QDateTime::currentDateTime());
-        addedEventUid = QUuid::createUuid().toString();
+        auto addedEventUid = QUuid::createUuid().toString();
         event->setUid(addedEventUid);
 
         auto ical = KCalCore::ICalFormat().toICalString(event);
@@ -119,37 +214,60 @@ private slots:
         sinkEvent.setIcal(ical.toUtf8());
         sinkEvent.setCalendar(calendar);
 
-        SinkLog() << "Adding event";
         VERIFYEXEC(Sink::Store::create(sinkEvent));
         VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
 
-        auto verifyEventCountJob =
-            Sink::Store::fetchAll<Event>(Sink::Query().request<Event::Uid>()).then([](const QList<Event::Ptr> &events) {
-                QCOMPARE(events.size(), 1);
-            });
-        VERIFYEXEC(verifyEventCountJob);
+        auto events = Sink::Store::read<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)));
+        QCOMPARE(events.size(), 1);
+        QCOMPARE(events.first().getSummary(), {"Hello"});
+
+        //Modify
+        {
+            auto event = events.first();
+            auto incidence = KCalCore::ICalFormat().readIncidence(event.getIcal());
+            auto calevent = incidence.dynamicCast<KCalCore::Event>();
+            QVERIFY2(calevent, "Cannot convert to KCalCore event");
+
+            calevent->setSummary("Hello World!");
+            auto dummy = QSharedPointer<KCalCore::Event>(calevent);
+            auto newical = KCalCore::ICalFormat().toICalString(dummy);
+
+            event.setIcal(newical.toUtf8());
+
+            VERIFYEXEC(Sink::Store::modify(event));
+
+            VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        auto verifyEventJob =
-            Sink::Store::fetchOne<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
-                .then([](const Event &event) { QCOMPARE(event.getSummary(), {"Hello"}); });
-        VERIFYEXEC(verifyEventJob);
+            auto events = Sink::Store::read<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)));
+            QCOMPARE(events.size(), 1);
+            QCOMPARE(events.first().getSummary(), {"Hello World!"});
+        }
+        //Delete
+        {
+            auto event = events.first();
+
+            VERIFYEXEC(Sink::Store::remove(event));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
+
+            auto events = Sink::Store::read<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)));
+            QCOMPARE(events.size(), 0);
+        }
     }
 
-    void testAddTodo()
+    void testCreateModifyDeleteTodo()
     {
         VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        auto job = Sink::Store::fetchOne<Calendar>({}).exec();
-        job.waitForFinished();
-        QVERIFY2(!job.errorCode(), "Fetching Calendar failed");
-        auto calendar = job.value();
+        auto calendar = Sink::Store::readOne<Calendar>(Sink::Query{}.filter<Calendar::Name>("personal"));
 
         auto todo = QSharedPointer<KCalCore::Todo>::create();
         todo->setSummary("Hello");
         todo->setDtStart(QDateTime::currentDateTime());
         todo->setCreated(QDateTime::currentDateTime());
-        addedTodoUid = QUuid::createUuid().toString();
+        auto addedTodoUid = QUuid::createUuid().toString();
         todo->setUid(addedTodoUid);
 
         auto ical = KCalCore::ICalFormat().toICalString(todo);
@@ -157,104 +275,74 @@ private slots:
         sinkTodo.setIcal(ical.toUtf8());
         sinkTodo.setCalendar(calendar);
 
-        SinkLog() << "Adding todo";
         VERIFYEXEC(Sink::Store::create(sinkTodo));
         VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
 
-        auto verifyTodoCountJob =
-            Sink::Store::fetchAll<Todo>(Sink::Query().request<Todo::Uid>()).then([](const QList<Todo::Ptr> &todos) {
-                QCOMPARE(todos.size(), 1);
-            });
-        VERIFYEXEC(verifyTodoCountJob);
+        auto todos = Sink::Store::read<Todo>(Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)));
+        QCOMPARE(todos.size(), 1);
+        QCOMPARE(todos.first().getSummary(), {"Hello"});
 
-        auto verifyTodoJob =
-            Sink::Store::fetchOne<Todo>(Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)))
-                .then([](const Todo &todo) { QCOMPARE(todo.getSummary(), {"Hello"}); });
-        VERIFYEXEC(verifyTodoJob);
-    }
-
-    void testModifyEvent()
-    {
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
-
-        auto job = Sink::Store::fetchOne<Event>(
-            Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
-                       .exec();
-        job.waitForFinished();
-        QVERIFY2(!job.errorCode(), "Fetching Event failed");
-        auto event = job.value();
+        //Modify
+        {
+            auto todo = todos.first();
+            auto incidence = KCalCore::ICalFormat().readIncidence(todo.getIcal());
+            auto caltodo = incidence.dynamicCast<KCalCore::Todo>();
+            QVERIFY2(caltodo, "Cannot convert to KCalCore todo");
 
-        auto incidence = KCalCore::ICalFormat().readIncidence(event.getIcal());
-        auto calevent = incidence.dynamicCast<KCalCore::Event>();
-        QVERIFY2(calevent, "Cannot convert to KCalCore event");
+            caltodo->setSummary("Hello World!");
+            auto dummy = QSharedPointer<KCalCore::Todo>(caltodo);
+            auto newical = KCalCore::ICalFormat().toICalString(dummy);
 
-        calevent->setSummary("Hello World!");
-        auto dummy = QSharedPointer<KCalCore::Event>(calevent);
-        auto newical = KCalCore::ICalFormat().toICalString(dummy);
+            todo.setIcal(newical.toUtf8());
 
-        event.setIcal(newical.toUtf8());
+            VERIFYEXEC(Sink::Store::modify(todo));
 
-        VERIFYEXEC(Sink::Store::modify(event));
+            VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            auto todos = Sink::Store::read<Todo>(Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)));
+            QCOMPARE(todos.size(), 1);
+            QCOMPARE(todos.first().getSummary(), {"Hello World!"});
+        }
+        //Delete
+        {
+            auto todo = todos.first();
 
-        auto verifyEventCountJob = Sink::Store::fetchAll<Event>({}).then(
-            [](const QList<Event::Ptr> &events) { QCOMPARE(events.size(), 1); });
-        VERIFYEXEC(verifyEventCountJob);
+            VERIFYEXEC(Sink::Store::remove(todo));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
 
-        auto verifyEventJob =
-            Sink::Store::fetchOne<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
-                .then([](const Event &event) { QCOMPARE(event.getSummary(), {"Hello World!"}); });
-        VERIFYEXEC(verifyEventJob);
+            auto todos = Sink::Store::read<Todo>(Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)));
+            QCOMPARE(todos.size(), 0);
+        }
     }
 
-    void testModifyTodo()
+    void testModificationConflict()
     {
         VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
 
-        auto job = Sink::Store::fetchOne<Todo>(
-            Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)))
-                       .exec();
-        job.waitForFinished();
-        QVERIFY2(!job.errorCode(), "Fetching Todo failed");
-        auto todo = job.value();
-
-        auto incidence = KCalCore::ICalFormat().readIncidence(todo.getIcal());
-        auto caltodo = incidence.dynamicCast<KCalCore::Todo>();
-        QVERIFY2(caltodo, "Cannot convert to KCalCore todo");
-
-        caltodo->setSummary("Hello World!");
-        auto dummy = QSharedPointer<KCalCore::Todo>(caltodo);
-        auto newical = KCalCore::ICalFormat().toICalString(dummy);
-
-        todo.setIcal(newical.toUtf8());
-
-        VERIFYEXEC(Sink::Store::modify(todo));
+        auto calendar = Sink::Store::readOne<Calendar>(Sink::Query{}.filter<Calendar::Name>("personal"));
 
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
-
-        auto verifyTodoCountJob = Sink::Store::fetchAll<Todo>({}).then(
-            [](const QList<Todo::Ptr> &todos) { QCOMPARE(todos.size(), 1); });
-        VERIFYEXEC(verifyTodoCountJob);
+        auto event = QSharedPointer<KCalCore::Event>::create();
+        event->setSummary("Hello");
+        event->setDtStart(QDateTime::currentDateTime());
+        event->setDtEnd(QDateTime::currentDateTime().addSecs(3600));
+        event->setCreated(QDateTime::currentDateTime());
+        auto addedEventUid = QUuid::createUuid().toString();
+        event->setUid(addedEventUid);
 
-        auto verifyTodoJob =
-            Sink::Store::fetchOne<Todo>(Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)))
-                .then([](const Todo &todo) { QCOMPARE(todo.getSummary(), {"Hello World!"}); });
-        VERIFYEXEC(verifyTodoJob);
-    }
+        auto ical = KCalCore::ICalFormat().toICalString(event);
+        Event sinkEvent(mResourceInstanceIdentifier);
+        sinkEvent.setIcal(ical.toUtf8());
+        sinkEvent.setCalendar(calendar);
 
-    void testSneakyModifyEvent()
-    {
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+        VERIFYEXEC(Sink::Store::create(sinkEvent));
+        VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
 
         // Change the item without sink's knowledge
         {
-            auto collection = ([this]() -> KDAV2::DavCollection {
+            auto collection = [&]() -> KDAV2::DavCollection {
                 QUrl url(baseUrl);
                 url.setUserName(username);
                 url.setPassword(password);
@@ -262,8 +350,13 @@ private slots:
                 auto collectionsJob = new KDAV2::DavCollectionsFetchJob(davurl);
                 collectionsJob->exec();
                 Q_ASSERT(collectionsJob->error() == 0);
-                return collectionsJob->collections()[0];
-            })();
+                for (const auto &col : collectionsJob->collections()) {
+                    if (col.displayName() == "personal") {
+                        return col;
+                    }
+                }
+                return {};
+            }();
 
             auto itemList = ([&collection]() -> KDAV2::DavItem::List {
                 auto cache = std::make_shared<KDAV2::EtagCache>();
@@ -273,12 +366,12 @@ private slots:
                 return itemsListJob->items();
             })();
             auto hollowDavItemIt =
-                std::find_if(itemList.begin(), itemList.end(), [this](const KDAV2::DavItem &item) {
+                std::find_if(itemList.begin(), itemList.end(), [&](const KDAV2::DavItem &item) {
                     return item.url().url().path().endsWith(addedEventUid);
                 });
             QVERIFY(hollowDavItemIt != itemList.end());
 
-            auto davitem = ([this, &collection, &hollowDavItemIt]() -> KDAV2::DavItem {
+            auto davitem = ([&]() -> KDAV2::DavItem {
                 QString itemUrl = collection.url().url().toEncoded() + addedEventUid;
                 auto itemFetchJob = new KDAV2::DavItemFetchJob (*hollowDavItemIt);
                 itemFetchJob->exec();
@@ -299,70 +392,22 @@ private slots:
             QVERIFY2(itemModifyJob->error() == 0, "Cannot modify item");
         }
 
-        // Try to change the item with sink
+        //Change the item with sink as well
         {
-            auto job = Sink::Store::fetchOne<Event>(
-                Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
-                           .exec();
-            job.waitForFinished();
-            QVERIFY2(!job.errorCode(), "Fetching Event failed");
-            auto event = job.value();
-
-            auto incidence = KCalCore::ICalFormat().readIncidence(event.getIcal());
-            auto calevent = incidence.dynamicCast<KCalCore::Event>();
-            QVERIFY2(calevent, "Cannot convert to KCalCore event");
+            auto event = Sink::Store::readOne<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)));
+            auto calevent = KCalCore::ICalFormat().readIncidence(event.getIcal()).dynamicCast<KCalCore::Event>();
+            QVERIFY(calevent);
 
             calevent->setSummary("Sink Hello World!");
-            auto dummy = QSharedPointer<KCalCore::Event>(calevent);
-            auto newical = KCalCore::ICalFormat().toICalString(dummy);
+            event.setIcal(KCalCore::ICalFormat().toICalString(calevent).toUtf8());
 
-            event.setIcal(newical.toUtf8());
-
-            // TODO: make that fail
+            // TODO: this produced a conflict, but we're not dealing with it in any way
             VERIFYEXEC(Sink::Store::modify(event));
             VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
         }
     }
 
-    void testRemoveEvent()
-    {
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
-
-        auto job = Sink::Store::fetchOne<Event>(
-            Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
-                       .exec();
-        job.waitForFinished();
-        QVERIFY2(!job.errorCode(), "Fetching Event failed");
-        auto event = job.value();
-
-        VERIFYEXEC(Sink::Store::remove(event));
-        VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
-
-        auto verifyEventCountJob = Sink::Store::fetchAll<Event>({}).then(
-            [](const QList<Event::Ptr> &events) { QCOMPARE(events.size(), 0); });
-        VERIFYEXEC(verifyEventCountJob);
-    }
-
-    void testRemoveTodo()
-    {
-        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
-
-        auto job = Sink::Store::fetchOne<Todo>(
-            Sink::Query().filter("uid", Sink::Query::Comparator(addedTodoUid)))
-                       .exec();
-        job.waitForFinished();
-        QVERIFY2(!job.errorCode(), "Fetching Todo failed");
-        auto todo = job.value();
 
-        VERIFYEXEC(Sink::Store::remove(todo));
-        VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier));
-
-        auto verifyTodoCountJob = Sink::Store::fetchAll<Todo>({}).then(
-            [](const QList<Todo::Ptr> &todos) { QCOMPARE(todos.size(), 0); });
-        VERIFYEXEC(verifyTodoCountJob);
-    }
 };
 
 QTEST_MAIN(CalDavTest)
diff --git a/examples/carddavresource/CMakeLists.txt b/examples/carddavresource/CMakeLists.txt
index 0632804..97208b1 100644
--- a/examples/carddavresource/CMakeLists.txt
+++ b/examples/carddavresource/CMakeLists.txt
@@ -2,7 +2,7 @@ project(sink_resource_carddav)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KPimKDAV2 REQUIRED)
+find_package(KPimKDAV2 REQUIRED 0.2.0)
 
 add_library(${PROJECT_NAME} SHARED carddavresource.cpp)
 target_link_libraries(${PROJECT_NAME} sink_webdav_common sink Qt5::Core Qt5::Network KPim::KDAV2)
diff --git a/examples/carddavresource/tests/carddavtest.cpp b/examples/carddavresource/tests/carddavtest.cpp
index b0f41d1..1d6762d 100644
--- a/examples/carddavresource/tests/carddavtest.cpp
+++ b/examples/carddavresource/tests/carddavtest.cpp
@@ -11,6 +11,7 @@
 #include <KDAV2/DavUrl>
 #include <KDAV2/DavItemCreateJob>
 #include <KDAV2/DavCollectionsFetchJob>
+#include <KDAV2/DavCollectionCreateJob>
 #include <KDAV2/DavCollection>
 #include <KContacts/Addressee>
 #include <KContacts/VCardConverter>
@@ -30,28 +31,28 @@ class CardDavTest : public QObject
         resource.setProperty("server", "http://localhost/dav/addressbooks/user/doe");
         resource.setProperty("username", "doe");
         Sink::SecretStore::instance().insert(resource.identifier(), "doe");
-        resource.setProperty("testmode", true);
         return resource;
     }
 
 
     QByteArray mResourceInstanceIdentifier;
 
-    void createContact(const QString &firstname, const QString &lastname)
+    void createContact(const QString &firstname, const QString &lastname, const QString &collectionName)
     {
         QUrl mainUrl(QStringLiteral("http://localhost/dav/addressbooks/user/doe"));
         mainUrl.setUserName(QStringLiteral("doe"));
         mainUrl.setPassword(QStringLiteral("doe"));
 
-
         KDAV2::DavUrl davUrl(mainUrl, KDAV2::CardDav);
 
         auto *job = new KDAV2::DavCollectionsFetchJob(davUrl);
         job->exec();
 
         const auto collectionUrl = [&] {
-            if (!job->collections().isEmpty()) {
-                return job->collections().first().url().url();
+            for (const auto &col : job->collections()) {
+                if (col.displayName() == collectionName) {
+                    return col.url().url();
+                }
             }
             return QUrl{};
         }();
@@ -69,11 +70,33 @@ class CardDavTest : public QObject
         }
     }
 
+    void createCollection(const QString &name)
+    {
+        QUrl mainUrl(QStringLiteral("http://localhost/dav/addressbooks/user/doe/") + name);
+        mainUrl.setUserName(QStringLiteral("doe"));
+        mainUrl.setPassword(QStringLiteral("doe"));
+
+        KDAV2::DavUrl davUrl(mainUrl, KDAV2::CardDav);
+        KDAV2::DavCollection collection{davUrl, name, KDAV2::DavCollection::Contacts};
+
+        auto createJob = new KDAV2::DavCollectionCreateJob(collection);
+        createJob->exec();
+        if (createJob->error()) {
+            qWarning() << createJob->errorString();
+        }
+    }
+
+    void resetTestEnvironment()
+    {
+        system("resetmailbox.sh");
+    }
+
 private slots:
 
     void initTestCase()
     {
         Sink::Test::initTest();
+        resetTestEnvironment();
         auto resource = createResource();
         QVERIFY(!resource.identifier().isEmpty());
         VERIFYEXEC(Sink::Store::create(resource));
@@ -90,10 +113,25 @@ private slots:
         VERIFYEXEC(Sink::ResourceControl::start(mResourceInstanceIdentifier));
     }
 
+    void testSyncAddressbooks()
+    {
+        createCollection("addressbook2");
+
+        Sink::SyncScope scope;
+        scope.setType<Addressbook>();
+        scope.resourceFilter(mResourceInstanceIdentifier);
+
+        VERIFYEXEC(Sink::Store::synchronize(scope));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+        const auto addressbooks = Sink::Store::read<Addressbook>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+        QCOMPARE(addressbooks.size(), 2);
+    }
+
     void testSyncContacts()
     {
-        createContact("john", "doe");
-        createContact("jane", "doe");
+        createContact("john", "doe", "personal");
+        createContact("jane", "doe", "personal");
+        createContact("fred", "durst", "addressbook2");
         Sink::SyncScope scope;
         scope.setType<Sink::ApplicationDomain::Contact>();
         scope.resourceFilter(mResourceInstanceIdentifier);
@@ -101,27 +139,24 @@ private slots:
         VERIFYEXEC(Sink::Store::synchronize(scope));
         VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
         const auto contacts = Sink::Store::read<Sink::ApplicationDomain::Contact>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
-        QCOMPARE(contacts.size(), 2);
+        QCOMPARE(contacts.size(), 3);
 
         //Ensure a resync works
         {
             VERIFYEXEC(Sink::Store::synchronize(scope));
             VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
             const auto contacts = Sink::Store::read<Sink::ApplicationDomain::Contact>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
-            QCOMPARE(contacts.size(), 2);
+            QCOMPARE(contacts.size(), 3);
         }
-    }
 
-    void testSyncAddressbooks()
-    {
-        Sink::SyncScope scope;
-        scope.setType<Addressbook>();
-        scope.resourceFilter(mResourceInstanceIdentifier);
-
-        VERIFYEXEC(Sink::Store::synchronize(scope));
-        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
-        const auto addressbooks = Sink::Store::read<Addressbook>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
-        QCOMPARE(addressbooks.size(), 1);
+        //Ensure a resync after another creation works
+        createContact("alf", "alf", "addressbook2");
+        {
+            VERIFYEXEC(Sink::Store::synchronize(scope));
+            VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+            const auto contacts = Sink::Store::read<Sink::ApplicationDomain::Contact>(Sink::Query().resourceFilter(mResourceInstanceIdentifier));
+            QCOMPARE(contacts.size(), 4);
+        }
     }
 
     void testAddContact()
diff --git a/examples/mailtransportresource/mailtransport.cpp b/examples/mailtransportresource/mailtransport.cpp
index ce24d7f..c455b7c 100644
--- a/examples/mailtransportresource/mailtransport.cpp
+++ b/examples/mailtransportresource/mailtransport.cpp
@@ -83,7 +83,7 @@ CurlVersionInfo getVersionInfo()
 bool sendMessageCurl(const char *to[], int numTos,
         const char *cc[], int numCcs,
         const char *msg,
-        bool useTls,
+        bool useStarttls,
         const char* from,
         const char *username, const char *password,
         const char *server, bool verifyPeer, const QByteArray &cacert, QByteArray &errorMessage,
@@ -107,7 +107,7 @@ bool sendMessageCurl(const char *to[], int numTos,
 
         curl_easy_setopt(curl, CURLOPT_URL, server);
 
-        if (useTls) {
+        if (useStarttls) {
             curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
         }
 
@@ -186,6 +186,7 @@ MailTransport::SendResult MailTransport::sendMessage(const KMime::Message::Ptr &
         ccList << mb.address();
     }
     const bool verifyPeer = options.testFlag(VerifyPeers);
+    const bool useStarttls = options.testFlag(UseStarttls);
     const bool useTls = options.testFlag(UseTls);
 
     const int numTos = toList.size();
@@ -199,12 +200,21 @@ MailTransport::SendResult MailTransport::sendMessage(const KMime::Message::Ptr &
     for (int i = 0; i < numCcs; i++) {
         cc[i] = ccList.at(i);
     }
-    //Because curl will fail with smtps, but it won't tell you why.
     auto serverAddress = server;
-    serverAddress.replace("smtps://", "smtp://");
+    if (serverAddress.startsWith("smtps://")) {
+        serverAddress = serverAddress.mid(8);
+    }
+    if (serverAddress.startsWith("smtp://")) {
+        serverAddress = serverAddress.mid(7);
+    }
+    if (useStarttls) {
+        serverAddress = "smtp://" + serverAddress;
+    } else if (useTls) {
+        serverAddress = "smtps://" + serverAddress;
+    }
 
     const auto versionInfo = getVersionInfo();
-    if (useTls && !versionInfo.supportsSsl) {
+    if ((useTls || useStarttls) && !versionInfo.supportsSsl) {
         qCWarning(mailtransportCategory) << "libcurl built without ssl support: " << versionInfo.info;
     }
 
@@ -212,7 +222,7 @@ MailTransport::SendResult MailTransport::sendMessage(const KMime::Message::Ptr &
     QByteArray errorMessage;
     auto ret = sendMessageCurl(to, numTos, cc, numCcs,
             message->encodedContent(),
-            useTls,
+            useStarttls,
             from.isEmpty() ? nullptr : from,
             username, password,
             serverAddress, verifyPeer, cacert,
diff --git a/examples/mailtransportresource/mailtransport.h b/examples/mailtransportresource/mailtransport.h
index 0fa5a66..0f53c2b 100644
--- a/examples/mailtransportresource/mailtransport.h
+++ b/examples/mailtransportresource/mailtransport.h
@@ -27,7 +27,8 @@ namespace MailTransport
 {
     enum Option {
         UseTls = 1,
-        VerifyPeers = 2
+        UseStarttls = 2,
+        VerifyPeers = 4
     };
     Q_DECLARE_FLAGS(Options, Option);
 
diff --git a/examples/mailtransportresource/mailtransportresource.cpp b/examples/mailtransportresource/mailtransportresource.cpp
index 10d94bc..9163d3b 100644
--- a/examples/mailtransportresource/mailtransportresource.cpp
+++ b/examples/mailtransportresource/mailtransportresource.cpp
@@ -127,7 +127,11 @@ public:
             } else {
                 MailTransport::Options options;
                 if (settings.server.contains("smtps")) {
-                    options |= MailTransport::UseTls;
+                    if (settings.server.contains("465")) {
+                        options |= MailTransport::UseTls;
+                    } else {
+                        options |= MailTransport::UseStarttls;
+                    }
                 }
 
                 SinkLog() << "Sending message " << settings.server << settings.username << "CaCert: " << settings.cacert << "Using tls: " << bool(options & MailTransport::UseTls);
diff --git a/examples/webdavcommon/CMakeLists.txt b/examples/webdavcommon/CMakeLists.txt
index c4e99f2..51bf151 100644
--- a/examples/webdavcommon/CMakeLists.txt
+++ b/examples/webdavcommon/CMakeLists.txt
@@ -2,7 +2,7 @@ project(sink_webdav_common)
 
 set(CMAKE_CXX_STANDARD 14)
 
-find_package(KPimKDAV2 REQUIRED)
+find_package(KPimKDAV2 REQUIRED 0.2.0)
 
 add_library(${PROJECT_NAME} STATIC webdav.cpp)
 target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network KPim::KDAV2 sink)
diff --git a/examples/webdavcommon/webdav.cpp b/examples/webdavcommon/webdav.cpp
index 904e1e2..0dfb6c0 100644
--- a/examples/webdavcommon/webdav.cpp
+++ b/examples/webdavcommon/webdav.cpp
@@ -89,11 +89,11 @@ static KAsync::Job<T> runJob(KJob *job, const std::function<T(KJob *)> &func)
 }
 
 WebDavSynchronizer::WebDavSynchronizer(const Sink::ResourceContext &context,
-    KDAV2::Protocol protocol, QByteArray collectionName, QByteArray itemName)
+    KDAV2::Protocol protocol, QByteArray mCollectionType, QByteArray mEntityType)
     : Sink::Synchronizer(context),
       protocol(protocol),
-      collectionName(std::move(collectionName)),
-      itemName(std::move(itemName))
+      mCollectionType(std::move(mCollectionType)),
+      mEntityType(std::move(mEntityType))
 {
     auto config = ResourceConfig::getConfiguration(context.instanceId());
 
@@ -111,15 +111,16 @@ QList<Sink::Synchronizer::SyncRequest> WebDavSynchronizer::getSyncRequests(const
         // We want to synchronize everything
 
         // Item synchronization does the collections anyway
-        // list << Synchronizer::SyncRequest{ Sink::QueryBase(collectionName) };
-        list << Synchronizer::SyncRequest{ Sink::QueryBase(itemName) };
+        // list << Synchronizer::SyncRequest{ Sink::QueryBase(mCollectionType) };
+        list << Synchronizer::SyncRequest{ Sink::QueryBase(mEntityType) };
     }
     return list;
 }
 
 KAsync::Job<void> WebDavSynchronizer::synchronizeWithSource(const Sink::QueryBase &query)
 {
-    if (query.type() != collectionName && query.type() != itemName) {
+    if (query.type() != mCollectionType && query.type() != mEntityType) {
+        SinkWarning() << "Received synchronization reuqest with unkown type" << query;
         return KAsync::null<void>();
     }
 
@@ -133,10 +134,10 @@ KAsync::Job<void> WebDavSynchronizer::synchronizeWithSource(const Sink::QueryBas
                        return collections;
                    });
 
-    if (query.type() == collectionName) {
+    if (query.type() == mCollectionType) {
         // Do nothing more
         return job;
-    } else if (query.type() == itemName) {
+    } else if (query.type() == mEntityType) {
         auto progress = QSharedPointer<int>::create(0);
         auto total = QSharedPointer<int>::create(0);
 
@@ -156,17 +157,24 @@ KAsync::Job<void> WebDavSynchronizer::synchronizeWithSource(const Sink::QueryBas
                     return KAsync::null<void>();
                 }
 
-                SinkTrace() << "Syncing collection:" << collectionResourceID;
+                SinkTrace() << "Syncing collection:" << collectionResourceID << collection.displayName();
                 auto itemsResourceIDs = QSharedPointer<QSet<QByteArray>>::create();
                 return synchronizeCollection(collection, progress, total, itemsResourceIDs)
                 .then([=] {
-                    scanForRemovals(itemName, [&itemsResourceIDs](const QByteArray &remoteId) {
-                        return itemsResourceIDs->contains(remoteId);
-                    });
+                    const auto collectionLocalId = collectionLocalResourceID(collection);
+                    scanForRemovals(mEntityType,
+                        [&](const std::function<void(const QByteArray &)> &callback) {
+                            //FIXME: The collection type just happens to have the same name as the parent collection property
+                            const auto collectionProperty = mCollectionType;
+                            store().indexLookup(mEntityType, collectionProperty, collectionLocalId, callback);
+                        },
+                        [&itemsResourceIDs](const QByteArray &remoteId) {
+                            return itemsResourceIDs->contains(remoteId);
+                        });
                 });
             })
             .then([=]() {
-                scanForRemovals(collectionName, [&collectionResourceIDs](const QByteArray &remoteId) {
+                scanForRemovals(mCollectionType, [&collectionResourceIDs](const QByteArray &remoteId) {
                     return collectionResourceIDs->contains(remoteId);
                 });
             });
diff --git a/examples/webdavcommon/webdav.h b/examples/webdavcommon/webdav.h
index 813da60..af6c47e 100644
--- a/examples/webdavcommon/webdav.h
+++ b/examples/webdavcommon/webdav.h
@@ -109,8 +109,8 @@ protected:
 
 private:
     KDAV2::Protocol protocol;
-    const QByteArray collectionName;
-    const QByteArray itemName;
+    const QByteArray mCollectionType;
+    const QByteArray mEntityType;
 
     QUrl mServer;
     QString mUsername;
diff --git a/tests/dbwriter.cpp b/tests/dbwriter.cpp
index 3045eac..a25faec 100644
--- a/tests/dbwriter.cpp
+++ b/tests/dbwriter.cpp
@@ -29,14 +29,14 @@ int main(int argc, char *argv[])
             qWarning() << "No valid transaction";
             return -1;
         }
-        transaction.openDatabase("a", nullptr, false).write(QByteArray::number(i), "a");
-        transaction.openDatabase("b", nullptr, false).write(QByteArray::number(i), "b");
-        transaction.openDatabase("c", nullptr, false).write(QByteArray::number(i), "c");
-        transaction.openDatabase("p", nullptr, false).write(QByteArray::number(i), "c");
-        transaction.openDatabase("q", nullptr, false).write(QByteArray::number(i), "c");
+        transaction.openDatabase("a", nullptr, 0).write(QByteArray::number(i), "a");
+        transaction.openDatabase("b", nullptr, 0).write(QByteArray::number(i), "b");
+        transaction.openDatabase("c", nullptr, 0).write(QByteArray::number(i), "c");
+        transaction.openDatabase("p", nullptr, 0).write(QByteArray::number(i), "c");
+        transaction.openDatabase("q", nullptr, 0).write(QByteArray::number(i), "c");
         if (i > (count/2)) {
             for (int d = 0; d < 40; d++) {
-                transaction.openDatabase("db" + QByteArray::number(d), nullptr, false).write(QByteArray::number(i), "a");
+                transaction.openDatabase("db" + QByteArray::number(d), nullptr, 0).write(QByteArray::number(i), "a");
             }
         }
         if ((i % 1000) == 0) {
diff --git a/tests/pipelinetest.cpp b/tests/pipelinetest.cpp
index 34ee3a5..801a9e0 100644
--- a/tests/pipelinetest.cpp
+++ b/tests/pipelinetest.cpp
@@ -32,10 +32,10 @@ static QList<Sink::Storage::Key> getKeys(const QByteArray &dbEnv, const QByteArr
 {
     Sink::Storage::DataStore store(Sink::storageLocation(), dbEnv, Sink::Storage::DataStore::ReadOnly);
     auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
-    auto db = transaction.openDatabase(name, nullptr, false);
+    auto db = transaction.openDatabase(name, nullptr, Sink::Storage::IntegerKeys);
     QList<Sink::Storage::Key> result;
     db.scan("", [&](const QByteArray &key, const QByteArray &value) {
-        size_t revision = Sink::byteArrayToSizeT(value);
+        size_t revision = Sink::byteArrayToSizeT(key);
         result << Sink::Storage::Key(Sink::Storage::Identifier::fromDisplayByteArray(
                                          Sink::Storage::DataStore::getUidFromRevision(transaction, revision)),
             revision);
@@ -48,7 +48,7 @@ static QByteArray getEntity(const QByteArray &dbEnv, const QByteArray &name, con
 {
     Sink::Storage::DataStore store(Sink::storageLocation(), dbEnv, Sink::Storage::DataStore::ReadOnly);
     auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
-    auto db = transaction.openDatabase(name, nullptr, false);
+    auto db = transaction.openDatabase(name, nullptr, Sink::Storage::IntegerKeys);
     QByteArray result;
     db.scan(key.revision().toSizeT(), [&](size_t rev, const QByteArray &value) {
         result = value;