Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

test: [ut]Write the docopyfileworker class ut #1233

Merged
merged 1 commit into from
Jul 24, 2023
+1,011 −5
Merged

test: [ut]Write the docopyfileworker class ut #1233

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions ...ommon/core/dfmplugin-fileoperations/fileoperations/cleantrash/docleantrashfilesworker.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -101,6 +101,7 @@ bool DoCleanTrashFilesWorker::cleanAllTrashFiles()
if (AbstractJobHandler::SupportAction::kSkipAction != action) {
return false;
} else {
++it;
continue;
}
}
Expand All @@ -112,6 +113,7 @@ bool DoCleanTrashFilesWorker::cleanAllTrashFiles()
if (AbstractJobHandler::SupportAction::kSkipAction != action) {
return false;
} else {
++it;
continue;
}
}
Expand Down
132 changes: 132 additions & 0 deletions ...in-fileoperations/fileoperations/fileoperations/cleantrash/ut_docleantrashfilesworker.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,132 @@
// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: GPL-3.0-or-later

#include "stubext.h"
#include "plugins/common/core/dfmplugin-fileoperations/fileoperations/cleantrash/cleantrashfiles.h"
#include "plugins/common/core/dfmplugin-fileoperations/fileoperations/cleantrash/docleantrashfilesworker.h"
#include "plugins/common/core/dfmplugin-fileoperations/fileoperations/copyfiles/storageinfo.h"

#include <dfm-base/base/urlroute.h>
#include <dfm-base/base/schemefactory.h>
#include <dfm-base/file/local/asyncfileinfo.h>
#include <dfm-base/file/local/syncfileinfo.h>
#include <dfm-base/file/local/localfilehandler.h>
#include <dfm-base/utils/clipboard.h>

#include <dfm-framework/event/event.h>

#include <gtest/gtest.h>

#include <dfm-io/denumerator.h>

typedef QMap<QString,QVariant> * mapValue;
Q_DECLARE_METATYPE(mapValue);

DPFILEOPERATIONS_USE_NAMESPACE
DFMBASE_USE_NAMESPACE
DPF_USE_NAMESPACE
class UT_DoCleanTrashFilesWorker : public testing::Test
{
public:
void SetUp() override {
// 注册路由
UrlRoute::regScheme(Global::Scheme::kFile, "/", QIcon(), false, QObject::tr("System Disk"));
UrlRoute::regScheme(Global::Scheme::kAsyncFile, "/", QIcon(), false, QObject::tr("System Disk"));
// 注册Scheme为"file"的扩展的文件信息 本地默认文件的
InfoFactory::regClass<dfmbase::SyncFileInfo>(Global::Scheme::kFile);
InfoFactory::regClass<AsyncFileInfo>(Global::Scheme::kAsyncFile);
}
void TearDown() override {}
};

TEST_F(UT_DoCleanTrashFilesWorker, testDoWork)
{
CleanTrashFiles job;
DoCleanTrashFilesWorker worker;
stub_ext::StubExt stub;
stub.set_lamda(&DoCleanTrashFilesWorker::saveOperations, []{ __DBG_STUB_INVOKE__ });
stub.set_lamda(VADDR(AbstractWorker, doWork), []{ __DBG_STUB_INVOKE__ return false;});
EXPECT_FALSE(worker.doWork());

stub.set_lamda(VADDR(AbstractWorker, doWork), []{ __DBG_STUB_INVOKE__ return true;});
stub.set_lamda(VADDR(AbstractWorker, endWork), []{ __DBG_STUB_INVOKE__ });
EXPECT_TRUE(worker.doWork());

worker.onUpdateProgress();

stub.set_lamda(VADDR(AbstractWorker, initArgs), []{ __DBG_STUB_INVOKE__ return true;});
EXPECT_TRUE(worker.initArgs());

EXPECT_FALSE(worker.statisticsFilesSize());

worker.sourceUrls.append(FileUtils::trashRootUrl());
int index = 0;
stub.set_lamda(&DEnumerator::hasNext, [&index]{ __DBG_STUB_INVOKE__ index++; return index % 2;});
stub.set_lamda(&DEnumerator::next, []{ __DBG_STUB_INVOKE__ return QUrl::fromLocalFile(QDir::currentPath());});
EXPECT_TRUE(worker.statisticsFilesSize());
}

