libcryfs/test/cryfs/impl/config/CryConfigConsoleTest.cpp

115 lines
4.6 KiB
C++
Raw Normal View History

2016-02-11 16:39:42 +01:00
#include <gtest/gtest.h>
#include <gmock/gmock.h>
2019-01-26 08:38:34 +01:00
#include <cryfs/impl/config/CryConfigConsole.h>
#include <cryfs/impl/config/CryCipher.h>
2016-02-11 16:39:42 +01:00
#include <cpp-utils/crypto/symmetric/ciphers.h>
2016-09-25 02:50:28 +02:00
#include <cpp-utils/io/NoninteractiveConsole.h>
2019-01-26 08:38:34 +01:00
#include "../../impl/testutils/MockConsole.h"
2016-01-25 14:03:32 +01:00
using namespace cryfs;
using boost::optional;
using boost::none;
2016-09-25 02:50:28 +02:00
using cpputils::NoninteractiveConsole;
2016-01-25 14:03:32 +01:00
using std::string;
using std::shared_ptr;
using std::make_shared;
using ::testing::_;
using ::testing::NiceMock;
2016-01-25 14:03:32 +01:00
using ::testing::Return;
using ::testing::ValuesIn;
using ::testing::HasSubstr;
using ::testing::UnorderedElementsAreArray;
using ::testing::WithParamInterface;
class CryConfigConsoleTest: public ::testing::Test {
public:
CryConfigConsoleTest()
: console(make_shared<NiceMock<MockConsole>>()),
2016-09-25 02:50:28 +02:00
cryconsole(console),
noninteractiveCryconsole(make_shared<NoninteractiveConsole>(console)) {
2016-01-25 14:03:32 +01:00
}
shared_ptr<NiceMock<MockConsole>> console;
2016-01-25 14:03:32 +01:00
CryConfigConsole cryconsole;
CryConfigConsole noninteractiveCryconsole;
2016-01-25 14:03:32 +01:00
};
class CryConfigConsoleTest_Cipher: public CryConfigConsoleTest {};
#define EXPECT_ASK_FOR_CIPHER() \
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(false)); \
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), UnorderedElementsAreArray(CryCiphers::supportedCipherNames()))).Times(1)
2016-01-25 14:03:32 +01:00
#define EXPECT_ASK_FOR_BLOCKSIZE() \
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(false)); \
EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(1)
2016-09-25 20:05:38 +02:00
#define EXPECT_ASK_FOR_MISSINGBLOCKISINTEGRITYVIOLATION() \
EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(false)); \
EXPECT_CALL(*console, askYesNo(HasSubstr("missing block"), _)).Times(1)
2016-01-25 14:03:32 +01:00
TEST_F(CryConfigConsoleTest_Cipher, AsksForCipher) {
EXPECT_ASK_FOR_CIPHER().WillOnce(ChooseAnyCipher());
2016-01-25 14:03:32 +01:00
cryconsole.askCipher();
}
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipher) {
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(true));
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0);
string cipher = cryconsole.askCipher();
EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher);
}
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipherWhenNoninteractiveEnvironment) {
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo(HasSubstr("default"), _)).Times(0);
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0);
string cipher = noninteractiveCryconsole.askCipher();
EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher);
}
TEST_F(CryConfigConsoleTest_Cipher, AsksForBlocksize) {
EXPECT_ASK_FOR_BLOCKSIZE().WillOnce(Return(0));
cryconsole.askBlocksizeBytes();
}
TEST_F(CryConfigConsoleTest_Cipher, AsksForMissingBlockIsIntegrityViolation) {
EXPECT_ASK_FOR_MISSINGBLOCKISINTEGRITYVIOLATION().WillOnce(Return(true));
cryconsole.askMissingBlockIsIntegrityViolation();
}
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultBlocksizeWhenNoninteractiveEnvironment) {
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo(HasSubstr("default"), _)).Times(0);
EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(0);
uint32_t blocksize = noninteractiveCryconsole.askBlocksizeBytes();
EXPECT_EQ(CryConfigConsole::DEFAULT_BLOCKSIZE_BYTES, blocksize);
}
2016-01-25 14:03:32 +01:00
class CryConfigConsoleTest_Cipher_Choose: public CryConfigConsoleTest_Cipher, public ::testing::WithParamInterface<string> {
public:
string cipherName = GetParam();
optional<string> cipherWarning = CryCiphers::find(cipherName).warning();
void EXPECT_DONT_SHOW_WARNING() {
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo(_, _)).Times(0);
2016-01-25 14:03:32 +01:00
}
void EXPECT_SHOW_WARNING(const string &warning) {
2016-09-25 02:50:28 +02:00
EXPECT_CALL(*console, askYesNo(HasSubstr(warning), _)).WillOnce(Return(true));
2016-01-25 14:03:32 +01:00
}
};
TEST_P(CryConfigConsoleTest_Cipher_Choose, ChoosesCipherCorrectly) {
if (cipherWarning == none) {
EXPECT_DONT_SHOW_WARNING();
} else {
EXPECT_SHOW_WARNING(*cipherWarning);
}
EXPECT_ASK_FOR_CIPHER().WillOnce(ChooseCipher(cipherName));
string chosenCipher = cryconsole.askCipher();
EXPECT_EQ(cipherName, chosenCipher);
}
2019-10-13 14:16:06 +02:00
INSTANTIATE_TEST_SUITE_P(CryConfigConsoleTest_Cipher_Choose, CryConfigConsoleTest_Cipher_Choose, ValuesIn(CryCiphers::supportedCipherNames()));