diff --git a/src/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene.cpp b/src/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene.cpp index 493ec2b175..655c9a1d82 100644 --- a/src/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene.cpp +++ b/src/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene.cpp @@ -127,6 +127,9 @@ bool VirtualEntryMenuScene::create(QMenu *parent) void VirtualEntryMenuScene::updateState(QMenu *parent) { + if (!parent) + return; + using namespace menu_action_id; QStringList visibleActions; if (d->aggregatedEntrySelected) @@ -141,6 +144,9 @@ void VirtualEntryMenuScene::updateState(QMenu *parent) bool VirtualEntryMenuScene::triggered(QAction *action) { + if (!action) + return false; + using namespace menu_action_id; auto key = action->property(ActionPropertyKey::kActionID).toString(); bool handled = false; @@ -208,6 +214,9 @@ void VirtualEntryMenuScenePrivate::insertActionBefore(const QString &inserted, c void VirtualEntryMenuScenePrivate::hookCptActions(QAction *triggered) { + if (!triggered) + return; + const QString &triggeredId = triggered->property(ActionPropertyKey::kActionID).toString(); if (triggeredId == menu_action_id::kCptActLogoutAndForget) actCptForget(); diff --git a/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/ut_virtualentrydata.cpp b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/ut_virtualentrydata.cpp new file mode 100644 index 0000000000..6cf358c174 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/ut_virtualentrydata.cpp @@ -0,0 +1,53 @@ +// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/virtualentrydata.h" + +#include + +DPSMBBROWSER_USE_NAMESPACE + +class UT_VirtualEntryData : public testing::Test +{ +protected: + virtual void SetUp() override + { + } + virtual void TearDown() override + { + stub.clear(); + } + +private: + stub_ext::StubExt stub; +}; + +TEST_F(UT_VirtualEntryData, AllInOne) +{ + VirtualEntryData d1, d2; + EXPECT_NO_FATAL_FAILURE(d1 = d2); + + EXPECT_NO_FATAL_FAILURE(d1.setDisplayName("hello")); + EXPECT_NO_FATAL_FAILURE(d1.setHost("1.2.3.4")); + EXPECT_NO_FATAL_FAILURE(d1.setProtocol("smb")); + EXPECT_NO_FATAL_FAILURE(d1.setPort(139)); + EXPECT_EQ(d1.getDisplayName(), "hello"); + EXPECT_EQ(d1.getHost(), "1.2.3.4"); + EXPECT_EQ(d1.getProtocol(), "smb"); + EXPECT_EQ(d1.getPort(), 139); + + VirtualEntryData d3("smb://1.2.3.4"); + EXPECT_EQ(d3.getDisplayName(), "1.2.3.4"); + EXPECT_EQ(d3.getHost(), "1.2.3.4"); + EXPECT_EQ(d3.getProtocol(), "smb"); + EXPECT_EQ(d3.getPort(), -1); + + VirtualEntryData d4(d3); + EXPECT_EQ(d4.getDisplayName(), "1.2.3.4"); + EXPECT_EQ(d4.getHost(), "1.2.3.4"); + EXPECT_EQ(d4.getProtocol(), "smb"); + EXPECT_EQ(d4.getPort(), -1); +} diff --git a/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/ut_virtualentrymenuscene.cpp b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/ut_virtualentrymenuscene.cpp new file mode 100644 index 0000000000..9869509a45 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/ut_virtualentrymenuscene.cpp @@ -0,0 +1,287 @@ +// SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" + +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene.h" +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/menu/virtualentrymenuscene_p.h" +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/utilities/protocoldisplayutilities.h" +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/virtualentrydbhandler.h" + +#include +#include +#include +#include +#include +#include + +#include + +#include + +DPSMBBROWSER_USE_NAMESPACE +DFMBASE_USE_NAMESPACE + +class UT_VirtualEntryMenuScene : public testing::Test +{ +protected: + virtual void SetUp() override + { + scene = new VirtualEntryMenuScene(); + } + virtual void TearDown() override + { + stub.clear(); + delete scene; + } + +private: + stub_ext::StubExt stub; + VirtualEntryMenuScene *scene { nullptr }; +}; + +TEST_F(UT_VirtualEntryMenuScene, Name) +{ + EXPECT_EQ("VirtualEntry", scene->name()); + EXPECT_NE("XXX", scene->name()); +} + +TEST_F(UT_VirtualEntryMenuScene, Initialize) +{ + QVariantHash params; + EXPECT_FALSE(scene->initialize(params)); + + QList urls { QUrl::fromLocalFile("/home") }; + params.insert(MenuParamKey::kSelectFiles, QVariant::fromValue>(urls)); + + typedef QVariant (dpf::EventChannelManager::*Push)(const QString &, const QString &, QString); + auto f = static_cast(&dpf::EventChannelManager::push); + stub.set_lamda(f, [] { __DBG_STUB_INVOKE__ return QVariant::fromValue(nullptr); }); + EXPECT_FALSE(scene->initialize(params)); + + QUrl u; + u.setScheme("entry"); + u.setPath("smb://1.2.3.4/share/.ventry"); + urls = { u }; + params.insert(MenuParamKey::kSelectFiles, QVariant::fromValue>(urls)); + EXPECT_TRUE(scene->initialize(params)); + EXPECT_EQ("smb://1.2.3.4/share/", scene->d->stdSmb); + EXPECT_TRUE(scene->d->seperatedEntrySelected); + + u.setPath("smb://1.2.3.4.ventry"); + urls = { u }; + params.insert(MenuParamKey::kSelectFiles, QVariant::fromValue>(urls)); + EXPECT_TRUE(scene->initialize(params)); + EXPECT_EQ("smb://1.2.3.4", scene->d->stdSmb); + EXPECT_TRUE(scene->d->aggregatedEntrySelected); + + u.setPath("/home.protodev"); + urls = { u }; + params.insert(MenuParamKey::kSelectFiles, QVariant::fromValue>(urls)); + typedef QString (*GetPath)(const QString &); + auto ff = static_cast(protocol_display_utilities::getStandardSmbPath); + stub.set_lamda(ff, [] { __DBG_STUB_INVOKE__ return "hello"; }); + EXPECT_FALSE(scene->initialize(params)); + + stub.set_lamda(ff, [] { __DBG_STUB_INVOKE__ return "smb://1.2.3.4"; }); + EXPECT_TRUE(scene->initialize(params)); +} + +TEST_F(UT_VirtualEntryMenuScene, Create) +{ + EXPECT_FALSE(scene->create(nullptr)); + + QMenu menu; + scene->d->aggregatedEntrySelected = true; + bool hasMounted = false; + stub.set_lamda(protocol_display_utilities::hasMountedShareOf, [&] { __DBG_STUB_INVOKE__ return hasMounted; }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::insertActionBefore, [] { __DBG_STUB_INVOKE__ }); + EXPECT_TRUE(scene->create(&menu)); + + scene->d->aggregatedEntrySelected = false; + scene->d->seperatedEntrySelected = true; + EXPECT_TRUE(scene->create(&menu)); +} + +TEST_F(UT_VirtualEntryMenuScene, UpdateState) +{ + EXPECT_NO_FATAL_FAILURE(scene->updateState(nullptr)); + + stub.set_lamda(&VirtualEntryMenuScenePrivate::setActionVisible, [] { __DBG_STUB_INVOKE__ }); + QMenu menu; + scene->d->aggregatedEntrySelected = true; + EXPECT_NO_FATAL_FAILURE(scene->updateState(&menu)); + + scene->d->aggregatedEntrySelected = false; + scene->d->seperatedEntrySelected = true; + EXPECT_NO_FATAL_FAILURE(scene->updateState(&menu)); +} + +TEST_F(UT_VirtualEntryMenuScene, Triggered) +{ + EXPECT_NO_FATAL_FAILURE(scene->triggered(nullptr)); + + stub.set_lamda(&VirtualEntryMenuScenePrivate::actUnmountAggregatedItem, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::actForgetAggregatedItem, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::actRemoveVirtualEntry, [] { __DBG_STUB_INVOKE__ }); + + QAction act; + act.setProperty("actionID", "aggregated-unmount"); + EXPECT_NO_FATAL_FAILURE(scene->triggered(&act)); + + act.setProperty("actionID", "aggregated-forget"); + EXPECT_NO_FATAL_FAILURE(scene->triggered(&act)); + + act.setProperty("actionID", "virtual-entry-remove"); + EXPECT_NO_FATAL_FAILURE(scene->triggered(&act)); +} + +TEST_F(UT_VirtualEntryMenuScene, Scene) +{ + EXPECT_NO_FATAL_FAILURE(scene->scene(nullptr)); + EXPECT_EQ(nullptr, scene->scene(nullptr)); + + QAction act; + scene->d->predicateAction.insert("test", &act); + EXPECT_EQ(scene, scene->scene(&act)); + + QAction act2; + EXPECT_NO_FATAL_FAILURE(scene->scene(&act2)); +} + +class UT_VirtualEntryMenuScenePrivate : public testing::Test +{ +protected: + virtual void SetUp() override + { + scene = new VirtualEntryMenuScene(); + d = scene->d.data(); + } + virtual void TearDown() override + { + stub.clear(); + delete scene; + } + +private: + stub_ext::StubExt stub; + VirtualEntryMenuScene *scene { nullptr }; + VirtualEntryMenuScenePrivate *d { nullptr }; +}; + +TEST_F(UT_VirtualEntryMenuScenePrivate, SetActionVisiable) +{ + EXPECT_NO_FATAL_FAILURE(d->setActionVisible(QStringList(), nullptr)); + + QMenu m; + m.addAction("hello"); + EXPECT_NO_FATAL_FAILURE(d->setActionVisible(QStringList(), &m)); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, InsertActionBefore) +{ + QMenu m; + auto act = m.addAction("hello"); + act->setProperty(ActionPropertyKey::kActionID, "hello"); + + EXPECT_NO_FATAL_FAILURE(d->insertActionBefore("test", "hello", &m)); + EXPECT_TRUE(m.actions().count() == 2); + + EXPECT_NO_FATAL_FAILURE(d->insertActionBefore("test", "xxx", &m)); + EXPECT_TRUE(m.actions().count() == 3); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, HookCptActions) +{ + stub.set_lamda(&VirtualEntryMenuScenePrivate::actCptForget, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::actCptMount, [] { __DBG_STUB_INVOKE__ }); + + EXPECT_NO_FATAL_FAILURE(d->hookCptActions(nullptr)); + + QAction act; + act.setProperty(ActionPropertyKey::kActionID, "computer-logout-and-forget-passwd"); + EXPECT_NO_FATAL_FAILURE(d->hookCptActions(&act)); + act.setProperty(ActionPropertyKey::kActionID, "computer-mount"); + EXPECT_NO_FATAL_FAILURE(d->hookCptActions(&act)); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, ActUnmountAggregatedItem) +{ + stub.set_lamda(protocol_display_utilities::getMountedSmb, [] { __DBG_STUB_INVOKE__ return QStringList { "smb://1.2.3.4" }; }); + typedef QString (*GetPath)(const QString &); + auto f = static_cast(protocol_display_utilities::getStandardSmbPath); + stub.set_lamda(f, [] { __DBG_STUB_INVOKE__ return "smb://1.2.3.4"; }); + stub.set_lamda(&DialogManager::showErrorDialogWhenOperateDeviceFailed, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::tryRemoveAggregatedEntry, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::gotoDefaultPageOnUnmount, [] { __DBG_STUB_INVOKE__ }); + + bool unmountResult = false; + stub.set_lamda(&DeviceManager::unmountProtocolDevAsync, [&](void *, const QString &, const QVariantMap &, CallbackType2 cb) { + __DBG_STUB_INVOKE__ + if (cb) cb(unmountResult, DFMMOUNT::OperationErrorInfo()); + }); + + EXPECT_NO_FATAL_FAILURE(d->actUnmountAggregatedItem(false)); + unmountResult = true; + EXPECT_NO_FATAL_FAILURE(d->actUnmountAggregatedItem(true)); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, ActForgetAggregatedItem) +{ + stub.set_lamda(computer_sidebar_event_calls::callForgetPasswd, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryMenuScenePrivate::actUnmountAggregatedItem, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(d->actForgetAggregatedItem()); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, ActMountSeperatedItem) +{ + bool unmountResult = false; + stub.set_lamda(&DeviceManager::mountNetworkDeviceAsync, [&](void *, const QString &, CallbackType1 cb, int) { + __DBG_STUB_INVOKE__ + if (cb) cb(unmountResult, DFMMOUNT::OperationErrorInfo(), ""); + }); + stub.set_lamda(&DialogManager::showErrorDialogWhenOperateDeviceFailed, [] { __DBG_STUB_INVOKE__ }); + + d->stdSmb = "smb://1.2.3.4/share///"; + EXPECT_NO_FATAL_FAILURE(d->actMountSeperatedItem()); +} +TEST_F(UT_VirtualEntryMenuScenePrivate, ActRemoveVirtualEntry) { } + +TEST_F(UT_VirtualEntryMenuScenePrivate, ActCptMount) +{ + stub.set_lamda(&VirtualEntryMenuScenePrivate::actMountSeperatedItem, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(d->actCptMount()); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, ActCptForget) +{ + stub.set_lamda(&VirtualEntryDbHandler::removeData, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(d->actCptForget()); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, GotoDefaultPageOnUnmount) +{ + stub.set_lamda(&Application::appAttribute, [] { __DBG_STUB_INVOKE__ return QUrl::fromLocalFile("/home"); }); + stub.set_lamda(&FileManagerWindowsManager::windowIdList, [] { __DBG_STUB_INVOKE__ return QList { 1 }; }); + stub.set_lamda(&FileManagerWindowsManager::findWindowById, [] { __DBG_STUB_INVOKE__ return reinterpret_cast(1); }); + stub.set_lamda(&FileManagerWindow::currentUrl, [] { __DBG_STUB_INVOKE__ return QUrl::fromLocalFile("/home"); }); + typedef bool (dpf::EventDispatcherManager::*Publish)(dpf::EventType, quint64, QUrl &); + auto f = static_cast(&dpf::EventDispatcherManager::publish); + stub.set_lamda(f, [] { __DBG_STUB_INVOKE__ return true; }); + + EXPECT_NO_FATAL_FAILURE(d->gotoDefaultPageOnUnmount()); + d->stdSmb = "file:///home"; + EXPECT_NO_FATAL_FAILURE(d->gotoDefaultPageOnUnmount()); +} + +TEST_F(UT_VirtualEntryMenuScenePrivate, TryRemoveAggregatedEntry) +{ + stub.set_lamda(&VirtualEntryDbHandler::removeData, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(protocol_display_utilities::getMountedSmb, [] { __DBG_STUB_INVOKE__ return QStringList { "smb://1.2.3.4" }; }); + stub.set_lamda(protocol_display_utilities::makeVEntryUrl, [] { __DBG_STUB_INVOKE__ return QUrl(); }); + stub.set_lamda(computer_sidebar_event_calls::callItemRemove, [] { __DBG_STUB_INVOKE__ }); + + EXPECT_NO_FATAL_FAILURE(VirtualEntryMenuScenePrivate::tryRemoveAggregatedEntry("smb://1.2.3.4", "")); + EXPECT_NO_FATAL_FAILURE(VirtualEntryMenuScenePrivate::tryRemoveAggregatedEntry("smb://3.4.5.6", "")); +} diff --git a/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/ut_protocoldevicedisplaymanager.cpp b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/ut_protocoldevicedisplaymanager.cpp index c1554de634..0232f9acf2 100644 --- a/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/ut_protocoldevicedisplaymanager.cpp +++ b/tests/plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/ut_protocoldevicedisplaymanager.cpp @@ -5,16 +5,28 @@ #include "stubext.h" #include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/protocoldevicedisplaymanager.h" #include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/protocoldevicedisplaymanager_p.h" +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/utilities/protocoldisplayutilities.h" +#include "plugins/filemanager/dfmplugin-smbbrowser/displaycontrol/datahelper/virtualentrydbhandler.h" + +#include +#include +#include +#include +#include #include +#include + using namespace dfmplugin_smbbrowser; +DFMBASE_USE_NAMESPACE class UT_ProtocolDeviceDisplayManager : public testing::Test { protected: virtual void SetUp() override { + stub.set_lamda(&ProtocolDeviceDisplayManagerPrivate::init, [] { __DBG_STUB_INVOKE__ }); } virtual void TearDown() override { @@ -27,23 +39,146 @@ class UT_ProtocolDeviceDisplayManager : public testing::Test TEST_F(UT_ProtocolDeviceDisplayManager, Instance) { + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()); + EXPECT_EQ(ProtocolDeviceDisplayManager::instance(), ProtocolDeviceDisplayManager::instance()); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, DisplayMode) +{ + EXPECT_EQ(SmbDisplayMode::kSeperate, ProtocolDeviceDisplayManager::instance()->displayMode()); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->displayMode = SmbDisplayMode::kAggregation); + EXPECT_EQ(SmbDisplayMode::kAggregation, ProtocolDeviceDisplayManager::instance()->displayMode()); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->displayMode = SmbDisplayMode::kSeperate); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, IsShowOfflineItem) +{ + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->isShowOfflineItem()); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->showOffline = true); + EXPECT_TRUE(ProtocolDeviceDisplayManager::instance()->isShowOfflineItem()); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->showOffline = false); } -TEST_F(UT_ProtocolDeviceDisplayManager, DisplayMode) { } -TEST_F(UT_ProtocolDeviceDisplayManager, IsShowOfflineItem) { } -TEST_F(UT_ProtocolDeviceDisplayManager, HookItemInsert) { } -TEST_F(UT_ProtocolDeviceDisplayManager, HookItemsFilter) { } -TEST_F(UT_ProtocolDeviceDisplayManager, OnDevMounted) { } -TEST_F(UT_ProtocolDeviceDisplayManager, OnDevUnmounted) { } -TEST_F(UT_ProtocolDeviceDisplayManager, OnDConfigChanged) { } -TEST_F(UT_ProtocolDeviceDisplayManager, OnJsonConfigChanged) { } -TEST_F(UT_ProtocolDeviceDisplayManager, OnMenuSceneAdded) { } +TEST_F(UT_ProtocolDeviceDisplayManager, HookItemInsert) +{ + bool support = false; + + typedef bool (ProtocolDeviceDisplayManagerPrivate::*IsSupportVEntry)(const QUrl &); + auto func = static_cast(&ProtocolDeviceDisplayManagerPrivate::isSupportVEntry); + stub.set_lamda(func, [&] { __DBG_STUB_INVOKE__ return support; }); + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->hookItemInsert(QUrl::fromLocalFile("/home"))); + support = true; + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->hookItemInsert(QUrl::fromLocalFile("/home"))); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->displayMode = SmbDisplayMode::kAggregation); + stub.set_lamda(ui_ventry_calls::addAggregatedItemForSeperatedOnlineItem, [] { __DBG_STUB_INVOKE__ }); + EXPECT_TRUE(ProtocolDeviceDisplayManager::instance()->hookItemInsert(QUrl::fromLocalFile("/home"))); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, HookItemsFilter) +{ + SmbDisplayMode mode = SmbDisplayMode::kSeperate; + stub.set_lamda(&ProtocolDeviceDisplayManager::displayMode, [&] { __DBG_STUB_INVOKE__ return mode; }); + stub.set_lamda(&ProtocolDeviceDisplayManager::isShowOfflineItem, [] { __DBG_STUB_INVOKE__ return true; }); + stub.set_lamda(ui_ventry_calls::addSeperatedOfflineItems, [] { __DBG_STUB_INVOKE__ }); + QList lst; + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->hookItemsFilter(&lst)); + + mode = SmbDisplayMode::kAggregation; + stub.set_lamda(&ProtocolDeviceDisplayManagerPrivate::removeAllSmb, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(ui_ventry_calls::addAggregatedItems, [] { __DBG_STUB_INVOKE__ }); + EXPECT_TRUE(ProtocolDeviceDisplayManager::instance()->hookItemsFilter(&lst)); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, OnDevMounted) +{ + bool isSamba = false; + stub.set_lamda(&DeviceUtils::isSamba, [&] { __DBG_STUB_INVOKE__ return isSamba; }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevMounted("1234", "1234")); + + isSamba = true; + bool showOffline = false; + stub.set_lamda(&ProtocolDeviceDisplayManager::isShowOfflineItem, [&] { __DBG_STUB_INVOKE__ return showOffline; }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevMounted("1234", "1234")); + + showOffline = true; + stub.set_lamda(computer_sidebar_event_calls::callItemRemove, [] { __DBG_STUB_INVOKE__ }); + stub.set_lamda(&VirtualEntryDbHandler::saveAggregatedAndSperated, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevMounted("1234", "1234")); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, OnDevUnmounted) +{ + bool isSamba = false; + stub.set_lamda(&DeviceUtils::isSamba, [&] { __DBG_STUB_INVOKE__ return isSamba; }); + bool showOffline = true; + stub.set_lamda(&ProtocolDeviceDisplayManager::isShowOfflineItem, [&] { __DBG_STUB_INVOKE__ return showOffline; }); + SmbDisplayMode mode = SmbDisplayMode::kSeperate; + stub.set_lamda(&ProtocolDeviceDisplayManager::displayMode, [&] { __DBG_STUB_INVOKE__ return mode; }); + + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("1234")); + + isSamba = true; + showOffline = true; + mode = SmbDisplayMode::kSeperate; + typedef QString (*GetStdSmbPath)(const QString &); + auto func = static_cast(protocol_display_utilities::getStandardSmbPath); + stub.set_lamda(func, [] { __DBG_STUB_INVOKE__ return "smb://1.2.3.4"; }); + bool hasOffline = false; + stub.set_lamda(&VirtualEntryDbHandler::hasOfflineEntry, [&] { __DBG_STUB_INVOKE__ return hasOffline; }); + stub.set_lamda(computer_sidebar_event_calls::callItemAdd, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("1234")); + hasOffline = true; + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("1234")); + + mode = SmbDisplayMode::kAggregation; + showOffline = true; + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("1234")); + + showOffline = false; + stub.set_lamda(protocol_display_utilities::getMountedSmb, [] { __DBG_STUB_INVOKE__ return QStringList { "smb://2.3.4.5" }; }); + stub.set_lamda(protocol_display_utilities::getStandardSmbPaths, [] { __DBG_STUB_INVOKE__ return QStringList { "smb://2.3.4.5" }; }); + stub.set_lamda(computer_sidebar_event_calls::callItemRemove, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("smb://1.2.3.4")); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDevUnmounted("smb://2.3.4.5")); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, OnDConfigChanged) +{ + stub.set_lamda(&DConfigManager::value, [] { __DBG_STUB_INVOKE__ return false; }); + stub.set_lamda(&ProtocolDeviceDisplayManagerPrivate::onShowOfflineChanged, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDConfigChanged("aaa", "bbb")); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onDConfigChanged("org.deepin.dde.file-manager", "dfm.samba.permanent")); + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->d->showOffline); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, OnJsonConfigChanged) +{ + stub.set_lamda(&ProtocolDeviceDisplayManagerPrivate::onDisplayModeChanged, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onJsonConfigChanged("a", "b", "c")); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onJsonConfigChanged("GenericAttribute", "MergeTheEntriesOfSambaSharedFolders", "c")); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onJsonConfigChanged("GenericAttribute", "MergeTheEntriesOfSambaSharedFolders", true)); + EXPECT_EQ(SmbDisplayMode::kAggregation, ProtocolDeviceDisplayManager::instance()->d->displayMode); +} + +TEST_F(UT_ProtocolDeviceDisplayManager, OnMenuSceneAdded) +{ + typedef QVariant (dpf::EventChannelManager::*Push)(const QString &, const QString &, QString, const QString &); + auto func = static_cast(&dpf::EventChannelManager::push); + stub.set_lamda(func, [] { __DBG_STUB_INVOKE__ return true; }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onMenuSceneAdded("hello")); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->onMenuSceneAdded("ComputerMenu")); +} class UT_ProtocolDeviceDisplayManagerPrivate : public testing::Test { protected: virtual void SetUp() override { + stub.set_lamda(&DConfigManager::value, [] { __DBG_STUB_INVOKE__ return false; }); + + typedef QVariant (Settings::*Value)(const QString &, const QString &, const QVariant &) const; + auto func = static_cast(&Settings::value); + stub.set_lamda(func, [] { __DBG_STUB_INVOKE__ return true; }); } virtual void TearDown() override { @@ -54,8 +189,60 @@ class UT_ProtocolDeviceDisplayManagerPrivate : public testing::Test stub_ext::StubExt stub; }; -TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, Init) { } -TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, OnDisplayModeChanged) { } -TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, OnShowOfflineChanged) { } -TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, IsSupportVEntry) { } -TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, RemoveAllSmb) { } +TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, Init) +{ + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->init()); +} + +TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, OnDisplayModeChanged) +{ + stub.set_lamda(computer_sidebar_event_calls::callComputerRefresh, [] { __DBG_STUB_INVOKE__ }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->onDisplayModeChanged()); +} + +TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, OnShowOfflineChanged) +{ + stub.set_lamda(protocol_display_utilities::getMountedSmb, [] { __DBG_STUB_INVOKE__ return QStringList { "smb://1.2.3.4", "smb://2.3.4.5" }; }); + ProtocolDeviceDisplayManager::instance()->d->showOffline = true; + stub.set_lamda(&VirtualEntryDbHandler::saveAggregatedAndSperated, [] { __DBG_STUB_INVOKE__ }); + + typedef QString (*GetName)(const QString &); + auto f = static_cast(protocol_display_utilities::getDisplayNameOf); + stub.set_lamda(f, [] { __DBG_STUB_INVOKE__ return "Hello"; }); + + f = static_cast(protocol_display_utilities::getStandardSmbPath); + stub.set_lamda(f, [] { __DBG_STUB_INVOKE__ return "smb://1.2.3.4"; }); + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->onShowOfflineChanged()); +} + +TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, IsSupportVEntry) +{ + ProtocolDeviceDisplayManager::instance()->d->showOffline = false; + ProtocolDeviceDisplayManager::instance()->d->displayMode = SmbDisplayMode::kSeperate; + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->d->isSupportVEntry(QUrl::fromLocalFile("/home"))); + + ProtocolDeviceDisplayManager::instance()->d->showOffline = true; + stub.set_lamda(&DeviceUtils::isSamba, [] { __DBG_STUB_INVOKE__ return false; }); + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->d->isSupportVEntry(QUrl::fromLocalFile("/home"))); + + stub.set_lamda(&DeviceUtils::isSamba, [] { __DBG_STUB_INVOKE__ return true; }); + EXPECT_FALSE(ProtocolDeviceDisplayManager::instance()->d->isSupportVEntry(QUrl::fromLocalFile("/home"))); + + EXPECT_TRUE(ProtocolDeviceDisplayManager::instance()->d->isSupportVEntry(QUrl("entry:///home.protodev"))); +} + +TEST_F(UT_ProtocolDeviceDisplayManagerPrivate, RemoveAllSmb) +{ + bool support = false; + typedef bool (ProtocolDeviceDisplayManagerPrivate::*Support)(const QUrl &); + auto func = static_cast(&ProtocolDeviceDisplayManagerPrivate::isSupportVEntry); + stub.set_lamda(func, [&] { __DBG_STUB_INVOKE__ return support; }); + QList urls { QUrl::fromLocalFile("/home") }; + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->removeAllSmb(&urls)); + EXPECT_TRUE(urls.count() == 1); + + support = true; + EXPECT_NO_FATAL_FAILURE(ProtocolDeviceDisplayManager::instance()->d->removeAllSmb(&urls)); + EXPECT_TRUE(urls.count() == 0); +}