TEST_F(UT_DoCleanTrashFilesWorker, testCleanAllTrashFiles)
{
DoCleanTrashFilesWorker worker;
stub_ext::StubExt stub;
stub.set_lamda(&DoCleanTrashFilesWorker::saveOperations, []{ __DBG_STUB_INVOKE__ });
worker.stop();
EXPECT_TRUE(worker.cleanAllTrashFiles());

worker.sourceUrls.append(QUrl());
EXPECT_FALSE(worker.cleanAllTrashFiles());

worker.allFilesList.append(QUrl());
EXPECT_FALSE(worker.cleanAllTrashFiles());

worker.resume();
stub.set_lamda(&DoCleanTrashFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
EXPECT_FALSE(worker.cleanAllTrashFiles());

stub.set_lamda(&DoCleanTrashFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kSkipAction;});
EXPECT_TRUE(worker.cleanAllTrashFiles());

worker.allFilesList.clear();
QUrl url("trash:///text_DoCleanTrashFilesWorker.txt");
worker.allFilesList.append(url);
EXPECT_TRUE(worker.cleanAllTrashFiles());

stub.set_lamda(&DoCleanTrashFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
EXPECT_FALSE(worker.cleanAllTrashFiles());

QSharedPointer<SyncFileInfo> info(new SyncFileInfo(QUrl::fromLocalFile(QDir::currentPath())));
stub.set_lamda(&InfoFactory::create<FileInfo>, [&info] { __DBG_STUB_INVOKE__ return info; });
stub.set_lamda(&DoCleanTrashFilesWorker::clearTrashFile, []{ __DBG_STUB_INVOKE__ return false;});
EXPECT_FALSE(worker.cleanAllTrashFiles());

stub.set_lamda(&DoCleanTrashFilesWorker::clearTrashFile, []{ __DBG_STUB_INVOKE__ return true;});
EXPECT_TRUE(worker.cleanAllTrashFiles());

}

TEST_F(UT_DoCleanTrashFilesWorker, testClearTrashFile)
{
DoCleanTrashFilesWorker worker;
stub_ext::StubExt stub;
stub.set_lamda(&DoCleanTrashFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
stub.set_lamda(&DoCleanTrashFilesWorker::deleteFile, []{ __DBG_STUB_INVOKE__ return false;});
worker.localFileHandler.reset(new LocalFileHandler);
QUrl url(QUrl::fromLocalFile(QDir::currentPath()));
FileInfoPointer info(new SyncFileInfo(url));
EXPECT_TRUE(worker.clearTrashFile(info));

stub.clear();
stub.set_lamda(static_cast<bool(QWaitCondition::*)(QMutex *, unsigned long )>(&QWaitCondition::wait), []{ __DBG_STUB_INVOKE__ return false;});
EXPECT_EQ(AbstractJobHandler::SupportAction::kNoAction,
worker.doHandleErrorAndWait(url, AbstractJobHandler::JobErrorType::kNoError));

stub.set_lamda(&LocalFileHandler::deleteFile, []{ __DBG_STUB_INVOKE__ return true;});
EXPECT_TRUE(worker.deleteFile(url));

}
136 changes: 136 additions & 0 deletions ...dfmplugin-fileoperations/fileoperations/fileoperations/copyfiles/ut_docopyfilesworker.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,136 @@
// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd.
//
// SPDX-License-Identifier: GPL-3.0-or-later

#include "stubext.h"
#include "plugins/common/core/dfmplugin-fileoperations/fileoperations/copyfiles/copyfiles.h"
#include "plugins/common/core/dfmplugin-fileoperations/fileoperations/copyfiles/docopyfilesworker.h"

#include <dfm-base/base/urlroute.h>
#include <dfm-base/base/schemefactory.h>
#include <dfm-base/file/local/asyncfileinfo.h>
#include <dfm-base/file/local/syncfileinfo.h>
#include <dfm-base/file/local/localfilehandler.h>
#include <dfm-base/utils/clipboard.h>

#include <dfm-framework/event/event.h>

#include <gtest/gtest.h>

typedef QMap<QString,QVariant> * mapValue;
Q_DECLARE_METATYPE(mapValue);

DPFILEOPERATIONS_USE_NAMESPACE
DFMBASE_USE_NAMESPACE
DPF_USE_NAMESPACE
class UT_DoCopyFilesWorker : public testing::Test
{
public:
void SetUp() override {
// 注册路由
UrlRoute::regScheme(Global::Scheme::kFile, "/", QIcon(), false, QObject::tr("System Disk"));
UrlRoute::regScheme(Global::Scheme::kAsyncFile, "/", QIcon(), false, QObject::tr("System Disk"));
// 注册Scheme为"file"的扩展的文件信息 本地默认文件的
InfoFactory::regClass<dfmbase::SyncFileInfo>(Global::Scheme::kFile);
InfoFactory::regClass<AsyncFileInfo>(Global::Scheme::kAsyncFile);
}
void TearDown() override {}
};

TEST_F(UT_DoCopyFilesWorker, testDoWork)
{
CopyFiles job;
DoCopyFilesWorker worker;
worker.workData.reset(new WorkerData);
worker.workData->jobFlags |= AbstractJobHandler::JobFlag::kCopyRemote;
stub_ext::StubExt stub;
stub.set_lamda(&ClipBoard::getRemoteUrls, []{ __DBG_STUB_INVOKE__ return QList<QUrl>();});
stub.set_lamda(&DoCopyFilesWorker::saveOperations, []{ __DBG_STUB_INVOKE__ });
stub.set_lamda(VADDR(AbstractWorker, doWork), []{__DBG_STUB_INVOKE__ return false;});
stub.set_lamda(&DoCopyFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
EXPECT_FALSE(worker.doWork());

worker.workData->jobFlags &= AbstractJobHandler::JobFlag::kNoHint;
stub.clear();
stub.set_lamda(VADDR(AbstractWorker, doWork), []{__DBG_STUB_INVOKE__ return true;});
EXPECT_TRUE(worker.doWork());

stub.set_lamda(&DoCopyFilesWorker::copyFiles, []{__DBG_STUB_INVOKE__ return false;});
EXPECT_FALSE(worker.doWork());
}

TEST_F(UT_DoCopyFilesWorker, testInitArgs)
{
DoCopyFilesWorker worker;
worker.workData.reset(new WorkerData);
stub_ext::StubExt stub;
stub.set_lamda(&DoCopyFilesWorker::saveOperations, []{ __DBG_STUB_INVOKE__ });
stub.set_lamda(&DoCopyFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
EXPECT_FALSE(worker.initArgs());

worker.sourceUrls.append(QUrl());
EXPECT_FALSE(worker.initArgs());

QUrl targetUrl;
targetUrl.setScheme("smb");
worker.targetUrl = targetUrl;
EXPECT_FALSE(worker.initArgs());

targetUrl = QUrl::fromLocalFile(QDir::currentPath() + QDir::separator() + "target.txt");
worker.targetUrl = targetUrl;
EXPECT_FALSE(worker.initArgs());

stub.set_lamda(VADDR(SyncFileInfo, exists), []{ __DBG_STUB_INVOKE__ return true;});
EXPECT_TRUE(worker.initArgs());

auto targetInfo = InfoFactory::create<FileInfo>(targetUrl);
worker.precompleteTargetFileInfo.append(targetInfo);
worker.endWork();
}

bool copyFileFunc(DoCopyFilesWorker *&, const FileInfoPointer &, const FileInfoPointer &, bool *skip) {
__DBG_STUB_INVOKE__
if (skip)
*skip = true;
return false;
}

TEST_F(UT_DoCopyFilesWorker, testCopyFiles)
{
DoCopyFilesWorker worker;
worker.workData.reset(new WorkerData);
stub_ext::StubExt stub;
auto sorceUrl = QUrl::fromLocalFile(QDir::currentPath() + "/sourceUrl.txt");
auto targetUrl = QUrl::fromLocalFile(QDir::currentPath() + "/targetUrl.txt");
worker.stop();
worker.sourceUrls.append(QUrl());
EXPECT_FALSE(worker.copyFiles());

worker.resume();
stub.set_lamda(&DoCopyFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kSkipAction;});
EXPECT_TRUE(worker.copyFiles());

stub.set_lamda(&DoCopyFilesWorker::doHandleErrorAndWait, []{ __DBG_STUB_INVOKE__
return AbstractJobHandler::SupportAction::kNoAction;});
EXPECT_FALSE(worker.copyFiles());

auto targetInfo = InfoFactory::create<FileInfo>(targetUrl);
worker.targetInfo = targetInfo;
stub.set_lamda(VADDR(SyncFileInfo, isAttributes), []{ __DBG_STUB_INVOKE__ return true;});
stub.set_lamda(&FileUtils::isHigherHierarchy, []{ __DBG_STUB_INVOKE__ return true;});
worker.sourceUrls.clear();
worker.sourceUrls.append(sorceUrl);
EXPECT_FALSE(worker.copyFiles());

stub.set_lamda(VADDR(SyncFileInfo, isAttributes), []{ __DBG_STUB_INVOKE__ return false;});
stub.set_lamda(&DoCopyFilesWorker::doCopyFile, []{ __DBG_STUB_INVOKE__ return false;});
EXPECT_FALSE(worker.copyFiles());

stub.set(ADDR(DoCopyFilesWorker, doCopyFile), copyFileFunc);
EXPECT_TRUE(worker.copyFiles());

worker.onUpdateProgress();
}
Loading
Loading