hardcoresushi/libcryfs
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Fix test cases

Browse Source
This commit is contained in:
Sebastian Messmer 2016-09-25 02:50:28 +02:00
parent f79b80cc56
commit 443298844e
12 changed files with 57 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/cpp-utils/io/NoninteractiveConsole.cpp
View File

@ -2,10 +2,11 @@
using std::string; using std::string;
using std::vector; using std::vector;
using std::shared_ptr;
namespace cpputils { namespace cpputils {
NoninteractiveConsole::NoninteractiveConsole(unique_ref<Console> baseConsole): _baseConsole(std::move(baseConsole)) { NoninteractiveConsole::NoninteractiveConsole(shared_ptr<Console> baseConsole): _baseConsole(std::move(baseConsole)) {
} }
bool NoninteractiveConsole::askYesNo(const string &/*question*/, bool defaultValue) { bool NoninteractiveConsole::askYesNo(const string &/*question*/, bool defaultValue) {

4
src/cpp-utils/io/NoninteractiveConsole.h
View File

@ -9,14 +9,14 @@ namespace cpputils {
//TODO Add test cases for NoninteractiveConsole //TODO Add test cases for NoninteractiveConsole
class NoninteractiveConsole final: public Console { class NoninteractiveConsole final: public Console {
public: public:
NoninteractiveConsole(unique_ref<Console> baseConsole); NoninteractiveConsole(std::shared_ptr<Console> baseConsole);
unsigned int ask(const std::string &question, const std::vector<std::string> &options) override; unsigned int ask(const std::string &question, const std::vector<std::string> &options) override;
bool askYesNo(const std::string &question, bool defaultValue) override; bool askYesNo(const std::string &question, bool defaultValue) override;
void print(const std::string &output) override; void print(const std::string &output) override;
private: private:
unique_ref<Console> _baseConsole; std::shared_ptr<Console> _baseConsole;
DISALLOW_COPY_AND_ASSIGN(NoninteractiveConsole); DISALLOW_COPY_AND_ASSIGN(NoninteractiveConsole);
}; };

6
src/cryfs-cli/Cli.cpp
View File

@ -75,13 +75,13 @@ using gitversion::VersionCompare;
namespace cryfs { namespace cryfs {
Cli::Cli(RandomGenerator &keyGenerator, const SCryptSettings &scryptSettings, unique_ref<Console> console, shared_ptr<HttpClient> httpClient): Cli::Cli(RandomGenerator &keyGenerator, const SCryptSettings &scryptSettings, shared_ptr<Console> console, shared_ptr<HttpClient> httpClient):
_keyGenerator(keyGenerator), _scryptSettings(scryptSettings), _console(), _httpClient(httpClient), _noninteractive(false) { _keyGenerator(keyGenerator), _scryptSettings(scryptSettings), _console(), _httpClient(httpClient), _noninteractive(false) {
_noninteractive = Environment::isNoninteractive(); _noninteractive = Environment::isNoninteractive();
if (_noninteractive) { if (_noninteractive) {
_console = make_shared<NoninteractiveConsole>(std::move(console)); _console = make_shared<NoninteractiveConsole>(console);
} else { } else {
_console = cpputils::to_unique_ptr(std::move(console)); _console = console;
} }
} }

2
src/cryfs-cli/Cli.h
View File

@ -15,7 +15,7 @@
namespace cryfs { namespace cryfs {
class Cli final { class Cli final {
public: public:
Cli(cpputils::RandomGenerator &keyGenerator, const cpputils::SCryptSettings &scryptSettings, cpputils::unique_ref<cpputils::Console> console, std::shared_ptr<cpputils::HttpClient> httpClient); Cli(cpputils::RandomGenerator &keyGenerator, const cpputils::SCryptSettings &scryptSettings, std::shared_ptr<cpputils::Console> console, std::shared_ptr<cpputils::HttpClient> httpClient);
int main(int argc, const char *argv[]); int main(int argc, const char *argv[]);
private: private:

3
src/cryfs-cli/main.cpp
View File

@ -8,7 +8,6 @@ using namespace cryfs;
using cpputils::Random; using cpputils::Random;
using cpputils::SCrypt; using cpputils::SCrypt;
using cpputils::CurlHttpClient; using cpputils::CurlHttpClient;
using cpputils::make_unique_ref;
using cpputils::IOStreamConsole; using cpputils::IOStreamConsole;
using std::make_shared; using std::make_shared;
using std::cerr; using std::cerr;
@ -16,7 +15,7 @@ using std::cerr;
int main(int argc, const char *argv[]) { int main(int argc, const char *argv[]) {
try { try {
auto &keyGenerator = Random::OSRandom(); auto &keyGenerator = Random::OSRandom();
return Cli(keyGenerator, SCrypt::DefaultSettings, make_unique_ref<IOStreamConsole>(), return Cli(keyGenerator, SCrypt::DefaultSettings, make_shared<IOStreamConsole>(),
make_shared<CurlHttpClient>()).main(argc, argv); make_shared<CurlHttpClient>()).main(argc, argv);
} catch (const std::exception &e) { } catch (const std::exception &e) {
cerr << "Error: " << e.what(); cerr << "Error: " << e.what();

12
test/cryfs-cli/CliTest_WrongEnvironment.cpp
View File

@ -118,7 +118,7 @@ TEST_P(CliTest_WrongEnvironment, MountDirIsBaseDir_BothRelative) {
TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist) { TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist) {
_basedir.remove(); _basedir.remove();
// ON_CALL and not EXPECT_CALL, because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents. // ON_CALL and not EXPECT_CALL, because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents.
ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?")).WillByDefault(Return(false)); ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?", _)).WillByDefault(Return(false));
Test_Run_Error("Error: base directory not found"); Test_Run_Error("Error: base directory not found");
} }
@ -126,7 +126,7 @@ TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist_Noninteractive) {
_basedir.remove(); _basedir.remove();
// We can't set an EXPECT_CALL().Times(0), because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents. // We can't set an EXPECT_CALL().Times(0), because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents.
// So we set a default answer that shouldn't crash and check it's not called by checking that it crashes. // So we set a default answer that shouldn't crash and check it's not called by checking that it crashes.
ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?")).WillByDefault(Return(true)); ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?", _)).WillByDefault(Return(true));
::setenv("CRYFS_FRONTEND", "noninteractive", 1); ::setenv("CRYFS_FRONTEND", "noninteractive", 1);
Test_Run_Error("Error: base directory not found"); Test_Run_Error("Error: base directory not found");
::unsetenv("CRYFS_FRONTEND"); ::unsetenv("CRYFS_FRONTEND");
@ -135,7 +135,7 @@ TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist_Noninteractive) {
TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist_Create) { TEST_P(CliTest_WrongEnvironment, BaseDir_DoesntExist_Create) {
if (!GetParam().runningInForeground) {return;} // TODO Make this work also if run in background (see CliTest::EXPECT_RUN_SUCCESS) if (!GetParam().runningInForeground) {return;} // TODO Make this work also if run in background (see CliTest::EXPECT_RUN_SUCCESS)
_basedir.remove(); _basedir.remove();
ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?")).WillByDefault(Return(true)); ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?", _)).WillByDefault(Return(true));
Test_Run_Success(); Test_Run_Success();
EXPECT_TRUE(bf::exists(_basedir.path()) && bf::is_directory(_basedir.path())); EXPECT_TRUE(bf::exists(_basedir.path()) && bf::is_directory(_basedir.path()));
} }
@ -176,7 +176,7 @@ TEST_P(CliTest_WrongEnvironment, BaseDir_NoPermission) {
TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist) { TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist) {
_mountdir.remove(); _mountdir.remove();
// ON_CALL and not EXPECT_CALL, because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents. // ON_CALL and not EXPECT_CALL, because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents.
ON_CALL(*console, askYesNo("Could not find mount directory. Do you want to create it?")).WillByDefault(Return(false)); ON_CALL(*console, askYesNo("Could not find mount directory. Do you want to create it?", _)).WillByDefault(Return(false));
Test_Run_Error("Error: mount directory not found"); Test_Run_Error("Error: mount directory not found");
} }
@ -184,7 +184,7 @@ TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist_Noninteractive) {
_mountdir.remove(); _mountdir.remove();
// We can't set an EXPECT_CALL().Times(0), because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents. // We can't set an EXPECT_CALL().Times(0), because this is a death test (i.e. it is forked) and gmock EXPECT_CALL in fork children don't report to parents.
// So we set a default answer that shouldn't crash and check it's not called by checking that it crashes. // So we set a default answer that shouldn't crash and check it's not called by checking that it crashes.
ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?")).WillByDefault(Return(true)); ON_CALL(*console, askYesNo("Could not find base directory. Do you want to create it?", _)).WillByDefault(Return(true));
::setenv("CRYFS_FRONTEND", "noninteractive", 1); ::setenv("CRYFS_FRONTEND", "noninteractive", 1);
Test_Run_Error("Error: mount directory not found"); Test_Run_Error("Error: mount directory not found");
::unsetenv("CRYFS_FRONTEND"); ::unsetenv("CRYFS_FRONTEND");
@ -193,7 +193,7 @@ TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist_Noninteractive) {
TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist_Create) { TEST_P(CliTest_WrongEnvironment, MountDir_DoesntExist_Create) {
if (!GetParam().runningInForeground) {return;} // TODO Make this work also if run in background (see CliTest::EXPECT_RUN_SUCCESS) if (!GetParam().runningInForeground) {return;} // TODO Make this work also if run in background (see CliTest::EXPECT_RUN_SUCCESS)
_mountdir.remove(); _mountdir.remove();
ON_CALL(*console, askYesNo("Could not find mount directory. Do you want to create it?")).WillByDefault(Return(true)); ON_CALL(*console, askYesNo("Could not find mount directory. Do you want to create it?", _)).WillByDefault(Return(true));
Test_Run_Success(); Test_Run_Success();
EXPECT_TRUE(bf::exists(_mountdir.path()) && bf::is_directory(_mountdir.path())); EXPECT_TRUE(bf::exists(_mountdir.path()) && bf::is_directory(_mountdir.path()));
} }

20
test/cryfs/config/CryConfigConsoleTest.cpp
View File

@ -3,6 +3,7 @@
#include <cryfs/config/CryConfigConsole.h> #include <cryfs/config/CryConfigConsole.h>
#include <cryfs/config/CryCipher.h> #include <cryfs/config/CryCipher.h>
#include <cpp-utils/crypto/symmetric/ciphers.h> #include <cpp-utils/crypto/symmetric/ciphers.h>
#include <cpp-utils/io/NoninteractiveConsole.h>
#include "../testutils/MockConsole.h" #include "../testutils/MockConsole.h"
using namespace cryfs; using namespace cryfs;
@ -10,6 +11,7 @@ using namespace cryfs;
using boost::optional; using boost::optional;
using boost::none; using boost::none;
using cpputils::Console; using cpputils::Console;
using cpputils::NoninteractiveConsole;
using cpputils::unique_ref; using cpputils::unique_ref;
using cpputils::make_unique_ref; using cpputils::make_unique_ref;
using std::string; using std::string;
@ -28,8 +30,8 @@ class CryConfigConsoleTest: public ::testing::Test {
public: public:
CryConfigConsoleTest() CryConfigConsoleTest()
: console(make_shared<MockConsole>()), : console(make_shared<MockConsole>()),
cryconsole(console, false), cryconsole(console),
noninteractiveCryconsole(console, true) { noninteractiveCryconsole(make_shared<NoninteractiveConsole>(console)) {
} }
shared_ptr<MockConsole> console; shared_ptr<MockConsole> console;
CryConfigConsole cryconsole; CryConfigConsole cryconsole;
@ -39,11 +41,11 @@ public:
class CryConfigConsoleTest_Cipher: public CryConfigConsoleTest {}; class CryConfigConsoleTest_Cipher: public CryConfigConsoleTest {};
#define EXPECT_ASK_FOR_CIPHER() \ #define EXPECT_ASK_FOR_CIPHER() \
EXPECT_CALL(*console, askYesNo("Use default settings?")).Times(1).WillOnce(Return(false)); \ EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(false)); \
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), UnorderedElementsAreArray(CryCiphers::supportedCipherNames()))).Times(1) EXPECT_CALL(*console, ask(HasSubstr("block cipher"), UnorderedElementsAreArray(CryCiphers::supportedCipherNames()))).Times(1)
#define EXPECT_ASK_FOR_BLOCKSIZE() \ #define EXPECT_ASK_FOR_BLOCKSIZE() \
EXPECT_CALL(*console, askYesNo("Use default settings?")).Times(1).WillOnce(Return(false)); \ EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(false)); \
EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(1) EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(1)
TEST_F(CryConfigConsoleTest_Cipher, AsksForCipher) { TEST_F(CryConfigConsoleTest_Cipher, AsksForCipher) {
@ -52,14 +54,14 @@ TEST_F(CryConfigConsoleTest_Cipher, AsksForCipher) {
} }
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipher) { TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipher) {
EXPECT_CALL(*console, askYesNo("Use default settings?")).Times(1).WillOnce(Return(true)); EXPECT_CALL(*console, askYesNo("Use default settings?", _)).Times(1).WillOnce(Return(true));
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0); EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0);
string cipher = cryconsole.askCipher(); string cipher = cryconsole.askCipher();
EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher); EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher);
} }
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipherWhenNoninteractiveEnvironment) { TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultCipherWhenNoninteractiveEnvironment) {
EXPECT_CALL(*console, askYesNo(HasSubstr("default"))).Times(0); EXPECT_CALL(*console, askYesNo(HasSubstr("default"), _)).Times(0);
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0); EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).Times(0);
string cipher = noninteractiveCryconsole.askCipher(); string cipher = noninteractiveCryconsole.askCipher();
EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher); EXPECT_EQ(CryConfigConsole::DEFAULT_CIPHER, cipher);
@ -71,7 +73,7 @@ TEST_F(CryConfigConsoleTest_Cipher, AsksForBlocksize) {
} }
TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultBlocksizeWhenNoninteractiveEnvironment) { TEST_F(CryConfigConsoleTest_Cipher, ChooseDefaultBlocksizeWhenNoninteractiveEnvironment) {
EXPECT_CALL(*console, askYesNo(HasSubstr("default"))).Times(0); EXPECT_CALL(*console, askYesNo(HasSubstr("default"), _)).Times(0);
EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(0); EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).Times(0);
uint32_t blocksize = noninteractiveCryconsole.askBlocksizeBytes(); uint32_t blocksize = noninteractiveCryconsole.askBlocksizeBytes();
EXPECT_EQ(CryConfigConsole::DEFAULT_BLOCKSIZE_BYTES, blocksize); EXPECT_EQ(CryConfigConsole::DEFAULT_BLOCKSIZE_BYTES, blocksize);
@ -83,11 +85,11 @@ public:
optional<string> cipherWarning = CryCiphers::find(cipherName).warning(); optional<string> cipherWarning = CryCiphers::find(cipherName).warning();
void EXPECT_DONT_SHOW_WARNING() { void EXPECT_DONT_SHOW_WARNING() {
EXPECT_CALL(*console, askYesNo(_)).Times(0); EXPECT_CALL(*console, askYesNo(_, _)).Times(0);
} }
void EXPECT_SHOW_WARNING(const string &warning) { void EXPECT_SHOW_WARNING(const string &warning) {
EXPECT_CALL(*console, askYesNo(HasSubstr(warning))).WillOnce(Return(true)); EXPECT_CALL(*console, askYesNo(HasSubstr(warning), _)).WillOnce(Return(true));
} }
}; };

