diff --git a/src/plugins/common/dfmplugin-tag/events/tageventreceiver.cpp b/src/plugins/common/dfmplugin-tag/events/tageventreceiver.cpp index 799c3b4638..070b23f9b8 100644 --- a/src/plugins/common/dfmplugin-tag/events/tageventreceiver.cpp +++ b/src/plugins/common/dfmplugin-tag/events/tageventreceiver.cpp @@ -32,7 +32,7 @@ void TagEventReceiver::handleFileCutResult(const QList &srcUrls, const QLi { Q_UNUSED(errMsg) - if (!ok) + if (!ok || destUrls.isEmpty()) return; for (const QUrl &url : srcUrls) { diff --git a/src/plugins/common/dfmplugin-tag/tag.h b/src/plugins/common/dfmplugin-tag/tag.h index 0d7c6d24d4..e9bf8f78bc 100644 --- a/src/plugins/common/dfmplugin-tag/tag.h +++ b/src/plugins/common/dfmplugin-tag/tag.h @@ -25,7 +25,6 @@ class Tag : public dpf::Plugin DPF_EVENT_REG_SIGNAL(signal_ReportLog_MenuData) // hook events - DPF_EVENT_REG_HOOK(hook_CanTag) // Warning: The event is abandoned, please do not use it. DPF_EVENT_REG_HOOK(hook_CanTaged) public: diff --git a/src/plugins/common/dfmplugin-tag/utils/anythingmonitorfilter.cpp b/src/plugins/common/dfmplugin-tag/utils/anythingmonitorfilter.cpp index 341313a37f..3847d52a8f 100644 --- a/src/plugins/common/dfmplugin-tag/utils/anythingmonitorfilter.cpp +++ b/src/plugins/common/dfmplugin-tag/utils/anythingmonitorfilter.cpp @@ -214,7 +214,7 @@ void AnythingMonitorFilter::reserveDir(QStringList *list) for (const QString &path : *list) { auto fileInfo { InfoFactory::create(QUrl::fromLocalFile(path)) }; - if (!fileInfo->isAttributes(OptInfoType::kIsDir)) + if (fileInfo && !fileInfo->isAttributes(OptInfoType::kIsDir)) pathInvalid.push_back(path); } diff --git a/src/plugins/common/dfmplugin-tag/utils/tagmanager.cpp b/src/plugins/common/dfmplugin-tag/utils/tagmanager.cpp index e2eb4e97a7..2089b3c908 100644 --- a/src/plugins/common/dfmplugin-tag/utils/tagmanager.cpp +++ b/src/plugins/common/dfmplugin-tag/utils/tagmanager.cpp @@ -103,9 +103,6 @@ bool TagManager::canTagFile(const QUrl &url) const return localFileCanTagFilter(info); } - if (dpfHookSequence->run("dfmplugin_tag", "hook_CanTag", url)) - return true; - return false; } @@ -121,10 +118,6 @@ bool TagManager::canTagFile(const FileInfoPointer &info) const } bool canTag = localFileCanTagFilter(info); - if (!canTag) { - if (dpfHookSequence->run("dfmplugin_tag", "hook_CanTag", url)) - return true; - } return canTag; } diff --git a/src/plugins/filemanager/core/dfmplugin-recent/files/recentfilewatcher.cpp b/src/plugins/filemanager/core/dfmplugin-recent/files/recentfilewatcher.cpp index 27d2dc8361..621b229962 100644 --- a/src/plugins/filemanager/core/dfmplugin-recent/files/recentfilewatcher.cpp +++ b/src/plugins/filemanager/core/dfmplugin-recent/files/recentfilewatcher.cpp @@ -50,7 +50,7 @@ void RecentFileWatcherPrivate::initConnect() auto onParentDeleted = [=](const QString &, const QString &deletedPath) { if (path.startsWith(deletedPath) && !deletedPath.isEmpty()) { - qDebug() << "recent: watched: " << path << ", deleted: " << deletedPath; + qInfo() << "recent: watched: " << path << ", deleted: " << deletedPath; Q_EMIT q->fileDeleted(QUrl::fromLocalFile(path)); } }; diff --git a/src/plugins/filemanager/core/dfmplugin-recent/menus/recentmenuscene.cpp b/src/plugins/filemanager/core/dfmplugin-recent/menus/recentmenuscene.cpp index 79da1c37a3..9dd2237eae 100644 --- a/src/plugins/filemanager/core/dfmplugin-recent/menus/recentmenuscene.cpp +++ b/src/plugins/filemanager/core/dfmplugin-recent/menus/recentmenuscene.cpp @@ -74,7 +74,7 @@ bool RecentMenuScene::initialize(const QVariantHash ¶ms) QString errString; d->focusFileInfo = DFMBASE_NAMESPACE::InfoFactory::create(d->focusFile, Global::CreateFileInfoType::kCreateFileInfoAuto, &errString); if (d->focusFileInfo.isNull()) { - qDebug() << errString; + qWarning() << "focusFileInfo isNull :" << errString; return false; } if (auto workspaceScene = dfmplugin_menu_util::menuSceneCreateScene(kWorkspaceMenuSceneName)) diff --git a/tests/plugins/common/dfmplugin-tag/data/ut_tagproxyhandle.cpp b/tests/plugins/common/dfmplugin-tag/data/ut_tagproxyhandle.cpp new file mode 100644 index 0000000000..8f0223c752 --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/data/ut_tagproxyhandle.cpp @@ -0,0 +1,128 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "data/tagproxyhandle.h" +#include "tagmanager_interface.h" + +#include +#include + +#include +#include +DFMBASE_USE_NAMESPACE +DPF_USE_NAMESPACE +using namespace dfmplugin_tag; + +TEST(UT_TagProxyHandle, deleteFileTags) +{ + bool isRun { false }; + stub_ext::StubExt stub; + stub.set_lamda(&OrgDeepinFilemanagerServerTagManagerInterface::Delete, [&isRun]() { + isRun = true; + return QDBusPendingReply(); + }); + QMap fileWithTag; + fileWithTag["1"] = QVariant(QStringList() << "red"); + + TagProxyHandle::instance()->deleteFileTags(fileWithTag); + + EXPECT_TRUE(isRun); +} + +TEST(UT_TagProxyHandle, deleteFiles) +{ + bool isRun { false }; + stub_ext::StubExt stub; + stub.set_lamda(&OrgDeepinFilemanagerServerTagManagerInterface::Delete, [&isRun]() { + isRun = true; + return QDBusPendingReply(); + }); + QMap fileWithTag; + fileWithTag["1"] = QVariant(QStringList() << "red"); + + TagProxyHandle::instance()->deleteFiles(fileWithTag); + + EXPECT_TRUE(isRun); +} + +TEST(UT_TagProxyHandle, deleteTags) +{ + bool isRun { false }; + stub_ext::StubExt stub; + stub.set_lamda(&OrgDeepinFilemanagerServerTagManagerInterface::Delete, [&isRun]() { + isRun = true; + return QDBusPendingReply(); + }); + QMap fileWithTag; + fileWithTag["1"] = QVariant(QStringList() << "red"); + + TagProxyHandle::instance()->deleteTags(fileWithTag); + + EXPECT_TRUE(isRun); +} + +TEST(UT_TagProxyHandle, update) +{ + int isRun = 0; + stub_ext::StubExt stub; + stub.set_lamda(&OrgDeepinFilemanagerServerTagManagerInterface::Update, [&isRun]() { + isRun++; + return QDBusPendingReply(); + }); + QMap fileWithTag; + fileWithTag["1"] = QVariant(QStringList() << "red"); + + TagProxyHandle::instance()->changeFilePaths(fileWithTag); + TagProxyHandle::instance()->changeTagNamesWithFiles(fileWithTag); + TagProxyHandle::instance()->changeTagsColor(fileWithTag); + EXPECT_TRUE(isRun == 3); +} + +TEST(UT_TagProxyHandle, Insert) +{ + int isRun = 0; + stub_ext::StubExt stub; + stub.set_lamda(&OrgDeepinFilemanagerServerTagManagerInterface::Insert, [&isRun]() { + isRun++; + return QDBusPendingReply(); + }); + QMap fileWithTag; + fileWithTag["1"] = QVariant(QStringList() << "red"); + + TagProxyHandle::instance()->addTags(fileWithTag); + TagProxyHandle::instance()->addTagsForFiles(fileWithTag); + EXPECT_TRUE(isRun == 2); +} + +TEST(UT_TagProxyHandle, Query) +{ + int isRun = 0; + stub_ext::StubExt stub; + auto func = static_cast (OrgDeepinFilemanagerServerTagManagerInterface::*)(int opt, const QStringList &)>(&OrgDeepinFilemanagerServerTagManagerInterface::Query); + stub.set_lamda(func, [&isRun]() { + isRun++; + return QDBusPendingReply(); + }); + + TagProxyHandle::instance()->getTagsColor(QStringList()); + TagProxyHandle::instance()->getFilesThroughTag(QStringList()); + TagProxyHandle::instance()->getSameTagsOfDiffFiles(QStringList()); + TagProxyHandle::instance()->getTagsThroughFile(QStringList()); + EXPECT_TRUE(isRun == 4); +} + +TEST(UT_TagProxyHandle, Query2) +{ + int isRun = 0; + stub_ext::StubExt stub; + auto func = static_cast (OrgDeepinFilemanagerServerTagManagerInterface::*)(int opt)>(&OrgDeepinFilemanagerServerTagManagerInterface::Query); + stub.set_lamda(func, [&isRun]() { + isRun++; + return QDBusPendingReply(); + }); + + TagProxyHandle::instance()->getAllFileWithTags(); + EXPECT_TRUE(isRun == 1); +} diff --git a/tests/plugins/common/dfmplugin-tag/event/ut_tageventcaller.cpp b/tests/plugins/common/dfmplugin-tag/event/ut_tageventcaller.cpp new file mode 100644 index 0000000000..b3582f439d --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/event/ut_tageventcaller.cpp @@ -0,0 +1,128 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "events/tageventcaller.h" + +#include + +#include + +#include +#include +DFMBASE_USE_NAMESPACE +DPF_USE_NAMESPACE +using namespace dfmplugin_tag; + +Q_DECLARE_METATYPE(QRectF *) +Q_DECLARE_METATYPE(QPoint *) + +TEST(UT_TagEventCaller, sendOpenWindow) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef bool (EventDispatcherManager::*FuncType)(EventType, QUrl); + stub.set_lamda(static_cast(&EventDispatcherManager::publish), [&isCall] { + isCall = true; + return true; + }); + + TagEventCaller::sendOpenWindow(QUrl()); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, sendOpenTab) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef bool (EventDispatcherManager::*FuncType)(EventType, quint64, const QUrl &); + stub.set_lamda(static_cast(&EventDispatcherManager::publish), [&isCall] { + isCall = true; + return true; + }); + + TagEventCaller::sendOpenTab(0, QUrl()); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, sendCheckTabAddable) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef QVariant (EventChannelManager::*FuncType)(const QString &, const QString &, quint64); + stub.set_lamda(static_cast(&EventChannelManager::push), [&isCall] { + isCall = true; + return true; + }); + TagEventCaller::sendCheckTabAddable(0); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, getCollectionView) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef QVariant (EventChannelManager::*FuncType)(const QString &, const QString &, QString); + stub.set_lamda(static_cast(&EventChannelManager::push), [&isCall] { + isCall = true; + return QVariant(); + }); + + TagEventCaller::getCollectionView(""); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, sendOpenFiles) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef bool (EventDispatcherManager::*FuncType)(EventType, quint64, const QList &); + stub.set_lamda(static_cast(&EventDispatcherManager::publish), [&isCall] { + isCall = true; + return true; + }); + + TagEventCaller::sendOpenFiles(0, QList() << QUrl()); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, getCollectionVisualRect) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef QVariant (EventChannelManager::*FuncType)(const QString &, const QString &, QString, const QUrl &); + stub.set_lamda(static_cast(&EventChannelManager::push), [&isCall] { + isCall = true; + return QVariant(); + }); + TagEventCaller::getCollectionVisualRect("", QUrl()); + + EXPECT_TRUE(isCall); +} + +TEST(UT_TagEventCaller, getCollectionIconRect) +{ + bool isCall { false }; + + stub_ext::StubExt stub; + typedef QVariant (EventChannelManager::*FuncType)(const QString &, const QString &, QString, QRect &); + stub.set_lamda(static_cast(&EventChannelManager::push), [&isCall] { + isCall = true; + return QVariant(); + }); + TagEventCaller::getCollectionIconRect("", QRect()); + + EXPECT_TRUE(isCall); +} diff --git a/tests/plugins/common/dfmplugin-tag/event/ut_tageventreceiver.cpp b/tests/plugins/common/dfmplugin-tag/event/ut_tageventreceiver.cpp new file mode 100644 index 0000000000..35698838f2 --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/event/ut_tageventreceiver.cpp @@ -0,0 +1,114 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "events/tageventreceiver.h" +#include "utils/tagmanager.h" +#include +#include +#include + +DPF_USE_NAMESPACE +using namespace dfmplugin_tag; +Q_DECLARE_METATYPE(QDir::Filters); +class TagEventReceiverTest : public testing::Test +{ +public: + void SetUp() override + { + } + void TearDown() override + { + stub.clear(); + } + + stub_ext::StubExt stub; +}; + +TEST_F(TagEventReceiverTest, handleFileCutResult) +{ + bool isRun = false; + stub.set_lamda(&TagManager::removeTagsOfFiles, []() { return true; }); + auto func = static_cast(&TagManager::canTagFile); + stub.set_lamda(func, []() -> bool { __DBG_STUB_INVOKE__ return true; }); + stub.set_lamda(&TagManager::addTagsForFiles, []() { return true; }); + + stub.set_lamda(&TagManager::getTagsByUrls, [&isRun]() { + __DBG_STUB_INVOKE__ + isRun = true; + return QVariant(QStringList() << "red"); + }); + TagEventReceiver::instance()->handleFileCutResult(QList() << QUrl("/"), QList(), true, QString()); + TagEventReceiver::instance()->handleFileCutResult(QList() << QUrl("/"), QList() << QUrl("/"), true, QString()); + EXPECT_TRUE(isRun); +} + +TEST_F(TagEventReceiverTest, handleHideFilesResult) +{ + bool isRun = false; + stub.set_lamda(&TagManager::hideFiles, []() {}); + + stub.set_lamda(&TagManager::getTagsByUrls, [&isRun]() { + __DBG_STUB_INVOKE__ + isRun = true; + return QVariant(QStringList() << "red"); + }); + TagEventReceiver::instance()->handleHideFilesResult(1, QList() << QUrl("/"), true); + EXPECT_TRUE(isRun); +} + +TEST_F(TagEventReceiverTest, handleFileRemoveResult) +{ + bool isRun = false; + stub.set_lamda(&TagManager::removeTagsOfFiles, []() { return true; }); + + stub.set_lamda(&TagManager::getTagsByUrls, [&isRun]() { + __DBG_STUB_INVOKE__ + isRun = true; + return QVariant(QStringList() << "red"); + }); + TagEventReceiver::instance()->handleWindowUrlChanged(1, QUrl("tag:/")); + TagEventReceiver::instance()->handleFileRemoveResult(QList() << QUrl("/"), true, QString()); + EXPECT_TRUE(isRun); +} + +TEST_F(TagEventReceiverTest, handleFileRenameResult) +{ + bool isRun = false; + stub.set_lamda(&TagManager::removeTagsOfFiles, []() { return true; }); + stub.set_lamda(&TagManager::addTagsForFiles, []() { return true; }); + + stub.set_lamda(&TagManager::getTagsByUrls, [&isRun]() { + __DBG_STUB_INVOKE__ + isRun = true; + return QVariant(QStringList() << "red"); + }); + QMap map; + map.insert(QUrl("/"), QUrl("/")); + TagEventReceiver::instance()->handleFileRenameResult(1, map, true, QString()); + EXPECT_TRUE(isRun); +} + +TEST_F(TagEventReceiverTest, handleGetTags) +{ + stub.set_lamda(&TagManager::getTagsByUrls, []() { + __DBG_STUB_INVOKE__ + return QVariant(QStringList() << "red"); + }); + EXPECT_TRUE(!TagEventReceiver::instance()->handleGetTags(QUrl("/")).isEmpty()); +} + +TEST_F(TagEventReceiverTest, handleSidebarOrderChanged) +{ + bool isRun = false; + typedef QVariant (dpf::EventChannelManager::*Push)(const QString &, const QString &, quint64, const QString &); + auto push = static_cast(&dpf::EventChannelManager::push); + stub.set_lamda(push, [&isRun] { + isRun = true; + return QVariant(); + }); + TagEventReceiver::instance()->handleSidebarOrderChanged(1, QString("Tag")); + EXPECT_TRUE(isRun); +} diff --git a/tests/plugins/common/dfmplugin-tag/files/ut_tagdiriterator.cpp b/tests/plugins/common/dfmplugin-tag/files/ut_tagdiriterator.cpp new file mode 100644 index 0000000000..a781bfc780 --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/files/ut_tagdiriterator.cpp @@ -0,0 +1,84 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "files/tagdiriterator.h" +#include "files/private/tagdiriterator_p.h" +#include "utils/tagmanager.h" +#include "utils/taghelper.h" +#include + +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class TagDirIteratorTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + + stub.set_lamda(&TagManager::getFilesByTag, []() { + __DBG_STUB_INVOKE__ + return QStringList() << QString("红色"); + }); + iter = new TagDirIterator(QUrl::fromLocalFile("/home/"), {}, QDir::AllEntries); + d = iter->d.data(); + } + + virtual void TearDown() override + { + stub.clear(); + delete iter; + iter = nullptr; + } + +private: + stub_ext::StubExt stub; + TagDirIterator *iter { nullptr }; + TagDirIteratorPrivate *d { nullptr }; +}; + +TEST_F(TagDirIteratorTest, Next) +{ + EXPECT_FALSE(iter->next().isValid()); +} + +TEST_F(TagDirIteratorTest, HasNext) +{ + EXPECT_FALSE(iter->hasNext()); +} + +TEST_F(TagDirIteratorTest, FileName) +{ + EXPECT_TRUE(iter->fileName() == ""); +} + +TEST_F(TagDirIteratorTest, FileUrl) +{ + EXPECT_FALSE(iter->fileUrl().isValid()); +} + +TEST_F(TagDirIteratorTest, FileInfo) +{ + EXPECT_TRUE(iter->fileInfo() == nullptr); +} + +TEST_F(TagDirIteratorTest, Url) +{ + EXPECT_TRUE(iter->url().isValid()); +} + +TEST_F(TagDirIteratorTest, loadTagsUrls) +{ + stub.set_lamda(&TagManager::getAllTags, []() { + __DBG_STUB_INVOKE__ + QMap map; + map.insert("红色", QColor("red")); + return map; + }); + d->loadTagsUrls(TagHelper::rootUrl()); +} diff --git a/tests/plugins/common/dfmplugin-tag/files/ut_tagfileinfo.cpp b/tests/plugins/common/dfmplugin-tag/files/ut_tagfileinfo.cpp new file mode 100644 index 0000000000..62494e74e5 --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/files/ut_tagfileinfo.cpp @@ -0,0 +1,100 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "files/tagfileinfo.h" +#include "utils/taghelper.h" +#include "utils/tagmanager.h" + +#include +#include +#include + +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class TagFileInfoTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + info = new TagFileInfo(QUrl("tag:///红色")); + } + virtual void TearDown() override + { + stub.clear(); + delete info; + info = nullptr; + } + +private: + stub_ext::StubExt stub; + + TagFileInfo *info { nullptr }; +}; + +TEST_F(TagFileInfoTest, exists) +{ + stub.set_lamda(&TagManager::getAllTags, []() { + __DBG_STUB_INVOKE__ + QMap map; + map.insert("红色", QColor("red")); + return map; + }); + EXPECT_TRUE(info->exists()); +} + +TEST_F(TagFileInfoTest, permissions) +{ + QFile::Permissions flag = info->permissions(); + EXPECT_TRUE(flag.testFlag(QFileDevice::ReadGroup)); + EXPECT_TRUE(flag.testFlag(QFileDevice::ReadOwner)); + EXPECT_TRUE(flag.testFlag(QFileDevice::ReadOther)); +} + +TEST_F(TagFileInfoTest, nameOf) +{ + EXPECT_EQ(info->nameOf(dfmbase::NameInfoType::kFileName), "红色"); +} + +TEST_F(TagFileInfoTest, displayOf) +{ + EXPECT_TRUE(info->displayOf(dfmbase::DisPlayInfoType::kFileDisplayName) == "红色"); +} + +TEST_F(TagFileInfoTest, urlOf) +{ + EXPECT_TRUE(info->urlOf(UrlInfoType::kUrl) == QUrl("tag:///红色")); +} + +TEST_F(TagFileInfoTest, isAttributes) +{ + EXPECT_TRUE(info->isAttributes(dfmbase::OptInfoType::kIsReadable)); + EXPECT_TRUE(info->isAttributes(dfmbase::OptInfoType::kIsWritable)); +} + +TEST_F(TagFileInfoTest, canAttributes) +{ + EXPECT_FALSE(info->canAttributes(dfmbase::CanableInfoType::kCanTrash)); + EXPECT_FALSE(info->canAttributes(dfmbase::CanableInfoType::kCanRename)); + EXPECT_FALSE(info->canAttributes(dfmbase::CanableInfoType::kCanRedirectionFileUrl)); +} + +TEST_F(TagFileInfoTest, fileName) +{ + EXPECT_FALSE(info->fileName().isEmpty()); +} + +TEST_F(TagFileInfoTest, tagName) +{ + EXPECT_FALSE(info->tagName().isEmpty()); +} + +TEST_F(TagFileInfoTest, fileType) +{ + EXPECT_TRUE(info->fileType() == FileInfo::FileType::kDirectory); +} diff --git a/tests/plugins/common/dfmplugin-tag/files/ut_tagfilewatcher.cpp b/tests/plugins/common/dfmplugin-tag/files/ut_tagfilewatcher.cpp new file mode 100644 index 0000000000..8e160a3f14 --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/files/ut_tagfilewatcher.cpp @@ -0,0 +1,116 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "files/tagfilewatcher.h" +#include "files/private/tagfilewatcher_p.h" +#include "utils/tagmanager.h" +#include "utils/taghelper.h" +#include +#include +#include +#include + +#include + +#include +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class TagFileWatcherTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + QSharedPointer w(new LocalFileWatcher(QUrl::fromLocalFile("/home"))); + stub.set_lamda(&WatcherFactory::create, [&w] { + return w; + }); + // stub.set_lamda(&TagFileWatcherPrivate::initConnect, [] {}); + // stub.set_lamda(&TagFileWatcherPrivate::initFileWatcher, [] {}); + watcher = new TagFileWatcher(TagHelper::rootUrl()); + } + virtual void TearDown() override + { + stub.clear(); + delete watcher; + watcher = nullptr; + } + +protected: + TagFileWatcher *watcher = { nullptr }; + stub_ext::StubExt stub; +}; + +TEST_F(TagFileWatcherTest, onTagRemoved) +{ + stub.set_lamda(&TagHelper::makeTagUrlByTagName, []() { + return TagHelper::rootUrl(); + }); + bool isRun = false; + QObject::connect(watcher, &AbstractFileWatcher::fileDeleted, [&isRun](const QUrl url) { + isRun = true; + EXPECT_EQ(url, TagHelper::rootUrl()); + }); + watcher->onTagRemoved("红色"); + EXPECT_TRUE(isRun); +} + +TEST_F(TagFileWatcherTest, onFilesTagged) +{ + stub.set_lamda(&TagHelper::getTagNameFromUrl, []() { + return QString("红色"); + }); + bool isRun = false; + QObject::connect(watcher, &AbstractFileWatcher::subfileCreated, [&isRun]() { + isRun = true; + }); + QVariantMap fileAndTags; + fileAndTags.insert(TagHelper::rootUrl().toString(), QVariant(QString("红色"))); + watcher->onFilesTagged(fileAndTags); + EXPECT_TRUE(isRun); +} + +TEST_F(TagFileWatcherTest, onFilesUntagged) +{ + stub.set_lamda(&TagHelper::getTagNameFromUrl, []() { + return QString("红色"); + }); + bool isRun = false; + QObject::connect(watcher, &AbstractFileWatcher::fileDeleted, [&isRun]() { + isRun = true; + }); + QVariantMap fileAndTags; + fileAndTags.insert(TagHelper::rootUrl().toString(), QVariant(QString("红色"))); + watcher->onFilesUntagged(fileAndTags); + EXPECT_TRUE(isRun); +} + +TEST_F(TagFileWatcherTest, onFilesHidden) +{ + stub.set_lamda(&TagHelper::getTagNameFromUrl, []() { + return QString("红色"); + }); + bool isRun = false; + QObject::connect(watcher, &AbstractFileWatcher::fileAttributeChanged, [&isRun]() { + isRun = true; + }); + QVariantMap fileAndTags; + fileAndTags.insert(TagHelper::rootUrl().toString(), QVariant(QString("红色"))); + watcher->onFilesHidden(fileAndTags); + EXPECT_TRUE(isRun); +} + +TEST_F(TagFileWatcherTest, start) +{ + EXPECT_TRUE(watcher->dptr->start()); +} + +TEST_F(TagFileWatcherTest, stop) +{ + EXPECT_FALSE(watcher->dptr->stop()); +} diff --git a/tests/plugins/common/dfmplugin-tag/menu/ut_tagdirmenuscene.cpp b/tests/plugins/common/dfmplugin-tag/menu/ut_tagdirmenuscene.cpp new file mode 100644 index 0000000000..662dba1e7b --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/menu/ut_tagdirmenuscene.cpp @@ -0,0 +1,124 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "menu/tagdirmenuscene.h" +#include "menu/private/tagdirmenuscene_p.h" +#include "plugins/common/core/dfmplugin-menu/menuscene/action_defines.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class TagDirMenuSceneTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + auto creator = new TagDirMenuCreator(); + scene = static_cast(creator->create()); + d = scene->d.data(); + } + virtual void TearDown() override + { + stub.clear(); + delete scene; + } + +protected: + stub_ext::StubExt stub; + TagDirMenuScene *scene { nullptr }; + TagDirMenuScenePrivate *d { nullptr }; +}; + +TEST_F(TagDirMenuSceneTest, name) +{ + EXPECT_TRUE(scene->name() == "TagDirMenu"); +} + +TEST_F(TagDirMenuSceneTest, initialize) +{ + QList urls { QUrl::fromLocalFile("/hello/world"), + QUrl::fromLocalFile("/i/can/eat/glass/without/hurt") }; + EXPECT_TRUE(scene->initialize({ { "currentDir", true } })); + EXPECT_TRUE(scene->initialize({ { "selectFiles", QVariant::fromValue>(urls) } })); + EXPECT_TRUE(scene->initialize({ { "onDesktop", true } })); + EXPECT_TRUE(scene->initialize({ { "isEmptyArea", true } })); + EXPECT_TRUE(scene->initialize({ { "indexFlags", true } })); +} + +TEST_F(TagDirMenuSceneTest, create) +{ + EXPECT_FALSE(scene->create(nullptr)); + + QMenu menu; + EXPECT_TRUE(scene->create(&menu)); +} + +TEST_F(TagDirMenuSceneTest, triggered) +{ + auto act = new QAction("hello"); + act->setProperty(TagActionId::kOpenFileLocation, "hello"); + EXPECT_TRUE(scene->initialize({ { "onDesktop", true }, { "onCollection", true } })); + EXPECT_FALSE(scene->triggered(act)); +} + +TEST_F(TagDirMenuSceneTest, updateMenu) +{ + QMenu menu; + menu.addSeparator(); + auto act = menu.addAction("Open file location"); + act->setProperty(ActionPropertyKey::kActionID, TagActionId::kOpenFileLocation); + + d->isEmptyArea = false; + EXPECT_NO_FATAL_FAILURE(d->updateMenu(&menu)); +} + +TEST_F(TagDirMenuSceneTest, scene) +{ + EXPECT_EQ(nullptr, scene->scene(nullptr)); + + auto act = new QAction("hello"); + d->predicateAction.insert("hello", act); + EXPECT_STREQ(scene->scene(act)->metaObject()->className(), + "dfmplugin_tag::TagDirMenuScene"); + + d->predicateAction.clear(); + scene->scene(act); + delete act; + act = nullptr; +} + +TEST_F(TagDirMenuSceneTest, openFileLocation) +{ + DWIDGET_USE_NAMESPACE + stub_ext::StubExt st; + st.set_lamda(SysInfoUtils::isRootUser, [] { return true; }); + + typedef bool (*StartFunc)(const QString &, const QStringList &); + auto func = static_cast(QProcess::startDetached); + st.set_lamda(func, [] { return true; }); + + EXPECT_TRUE(d->openFileLocation("/home")); + + st.reset(SysInfoUtils::isRootUser); + st.set_lamda(SysInfoUtils::isRootUser, [] { return false; }); + + typedef bool (*ShowItemFunc)(QString, const QString &); + auto func2 = static_cast(DDesktopServices::showFileItem); + st.set_lamda(func2, [] { return true; }); + EXPECT_TRUE(d->openFileLocation("/home")); +} diff --git a/tests/plugins/common/dfmplugin-tag/menu/ut_tagmenuscene.cpp b/tests/plugins/common/dfmplugin-tag/menu/ut_tagmenuscene.cpp new file mode 100644 index 0000000000..b5381883bc --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/menu/ut_tagmenuscene.cpp @@ -0,0 +1,163 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "menu/private/tagmenuscene_p.h" +#include "menu/tagmenuscene.h" +#include "utils/taghelper.h" +#include "utils/tagmanager.h" +#include "widgets/tagcolorlistwidget.h" + +#include +#include +#include +#include + +#include + +#include +#include +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class TagMenuSceneTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + auto creator = new TagMenuCreator(); + scene = static_cast(creator->create()); + d = scene->d.data(); + } + virtual void TearDown() override + { + stub.clear(); + delete scene; + } + +protected: + stub_ext::StubExt stub; + TagMenuScene *scene { nullptr }; + TagMenuScenePrivate *d { nullptr }; +}; + +TEST_F(TagMenuSceneTest, name) +{ + EXPECT_TRUE(scene->name() == "TagMenu"); +} + +TEST_F(TagMenuSceneTest, initialize) +{ + QList urls { QUrl::fromLocalFile("/hello/world"), + QUrl::fromLocalFile("/i/can/eat/glass/without/hurt") }; + EXPECT_TRUE(scene->initialize({ { "currentDir", true } })); + EXPECT_TRUE(scene->initialize( + { { "selectFiles", QVariant::fromValue>(urls) } })); + EXPECT_TRUE(scene->initialize({ { "onDesktop", true } })); + EXPECT_EQ(d->onDesktop, true); + EXPECT_TRUE(scene->initialize({ { "isEmptyArea", true } })); + EXPECT_TRUE(scene->initialize({ { "indexFlags", true } })); +} + +TEST_F(TagMenuSceneTest, create) +{ + EXPECT_FALSE(scene->create(nullptr)); + + QMenu menu; + EXPECT_TRUE(scene->create(&menu)); +} + +TEST_F(TagMenuSceneTest, triggered) +{ + auto act = new QAction("hello"); + stub.set_lamda(&TagHelper::showTagEdit, [] { __DBG_STUB_INVOKE__ }); + act->setProperty(ActionPropertyKey::kActionID, "hello"); + scene->d->predicateAction.insert(TagActionId::kActTagAddKey, act); + scene->d->focusFile.setUrl("/hello"); + + EXPECT_TRUE(scene->initialize({ { "onDesktop", true }, { "onCollection", true } })); + EXPECT_FALSE(scene->triggered(act)); + EXPECT_TRUE(scene->initialize({ { "onDesktop", true }, { "onCollection", false } })); + EXPECT_FALSE(scene->triggered(act)); + EXPECT_TRUE(scene->initialize({ { "onDesktop", true } })); + EXPECT_FALSE(scene->triggered(act)); + EXPECT_TRUE(scene->initialize({ { "onDesktop", false } })); + EXPECT_FALSE(scene->triggered(act)); +} + +TEST_F(TagMenuSceneTest, scene) +{ + EXPECT_EQ(nullptr, scene->scene(nullptr)); + + auto act = new QAction("hello"); + d->predicateAction.insert("hello", act); + EXPECT_STREQ(scene->scene(act)->metaObject()->className(), + "dfmplugin_tag::TagMenuScene"); + + d->predicateAction.clear(); + scene->scene(act); + delete act; + act = nullptr; +} + +TEST_F(TagMenuSceneTest, onHoverChanged) +{ + scene->d->selectFiles << QUrl::fromLocalFile("/test"); + stub.set_lamda(&TagManager::getTagsByUrls, + []() { __DBG_STUB_INVOKE__ return QVariant(); }); + bool flag = false; + TagColorListWidget *tagWidget = new TagColorListWidget(); + stub.set_lamda(&TagMenuScene::getMenuListWidget, [tagWidget]() { + __DBG_STUB_INVOKE__ + return tagWidget; + }); + stub.set_lamda(&TagColorListWidget::setToolTipText, + [&flag]() { __DBG_STUB_INVOKE__ flag = true; }); + stub.set_lamda(&TagManager::getTagsColor, []() { + __DBG_STUB_INVOKE__ + QMap map; + map["red"] = QColor("red"); + return map; + }); + scene->onHoverChanged(QColor("red")); + EXPECT_TRUE(flag); + delete tagWidget; + tagWidget = nullptr; +} + +TEST_F(TagMenuSceneTest, onColorClicked) +{ + TagColorListWidget *tagWidget = new TagColorListWidget(); + stub.set_lamda(&TagMenuScene::getMenuListWidget, [tagWidget]() { + __DBG_STUB_INVOKE__ + return tagWidget; + }); + + bool flag = false; + stub.set_lamda(&TagManager::addTagsForFiles, [&flag]() { + __DBG_STUB_INVOKE__ flag = true; + return true; + }); + stub.set_lamda(&TagManager::removeTagsOfFiles, [&flag]() { + __DBG_STUB_INVOKE__ flag = true; + return true; + }); + scene->onColorClicked(QColor("red")); + EXPECT_TRUE(flag); + delete tagWidget; + tagWidget = nullptr; +} + +TEST_F(TagMenuSceneTest, getSurfaceRect) +{ + QWidget *w = new QWidget(); + QWidget w2; + w2.setFixedSize(10, 10); + w2.setProperty("WidgetName", QString("organizersurface")); + w->setParent(&w2); + EXPECT_TRUE(d->getSurfaceRect(w) == w2.rect()); +} diff --git a/tests/plugins/common/dfmplugin-tag/ut_tag.cpp b/tests/plugins/common/dfmplugin-tag/ut_tag.cpp index 1d7150c602..e060e30158 100644 --- a/tests/plugins/common/dfmplugin-tag/ut_tag.cpp +++ b/tests/plugins/common/dfmplugin-tag/ut_tag.cpp @@ -6,30 +6,44 @@ #include "tag.h" #include "utils/tagmanager.h" +#include "utils/filetagcache.h" #include "widgets/tagwidget.h" #include "widgets/private/tagwidget_p.h" +#include "data/tagproxyhandle.h" #include #include +#include "plugins/common/core/dfmplugin-menu/menu_eventinterface_helper.h" #include #include #include +#include "qdbusabstractinterface.h" +#include using CustomViewExtensionView = std::function; DFMBASE_USE_NAMESPACE using namespace dfmplugin_tag; using namespace dpf; - +using namespace QDBus; Q_DECLARE_METATYPE(CustomViewExtensionView) class TagTest : public testing::Test { protected: - virtual void SetUp() override {} + virtual void SetUp() override + { + stub.set_lamda(&TagManager::getAllTags, []() { + __DBG_STUB_INVOKE__ + return QMap(); + }); + stub.set_lamda(&QDBusAbstractInterface::asyncCallWithArgumentList, []() { + return QDBusPendingCall::fromError(QDBusError()); + }); + } virtual void TearDown() override { stub.clear(); } private: @@ -48,6 +62,9 @@ TEST_F(TagTest, Start) stub.set_lamda(push1, [] { __DBG_STUB_INVOKE__ return QVariant(); }); stub.set_lamda(push2, [] { __DBG_STUB_INVOKE__ return QVariant(); }); stub.set_lamda(push3, [] { __DBG_STUB_INVOKE__ return QVariant(); }); + stub.set_lamda(&FileTagCacheController::initLoadTagInfos, []() { + __DBG_STUB_INVOKE__ + }); EXPECT_TRUE(ins.start()); } @@ -62,3 +79,54 @@ TEST_F(TagTest, createTagWidget) }); EXPECT_TRUE(ins.createTagWidget(QUrl("file://hello/world"))); } + +TEST_F(TagTest, initialize) +{ + bool isRegister = false; + stub.set_lamda(&TagProxyHandle::connectToService, [&isRegister]() { + __DBG_STUB_INVOKE__ + isRegister = true; + return true; + }); + ins.initialize(); + EXPECT_TRUE(isRegister); +} + +TEST_F(TagTest, onWindowOpened) +{ + bool isRun = false; + FileManagerWindow w(QUrl::fromLocalFile("/home")); + stub.set_lamda(&FileManagerWindowsManager::findWindowById, [&w, &isRun] { + isRun = true; + return &w; + }); + stub.set_lamda(&Tag::installToSideBar, [] {}); + ins.onWindowOpened(1); + EXPECT_TRUE(isRun); +} + +TEST_F(TagTest, onAllPluginsStarted) +{ + bool isRun = false; + typedef QVariant (dpf::EventChannelManager::*Push)(const QString &, const QString &, QString); + auto push = static_cast(&dpf::EventChannelManager::push); + stub.set_lamda(push, [&isRun] { + isRun = true; + return QVariant(); + }); + + ins.onAllPluginsStarted(); + EXPECT_TRUE(isRun); +} + +TEST_F(TagTest, installToSideBar) +{ + bool isRun = false; + stub.set_lamda(&TagManager::getAllTags, [&isRun]() { + __DBG_STUB_INVOKE__ + isRun = true; + return QMap(); + }); + ins.installToSideBar(); + EXPECT_TRUE(isRun); +} diff --git a/tests/plugins/common/dfmplugin-tag/utils/ut_anythingmonitorfilter.cpp b/tests/plugins/common/dfmplugin-tag/utils/ut_anythingmonitorfilter.cpp new file mode 100644 index 0000000000..b00cb2a86e --- /dev/null +++ b/tests/plugins/common/dfmplugin-tag/utils/ut_anythingmonitorfilter.cpp @@ -0,0 +1,38 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "utils/anythingmonitorfilter.h" + +#include +#include + +#include + +DFMBASE_USE_NAMESPACE +using namespace dfmplugin_tag; + +class AnythingMonitorFilterTest : public testing::Test +{ +protected: + virtual void SetUp() override + { + ins = &AnythingMonitorFilter::instance(); + } + virtual void TearDown() override + { + stub.clear(); + } + +private: + stub_ext::StubExt stub; + AnythingMonitorFilter *ins; +}; + +TEST_F(AnythingMonitorFilterTest, whetherFilterCurrentPath) +{ + EXPECT_TRUE(ins->whetherFilterCurrentPath("/media")); + EXPECT_TRUE(!ins->whetherFilterCurrentPath("~/.local/share/Trash")); +} diff --git a/tests/plugins/common/dfmplugin-tag/utils/ut_filetagcache.cpp b/tests/plugins/common/dfmplugin-tag/utils/ut_filetagcache.cpp index 9c44d3583c..10a8b85e34 100644 --- a/tests/plugins/common/dfmplugin-tag/utils/ut_filetagcache.cpp +++ b/tests/plugins/common/dfmplugin-tag/utils/ut_filetagcache.cpp @@ -51,6 +51,7 @@ TEST_F(FileTagCacheTest, loadFileTagsFromDatabase) hash["test"] = QColor("red"); return hash; }); + stub.set_lamda(&TagProxyHandle::isValid, []() { __DBG_STUB_INVOKE__ return true; }); ins->loadFileTagsFromDatabase(); EXPECT_TRUE(ins->getTagsColor(QStringList() << QString("test")).value("test") == QColor("red")); } diff --git a/tests/plugins/common/dfmplugin-tag/utils/ut_taghelper.cpp b/tests/plugins/common/dfmplugin-tag/utils/ut_taghelper.cpp index f0b425156b..2e7e2fe8af 100644 --- a/tests/plugins/common/dfmplugin-tag/utils/ut_taghelper.cpp +++ b/tests/plugins/common/dfmplugin-tag/utils/ut_taghelper.cpp @@ -7,6 +7,7 @@ #include "utils/taghelper.h" #include "utils/tagmanager.h" #include "widgets/tageditor.h" +#include "utils/filetagcache.h" #include #include diff --git a/tests/plugins/common/dfmplugin-tag/utils/ut_tagmanager.cpp b/tests/plugins/common/dfmplugin-tag/utils/ut_tagmanager.cpp index 80a27ba085..482f1f1add 100644 --- a/tests/plugins/common/dfmplugin-tag/utils/ut_tagmanager.cpp +++ b/tests/plugins/common/dfmplugin-tag/utils/ut_tagmanager.cpp @@ -7,19 +7,23 @@ #include "utils/tagmanager.h" #include "utils/taghelper.h" #include "data/tagproxyhandle.h" +#include "utils/filetagcache.h" #include #include #include +#include #include "utils/anythingmonitorfilter.h" +#include "files/tagfileinfo.h" #include #include #include +#include "qdbusabstractinterface.h" +#include -DFMBASE_USE_NAMESPACE -using namespace dfmplugin_tag; +DFMBASE_USE_NAMESPACE using namespace dfmplugin_tag; class TagManagerTest : public testing::Test { @@ -28,6 +32,9 @@ class TagManagerTest : public testing::Test virtual void SetUp() override { ins = TagManager::instance(); + stub.set_lamda(&QDBusAbstractInterface::asyncCallWithArgumentList, []() { + return QDBusPendingCall::fromError(QDBusError()); + }); } virtual void TearDown() override { @@ -41,11 +48,14 @@ class TagManagerTest : public testing::Test TEST_F(TagManagerTest, canTagFile) { + FileInfoPointer info(new FileInfo(QUrl("file:///test"))); + stub.set_lamda(&InfoFactory::create, [info](const QUrl &url, const Global::CreateFileInfoType type, QString *errorString) { + return info; + }); stub.set_lamda(&TagManager::localFileCanTagFilter, []() { __DBG_STUB_INVOKE__ return true; }); EXPECT_FALSE(ins->canTagFile(QUrl())); EXPECT_TRUE(ins->canTagFile(QUrl("file:/hello/world"))); EXPECT_FALSE(ins->canTagFile(FileInfoPointer())); - FileInfoPointer info(new FileInfo(QUrl("file:///test"))); EXPECT_TRUE(ins->canTagFile(info)); } @@ -78,6 +88,9 @@ TEST_F(TagManagerTest, paintIconTagsHandle2) TEST_F(TagManagerTest, fileDropHandle) { + stub.set_lamda(&InfoFactory::create, []() { + return nullptr; + }); EXPECT_TRUE(ins->fileDropHandle(QList() << QUrl("file:///test"), TagManager::rootUrl())); auto func = static_cast(&TagManager::canTagFile); stub.set_lamda(func, []() { __DBG_STUB_INVOKE__ return true; });