File indexing completed on 2024-11-10 04:40:10

 /*
     SPDX-FileCopyrightText: 2009 Stephen Kelly <steveire@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "qtest_akonadi.h"
 
 #include "entitydisplayattribute.h"
 #include "entitytreemodel.h"
 #include "entitytreemodel_p.h"
 #include "fakemonitor.h"
 #include "fakeserverdata.h"
 #include "fakesession.h"
 #include "imapparser_p.h"
 #include "modelspy.h"
 
 static const char serverContent1[] =
     // The format of these lines are first a type, either 'C' or 'I' for Item and collection.
     // The dashes show the depth in the hierarchy
     // Collections have a list of mimetypes they can contain, followed by an optional
     // displayName which is put into the EntityDisplayAttribute, followed by an optional order
     // which is the order in which the collections are returned from the job to the ETM.
 
     "- C (inode/directory)                  'Col 1'     4"
     "- - C (text/directory, message/rfc822) 'Col 2'     3"
     // Items just have the mimetype they contain in the payload.
     "- - - I text/directory                 'Item 1'"
     "- - - I text/directory                 'Item 2'"
     "- - - I message/rfc822                 'Item 3'"
     "- - - I message/rfc822                 'Item 4'"
     "- - C (text/directory)                 'Col 3'     3"
     "- - - C (text/directory)               'Col 4'     2"
     "- - - - C (text/directory)             'Col 5'     1" // <-- First collection to be returned
     "- - - - - I text/directory             'Item 5'"
     "- - - - - I text/directory             'Item 6'"
     "- - - - I text/directory               'Item 7'"
     "- - - I text/directory                 'Item 8'"
     "- - - I text/directory                 'Item 9'"
     "- - C (message/rfc822)                 'Col 6'     3"
     "- - - I message/rfc822                 'Item 10'"
     "- - - I message/rfc822                 'Item 11'"
     "- - C (text/directory, message/rfc822) 'Col 7'     3"
     "- - - I text/directory                 'Item 12'"
     "- - - I text/directory                 'Item 13'"
     "- - - I message/rfc822                 'Item 14'"
     "- - - I message/rfc822                 'Item 15'";
 
 /**
  * This test verifies that the ETM reacts as expected to signals from the monitor.
  *
  * The tested ETM is only talking to fake components so the reaction of the ETM to each signal can be tested.
  *
  * WARNING: This test does no handle jobs issued by the model. It simply shortcuts (calls emitResult) them, and the connected
  * slots are never executed (because the eventloop is not run after emitResult is called).
  * This test therefore only tests the reaction of the model to signals of the monitor and not the overall behaviour.
  */
 class EntityTreeModelTest : public QObject
 {
     Q_OBJECT
 
 public:
     EntityTreeModelTest()
     {
         QHashSeed::setDeterministicGlobalSeed();
     }
 
 private Q_SLOTS:
     void initTestCase();
     void cleanupTestCase();
 
     void testInitialFetch();
     void testCollectionMove_data();
     void testCollectionMove();
     void testCollectionAdded_data();
     void testCollectionAdded();
     void testCollectionRemoved_data();
     void testCollectionRemoved();
     void testCollectionChanged_data();
     void testCollectionChanged();
     void testItemMove_data();
     void testItemMove();
     void testItemAdded_data();
     void testItemAdded();
     void testItemRemoved_data();
     void testItemRemoved();
     void testItemChanged_data();
     void testItemChanged();
     void testRemoveCollectionOnChanged();
 
 private:
     QPair<FakeServerData *, Akonadi::EntityTreeModel *> populateModel(const QString &serverContent, const QString &mimeType = QString())
     {
         auto const fakeMonitor = new FakeMonitor(this);
 
         fakeMonitor->setSession(m_fakeSession);
         fakeMonitor->setCollectionMonitored(Collection::root());
         if (!mimeType.isEmpty()) {
             fakeMonitor->setMimeTypeMonitored(mimeType);
         }
         auto const model = new EntityTreeModel(fakeMonitor, this);
 
         m_modelSpy = new ModelSpy{model, this};
 
         auto const serverData = new FakeServerData(model, m_fakeSession, fakeMonitor, this);
         serverData->setCommands(FakeJobResponse::interpret(serverData, serverContent));
 
         // Give the model a chance to populate
         QTest::qWait(100);
         return qMakePair(serverData, model);
     }
 
 private:
     ModelSpy *m_modelSpy = nullptr;
     FakeSession *m_fakeSession = nullptr;
     QByteArray m_sessionName;
 };
 
 QModelIndex firstMatchedIndex(const QAbstractItemModel &model, const QString &pattern)
 {
     if (pattern.isEmpty()) {
         return {};
     }
     const auto list = model.match(model.index(0, 0), Qt::DisplayRole, pattern, 1, Qt::MatchRecursive);
     Q_ASSERT(!list.isEmpty());
     return list.first();
 }
 
 void EntityTreeModelTest::initTestCase()
 {
     m_sessionName = "EntityTreeModelTest fake session";
     m_fakeSession = new FakeSession(m_sessionName, FakeSession::EndJobsImmediately);
     m_fakeSession->setAsDefaultSession();
 
     qRegisterMetaType<QModelIndex>("QModelIndex");
 }
 
 void EntityTreeModelTest::cleanupTestCase()
 {
     delete m_fakeSession;
 }
 
 void EntityTreeModelTest::testInitialFetch()
 {
     auto const fakeMonitor = new FakeMonitor(this);
 
     fakeMonitor->setSession(m_fakeSession);
     fakeMonitor->setCollectionMonitored(Collection::root());
     auto const model = new EntityTreeModel(fakeMonitor, this);
 
     auto const serverData = new FakeServerData(model, m_fakeSession, fakeMonitor, this);
     serverData->setCommands(FakeJobResponse::interpret(serverData, QString::fromLatin1(serverContent1)));
 
     m_modelSpy = new ModelSpy(model, this);
     m_modelSpy->startSpying();
 
     const QList<ExpectedSignal> expectedSignals{// First the model gets a signal about the first collection to be returned, which is not a top-level collection.
                                                 // It uses the parentCollection hierarchy to put placeholder collections in the model until the root is reached.
                                                 // Then it inserts only one row and emits the correct signals. After that, when the other collections
                                                 // arrive, dataChanged is emitted for them.
                                                 {RowsAboutToBeInserted, 0, 0},
                                                 {RowsInserted, 0, 0},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 4")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 3")}},
                                                 // New collections are prepended
                                                 {RowsAboutToBeInserted, 0, 0, QStringLiteral("Col 1")},
                                                 {RowsInserted, 0, 0, QStringLiteral("Col 1"), QVariantList{QStringLiteral("Col 2")}},
                                                 {RowsAboutToBeInserted, 0, 0, QStringLiteral("Col 1")},
                                                 {RowsInserted, 0, 0, QStringLiteral("Col 1"), QVariantList{QStringLiteral("Col 6")}},
                                                 {RowsAboutToBeInserted, 0, 0, QStringLiteral("Col 1")},
                                                 {RowsInserted, 0, 0, QStringLiteral("Col 1"), QVariantList{QStringLiteral("Col 7")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 1")}},
                                                 // The items in the collections are appended.
                                                 {RowsAboutToBeInserted, 0, 3, QStringLiteral("Col 2")},
                                                 {RowsInserted, 0, 3, QStringLiteral("Col 2")},
                                                 {RowsAboutToBeInserted, 0, 1, QStringLiteral("Col 5")},
                                                 {RowsInserted, 0, 1, QStringLiteral("Col 5")},
                                                 {RowsAboutToBeInserted, 1, 1, QStringLiteral("Col 4")},
                                                 {RowsInserted, 1, 1, QStringLiteral("Col 4")},
                                                 {RowsAboutToBeInserted, 1, 2, QStringLiteral("Col 3")},
                                                 {RowsInserted, 1, 2, QStringLiteral("Col 3")},
                                                 {RowsAboutToBeInserted, 0, 1, QStringLiteral("Col 6")},
                                                 {RowsInserted, 0, 1, QStringLiteral("Col 6")},
                                                 {RowsAboutToBeInserted, 0, 3, QStringLiteral("Col 7")},
                                                 {RowsInserted, 0, 3, QStringLiteral("Col 7")},
                                                 {DataChanged, 3, 3, QVariantList{QStringLiteral("Col 3")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 1")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 5")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 4")}},
                                                 {DataChanged, 2, 2, QVariantList{QStringLiteral("Col 2")}},
                                                 {DataChanged, 1, 1, QVariantList{QStringLiteral("Col 7")}},
                                                 {DataChanged, 0, 0, QVariantList{QStringLiteral("Col 6")}}};
     m_modelSpy->setExpectedSignals(expectedSignals);
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(10);
 
     // We get all the signals we expected.
     QTRY_VERIFY(m_modelSpy->expectedSignals().isEmpty());
 
     QTest::qWait(10);
     // We didn't get signals we didn't expect.
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testCollectionMove_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("movedCollection");
     QTest::addColumn<QString>("targetCollection");
 
     QTest::newRow("move-collection01") << serverContent1 << "Col 5"
                                        << "Col 1";
     QTest::newRow("move-collection02") << serverContent1 << "Col 5"
                                        << "Col 2";
     QTest::newRow("move-collection03") << serverContent1 << "Col 5"
                                        << "Col 3";
     QTest::newRow("move-collection04") << serverContent1 << "Col 5"
                                        << "Col 6";
     QTest::newRow("move-collection05") << serverContent1 << "Col 5"
                                        << "Col 7";
     QTest::newRow("move-collection06") << serverContent1 << "Col 3"
                                        << "Col 2";
     QTest::newRow("move-collection07") << serverContent1 << "Col 3"
                                        << "Col 6";
     QTest::newRow("move-collection08") << serverContent1 << "Col 3"
                                        << "Col 7";
     QTest::newRow("move-collection09") << serverContent1 << "Col 7"
                                        << "Col 2";
     QTest::newRow("move-collection10") << serverContent1 << "Col 7"
                                        << "Col 5";
     QTest::newRow("move-collection11") << serverContent1 << "Col 7"
                                        << "Col 4";
     QTest::newRow("move-collection12") << serverContent1 << "Col 7"
                                        << "Col 3";
 }
 
 void EntityTreeModelTest::testCollectionMove()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, movedCollection);
     QFETCH(QString, targetCollection);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto movedIndex = firstMatchedIndex(*model, movedCollection);
     Q_ASSERT(movedIndex.isValid());
     const auto sourceCollection = movedIndex.parent().data().toString();
     const auto sourceRow = movedIndex.row();
 
     auto const moveCommand = new FakeCollectionMovedCommand(movedCollection, sourceCollection, targetCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({moveCommand});
 
     const QList<ExpectedSignal> expectedSignals{{RowsAboutToBeMoved, sourceRow, sourceRow, sourceCollection, 0, targetCollection, {movedCollection}},
                                                 {RowsMoved, sourceRow, sourceRow, sourceCollection, 0, targetCollection, {movedCollection}}};
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a change to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testCollectionAdded_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("addedCollection");
     QTest::addColumn<QString>("parentCollection");
 
     QTest::newRow("add-collection01") << serverContent1 << "new Collection"
                                       << "Col 1";
     QTest::newRow("add-collection02") << serverContent1 << "new Collection"
                                       << "Col 2";
     QTest::newRow("add-collection03") << serverContent1 << "new Collection"
                                       << "Col 3";
     QTest::newRow("add-collection04") << serverContent1 << "new Collection"
                                       << "Col 4";
     QTest::newRow("add-collection05") << serverContent1 << "new Collection"
                                       << "Col 5";
     QTest::newRow("add-collection06") << serverContent1 << "new Collection"
                                       << "Col 6";
     QTest::newRow("add-collection07") << serverContent1 << "new Collection"
                                       << "Col 7";
 }
 
 void EntityTreeModelTest::testCollectionAdded()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, addedCollection);
     QFETCH(QString, parentCollection);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
 
     auto const addCommand = new FakeCollectionAddedCommand(addedCollection, parentCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({addCommand});
 
     const QList<ExpectedSignal> expectedSignals{
         {RowsAboutToBeInserted, 0, 0, parentCollection, QVariantList{addedCollection}},
         {RowsInserted, 0, 0, parentCollection, QVariantList{addedCollection}},
         // The data changed signal comes from the item fetch job that is triggered because we have ImmediatePopulation enabled
         {DataChanged, 0, 0, parentCollection, QVariantList{addedCollection}}};
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testCollectionRemoved_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("removedCollection");
 
     // The test suite doesn't handle this case yet.
     //   QTest::newRow("remove-collection01") << serverContent1 << "Col 1";
     QTest::newRow("remove-collection02") << serverContent1 << "Col 2";
     QTest::newRow("remove-collection03") << serverContent1 << "Col 3";
     QTest::newRow("remove-collection04") << serverContent1 << "Col 4";
     QTest::newRow("remove-collection05") << serverContent1 << "Col 5";
     QTest::newRow("remove-collection06") << serverContent1 << "Col 6";
     QTest::newRow("remove-collection07") << serverContent1 << "Col 7";
 }
 
 void EntityTreeModelTest::testCollectionRemoved()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, removedCollection);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto removedIndex = firstMatchedIndex(*model, removedCollection);
     const auto parentCollection = removedIndex.parent().data().toString();
     const auto sourceRow = removedIndex.row();
 
     auto const removeCommand = new FakeCollectionRemovedCommand(removedCollection, parentCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({removeCommand});
 
     const QList<ExpectedSignal> expectedSignals{{RowsAboutToBeRemoved, sourceRow, sourceRow, parentCollection, QVariantList{removedCollection}},
                                                 {RowsRemoved, sourceRow, sourceRow, parentCollection, QVariantList{removedCollection}}};
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testCollectionChanged_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("collectionName");
     QTest::addColumn<QString>("monitoredMimeType");
 
     QTest::newRow("change-collection01") << serverContent1 << "Col 1" << QString();
     QTest::newRow("change-collection02") << serverContent1 << "Col 2" << QString();
     QTest::newRow("change-collection03") << serverContent1 << "Col 3" << QString();
     QTest::newRow("change-collection04") << serverContent1 << "Col 4" << QString();
     QTest::newRow("change-collection05") << serverContent1 << "Col 5" << QString();
     QTest::newRow("change-collection06") << serverContent1 << "Col 6" << QString();
     QTest::newRow("change-collection07") << serverContent1 << "Col 7" << QString();
     // Don't remove the parent due to a missing mimetype
     QTest::newRow("change-collection08") << serverContent1 << "Col 1" << QStringLiteral("message/rfc822");
 }
 
 void EntityTreeModelTest::testCollectionChanged()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, collectionName);
     QFETCH(QString, monitoredMimeType); // ##### TODO: this is unused. Is this test correct?
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto changedIndex = firstMatchedIndex(*model, collectionName);
     const auto parentCollection = changedIndex.parent().data().toString();
     qDebug() << parentCollection;
     const auto changedRow = changedIndex.row();
 
     auto const changeCommand = new FakeCollectionChangedCommand(collectionName, parentCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({changeCommand});
 
     const QList<ExpectedSignal> expectedSignals{{DataChanged, changedRow, changedRow, parentCollection, QVariantList{collectionName}}};
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testItemMove_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("movedItem");
     QTest::addColumn<QString>("targetCollection");
 
     QTest::newRow("move-item01") << serverContent1 << "Item 1"
                                  << "Col 7";
     QTest::newRow("move-item02") << serverContent1 << "Item 5"
                                  << "Col 4"; // Move item to grandparent.
     QTest::newRow("move-item03") << serverContent1 << "Item 7"
                                  << "Col 5"; // Move item to sibling.
     QTest::newRow("move-item04") << serverContent1 << "Item 8"
                                  << "Col 5"; // Move item to nephew
     QTest::newRow("move-item05") << serverContent1 << "Item 8"
                                  << "Col 6"; // Move item to uncle
     QTest::newRow("move-item02") << serverContent1 << "Item 5"
                                  << "Col 3"; // Move item to great-grandparent.
 }
 
 void EntityTreeModelTest::testItemMove()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, movedItem);
     QFETCH(QString, targetCollection);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto movedIndex = firstMatchedIndex(*model, movedItem);
     const auto sourceCollection = movedIndex.parent().data().toString();
     const auto sourceRow = movedIndex.row();
 
     const auto targetIndex = firstMatchedIndex(*model, targetCollection);
     const auto targetRow = model->rowCount(targetIndex);
 
     auto const moveCommand = new FakeItemMovedCommand(movedItem, sourceCollection, targetCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({moveCommand});
 
     const QList<ExpectedSignal> expectedSignals{
         // Currently moves are implemented as remove + insert in the ETM.
         {RowsAboutToBeRemoved, sourceRow, sourceRow, sourceCollection, QVariantList{movedItem}},
         {RowsRemoved, sourceRow, sourceRow, sourceCollection, QVariantList{movedItem}},
         {RowsAboutToBeInserted, targetRow, targetRow, targetCollection, QVariantList{movedItem}},
         {RowsInserted, targetRow, targetRow, targetCollection, QVariantList{movedItem}},
         // {RowsAboutToBeMoved, sourceRow, sourceRow, sourceCollection, targetRow, targetCollection, QVariantList{movedItem}},
         // {RowsMoved, sourceRow, sourceRow, sourceCollection, targetRow, targetCollection, QVariantList{movedItem}},
     };
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testItemAdded_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("addedItem");
     QTest::addColumn<QString>("parentCollection");
 
     QTest::newRow("add-item01") << serverContent1 << "new Item"
                                 << "Col 1";
     QTest::newRow("add-item02") << serverContent1 << "new Item"
                                 << "Col 2";
     QTest::newRow("add-item03") << serverContent1 << "new Item"
                                 << "Col 3";
     QTest::newRow("add-item04") << serverContent1 << "new Item"
                                 << "Col 4";
     QTest::newRow("add-item05") << serverContent1 << "new Item"
                                 << "Col 5";
     QTest::newRow("add-item06") << serverContent1 << "new Item"
                                 << "Col 6";
     QTest::newRow("add-item07") << serverContent1 << "new Item"
                                 << "Col 7";
 }
 
 void EntityTreeModelTest::testItemAdded()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, addedItem);
     QFETCH(QString, parentCollection);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto parentIndex = firstMatchedIndex(*model, parentCollection);
     const auto targetRow = model->rowCount(parentIndex);
 
     auto const addedCommand = new FakeItemAddedCommand(addedItem, parentCollection, serverData);
 
     m_modelSpy->startSpying();
 
     serverData->setCommands({addedCommand});
 
     const QList<ExpectedSignal> expectedSignals{{RowsAboutToBeInserted, targetRow, targetRow, parentCollection, QVariantList{addedItem}},
                                                 {RowsInserted, targetRow, targetRow, parentCollection, QVariantList{addedItem}}};
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testItemRemoved_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("removedItem");
 
     QTest::newRow("remove-item01") << serverContent1 << "Item 1";
     QTest::newRow("remove-item02") << serverContent1 << "Item 2";
     QTest::newRow("remove-item03") << serverContent1 << "Item 3";
     QTest::newRow("remove-item04") << serverContent1 << "Item 4";
     QTest::newRow("remove-item05") << serverContent1 << "Item 5";
     QTest::newRow("remove-item06") << serverContent1 << "Item 6";
     QTest::newRow("remove-item07") << serverContent1 << "Item 7";
     QTest::newRow("remove-item08") << serverContent1 << "Item 8";
     QTest::newRow("remove-item09") << serverContent1 << "Item 9";
     QTest::newRow("remove-item10") << serverContent1 << "Item 10";
     QTest::newRow("remove-item11") << serverContent1 << "Item 11";
     QTest::newRow("remove-item12") << serverContent1 << "Item 12";
     QTest::newRow("remove-item13") << serverContent1 << "Item 13";
     QTest::newRow("remove-item14") << serverContent1 << "Item 14";
     QTest::newRow("remove-item15") << serverContent1 << "Item 15";
 }
 
 void EntityTreeModelTest::testItemRemoved()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, removedItem);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto removedIndex = firstMatchedIndex(*model, removedItem);
     const auto sourceCollection = removedIndex.parent().data().toString();
     const auto sourceRow = removedIndex.row();
 
     auto const removeCommand = new FakeItemRemovedCommand(removedItem, sourceCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({removeCommand});
 
     const QList<ExpectedSignal> expectedSignals{{RowsAboutToBeRemoved, sourceRow, sourceRow, sourceCollection, QVariantList{removedItem}},
                                                 {RowsRemoved, sourceRow, sourceRow, sourceCollection, QVariantList{removedItem}}};
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testItemChanged_data()
 {
     QTest::addColumn<QString>("serverContent");
     QTest::addColumn<QString>("changedItem");
 
     QTest::newRow("change-item01") << serverContent1 << "Item 1";
     QTest::newRow("change-item02") << serverContent1 << "Item 2";
     QTest::newRow("change-item03") << serverContent1 << "Item 3";
     QTest::newRow("change-item04") << serverContent1 << "Item 4";
     QTest::newRow("change-item05") << serverContent1 << "Item 5";
     QTest::newRow("change-item06") << serverContent1 << "Item 6";
     QTest::newRow("change-item07") << serverContent1 << "Item 7";
     QTest::newRow("change-item08") << serverContent1 << "Item 8";
     QTest::newRow("change-item09") << serverContent1 << "Item 9";
     QTest::newRow("change-item10") << serverContent1 << "Item 10";
     QTest::newRow("change-item11") << serverContent1 << "Item 11";
     QTest::newRow("change-item12") << serverContent1 << "Item 12";
     QTest::newRow("change-item13") << serverContent1 << "Item 13";
     QTest::newRow("change-item14") << serverContent1 << "Item 14";
     QTest::newRow("change-item15") << serverContent1 << "Item 15";
 }
 
 void EntityTreeModelTest::testItemChanged()
 {
     QFETCH(QString, serverContent);
     QFETCH(QString, changedItem);
 
     const auto testDrivers = populateModel(serverContent);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto changedIndex = firstMatchedIndex(*model, changedItem);
     const auto parentCollection = changedIndex.parent().data().toString();
     const auto sourceRow = changedIndex.row();
 
     auto const changeCommand = new FakeItemChangedCommand(changedItem, parentCollection, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({changeCommand});
 
     const QList<ExpectedSignal> expectedSignals{{DataChanged, sourceRow, sourceRow, QVariantList{changedItem}}};
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 void EntityTreeModelTest::testRemoveCollectionOnChanged()
 {
     const auto serverContent = QStringLiteral(
         "- C (inode/directory, text/directory)  'Col 1'     2"
         "- - C (text/directory)                 'Col 2'     1"
         "- - - I text/directory                 'Item 1'");
     const auto collectionName = QStringLiteral("Col 2");
     const auto monitoredMimeType = QStringLiteral("text/directory");
 
     const auto testDrivers = populateModel(serverContent, monitoredMimeType);
     auto const serverData = testDrivers.first;
     auto const model = testDrivers.second;
 
     const auto changedIndex = firstMatchedIndex(*model, collectionName);
     auto changedCol = changedIndex.data(Akonadi::EntityTreeModel::CollectionRole).value<Akonadi::Collection>();
     changedCol.setContentMimeTypes({QStringLiteral("foobar")});
     const auto parentCollection = changedIndex.parent().data().toString();
 
     auto const changeCommand = new FakeCollectionChangedCommand(changedCol, serverData);
 
     m_modelSpy->startSpying();
     serverData->setCommands({changeCommand});
 
     const QList<ExpectedSignal> expectedSignals{
         {RowsAboutToBeRemoved, changedIndex.row(), changedIndex.row(), parentCollection, QVariantList{collectionName}},
         {RowsRemoved, changedIndex.row(), changedIndex.row(), parentCollection, QVariantList{collectionName}},
     };
 
     m_modelSpy->setExpectedSignals(expectedSignals);
     serverData->processNotifications();
 
     // Give the model a chance to run the event loop to process the signals.
     QTest::qWait(0);
 
     QVERIFY(m_modelSpy->isEmpty());
 }
 
 #include "entitytreemodeltest.moc"
 
 QTEST_MAIN(EntityTreeModelTest)