From 1e9fbf83cf67302535071fab4a6f6e735d52ad8d Mon Sep 17 00:00:00 2001 From: Gong Heng Date: Fri, 21 Jul 2023 18:06:28 +0800 Subject: [PATCH] test: [vault] add vault UT add vault UT --- .../fileutils/vaultfilewatcher.cpp | 1 - .../utils/encryption/operatorcenter.cpp | 6 +- .../fileutils/ut_vaultfileiterator.cpp | 94 ++++++++ .../fileutils/ut_vaultfilewatcher.cpp | 64 +++++ .../menus/ut_vaultcomputermenuscene.cpp | 151 ++++++++++++ .../menus/ut_vaultmenuscene.cpp | 166 +++++++++++++ .../encryption/ut_interfaceactivevault.cpp | 160 +++++++++++++ .../utils/encryption/ut_operatorcenter.cpp | 225 ++++++++++++++++++ 8 files changed, 863 insertions(+), 4 deletions(-) create mode 100644 tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfileiterator.cpp create mode 100644 tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfilewatcher.cpp create mode 100644 tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultcomputermenuscene.cpp create mode 100644 tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultmenuscene.cpp create mode 100644 tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_interfaceactivevault.cpp create mode 100644 tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp diff --git a/src/plugins/filemanager/dfmplugin-vault/fileutils/vaultfilewatcher.cpp b/src/plugins/filemanager/dfmplugin-vault/fileutils/vaultfilewatcher.cpp index 85be7e0b2d..74bafb10ba 100644 --- a/src/plugins/filemanager/dfmplugin-vault/fileutils/vaultfilewatcher.cpp +++ b/src/plugins/filemanager/dfmplugin-vault/fileutils/vaultfilewatcher.cpp @@ -30,7 +30,6 @@ VaultFileWatcher::VaultFileWatcher(const QUrl &url, QObject *parent) VaultFileWatcher::~VaultFileWatcher() { - qInfo() << "VaultFileWatcher :" << dptr->proxyStaging->url(); } void VaultFileWatcher::onFileDeleted(const QUrl &url) diff --git a/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp b/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp index df6cd5a732..05dc304670 100644 --- a/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp +++ b/src/plugins/filemanager/dfmplugin-vault/utils/encryption/operatorcenter.cpp @@ -156,7 +156,7 @@ bool OperatorCenter::verificationRetrievePassword(const QString keypath, QString { QFile localPubKeyfile(keypath); if (!localPubKeyfile.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "cant't open local public key file!"; + qCritical() << "Vault: cant't open local public key file!"; return false; } @@ -167,7 +167,7 @@ bool OperatorCenter::verificationRetrievePassword(const QString keypath, QString QString strRSACipherFilePath = makeVaultLocalPath(kRSACiphertextFileName); QFile rsaCipherfile(strRSACipherFilePath); if (!rsaCipherfile.open(QIODevice::Text | QIODevice::ReadOnly)) { - qDebug() << "cant't open rsa cipher file!"; + qCritical() << "Vault: cant't open rsa cipher file!"; return false; } @@ -179,7 +179,7 @@ bool OperatorCenter::verificationRetrievePassword(const QString keypath, QString // 判断密码的正确性，如果密码正确，则用户密钥正确，否则用户密钥错误 QString temp = ""; if (!checkPassword(password, temp)) { - qDebug() << "user key error!"; + qCritical() << "Vault: user key error!"; return false; } diff --git a/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfileiterator.cpp b/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfileiterator.cpp new file mode 100644 index 0000000000..87c34cdb7c --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfileiterator.cpp @@ -0,0 +1,94 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "fileutils/vaultfileiterator.h" +#include "utils/vaulthelper.h" + +#include + +#include +#include + +DPVAULT_USE_NAMESPACE +DFMBASE_USE_NAMESPACE + +TEST(UT_VaultFileIterator, next_one) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&QDirIterator::hasNext, [ &isOk ]{ + isOk = true; + return false; + }); + + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + QUrl url = iterator.next(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultFileIterator, hasNext) +{ + stub_ext::StubExt stub; + stub.set_lamda(&QDirIterator::hasNext, []{ + return false; + }); + + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + bool result = iterator.hasNext(); + + EXPECT_FALSE(result); +} + +TEST(UT_VaultFileIterator, fileName) +{ + stub_ext::StubExt stub; + stub.set_lamda(&QDirIterator::fileName, []{ + return "UT_TEST"; + }); + + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + QString name = iterator.fileName(); + + EXPECT_TRUE(name == "UT_TEST"); +} + +TEST(UT_VaultFileIterator, fileUrl) +{ + stub_ext::StubExt stub; + stub.set_lamda(&VaultHelper::pathToVaultVirtualUrl, []{ + return QUrl("dfmvault:///"); + }); + + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + QUrl url = iterator.fileUrl(); + + EXPECT_TRUE(url == QUrl("dfmvault:///")); +} + +TEST(UT_VaultFileIterator, fileInfo) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&InfoFactory::create, [ &isOk ]{ + isOk = true; + return QSharedPointer(new SyncFileInfo(QUrl("file:///home/UT_TEST"))); + }); + + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + iterator.fileInfo(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultFileIterator, url) +{ + VaultFileIterator iterator(QUrl("dfmvault:///"), QStringList(), QDir::NoDotAndDotDot, QDirIterator::NoIteratorFlags); + QUrl url = iterator.url(); + + EXPECT_TRUE(url == QUrl("dfmvault:///")); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfilewatcher.cpp b/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfilewatcher.cpp new file mode 100644 index 0000000000..c7f5110168 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/fileutils/ut_vaultfilewatcher.cpp @@ -0,0 +1,64 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "fileutils/vaultfilewatcher.h" + +#include + +#include + +DPVAULT_USE_NAMESPACE + +TEST(UT_VaultFileWatcher, onFileDeleted) +{ + bool isOk { false }; + + VaultFileWatcher watcher(QUrl("dfmvault:///UT_TEST")); + QObject::connect(&watcher, &VaultFileWatcher::fileDeleted, [ &isOk ]{ + isOk = true; + }); + watcher.onFileDeleted(QUrl("file:///UT_TEST")); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultFileWatcher, onFileAttributeChanged) +{ + bool isOk { false }; + + VaultFileWatcher watcher(QUrl("dfmvault:///UT_TEST")); + QObject::connect(&watcher, &VaultFileWatcher::fileAttributeChanged, [ &isOk ]{ + isOk = true; + }); + watcher.onFileAttributeChanged(QUrl("file:///UT_TEST")); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultFileWatcher, onFileRename) +{ + bool isOk { false }; + + VaultFileWatcher watcher(QUrl("dfmvault:///UT_TEST")); + QObject::connect(&watcher, &VaultFileWatcher::fileRename, [ &isOk ]{ + isOk = true; + }); + watcher.onFileRename(QUrl("dfmvault:///UT_TEST1"), QUrl("dfmvault:///UT_TEST2")); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultFileWatcher, onSubfileCreated) +{ + bool isOk { false }; + + VaultFileWatcher watcher(QUrl("dfmvault:///UT_TEST")); + QObject::connect(&watcher, &VaultFileWatcher::subfileCreated, [ &isOk ]{ + isOk = true; + }); + watcher.onSubfileCreated(QUrl("file:///UT_TEST")); + + EXPECT_TRUE(isOk); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultcomputermenuscene.cpp b/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultcomputermenuscene.cpp new file mode 100644 index 0000000000..d9bb6f20cd --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultcomputermenuscene.cpp @@ -0,0 +1,151 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "menus/vaultcomputermenuscene.h" +#include "menus/vaultcomputermenuscene_p.h" +#include "utils/vaulthelper.h" + +#include + +#include +#include +#include + +#include + +#include + +DPVAULT_USE_NAMESPACE +DFMBASE_USE_NAMESPACE +DWIDGET_USE_NAMESPACE + +TEST(UT_VaultComputerMenuScene, name) +{ + VaultComputerMenuScene scene; + QString name = scene.name(); + + EXPECT_TRUE(name == "VaultComputerSubMenu"); +} + +TEST(UT_VaultComputerMenuScene, initialize_one) +{ + QVariantHash params; + params.insert(MenuParamKey::kWindowId, 123); + QList urls { QUrl("dfmvault:///UT_TEST.vault") }; + QVariant vUrls = QVariant::fromValue>(urls); + params.insert(MenuParamKey::kSelectFiles, vUrls); + + VaultComputerMenuScene scene; + bool isOk = scene.initialize(params); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultComputerMenuScene, initialize_two) +{ + QVariantHash params; + params.insert(MenuParamKey::kWindowId, 123); + QList urls { QUrl("dfmvault:///UT_TEST") }; + QVariant vUrls = QVariant::fromValue>(urls); + params.insert(MenuParamKey::kSelectFiles, vUrls); + + VaultComputerMenuScene scene; + bool isOk = scene.initialize(params); + + EXPECT_FALSE(isOk); +} + +TEST(UT_VaultComputerMenuScene, create) +{ + stub_ext::StubExt stub; + stub.set_lamda(&VaultHelper::createMenu, []{ + DMenu *menu = new DMenu; + return menu; + }); + + QMenu menu; + VaultComputerMenuScene scene; + bool isOk = scene.create(&menu); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultComputerMenuScene, updateState) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, updateState), [ &isOk ]{ + isOk = true; + }); + + QMenu menu; + VaultComputerMenuScene scene; + scene.updateState(&menu); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultComputerMenuScene, triggered_one) +{ + QAction action; + VaultComputerMenuScene scene; + scene.d->acts.push_back(&action); + bool isOk = scene.triggered(&action); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultComputerMenuScene, triggered_two) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, triggered), [ &isOk ]{ + isOk = true; + return true; + }); + + QAction action; + VaultComputerMenuScene scene; + scene.triggered(&action); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultComputerMenuScene, scene_one) +{ + VaultComputerMenuScene scene; + AbstractMenuScene *result = scene.scene(nullptr); + + EXPECT_TRUE(result == nullptr); +} + +TEST(UT_VaultComputerMenuScene, scene_two) +{ + QAction action; + VaultComputerMenuScene scene; + scene.d->predicateAction.insert("UT_TEST", &action); + AbstractMenuScene *result = scene.scene(&action); + + EXPECT_TRUE(result == &scene); +} + +TEST(UT_VaultComputerMenuScene, scene_three) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, scene), [ &isOk ]{ + isOk = true; + return nullptr; + }); + + QAction action; + VaultComputerMenuScene scene; + AbstractMenuScene *result = scene.scene(&action); + + EXPECT_TRUE(isOk); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultmenuscene.cpp b/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultmenuscene.cpp new file mode 100644 index 0000000000..b1dbdf616f --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/menus/ut_vaultmenuscene.cpp @@ -0,0 +1,166 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "menus/vaultmenuscene.h" +#include "menus/vaultmenuscene_p.h" + +#include + +#include +#include +#include +#include + +#include + +DPVAULT_USE_NAMESPACE +DFMBASE_USE_NAMESPACE + +TEST(UT_VaultMenuScene, name) +{ + VaultMenuScene scene; + QString name = scene.name(); + + EXPECT_TRUE(name == "VaultMenu"); +} + +TEST(UT_VaultMenuScene, initialize_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScenePrivate, initializeParamsIsValid), []{ + return false; + }); + + QVariantHash params; + QList urls { QUrl("dfmvault:///") }; + QVariant vUrls = QVariant::fromValue>(urls); + params.insert(MenuParamKey::kSelectFiles, vUrls); + VaultMenuScene scene; + bool isOk = scene.initialize(params); + + EXPECT_FALSE(isOk); +} + +TEST(UT_VaultMenuScene, initialize_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScenePrivate, initializeParamsIsValid), []{ + return true; + }); + stub.set_lamda(VADDR(AbstractMenuScene, initialize), []{ + return true; + }); + + + QVariantHash params; + QVariant vUrl = QVariant::fromValue(QUrl("dfmvault:///")); + params.insert(MenuParamKey::kCurrentDir, vUrl); + VaultMenuScene scene; + bool isOk = scene.initialize(params); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultMenuScene, scene) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, scene), [ &isOk ]{ + isOk = true; + return nullptr; + }); + + VaultMenuScene scene1; + scene1.scene(nullptr); + + QAction action; + VaultMenuScene scene2; + scene2.scene(&action); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultMenuScene, create) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, create), [ &isOk ]{ + isOk = true; + return true; + }); + + VaultMenuScene scene1; + scene1.create(nullptr); + + QMenu menu; + VaultMenuScene scene2; + scene2.create(&menu); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultMenuScene, updateState) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, updateState), []{}); + stub.set_lamda(&VaultMenuScenePrivate::filterMenuAction, [ &isOk ]{ + isOk = true; + }); + + QMenu menu1; + VaultMenuScene scene1; + scene1.d->isEmptyArea = true; + scene1.updateState(&menu1); + + QMenu menu2; + VaultMenuScene scene2; + scene2.d->isEmptyArea = false; + scene2.updateState(&menu2); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultMenuScene, triggered) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(VADDR(AbstractMenuScene, triggered), [ &isOk ]{ + isOk = true; + return true; + }); + + QAction action; + VaultMenuScene scene; + scene.triggered(&action); + + EXPECT_TRUE(isOk); +} + +TEST(UT_VaultMenuScenePrivate, filterMenuAction) +{ + QMenu menu1; + QStringList actions1; + VaultMenuScenePrivate scenePri1; + scenePri1.filterMenuAction(&menu1, actions1); + + QMenu menu2; + QAction *actionA = menu2.addAction("UT_TEST"); + actionA->setProperty(ActionPropertyKey::kActionID, "send-to"); + + QMenu subMenu; + actionA->setMenu(&subMenu); + QAction *actionSub = subMenu.addAction("UT_TEST2"); + actionSub->setProperty(ActionPropertyKey::kActionID, "send-to-desktop"); + + menu2.addSeparator(); + QStringList actions2; + VaultMenuScenePrivate scenePri2; + scenePri2.filterMenuAction(&menu2, actions2); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_interfaceactivevault.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_interfaceactivevault.cpp new file mode 100644 index 0000000000..537b87eaec --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_interfaceactivevault.cpp @@ -0,0 +1,160 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/encryption/interfaceactivevault.h" +#include "utils/encryption/operatorcenter.h" +#include "utils/vaulthelper.h" + +#include + +DPVAULT_USE_NAMESPACE + +TEST(UT_InterfaceActiveVault, getPasswordHint) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::getPasswordHint, [ &isOk ]{ + isOk = true; + return true; + }); + + InterfaceActiveVault inter; + QString hint; + inter.getPasswordHint(hint); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, checkPassword) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::checkPassword, [ &isOk ]{ + isOk = true; + return true; + }); + + InterfaceActiveVault inter; + QString cipher; + inter.checkPassword("UT_TEST", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, checkUserKey) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::checkUserKey, [ &isOk ]{ + isOk = true; + return true; + }); + + InterfaceActiveVault inter; + QString cipher; + inter.checkUserKey("UT_TEST", cipher); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, getEncryptDir) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::getEncryptDirPath, [ &isOk ]{ + isOk = true; + return ""; + }); + + InterfaceActiveVault inter; + inter.getEncryptDir(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, getDecryptDir) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::getdecryptDirPath, [ &isOk ]{ + isOk = true; + return ""; + }); + + InterfaceActiveVault inter; + inter.getDecryptDir(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, getConfigFilePath) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::getConfigFilePath, [ &isOk ]{ + isOk = true; + return QStringList(); + }); + + InterfaceActiveVault inter; + inter.getConfigFilePath(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, vaultState) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&VaultHelper::state, [ &isOk ]{ + isOk = true; + return VaultState::kUnknow; + }); + + InterfaceActiveVault inter; + inter.vaultState(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, getRootPassword) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::getRootPassword, [ &isOk ]{ + isOk = true; + return true; + }); + + InterfaceActiveVault inter; + inter.getRootPassword(); + + EXPECT_TRUE(isOk); +} + +TEST(UT_InterfaceActiveVault, executionShellCommand) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::executionShellCommand, [ &isOk ]{ + isOk = true; + return 0; + }); + + InterfaceActiveVault inter; + QStringList output; + inter.executionShellCommand("UT_TEST", output); + + EXPECT_TRUE(isOk); +} diff --git a/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp new file mode 100644 index 0000000000..641c6fa488 --- /dev/null +++ b/tests/plugins/filemanager/dfmplugin-vault/utils/encryption/ut_operatorcenter.cpp @@ -0,0 +1,225 @@ +// SPDX-FileCopyrightText: 2022 - 2023 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "stubext.h" +#include "utils/encryption/operatorcenter.h" +#include "utils/encryption/vaultconfig.h" +#include "utils/operator/pbkdf2.h" +#include "utils/operator/rsam.h" + +#include + +#include + +DPVAULT_USE_NAMESPACE + +TEST(UT_OperatorCenter, makeVaultLocalPath) +{ + QString path = OperatorCenter::getInstance()->makeVaultLocalPath("UT_TEST", "UT_TEST"); + + EXPECT_TRUE(path == (kVaultBasePath + "/UT_TEST/UT_TEST")); +} + +TEST(UT_OperatorCenter, runCmd_one) +{ + stub_ext::StubExt stub; + typedef void(QProcess::*FuncType)(QProcess::OpenMode); + stub.set_lamda(static_cast(&QProcess::start), []{}); + stub.set_lamda(&QProcess::readAllStandardOutput, []{ + return QByteArray(""); + }); + stub.set_lamda(&QProcess::exitCode, []{ + return 127; + }); + + bool isOk = OperatorCenter::getInstance()->runCmd(kRootProxy); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, runCmd_two) +{ + stub_ext::StubExt stub; + typedef void(QProcess::*FuncType)(QProcess::OpenMode); + stub.set_lamda(static_cast(&QProcess::start), []{}); + stub.set_lamda(&QProcess::readAllStandardOutput, []{ + return QByteArray(""); + }); + stub.set_lamda(&QProcess::exitCode, []{ + return 0; + }); + + bool isOk = OperatorCenter::getInstance()->runCmd(kRootProxy); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, executeProcess) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&OperatorCenter::runCmd, [ &isOk ]{ + isOk = true; + return true; + }); + + OperatorCenter::getInstance()->executeProcess("UT_TEST"); + + OperatorCenter::getInstance()->standOutput = "root"; + OperatorCenter::getInstance()->executeProcess("sudo UT_TEST"); + + OperatorCenter::getInstance()->standOutput = ""; + OperatorCenter::getInstance()->executeProcess("sudo UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, secondSaveSaltAndCiphertext_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return ""; + }); + + bool isOk = OperatorCenter::getInstance()->secondSaveSaltAndCiphertext("TEST1", "TEST2", "TEST3"); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, secondSaveSaltAndCiphertext_two) +{ + bool isOk { false }; + + stub_ext::StubExt stub; + stub.set_lamda(&pbkdf2::pbkdf2EncrypyPassword, []{ + return "UT_TEST"; + }); + stub.set_lamda(&VaultConfig::set, [ &isOk ]{ + isOk = true; + }); + + OperatorCenter::getInstance()->secondSaveSaltAndCiphertext("TEST1", "TEST2", "TEST3"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, createKeyNew_one) +{ + stub_ext::StubExt stub; + stub.set_lamda(&rsam::createPublicAndPrivateKey, [](QString &publicKey, QString privateKey){ + publicKey = "UT"; + return true; + }); + stub.set_lamda(&rsam::privateKeyEncrypt, []{ + return "UT_TEST"; + }); + + bool isOk = OperatorCenter::getInstance()->createKeyNew("UT_TEST"); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, createKeyNew_two) +{ + stub_ext::StubExt stub; + stub.set_lamda(&rsam::createPublicAndPrivateKey, [](QString &publicKey, QString privateKey){ + Q_UNUSED(privateKey) + publicKey = "UT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TESTUT_TES"; + return true; + }); + stub.set_lamda(&rsam::privateKeyEncrypt, []{ + return "UT_TEST"; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + + bool isOk = OperatorCenter::getInstance()->createKeyNew("UT_TEST"); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, saveKey_one) +{ + bool isOk = OperatorCenter::getInstance()->saveKey("UT_TEST", "UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, saveKey_two) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType)(QIODevice::OpenMode); + stub.set_lamda((FuncType)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + + bool isOk = OperatorCenter::getInstance()->saveKey("UT_TEST", "/UT_TEST"); + + EXPECT_TRUE(isOk); +} + +TEST(UT_OperatorCenter, getPubKey) +{ + OperatorCenter::getInstance()->strPubKey = "UT_TEST"; + QString re = OperatorCenter::getInstance()->getPubKey(); + + EXPECT_TRUE(re == "UT_TEST"); +} + +TEST(UT_OperatorCenter, verificationRetrievePassword_one) +{ + QString passwd; + bool isOk = OperatorCenter::getInstance()->verificationRetrievePassword("/UT_TEST", passwd); + + EXPECT_FALSE(isOk); +} + +TEST(UT_OperatorCenter, verificationRetrievePassword_two) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType)(QIODevice::OpenMode); + stub.set_lamda((FuncType)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + stub.set_lamda(&rsam::publicKeyDecrypt, []{ + return "UT_TEST"; + }); + stub.set_lamda(&OperatorCenter::checkPassword, []{ + return false; + }); + + QString passwd; + bool isOk = OperatorCenter::getInstance()->verificationRetrievePassword("/UT_TEST", passwd); + + EXPECT_FALSE(isOk); +} + + +TEST(UT_OperatorCenter, verificationRetrievePassword_three) +{ + stub_ext::StubExt stub; + typedef bool(*FuncType)(QIODevice::OpenMode); + stub.set_lamda((FuncType)(bool(QFile::*)(QIODevice::OpenMode))(&QFile::open), [] { + return true; + }); + stub.set_lamda(&OperatorCenter::makeVaultLocalPath, []{ + return "/UT_TEST"; + }); + stub.set_lamda(&rsam::publicKeyDecrypt, []{ + return "UT_TEST"; + }); + stub.set_lamda(&OperatorCenter::checkPassword, []{ + return true; + }); + + QString passwd; + bool isOk = OperatorCenter::getInstance()->verificationRetrievePassword("/UT_TEST", passwd); + + EXPECT_TRUE(isOk); +}