1 files changed, 227 insertions, 32 deletions

diff --git a/examples/caldavresource/tests/caldavtest.cpp b/examples/caldavresource/tests/caldavtest.cpp
index 584e288..f9920d9 100644
--- a/examples/caldavresource/tests/caldavtest.cpp
+++ b/examples/caldavresource/tests/caldavtest.cpp
@@ -1,5 +1,14 @@
 #include <QtTest>
 
+#include <KDAV2/DavCollectionsFetchJob>
+#include <KDAV2/DavItemFetchJob>
+#include <KDAV2/DavItemModifyJob>
+#include <KDAV2/DavItemsListJob>
+#include <KDAV2/EtagCache>
+
+#include <KCalCore/Event>
+#include <KCalCore/ICalFormat>
+
 #include "../caldavresource.h"
 
 #include "common/resourcecontrol.h"
@@ -8,6 +17,8 @@
 #include "common/test.h"
 #include "tests/testutils.h"
 
+#include <algorithm>
+
 using Sink::ApplicationDomain::Calendar;
 using Sink::ApplicationDomain::DummyResource;
 using Sink::ApplicationDomain::Event;
@@ -17,19 +28,26 @@ class CalDavTest : public QObject
 {
     Q_OBJECT
 
+    // This test assumes a calendar MyCalendar with one event in it.
+
+    const QString baseUrl = "http://localhost/dav/calendars/users/doe";
+    const QString username = "doe";
+    const QString password = "doe";
+
     SinkResource createResource()
     {
         auto resource = Sink::ApplicationDomain::CalDavResource::create("account1");
-        resource.setProperty("server", "http://localhost/dav/calendars/users/doe");
-        resource.setProperty("username", "doe");
-        Sink::SecretStore::instance().insert(resource.identifier(), "doe");
+        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;
+
 private slots:
 
     void initTestCase()
@@ -51,34 +69,211 @@ private slots:
         VERIFYEXEC(Sink::ResourceControl::start(mResourceInstanceIdentifier));
     }
 
-    // void testSyncCal()
-    // {
-    //     VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-    //     // Check in the logs that it doesn't synchronize events again because same CTag
-    //     VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-    // }
-
-    // void testSyncCalEmpty()
-    // {
-    //     VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
-
-    //     auto eventJob =
-    //         Sink::Store::fetchAll<Event>(Sink::Query().request<Event::Uid>()).then([](const QList<Event::Ptr> &events) {
-    //             QCOMPARE(events.size(), 14);
-    //         });
-    //     VERIFYEXEC(eventJob);
-
-    //     auto calendarJob =
-    //         Sink::Store::fetchAll<Calendar>(Sink::Query().request<Calendar::Name>()).then([](const QList<Calendar::Ptr> &calendars) {
-    //             QCOMPARE(calendars.size(), 2);
-    //             for (const auto &calendar : calendars) {
-    //                 QVERIFY(calendar->getName() == "Calendar" || calendar->getName() == "Tasks");
-    //             }
-    //         });
-    //     VERIFYEXEC(calendarJob);
-
-    //     SinkLog() << "Finished";
-    // }
+    void testSyncCal()
+    {
+        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
+        // Check in the logs that it doesn't synchronize events again because same CTag
+        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
+    }
+
+    void testSyncCalEmpty()
+    {
+        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(), 1); });
+        VERIFYEXEC(eventJob);
+
+        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() == "MyCalendar");
+                                   }
+                               });
+        VERIFYEXEC(calendarJob);
+
+        SinkLog() << "Finished";
+    }
+
+    void testAddEvent()
+    {
+        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 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();
+        event->setUid(addedEventUid);
+
+        auto ical = KCalCore::ICalFormat().toICalString(event);
+        Event sinkEvent(mResourceInstanceIdentifier);
+        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(), 2);
+            });
+        VERIFYEXEC(verifyEventCountJob);
+
+        auto verifyEventJob =
+            Sink::Store::fetchOne<Event>(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid)))
+                .then([](const Event &event) { QCOMPARE(event.getSummary(), {"Hello"}); });
+        VERIFYEXEC(verifyEventJob);
+    }
+
+    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();
+
+        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 verifyEventCountJob = Sink::Store::fetchAll<Event>({}).then(
+            [](const QList<Event::Ptr> &events) { QCOMPARE(events.size(), 2); });
+        VERIFYEXEC(verifyEventCountJob);
+
+        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);
+    }
+
+    void testSneakyModifyEvent()
+    {
+        VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier)));
+        VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier));
+
+        // Change the item without sink's knowledge
+        {
+            qWarning() << 1;
+            auto collection = ([this]() -> KDAV2::DavCollection {
+                QUrl url(baseUrl);
+                url.setUserName(username);
+                url.setPassword(password);
+                KDAV2::DavUrl davurl(url, KDAV2::CalDav);
+                KDAV2::DavCollectionsFetchJob collectionsJob(davurl);
+                collectionsJob.exec();
+                Q_ASSERT(collectionsJob.error() == 0);
+                return collectionsJob.collections()[0];
+            })();
+
+            auto itemList = ([&collection]() -> KDAV2::DavItem::List {
+                auto cache = std::make_shared<KDAV2::EtagCache>();
+                KDAV2::DavItemsListJob itemsListJob(collection.url(), cache);
+                itemsListJob.exec();
+                Q_ASSERT(itemsListJob.error() == 0);
+                return itemsListJob.items();
+            })();
+            auto hollowDavItemIt =
+                std::find_if(itemList.begin(), itemList.end(), [this](const KDAV2::DavItem &item) {
+                    return item.url().url().path().endsWith(addedEventUid);
+                });
+
+            auto davitem = ([this, &collection, &hollowDavItemIt]() -> KDAV2::DavItem {
+                QString itemUrl = collection.url().url().toEncoded() + addedEventUid;
+                KDAV2::DavItemFetchJob itemFetchJob(*hollowDavItemIt);
+                itemFetchJob.exec();
+                Q_ASSERT(itemFetchJob.error() == 0);
+                return itemFetchJob.item();
+            })();
+
+            qWarning() << 3;
+            auto incidence = KCalCore::ICalFormat().readIncidence(davitem.data());
+            auto calevent = incidence.dynamicCast<KCalCore::Event>();
+            QVERIFY2(calevent, "Cannot convert to KCalCore event");
+
+            qWarning() << 4;
+            calevent->setSummary("Manual Hello World!");
+            auto newical = KCalCore::ICalFormat().toICalString(calevent);
+
+            qWarning() << 5;
+            davitem.setData(newical.toUtf8());
+            KDAV2::DavItemModifyJob itemModifyJob(davitem);
+            itemModifyJob.exec();
+            QVERIFY2(itemModifyJob.error() == 0, "Cannot modify item");
+
+            qWarning() << 6;
+        }
+
+        // Try to change the item with sink
+        {
+            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");
+
+            calevent->setSummary("Sink Hello World!");
+            auto dummy = QSharedPointer<KCalCore::Event>(calevent);
+            auto newical = KCalCore::ICalFormat().toICalString(dummy);
+
+            event.setIcal(newical.toUtf8());
+
+            // TODO: make that fail
+            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(), 1); });
+        VERIFYEXEC(verifyEventCountJob);
+    }
 };
 
 QTEST_MAIN(CalDavTest)