10
test/cryfs/config/CryConfigCreatorTest.cpp
View File

@ -4,6 +4,7 @@
#include <cryfs/config/CryCipher.h> #include <cryfs/config/CryCipher.h>
#include <cpp-utils/crypto/symmetric/ciphers.h> #include <cpp-utils/crypto/symmetric/ciphers.h>
#include "../testutils/MockConsole.h" #include "../testutils/MockConsole.h"
#include <cpp-utils/io/NoninteractiveConsole.h>
#include <gitversion/gitversion.h> #include <gitversion/gitversion.h>
using namespace cryfs; using namespace cryfs;
@ -11,6 +12,7 @@ using namespace cryfs;
using boost::optional; using boost::optional;
using boost::none; using boost::none;
using cpputils::Console; using cpputils::Console;
using cpputils::NoninteractiveConsole;
using cpputils::unique_ref; using cpputils::unique_ref;
using cpputils::make_unique_ref; using cpputils::make_unique_ref;
using std::string; using std::string;
@ -26,9 +28,9 @@ using ::testing::UnorderedElementsAreArray;
using ::testing::WithParamInterface; using ::testing::WithParamInterface;
#define EXPECT_ASK_TO_USE_DEFAULT_SETTINGS() \ #define EXPECT_ASK_TO_USE_DEFAULT_SETTINGS() \
EXPECT_CALL(*console, askYesNo("Use default settings?")).Times(1) EXPECT_CALL(*console, askYesNo("Use default settings?", true)).Times(1)
#define EXPECT_DOES_NOT_ASK_TO_USE_DEFAULT_SETTINGS() \ #define EXPECT_DOES_NOT_ASK_TO_USE_DEFAULT_SETTINGS() \
EXPECT_CALL(*console, askYesNo("Use default settings?")).Times(0) EXPECT_CALL(*console, askYesNo("Use default settings?", true)).Times(0)
#define EXPECT_ASK_FOR_CIPHER() \ #define EXPECT_ASK_FOR_CIPHER() \
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), UnorderedElementsAreArray(CryCiphers::supportedCipherNames()))).Times(1) EXPECT_CALL(*console, ask(HasSubstr("block cipher"), UnorderedElementsAreArray(CryCiphers::supportedCipherNames()))).Times(1)
#define EXPECT_DOES_NOT_ASK_FOR_CIPHER() \ #define EXPECT_DOES_NOT_ASK_FOR_CIPHER() \
@ -42,8 +44,8 @@ class CryConfigCreatorTest: public ::testing::Test {
public: public:
CryConfigCreatorTest() CryConfigCreatorTest()
: console(make_shared<MockConsole>()), : console(make_shared<MockConsole>()),
creator(console, cpputils::Random::PseudoRandom(), false), creator(console, cpputils::Random::PseudoRandom()),
noninteractiveCreator(console, cpputils::Random::PseudoRandom(), true) { noninteractiveCreator(make_shared<NoninteractiveConsole>(console), cpputils::Random::PseudoRandom()) {
EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).WillRepeatedly(ChooseAnyCipher()); EXPECT_CALL(*console, ask(HasSubstr("block cipher"), _)).WillRepeatedly(ChooseAnyCipher());
EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).WillRepeatedly(Return(0)); EXPECT_CALL(*console, ask(HasSubstr("block size"), _)).WillRepeatedly(Return(0));
} }

