X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/89e4e8dd0a589c99e451e9f0aa4855e5720652ad..af93215bfdb1c22e6a0914c26e33360602bc5ae2:/src/tests/placesitemmodeltest.cpp diff --git a/src/tests/placesitemmodeltest.cpp b/src/tests/placesitemmodeltest.cpp index 5eb65e076..ef8d265f9 100644 --- a/src/tests/placesitemmodeltest.cpp +++ b/src/tests/placesitemmodeltest.cpp @@ -19,9 +19,6 @@ #include #include -#include -#include -#include #include #include #include @@ -30,21 +27,16 @@ #include #include #include +#include +#include +#include "dolphin_generalsettings.h" #include "panels/places/placesitemmodel.h" #include "panels/places/placesitem.h" #include "views/viewproperties.h" -#include "kitemviews/kitemrange.h" Q_DECLARE_METATYPE(KItemRangeList) -Q_DECLARE_METATYPE(PlacesItem::GroupType) - -#ifdef Q_OS_WIN -//c:\ as root for windows -#define KDE_ROOT_PATH "C:\\" -#else -#define KDE_ROOT_PATH "/" -#endif +Q_DECLARE_METATYPE(KItemRange) static QString bookmarksFile() { @@ -63,8 +55,8 @@ private slots: void cleanupTestCase(); void testModelSort(); - void testModelMove(); void testGroups(); + void testDeletePlace(); void testPlaceItem_data(); void testPlaceItem(); void testTearDownDevice(); @@ -76,30 +68,44 @@ private slots: void testEditBookmark(); void testEditAfterCreation(); void testEditMetadata(); + void testRefresh(); + void testIcons_data(); + void testIcons(); + void testDragAndDrop(); + void testHideDevices(); + void testDuplicatedEntries(); + void renameAfterCreation(); private: PlacesItemModel* m_model; + QSet m_tobeRemoved; QMap m_interfacesMap; + int m_expectedModelCount = qEnvironmentVariableIsSet("KDE_FULL_SESSION") && KProtocolInfo::isKnownProtocol(QStringLiteral("recentlyused")) ? 16 : 14; + bool m_hasDesktopFolder = false; + bool m_hasDocumentsFolder = false; + bool m_hasDownloadsFolder = false; void setBalooEnabled(bool enabled); int indexOf(const QUrl &url); QDBusInterface *fakeManager(); QDBusInterface *fakeDevice(const QString &udi); - QStringList placesUrls() const; + QStringList placesUrls(PlacesItemModel *model = nullptr) const; QStringList initialUrls() const; void createPlaceItem(const QString &text, const QUrl &url, const QString &icon); + void schedulePlaceRemoval(int index); + void cancelPlaceRemoval(int index); + QMimeData *createMimeData(const QList &indexes) const; + QTemporaryDir m_tempHomeDir; }; -#define CHECK_PLACES_URLS(urls) \ - QStringList tmp(urls); \ - QStringList places = placesUrls(); \ - while(!places.isEmpty()) { \ - tmp.removeOne(places.takeFirst()); \ - } \ - if (!tmp.isEmpty()) { \ - qWarning() << "Expected:" << urls; \ - qWarning() << "Got:" << places; \ - QCOMPARE(places, urls); \ +#define CHECK_PLACES_URLS(urls) \ + { \ + QStringList places = placesUrls(); \ + if (places != urls) { \ + qWarning() << "Expected:" << urls; \ + qWarning() << "Got:" << places; \ + QCOMPARE(places, urls); \ + } \ } void PlacesItemModelTest::setBalooEnabled(bool enabled) @@ -137,41 +143,119 @@ QDBusInterface *PlacesItemModelTest::fakeDevice(const QString &udi) return iface; } -QStringList PlacesItemModelTest::placesUrls() const +QStringList PlacesItemModelTest::placesUrls(PlacesItemModel *model) const { QStringList urls; - for (int row = 0; row < m_model->count(); ++row) { - urls << m_model->placesItem(row)->url().toDisplayString(QUrl::PreferLocalFile); + if (!model) { + model = m_model; + } + + for (int row = 0; row < model->count(); ++row) { + urls << model->placesItem(row)->url().toDisplayString(QUrl::PreferLocalFile); + } + return urls; +} + +QStringList PlacesItemModelTest::initialUrls() const +{ + static QStringList urls; + if (urls.isEmpty()) { + urls << QDir::homePath(); + + if (m_hasDesktopFolder) { + urls << QDir::homePath() + QStringLiteral("/Desktop"); + } + + if (m_hasDocumentsFolder) { + urls << QDir::homePath() + QStringLiteral("/Documents"); + } + + if (m_hasDownloadsFolder) { + urls << QDir::homePath() + QStringLiteral("/Downloads"); + } + + urls << QStringLiteral("trash:/") + << QStringLiteral("remote:/") + << QStringLiteral("/media/nfs"); + + if (qEnvironmentVariableIsSet("KDE_FULL_SESSION") && KProtocolInfo::isKnownProtocol(QStringLiteral("recentlyused"))) { + urls << QStringLiteral("recentlyused:/files"); + urls << QStringLiteral("recentlyused:/locations"); + } + + urls << QStringLiteral("timeline:/today") << QStringLiteral("timeline:/yesterday") + << QStringLiteral("search:/documents") << QStringLiteral("search:/images") << QStringLiteral("search:/audio") << QStringLiteral("search:/videos") + << QStringLiteral("/foreign") + << QStringLiteral("/media/floppy0") << QStringLiteral("/media/XO-Y4") << QStringLiteral("/media/cdrom"); } return urls; } void PlacesItemModelTest::createPlaceItem(const QString &text, const QUrl &url, const QString &icon) { - PlacesItem *item = m_model->createPlacesItem(text, - url, - icon); - QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); - m_model->appendItemToGroup(item); - QTRY_COMPARE(itemsInsertedSpy.count(), 1); + m_model->createPlacesItem(text, url, icon); +} + +void PlacesItemModelTest::schedulePlaceRemoval(int index) +{ + m_tobeRemoved.insert(index); +} + +void PlacesItemModelTest::cancelPlaceRemoval(int index) +{ + m_tobeRemoved.remove(index); +} + +QMimeData *PlacesItemModelTest::createMimeData(const QList &indexes) const +{ + QByteArray itemData; + QDataStream stream(&itemData, QIODevice::WriteOnly); + QList urls; + + for (int index : indexes) { + const QUrl itemUrl = m_model->placesItem(index)->url(); + if (itemUrl.isValid()) { + urls << itemUrl; + } + stream << index; + } + + QMimeData* mimeData = new QMimeData(); + mimeData->setUrls(urls); + // copied from PlacesItemModel::internalMimeType() + const QString internalMimeType = "application/x-dolphinplacesmodel-" + + QString::number((qptrdiff)m_model); + mimeData->setData(internalMimeType, itemData); + return mimeData; } void PlacesItemModelTest::init() { m_model = new PlacesItemModel(); - // WORKAROUND: need to wait for bookmark to load, check: PlacesItemModel::updateBookmarks + // WORKAROUND: need to wait for bookmark to load QTest::qWait(300); - QCOMPARE(m_model->count(), 17); + QCOMPARE(m_model->count(), m_expectedModelCount); } void PlacesItemModelTest::cleanup() { + const auto tobeRemoved = m_tobeRemoved; + for (const int i : tobeRemoved) { + int before = m_model->count(); + m_model->deleteItem(i); + QTRY_COMPARE(m_model->count(), before - 1); + } + m_tobeRemoved.clear(); delete m_model; m_model = nullptr; } void PlacesItemModelTest::initTestCase() { + QVERIFY(m_tempHomeDir.isValid()); + QVERIFY(qputenv("HOME", m_tempHomeDir.path().toUtf8())); + QVERIFY(qputenv("KDE_FORK_SLAVES", "yes")); + QStandardPaths::setTestModeEnabled(true); const QString fakeHw = QFINDTESTDATA("data/fakecomputer.xml"); @@ -185,7 +269,23 @@ void PlacesItemModelTest::initTestCase() QVERIFY(QFile::remove(bookmarsFileName)); } + if (QDir(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).exists()) { + m_hasDesktopFolder = true; + m_expectedModelCount++; + } + + if (QDir(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)).exists()) { + m_hasDocumentsFolder = true; + m_expectedModelCount++; + } + + if (QDir(QStandardPaths::writableLocation(QStandardPaths::DownloadLocation)).exists()) { + m_hasDownloadsFolder = true; + m_expectedModelCount++; + } + qRegisterMetaType(); + qRegisterMetaType(); } void PlacesItemModelTest::cleanupTestCase() @@ -194,53 +294,48 @@ void PlacesItemModelTest::cleanupTestCase() QFile::remove(bookmarksFile()); } -QStringList PlacesItemModelTest::initialUrls() const -{ - QStringList urls; - - urls << QDir::homePath() << QStringLiteral("remote:/") << QStringLiteral(KDE_ROOT_PATH) << QStringLiteral("trash:/") - << QStringLiteral("timeline:/today") << QStringLiteral("timeline:/yesterday") << QStringLiteral("timeline:/thismonth") << QStringLiteral("timeline:/lastmonth") - << QStringLiteral("search:/documents") << QStringLiteral("search:/images") << QStringLiteral("search:/audio") << QStringLiteral("search:/videos") - << QStringLiteral("/media/cdrom") << QStringLiteral("/foreign") << QStringLiteral("/media/XO-Y4") << QStringLiteral("/media/nfs") << QStringLiteral("/media/floppy0"); - - return urls; -} - void PlacesItemModelTest::testModelSort() { CHECK_PLACES_URLS(initialUrls()); } -void PlacesItemModelTest::testModelMove() -{ - QStringList urls = initialUrls(); - KBookmarkManager *bookmarkManager = KBookmarkManager::managerForFile(bookmarksFile(), QStringLiteral("kfilePlaces")); - KBookmarkGroup root = bookmarkManager->root(); - KBookmark systemRoot = m_model->placesItem(1)->bookmark(); - KBookmark last = m_model->placesItem(m_model->count() - 1)->bookmark(); - - // try to move the "root" path to the end of the list - root.moveBookmark(systemRoot, last); - bookmarkManager->emitChanged(root); - - // make sure that the items still grouped and the "root" item was moved to the end of places group instead - urls.move(1, 2); - CHECK_PLACES_URLS(urls); -} - void PlacesItemModelTest::testGroups() { const auto groups = m_model->groups(); + int expectedRemoteIndex = 2; + if (m_hasDesktopFolder) { + expectedRemoteIndex++; + } + if (m_hasDocumentsFolder) { + expectedRemoteIndex++; + } + if (m_hasDownloadsFolder) { + expectedRemoteIndex++; + } + + QCOMPARE(groups.size(), 6); - QCOMPARE(groups.size(), 4); QCOMPARE(groups.at(0).first, 0); QCOMPARE(groups.at(0).second.toString(), QStringLiteral("Places")); - QCOMPARE(groups.at(1).first, 4); - QCOMPARE(groups.at(1).second.toString(), QStringLiteral("Recently Saved")); - QCOMPARE(groups.at(2).first, 8); - QCOMPARE(groups.at(2).second.toString(), QStringLiteral("Search For")); - QCOMPARE(groups.at(3).first, 12); - QCOMPARE(groups.at(3).second.toString(), QStringLiteral("Devices")); + + QCOMPARE(groups.at(1).first, expectedRemoteIndex); + QCOMPARE(groups.at(1).second.toString(), QStringLiteral("Remote")); + + QCOMPARE(groups.at(2).first, expectedRemoteIndex + 2); + QCOMPARE(groups.at(2).second.toString(), QStringLiteral("Recent")); + + if (qEnvironmentVariableIsSet("KDE_FULL_SESSION") && KProtocolInfo::isKnownProtocol(QStringLiteral("recentlyused"))) { + expectedRemoteIndex += 2; + } + + QCOMPARE(groups.at(3).first, expectedRemoteIndex + 4); + QCOMPARE(groups.at(3).second.toString(), QStringLiteral("Search For")); + + QCOMPARE(groups.at(4).first, expectedRemoteIndex + 8); + QCOMPARE(groups.at(4).second.toString(), QStringLiteral("Devices")); + + QCOMPARE(groups.at(5).first, expectedRemoteIndex + 9); + QCOMPARE(groups.at(5).second.toString(), QStringLiteral("Removable Devices")); } void PlacesItemModelTest::testPlaceItem_data() @@ -248,20 +343,20 @@ void PlacesItemModelTest::testPlaceItem_data() QTest::addColumn("url"); QTest::addColumn("expectedIsHidden"); QTest::addColumn("expectedIsSystemItem"); - QTest::addColumn("expectedGroupType"); + QTest::addColumn("expectedGroup"); QTest::addColumn("expectedStorageSetupNeeded"); // places - QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << false << true << PlacesItem::PlacesType << false; + QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << false << true << QStringLiteral("Places") << false; // baloo -search - QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << false << true << PlacesItem::SearchForType << false; + QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << false << true << QStringLiteral("Search For") << false; // baloo - timeline - QTest::newRow("Baloo - Last Month") << QUrl("timeline:/lastmonth") << false << true << PlacesItem::RecentlySavedType << false; + QTest::newRow("Baloo - Today") << QUrl("timeline:/today") << false << true << QStringLiteral("Recent") << false; // devices - QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << false << false << PlacesItem::DevicesType << false; + QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << false << false << QStringLiteral("Removable Devices") << false; } void PlacesItemModelTest::testPlaceItem() @@ -269,7 +364,7 @@ void PlacesItemModelTest::testPlaceItem() QFETCH(QUrl, url); QFETCH(bool, expectedIsHidden); QFETCH(bool, expectedIsSystemItem); - QFETCH(PlacesItem::GroupType, expectedGroupType); + QFETCH(QString, expectedGroup); QFETCH(bool, expectedStorageSetupNeeded); const int index = indexOf(url); @@ -277,10 +372,49 @@ void PlacesItemModelTest::testPlaceItem() QCOMPARE(item->url(), url); QCOMPARE(item->isHidden(), expectedIsHidden); QCOMPARE(item->isSystemItem(), expectedIsSystemItem); - QCOMPARE(item->groupType(), expectedGroupType); + QCOMPARE(item->group(), expectedGroup); QCOMPARE(item->storageSetupNeeded(), expectedStorageSetupNeeded); } +void PlacesItemModelTest::testDeletePlace() +{ + const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)); + QStringList urls = initialUrls(); + QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); + QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved); + + PlacesItemModel *model = new PlacesItemModel(); + + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + // create a new place + createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString()); + urls.insert(tempDirIndex, tempUrl.toLocalFile()); + + // check if the new entry was created + QTRY_COMPARE(itemsInsertedSpy.count(), 1); + CHECK_PLACES_URLS(urls); + QTRY_COMPARE(model->count(), m_model->count()); + + // delete item + m_model->deleteItem(tempDirIndex); + + // make sure that the new item is removed + QTRY_COMPARE(itemsRemovedSpy.count(), 1); + QTRY_COMPARE(m_model->count(), m_expectedModelCount); + CHECK_PLACES_URLS(initialUrls()); + QTRY_COMPARE(model->count(), m_model->count()); +} + void PlacesItemModelTest::testTearDownDevice() { const QUrl mediaUrl = QUrl::fromLocalFile(QStringLiteral("/media/XO-Y4")); @@ -293,11 +427,11 @@ void PlacesItemModelTest::testTearDownDevice() auto teardownAction = m_model->teardownAction(index); QVERIFY(teardownAction); - QCOMPARE(m_model->count(), 17); + QCOMPARE(m_model->count(), m_expectedModelCount); QSignalSpy spyItemsRemoved(m_model, &PlacesItemModel::itemsRemoved); fakeManager()->call(QStringLiteral("unplug"), "/org/kde/solid/fakehw/volume_part1_size_993284096"); - QTRY_COMPARE(m_model->count(), 16); + QTRY_COMPARE(m_model->count(), m_expectedModelCount - 1); QCOMPARE(spyItemsRemoved.count(), 1); const QList spyItemsRemovedArgs = spyItemsRemoved.takeFirst(); const KItemRangeList removedRange = spyItemsRemovedArgs.at(0).value(); @@ -309,7 +443,7 @@ void PlacesItemModelTest::testTearDownDevice() QSignalSpy spyItemsInserted(m_model, &PlacesItemModel::itemsInserted); fakeManager()->call(QStringLiteral("plug"), "/org/kde/solid/fakehw/volume_part1_size_993284096"); - QTRY_COMPARE(m_model->count(), 17); + QTRY_COMPARE(m_model->count(), m_expectedModelCount); QCOMPARE(spyItemsInserted.count(), 1); index = indexOf(mediaUrl); @@ -337,7 +471,7 @@ void PlacesItemModelTest::testDefaultViewProperties_data() QTest::newRow("Places - Audio") << QUrl("search:/audio") << DolphinView::DetailsView << false << QList({"text", "artist", "album"}); // baloo - timeline - QTest::newRow("Baloo - Last Month") << QUrl("timeline:/lastmonth") << DolphinView::DetailsView << true << QList({"text", "modificationtime"}); + QTest::newRow("Baloo - Today") << QUrl("timeline:/today") << DolphinView::DetailsView << true << QList({"text", "modificationtime"}); // devices QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << DolphinView::IconsView << true << QList({"text"}); @@ -351,18 +485,30 @@ void PlacesItemModelTest::testDefaultViewProperties() QFETCH(bool, expectedPreviewShow); QFETCH(QList, expectedVisibleRole); - ViewProperties properties(m_model->convertedUrl(url)); + // In order to test the default view properties, turn off the global view properties and re-init the test to reload the model. + GeneralSettings* settings = GeneralSettings::self(); + settings->setGlobalViewProps(false); + settings->save(); + cleanup(); + init(); + + ViewProperties properties(KFilePlacesModel::convertedUrl(url)); QCOMPARE(properties.viewMode(), expectedViewMode); QCOMPARE(properties.previewsShown(), expectedPreviewShow); QCOMPARE(properties.visibleRoles(), expectedVisibleRole); + + settings->setGlobalViewProps(true); + settings->save(); } void PlacesItemModelTest::testClear() { - QCOMPARE(m_model->count(), 17); + QCOMPARE(m_model->count(), m_expectedModelCount); m_model->clear(); QCOMPARE(m_model->count(), 0); QCOMPARE(m_model->hiddenCount(), 0); + m_model->refresh(); + QTRY_COMPARE(m_model->count(), m_expectedModelCount); } void PlacesItemModelTest::testHideItem() @@ -385,7 +531,7 @@ void PlacesItemModelTest::testHideItem() item->setHidden(true); // check if items removed was fired - QTRY_COMPARE(m_model->count(), 16); + QTRY_COMPARE(m_model->count(), m_expectedModelCount - 1); QCOMPARE(spyItemsRemoved.count(), 1); spyItemsRemovedArgs = spyItemsRemoved.takeFirst(); removedRange = spyItemsRemovedArgs.at(0).value(); @@ -410,125 +556,425 @@ void PlacesItemModelTest::testHideItem() // mark model to hide invisible items m_model->setHiddenItemsShown(true); - QTRY_COMPARE(m_model->count(), 17); + QTRY_COMPARE(m_model->count(), m_expectedModelCount); } void PlacesItemModelTest::testSystemItems() { - QCOMPARE(m_model->count(), 17); + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + QCOMPARE(m_model->count(), m_expectedModelCount); for (int r = 0; r < m_model->count(); r++) { QCOMPARE(m_model->placesItem(r)->isSystemItem(), !m_model->placesItem(r)->device().isValid()); } - // create a new entry (non system item) - PlacesItem *item = m_model->createPlacesItem(QStringLiteral("Temporary Dir"), - QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), - QString()); - QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); - m_model->appendItemToGroup(item); + + // create a new entry (non system item) + createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString()); // check if the new entry was created QTRY_COMPARE(itemsInsertedSpy.count(), 1); + + // make sure the new place get removed + schedulePlaceRemoval(tempDirIndex); + QList args = itemsInsertedSpy.takeFirst(); KItemRangeList range = args.at(0).value(); - QCOMPARE(range.first().index, 4); + QCOMPARE(range.first().index, tempDirIndex); QCOMPARE(range.first().count, 1); - QVERIFY(!m_model->placesItem(4)->isSystemItem()); - QCOMPARE(m_model->count(), 18); + QVERIFY(!m_model->placesItem(tempDirIndex)->isSystemItem()); + QCOMPARE(m_model->count(), m_expectedModelCount + 1); - // remove new entry + QTest::qWait(300); + // check if the removal signal is correct QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved); - m_model->removeItem(4); - m_model->saveBookmarks(); + m_model->deleteItem(tempDirIndex); QTRY_COMPARE(itemsRemovedSpy.count(), 1); args = itemsRemovedSpy.takeFirst(); range = args.at(0).value(); - QCOMPARE(range.first().index, 4); + QCOMPARE(range.first().index, tempDirIndex); QCOMPARE(range.first().count, 1); - QTRY_COMPARE(m_model->count(), 17); + QTRY_COMPARE(m_model->count(), m_expectedModelCount); + + //cancel removal (it was removed above) + cancelPlaceRemoval(tempDirIndex); } void PlacesItemModelTest::testEditBookmark() { + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + QScopedPointer other(new PlacesItemModel()); createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString()); + // make sure that the new item will be removed later + schedulePlaceRemoval(tempDirIndex); + QSignalSpy itemsChangedSply(m_model, &PlacesItemModel::itemsChanged); - m_model->item(4)->setText(QStringLiteral("Renamed place")); - m_model->saveBookmarks(); + + // modify place text + m_model->item(tempDirIndex)->setText(QStringLiteral("Renamed place")); + m_model->refresh(); + + // check if the correct signal was fired QTRY_COMPARE(itemsChangedSply.count(), 1); QList args = itemsChangedSply.takeFirst(); KItemRangeList range = args.at(0).value(); - QCOMPARE(range.first().index, 4); + QCOMPARE(range.first().index, tempDirIndex); QCOMPARE(range.first().count, 1); QSet roles = args.at(1).value >(); QCOMPARE(roles.size(), 1); QCOMPARE(*roles.begin(), QByteArrayLiteral("text")); - QCOMPARE(m_model->item(4)->text(), QStringLiteral("Renamed place")); + QCOMPARE(m_model->item(tempDirIndex)->text(), QStringLiteral("Renamed place")); // check if the item was updated in the other model - QTRY_COMPARE(other->item(4)->text(), QStringLiteral("Renamed place")); - - // remove new entry - QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved); - m_model->removeItem(4); - m_model->saveBookmarks(); - QTRY_COMPARE(itemsRemovedSpy.count(), 1); - args = itemsRemovedSpy.takeFirst(); - range = args.at(0).value(); - QCOMPARE(range.first().index, 4); - QCOMPARE(range.first().count, 1); - QTRY_COMPARE(m_model->count(), 17); + QTRY_COMPARE(other->item(tempDirIndex)->text(), QStringLiteral("Renamed place")); } void PlacesItemModelTest::testEditAfterCreation() { - createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString()); + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)); + QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); + + // create a new place + createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString()); + QTRY_COMPARE(itemsInsertedSpy.count(), 1); PlacesItemModel *model = new PlacesItemModel(); QTRY_COMPARE(model->count(), m_model->count()); - PlacesItem *item = m_model->placesItem(4); + // make sure that the new item will be removed later + schedulePlaceRemoval(tempDirIndex); + + // modify place text + PlacesItem *item = m_model->placesItem(tempDirIndex); item->setText(QStringLiteral("Renamed place")); - m_model->saveBookmarks(); + m_model->refresh(); + // check if the second model got the changes QTRY_COMPARE(model->count(), m_model->count()); - QTRY_COMPARE(model->placesItem(4)->text(), m_model->placesItem(4)->text()); - QTRY_COMPARE(model->placesItem(4)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), - m_model->placesItem(4)->bookmark().metaDataItem(QStringLiteral("OnlyInApp"))); - QTRY_COMPARE(model->placesItem(4)->icon(), m_model->placesItem(4)->icon()); - QTRY_COMPARE(model->placesItem(4)->url(), m_model->placesItem(4)->url()); - - m_model->removeItem(4); - m_model->saveBookmarks(); - QTRY_COMPARE(model->count(), m_model->count()); + QTRY_COMPARE(model->placesItem(tempDirIndex)->text(), m_model->placesItem(tempDirIndex)->text()); + QTRY_COMPARE(model->placesItem(tempDirIndex)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), + m_model->placesItem(tempDirIndex)->bookmark().metaDataItem(QStringLiteral("OnlyInApp"))); + QTRY_COMPARE(model->placesItem(tempDirIndex)->icon(), m_model->placesItem(tempDirIndex)->icon()); + QTRY_COMPARE(model->placesItem(tempDirIndex)->url(), m_model->placesItem(tempDirIndex)->url()); } void PlacesItemModelTest::testEditMetadata() { - createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString()); + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)); + QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); + + // create a new place + createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString()); + QTRY_COMPARE(itemsInsertedSpy.count(), 1); + // check if the new entry was created PlacesItemModel *model = new PlacesItemModel(); QTRY_COMPARE(model->count(), m_model->count()); - PlacesItem *item = m_model->placesItem(4); - item->bookmark().setMetaDataItem(QStringLiteral("OnlyInApp"), KAboutData::applicationData().componentName()); - m_model->saveBookmarks(); + // make sure that the new item will be removed later + schedulePlaceRemoval(tempDirIndex); - QTRY_COMPARE(model->count(), m_model->count()); - QTRY_COMPARE(model->placesItem(4)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), + // modify place metadata + auto bookmark = m_model->placesItem(tempDirIndex)->bookmark(); + bookmark.setMetaDataItem(QStringLiteral("OnlyInApp"), KAboutData::applicationData().componentName()); + m_model->refresh(); + + // check if the place was modified in both models + QTRY_COMPARE(model->placesItem(tempDirIndex)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), KAboutData::applicationData().componentName()); - QTRY_COMPARE(model->placesItem(4)->text(), m_model->placesItem(4)->text()); - QTRY_COMPARE(model->placesItem(4)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), - m_model->placesItem(4)->bookmark().metaDataItem(QStringLiteral("OnlyInApp"))); - QTRY_COMPARE(model->placesItem(4)->icon(), m_model->placesItem(4)->icon()); - QTRY_COMPARE(model->placesItem(4)->url(), m_model->placesItem(4)->url()); - - m_model->removeItem(4); - m_model->saveBookmarks(); + QTRY_COMPARE(model->placesItem(tempDirIndex)->text(), m_model->placesItem(tempDirIndex)->text()); + QTRY_COMPARE(model->placesItem(tempDirIndex)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")), + m_model->placesItem(tempDirIndex)->bookmark().metaDataItem(QStringLiteral("OnlyInApp"))); + QTRY_COMPARE(model->placesItem(tempDirIndex)->icon(), m_model->placesItem(tempDirIndex)->icon()); + QTRY_COMPARE(model->placesItem(tempDirIndex)->url(), m_model->placesItem(tempDirIndex)->url()); +} + +void PlacesItemModelTest::testRefresh() +{ + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)); + QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); + + // create a new place + createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString()); + QTRY_COMPARE(itemsInsertedSpy.count(), 1); + + PlacesItemModel *model = new PlacesItemModel(); + QTRY_COMPARE(model->count(), m_model->count()); + + // make sure that the new item will be removed later + schedulePlaceRemoval(tempDirIndex); + + PlacesItem *item = m_model->placesItem(tempDirIndex); + PlacesItem *sameItem = model->placesItem(tempDirIndex); + QCOMPARE(item->text(), sameItem->text()); + + // modify place text + item->setText(QStringLiteral("Renamed place")); + + // item from another model is not affected at the moment + QVERIFY(item->text() != sameItem->text()); + + // propagate change + m_model->refresh(); + + // item must be equal + QTRY_COMPARE(item->text(), sameItem->text()); +} + +void PlacesItemModelTest::testIcons_data() +{ + QTest::addColumn("url"); + QTest::addColumn("expectedIconName"); + + // places + QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << QStringLiteral("user-home"); + + // baloo -search + QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << QStringLiteral("folder-text"); + + // baloo - timeline + QTest::newRow("Baloo - Today") << QUrl("timeline:/today") << QStringLiteral("go-jump-today"); + + // devices + QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << QStringLiteral("blockdevice"); +} + +void PlacesItemModelTest::testIcons() +{ + QFETCH(QUrl, url); + QFETCH(QString, expectedIconName); + + PlacesItem *item = m_model->placesItem(indexOf(url)); + QCOMPARE(item->icon(), expectedIconName); + + for (int r = 0; r < m_model->count(); r++) { + QVERIFY(!m_model->placesItem(r)->icon().isEmpty()); + } +} + +void PlacesItemModelTest::testDragAndDrop() +{ + int lastIndex = 1; // last index of places group + if (m_hasDesktopFolder) { + lastIndex++; + } + if (m_hasDocumentsFolder) { + lastIndex++; + } + if (m_hasDownloadsFolder) { + lastIndex++; + } + + QList args; + KItemRangeList range; + QStringList urls = initialUrls(); + + QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted); + QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved); + + CHECK_PLACES_URLS(initialUrls()); + // Move the home directory to the end of the places group + QMimeData *dropData = createMimeData(QList() << 0); + m_model->dropMimeDataBefore(m_model->count() - 1, dropData); + urls.move(0, lastIndex); + delete dropData; + + QTRY_COMPARE(itemsInsertedSpy.count(), 1); + QTRY_COMPARE(itemsRemovedSpy.count(), 1); + + // remove item from actual position + args = itemsRemovedSpy.takeFirst(); + range = args.at(0).value(); + QCOMPARE(range.size(), 1); + QCOMPARE(range.at(0).count, 1); + QCOMPARE(range.at(0).index, 0); + + // insert intem in his group + args = itemsInsertedSpy.takeFirst(); + range = args.at(0).value(); + QCOMPARE(range.size(), 1); + QCOMPARE(range.at(0).count, 1); + QCOMPARE(range.at(0).index, lastIndex); + + CHECK_PLACES_URLS(urls); + + itemsInsertedSpy.clear(); + itemsRemovedSpy.clear(); + + // Move home directory item back to its original position + dropData = createMimeData(QList() << lastIndex); + m_model->dropMimeDataBefore(0, dropData); + urls.move(lastIndex, 0); + delete dropData; + + QTRY_COMPARE(itemsInsertedSpy.count(), 1); + QTRY_COMPARE(itemsRemovedSpy.count(), 1); + + // remove item from actual position + args = itemsRemovedSpy.takeFirst(); + range = args.at(0).value(); + QCOMPARE(range.size(), 1); + QCOMPARE(range.at(0).count, 1); + QCOMPARE(range.at(0).index, lastIndex); + + // insert intem in the requested position + args = itemsInsertedSpy.takeFirst(); + range = args.at(0).value(); + QCOMPARE(range.size(), 1); + QCOMPARE(range.at(0).count, 1); + QCOMPARE(range.at(0).index, 0); + + CHECK_PLACES_URLS(urls); +} + +void PlacesItemModelTest::testHideDevices() +{ + QSignalSpy itemsRemoved(m_model, &PlacesItemModel::itemsRemoved); + QStringList urls = initialUrls(); + + m_model->setGroupHidden(KFilePlacesModel::RemovableDevicesType, true); + QTRY_VERIFY(m_model->isGroupHidden(KFilePlacesModel::RemovableDevicesType)); + QTRY_COMPARE(itemsRemoved.count(), 3); + + // remove removable-devices + urls.removeOne(QStringLiteral("/media/floppy0")); + urls.removeOne(QStringLiteral("/media/XO-Y4")); + urls.removeOne(QStringLiteral("/media/cdrom")); + + // check if the correct urls was removed + CHECK_PLACES_URLS(urls); + + delete m_model; + m_model = new PlacesItemModel(); + QTRY_COMPARE(m_model->count(), urls.count()); + CHECK_PLACES_URLS(urls); + + // revert changes + m_model->setGroupHidden(KFilePlacesModel::RemovableDevicesType, false); + urls = initialUrls(); + QTRY_COMPARE(m_model->count(), urls.count()); + CHECK_PLACES_URLS(urls); +} + +void PlacesItemModelTest::testDuplicatedEntries() +{ + QStringList urls = initialUrls(); + // create a duplicated entry on bookmark + KBookmarkManager *bookmarkManager = KBookmarkManager::managerForFile(bookmarksFile(), QStringLiteral("kfilePlaces")); + KBookmarkGroup root = bookmarkManager->root(); + KBookmark bookmark = root.addBookmark(QStringLiteral("Duplicated Search Videos"), QUrl("search:/videos"), {}); + + const QString id = QUuid::createUuid().toString(); + bookmark.setMetaDataItem(QStringLiteral("ID"), id); + bookmark.setMetaDataItem(QStringLiteral("OnlyInApp"), KAboutData::applicationData().componentName()); + bookmarkManager->emitChanged(bookmarkManager->root()); + + PlacesItemModel *newModel = new PlacesItemModel(); + QTRY_COMPARE(placesUrls(newModel).count(QStringLiteral("search:/videos")), 1); + QTRY_COMPARE(urls, placesUrls(newModel)); + delete newModel; +} + +void PlacesItemModelTest::renameAfterCreation() +{ + int tempDirIndex = 2; + if (m_hasDesktopFolder) { + tempDirIndex++; + } + if (m_hasDocumentsFolder) { + tempDirIndex++; + } + if (m_hasDownloadsFolder) { + tempDirIndex++; + } + + const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)); + QStringList urls = initialUrls(); + PlacesItemModel *model = new PlacesItemModel(); + + CHECK_PLACES_URLS(urls); QTRY_COMPARE(model->count(), m_model->count()); + + // create a new place + createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString()); + urls.insert(tempDirIndex, tempUrl.toLocalFile()); + + // make sure that the new item will be removed later + schedulePlaceRemoval(tempDirIndex); + + CHECK_PLACES_URLS(urls); + QCOMPARE(model->count(), m_model->count()); + + + // modify place text + QSignalSpy changedSpy(m_model, &PlacesItemModel::itemsChanged); + + PlacesItem *item = m_model->placesItem(tempDirIndex); + item->setText(QStringLiteral("New Temporary Dir")); + item->setUrl(item->url()); + item->setIcon(item->icon()); + m_model->refresh(); + + QTRY_COMPARE(changedSpy.count(), 1); + + // check if the place was modified in both models + QTRY_COMPARE(m_model->placesItem(tempDirIndex)->text(), QStringLiteral("New Temporary Dir")); + QTRY_COMPARE(model->placesItem(tempDirIndex)->text(), QStringLiteral("New Temporary Dir")); } QTEST_MAIN(PlacesItemModelTest)