21
test/cryfs/config/CryConfigLoaderTest.cpp
View File

@ -5,6 +5,7 @@
#include <cpp-utils/random/Random.h> #include <cpp-utils/random/Random.h>
#include <cpp-utils/crypto/symmetric/ciphers.h> #include <cpp-utils/crypto/symmetric/ciphers.h>
#include <cpp-utils/data/DataFixture.h> #include <cpp-utils/data/DataFixture.h>
#include <cpp-utils/io/NoninteractiveConsole.h>
#include <gitversion/gitversion.h> #include <gitversion/gitversion.h>
#include <gitversion/VersionCompare.h> #include <gitversion/VersionCompare.h>
@ -13,10 +14,12 @@ using cpputils::make_unique_ref;
using cpputils::TempFile; using cpputils::TempFile;
using cpputils::SCrypt; using cpputils::SCrypt;
using cpputils::DataFixture; using cpputils::DataFixture;
using cpputils::NoninteractiveConsole;
using boost::optional; using boost::optional;
using boost::none; using boost::none;
using std::string; using std::string;
using std::ostream; using std::ostream;
using std::make_shared;
using ::testing::Return; using ::testing::Return;
using ::testing::_; using ::testing::_;
using ::testing::HasSubstr; using ::testing::HasSubstr;
@ -39,7 +42,13 @@ public:
CryConfigLoader loader(const string &password, bool noninteractive, const optional<string> &cipher = none) { CryConfigLoader loader(const string &password, bool noninteractive, const optional<string> &cipher = none) {
auto askPassword = [password] { return password;}; auto askPassword = [password] { return password;};
return CryConfigLoader(console, cpputils::Random::PseudoRandom(), SCrypt::TestSettings, askPassword, askPassword, cipher, none, noninteractive); if(noninteractive) {
return CryConfigLoader(make_shared<NoninteractiveConsole>(console), cpputils::Random::PseudoRandom(), SCrypt::TestSettings, askPassword,
askPassword, cipher, none);
} else {
return CryConfigLoader(console, cpputils::Random::PseudoRandom(), SCrypt::TestSettings, askPassword,
askPassword, cipher, none);
}
} }
CryConfigFile Create(const string &password = "mypassword", const optional<string> &cipher = none, bool noninteractive = false) { CryConfigFile Create(const string &password = "mypassword", const optional<string> &cipher = none, bool noninteractive = false) {
@ -220,7 +229,7 @@ TEST_F(CryConfigLoaderTest, FilesystemID_Create) {
} }
TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerYes) { TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerYes) {
EXPECT_CALL(*console, askYesNo(HasSubstr("should not be opened with older versions"))).Times(1).WillOnce(Return(true)); EXPECT_CALL(*console, askYesNo(HasSubstr("should not be opened with older versions"), false)).Times(1).WillOnce(Return(true));
string version = newerVersion(); string version = newerVersion();
CreateWithVersion(version); CreateWithVersion(version);
@ -228,7 +237,7 @@ TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerYes) {
} }
TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerNo) { TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerNo) {
EXPECT_CALL(*console, askYesNo(HasSubstr("should not be opened with older versions"))).Times(1).WillOnce(Return(false)); EXPECT_CALL(*console, askYesNo(HasSubstr("should not be opened with older versions"), false)).Times(1).WillOnce(Return(false));
string version = newerVersion(); string version = newerVersion();
CreateWithVersion(version); CreateWithVersion(version);
@ -241,7 +250,7 @@ TEST_F(CryConfigLoaderTest, AsksWhenLoadingNewerFilesystem_AnswerNo) {
} }
TEST_F(CryConfigLoaderTest, AsksWhenMigratingOlderFilesystem) { TEST_F(CryConfigLoaderTest, AsksWhenMigratingOlderFilesystem) {
EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"))).Times(1).WillOnce(Return(true)); EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"), false)).Times(1).WillOnce(Return(true));
string version = olderVersion(); string version = olderVersion();
CreateWithVersion(version); CreateWithVersion(version);
@ -249,14 +258,14 @@ TEST_F(CryConfigLoaderTest, AsksWhenMigratingOlderFilesystem) {
} }
TEST_F(CryConfigLoaderTest, DoesNotAskForMigrationWhenCorrectVersion) { TEST_F(CryConfigLoaderTest, DoesNotAskForMigrationWhenCorrectVersion) {
EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"))).Times(0); EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"), false)).Times(0);
CreateWithVersion(gitversion::VersionString()); CreateWithVersion(gitversion::VersionString());
EXPECT_NE(boost::none, Load()); EXPECT_NE(boost::none, Load());
} }
TEST_F(CryConfigLoaderTest, DontMigrateWhenAnsweredNo) { TEST_F(CryConfigLoaderTest, DontMigrateWhenAnsweredNo) {
EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"))).Times(1).WillOnce(Return(false)); EXPECT_CALL(*console, askYesNo(HasSubstr("Do you want to migrate it?"), false)).Times(1).WillOnce(Return(false));
string version = olderVersion(); string version = olderVersion();
CreateWithVersion(version); CreateWithVersion(version);

5
test/cryfs/filesystem/CryFsTest.cpp
View File

@ -9,12 +9,14 @@
#include <cryfs/filesystem/CryOpenFile.h> #include <cryfs/filesystem/CryOpenFile.h>
#include "../testutils/MockConsole.h" #include "../testutils/MockConsole.h"
#include <cryfs/config/CryConfigLoader.h> #include <cryfs/config/CryConfigLoader.h>
#include <cpp-utils/io/NoninteractiveConsole.h>
//TODO (whole project) Make constructors explicit when implicit construction not needed //TODO (whole project) Make constructors explicit when implicit construction not needed
using ::testing::Test; using ::testing::Test;
using ::testing::Return; using ::testing::Return;
using ::testing::_; using ::testing::_;
using std::make_shared;
using cpputils::TempDir; using cpputils::TempDir;
using cpputils::TempFile; using cpputils::TempFile;
using cpputils::dynamic_pointer_move; using cpputils::dynamic_pointer_move;
@ -24,6 +26,7 @@ using cpputils::Console;
using cpputils::Random; using cpputils::Random;
using cpputils::SCrypt; using cpputils::SCrypt;
using cpputils::Data; using cpputils::Data;
using cpputils::NoninteractiveConsole;
using blockstore::ondisk::OnDiskBlockStore; using blockstore::ondisk::OnDiskBlockStore;
using boost::none; using boost::none;
@ -37,7 +40,7 @@ public:
CryConfigFile loadOrCreateConfig() { CryConfigFile loadOrCreateConfig() {
auto askPassword = [] {return "mypassword";}; auto askPassword = [] {return "mypassword";};
return CryConfigLoader(mockConsole(), Random::PseudoRandom(), SCrypt::TestSettings, askPassword, askPassword, none, none, true).loadOrCreate(config.path()).value(); return CryConfigLoader(make_shared<NoninteractiveConsole>(mockConsole()), Random::PseudoRandom(), SCrypt::TestSettings, askPassword, askPassword, none, none).loadOrCreate(config.path()).value();
} }
unique_ref<OnDiskBlockStore> blockStore() { unique_ref<OnDiskBlockStore> blockStore() {

7
test/cryfs/filesystem/FileSystemTest.cpp
View File

@ -1,7 +1,7 @@
#include <blockstore/implementations/testfake/FakeBlockStore.h> #include <blockstore/implementations/testfake/FakeBlockStore.h>
#include <fspp/fstest/FsTest.h> #include <fspp/fstest/FsTest.h>
#include <cpp-utils/tempfile/TempFile.h> #include <cpp-utils/tempfile/TempFile.h>
#include <cpp-utils/io/NoninteractiveConsole.h>
#include <cryfs/filesystem/CryDevice.h> #include <cryfs/filesystem/CryDevice.h>
#include <cryfs/config/CryConfigLoader.h> #include <cryfs/config/CryConfigLoader.h>
#include "../testutils/MockConsole.h" #include "../testutils/MockConsole.h"
@ -10,11 +10,12 @@ using cpputils::unique_ref;
using cpputils::make_unique_ref; using cpputils::make_unique_ref;
using cpputils::Random; using cpputils::Random;
using cpputils::SCrypt; using cpputils::SCrypt;
using cpputils::NoninteractiveConsole;
using fspp::Device; using fspp::Device;
using ::testing::Return; using ::testing::Return;
using ::testing::_; using ::testing::_;
using boost::none; using boost::none;
using std::make_shared;
using blockstore::testfake::FakeBlockStore; using blockstore::testfake::FakeBlockStore;
using namespace cryfs; using namespace cryfs;
@ -28,7 +29,7 @@ public:
unique_ref<Device> createDevice() override { unique_ref<Device> createDevice() override {
auto blockStore = cpputils::make_unique_ref<FakeBlockStore>(); auto blockStore = cpputils::make_unique_ref<FakeBlockStore>();
auto askPassword = [] {return "mypassword";}; auto askPassword = [] {return "mypassword";};
auto config = CryConfigLoader(mockConsole(), Random::PseudoRandom(), SCrypt::TestSettings, askPassword, askPassword, none, none, true) auto config = CryConfigLoader(make_shared<NoninteractiveConsole>(mockConsole()), Random::PseudoRandom(), SCrypt::TestSettings, askPassword, askPassword, none, none)
.loadOrCreate(configFile.path()).value(); .loadOrCreate(configFile.path()).value();
return make_unique_ref<CryDevice>(std::move(config), std::move(blockStore)); return make_unique_ref<CryDevice>(std::move(config), std::move(blockStore));
} }

4
test/cryfs/testutils/MockConsole.h
View File

@ -9,7 +9,7 @@ class MockConsole: public cpputils::Console {
public: public:
MOCK_METHOD1(print, void(const std::string&)); MOCK_METHOD1(print, void(const std::string&));
MOCK_METHOD2(ask, unsigned int(const std::string&, const std::vector<std::string>&)); MOCK_METHOD2(ask, unsigned int(const std::string&, const std::vector<std::string>&));
MOCK_METHOD1(askYesNo, bool(const std::string&)); MOCK_METHOD2(askYesNo, bool(const std::string&, bool));
}; };
ACTION_P(ChooseCipher, cipherName) { ACTION_P(ChooseCipher, cipherName) {
@ -24,7 +24,7 @@ public:
static std::shared_ptr<MockConsole> mockConsole() { static std::shared_ptr<MockConsole> mockConsole() {
auto console = std::make_shared<MockConsole>(); auto console = std::make_shared<MockConsole>();
EXPECT_CALL(*console, ask(::testing::_, ::testing::_)).WillRepeatedly(ChooseCipher("aes-256-gcm")); EXPECT_CALL(*console, ask(::testing::_, ::testing::_)).WillRepeatedly(ChooseCipher("aes-256-gcm"));
EXPECT_CALL(*console, askYesNo(::testing::_)).WillRepeatedly(::testing::Return(true)); EXPECT_CALL(*console, askYesNo(::testing::_, ::testing::_)).WillRepeatedly(::testing::Return(true));
return console; return console;
} }
}; };