doc/passwordfile/passwordfiletests_8cpp_source.html

#include "../io/cryptoexception.h"

#include "../io/entry.h"

#include "../io/passwordfile.h"


#include "./utils.h"


#include <cppunit/TestFixture.h>

#include <cppunit/extensions/HelperMacros.h>


using namespace std;

using namespace Io;

using namespace CppUtilities;

using namespace CppUtilities::Literals;

using namespace CPPUNIT_NS;


class PasswordFileTests : public TestFixture {

    CPPUNIT_TEST_SUITE(PasswordFileTests);

    CPPUNIT_TEST(testReading);

    CPPUNIT_TEST(testBasicWriting);

    CPPUNIT_TEST(testExtendedWriting);

    CPPUNIT_TEST_SUITE_END();


public:

    void setUp() override;

    void tearDown() override;


    void testReading();

    void testReading(const string &context, const string &testfile1path, const string &testfile1password, const string &testfile2,

        const string &testfile2password, bool testfile2Mod, bool extendedHeaderMod);

    void testBasicWriting();

    void testExtendedWriting();

};


CPPUNIT_TEST_SUITE_REGISTRATION(PasswordFileTests);


void PasswordFileTests::setUp()

{

}


void PasswordFileTests::tearDown()

{

}


void PasswordFileTests::testReading()

{

    testReading("read", testFilePath("testfile1.pwmgr"), "123456", testFilePath("testfile2.pwmgr"), string(), false, false);

}


void PasswordFileTests::testReading(const string &context, const string &testfile1path, const string &testfile1password, const string &testfile2,

    const string &testfile2password, bool testfilesMod, bool extendedHeaderMod)

{

    PasswordFile file;


    // open testfile 1 ...

    file.setPath(testfile1path);

    file.open(PasswordFileOpenFlags::ReadOnly);


    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, !testfile1password.empty(), file.isEncryptionUsed());

    // attempt to decrypt using a wrong password

    file.setPassword(testfile1password + "asdf");

    if (!testfile1password.empty()) {

        CPPUNIT_ASSERT_THROW(file.load(), CryptoException);

    }

    // attempt to decrypt using the correct password

    file.setPassword(testfile1password);

    file.load();

    // test root entry

    const NodeEntry *const rootEntry = file.rootEntry();

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile1"s, rootEntry->label());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 4_st, rootEntry->children().size());


    // test testaccount1

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testaccount1"s, rootEntry->children()[0]->label());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, EntryType::Account, rootEntry->children()[0]->type());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "pin"s, static_cast<AccountEntry *>(rootEntry->children()[0])->fields().at(0).name());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "123456"s, static_cast<AccountEntry *>(rootEntry->children()[0])->fields().at(0).value());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, FieldType::Password, static_cast<AccountEntry *>(rootEntry->children()[0])->fields().at(0).type());

    CPPUNIT_ASSERT(

        static_cast<AccountEntry *>(rootEntry->children()[0])->fields().at(0).tiedAccount() == static_cast<AccountEntry *>(rootEntry->children()[0]));

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, FieldType::Normal, static_cast<AccountEntry *>(rootEntry->children()[0])->fields().at(1).type());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 2_st, static_cast<AccountEntry *>(rootEntry->children()[0])->fields().size());


    // test testaccount2

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testaccount2"s, rootEntry->children()[1]->label());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, EntryType::Account, rootEntry->children()[1]->type());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 0_st, static_cast<AccountEntry *>(rootEntry->children()[1])->fields().size());


    // test testcategory1

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testcategory1"s, rootEntry->children()[2]->label());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, EntryType::Node, rootEntry->children()[2]->type());

    const NodeEntry *const category = static_cast<NodeEntry *>(rootEntry->children()[2]);

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 3_st, category->children().size());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, EntryType::Node, category->children()[2]->type());

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 2_st, static_cast<NodeEntry *>(category->children()[2])->children().size());


    // test testaccount3

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testaccount3"s, rootEntry->children()[3]->label());


    if (!testfilesMod) {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption, compression"s, flagsToString(file.saveOptions()));

    } else if (extendedHeaderMod) {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "foo"s, file.extendedHeader());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption, password hashing"s, flagsToString(file.saveOptions()));

    } else {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, ""s, file.extendedHeader());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "compression"s, flagsToString(file.saveOptions()));

    }

    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, ""s, file.encryptedExtendedHeader());


    // open testfile 2

    file.setPath(testfile2);

    file.open(PasswordFileOpenFlags::ReadOnly);


    CPPUNIT_ASSERT_EQUAL_MESSAGE(context, !testfile2password.empty(), file.isEncryptionUsed());

    file.setPassword(testfile2password);

    file.load();

    const NodeEntry *const rootEntry2 = file.rootEntry();

    if (testfilesMod) {

        if (extendedHeaderMod) {

            CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(6), file.version());

            CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption, password hashing"s, flagsToString(file.saveOptions()));

        } else {

            CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(3), file.version());

            CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption"s, flagsToString(file.saveOptions()));

        }

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2 - modified"s, rootEntry2->label());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 2_st, rootEntry2->children().size());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "newAccount"s, rootEntry2->children()[1]->label());

    } else {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(3), file.version());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2"s, rootEntry2->label());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 1_st, rootEntry2->children().size());

    }

    if (extendedHeaderMod) {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "foo"s, file.extendedHeader());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "bar"s, file.encryptedExtendedHeader());


    } else {

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, ""s, file.extendedHeader());

        CPPUNIT_ASSERT_EQUAL_MESSAGE(context, ""s, file.encryptedExtendedHeader());

    }

}


void PasswordFileTests::testBasicWriting()

{

    const string testfile1 = workingCopyPath("testfile1.pwmgr");

    const string testfile2 = workingCopyPath("testfile2.pwmgr");

    PasswordFile file;


    // resave testfile 1

    file.setPath(testfile1);

    file.open();

    file.setPassword("123456");

    file.load();

    file.doBackup();

    file.save(PasswordFileSaveFlags::Compression);


    // resave testfile 2

    file.setPath(testfile2);

    file.open();

    file.load();

    file.rootEntry()->setLabel("testfile2 - modified");

    new AccountEntry("newAccount", file.rootEntry());

    file.setPassword("654321");

    file.doBackup();

    file.save(PasswordFileSaveFlags::Encryption);


    // check results using the reading test

    testReading("basic writing", testfile1, string(), testfile2, "654321", true, false);


    // check backup files

    testReading("basic writing", testfile1 + ".backup", "123456", testfile2 + ".backup", string(), false, false);

}


void PasswordFileTests::testExtendedWriting()

{

    const string testfile1 = workingCopyPath("testfile1.pwmgr");

    const string testfile2 = workingCopyPath("testfile2.pwmgr");

    PasswordFile file;


    // resave testfile 1

    file.setPath(testfile1);

    file.open();

    file.setPassword("123456");

    file.load();

    CPPUNIT_ASSERT_EQUAL(""s, file.extendedHeader());

    CPPUNIT_ASSERT_EQUAL(""s, file.encryptedExtendedHeader());

    file.doBackup();

    file.extendedHeader() = "foo";

    file.save(PasswordFileSaveFlags::Encryption | PasswordFileSaveFlags::PasswordHashing);


    // resave testfile 2

    file.setPath(testfile2);

    file.open();

    file.load();

    CPPUNIT_ASSERT_EQUAL(""s, file.extendedHeader());

    CPPUNIT_ASSERT_EQUAL(""s, file.encryptedExtendedHeader());

    file.rootEntry()->setLabel("testfile2 - modified");

    auto *const newAccount = new AccountEntry("newAccount", file.rootEntry());

    file.setPassword("654321");

    file.extendedHeader() = "foo";

    file.encryptedExtendedHeader() = "bar";

    file.doBackup();

    file.save(PasswordFileSaveFlags::Encryption | PasswordFileSaveFlags::PasswordHashing);


    // check results using the reading test

    testReading("extended writing", testfile1, "123456", testfile2, "654321", true, true);


    // check backup files

    testReading("extended writing", testfile1 + ".backup", "123456", testfile2 + ".backup", string(), false, false);


    // remove newAccount again to check what happens if the file size decreases

    const auto fileSize = file.size();

    delete newAccount;

    file.save(PasswordFileSaveFlags::Encryption | PasswordFileSaveFlags::PasswordHashing);

    file.close();

    file.clearEntries();

    file.open();

    CPPUNIT_ASSERT_LESS(fileSize, file.size());

    file.load();


    auto path = std::list<std::string>{ "newAccount" };

    CPPUNIT_ASSERT(file.rootEntry());

    CPPUNIT_ASSERT(!file.rootEntry()->entryByPath(path));

}


Io::AccountEntry
The exception that is thrown when a parsing error occurs.
Definition entry.h:170

Io::AccountEntry::fields
const std::vector< Field > & fields() const
Definition entry.h:194

Io::CryptoException
The exception that is thrown when an encryption/decryption error occurs.
Definition cryptoexception.h:11

Io::Entry::setLabel
void setLabel(const std::string &label)
Sets the label.
Definition entry.h:80

Io::Entry::label
const std::string & label() const
Returns the label.
Definition entry.h:70

Io::NodeEntry
The NodeEntry class acts as parent for other entries.
Definition entry.h:114

Io::NodeEntry::entryByPath
Entry * entryByPath(std::list< std::string > &path, bool includeThis=true, const EntryType *creationType=nullptr)
Returns an entry specified by the provided path.
Definition entry.cpp:350

Io::NodeEntry::children
const std::vector< Entry * > & children() const
Definition entry.h:145

Io::PasswordFile
The PasswordFile class holds account information in the form of Entry and Field instances and provide...
Definition passwordfile.h:40

Io::PasswordFile::rootEntry
const NodeEntry * rootEntry() const
Returns the root entry if present or nullptr otherwise.
Definition passwordfile.cpp:685

Io::PasswordFile::clearEntries
void clearEntries()
Removes the root element if one is present.
Definition passwordfile.cpp:588

Io::PasswordFile::open
void open(PasswordFileOpenFlags options=PasswordFileOpenFlags::Default)
Opens the file.
Definition passwordfile.cpp:119

Io::PasswordFile::load
void load()
Reads the contents of the file.
Definition passwordfile.cpp:177

Io::PasswordFile::close
void close()
Closes the file if currently opened.
Definition passwordfile.cpp:701

Io::PasswordFile::version
std::uint32_t version() const
Returns the file version used the last time when saving the file (the version of the file as it is on...
Definition passwordfile.h:198

Io::PasswordFile::setPassword
void setPassword(const std::string &password)
Sets the current password.
Definition passwordfile.h:133

Io::PasswordFile::isEncryptionUsed
bool isEncryptionUsed()
Returns an indication whether encryption is used and the file is open; returns always false otherwise...
Definition passwordfile.cpp:728

Io::PasswordFile::size
std::size_t size()
Returns the size of the file if the file is open; otherwise returns zero.
Definition passwordfile.cpp:754

Io::PasswordFile::save
void save(PasswordFileSaveFlags options=PasswordFileSaveFlags::Default)
Writes the current root entry to the file under path() replacing its previous contents.
Definition passwordfile.cpp:399

Io::PasswordFile::encryptedExtendedHeader
std::string & encryptedExtendedHeader()
Returns the encrypted extended header.
Definition passwordfile.h:181

Io::PasswordFile::setPath
void setPath(const std::string &value)
Sets the current file path.
Definition passwordfile.cpp:712

Io::PasswordFile::extendedHeader
std::string & extendedHeader()
Returns the extended header.
Definition passwordfile.h:165

Io::PasswordFile::doBackup
void doBackup()
Creates a backup of the file.
Definition passwordfile.cpp:654

Io::PasswordFile::saveOptions
PasswordFileSaveFlags saveOptions() const
Returns the save options used the last time when saving the file.
Definition passwordfile.h:214

PasswordFileTests
The PasswordFileTests class tests the Io::PasswordFile class.
Definition passwordfiletests.cpp:19

PasswordFileTests::setUp
void setUp() override
Definition passwordfiletests.cpp:39

PasswordFileTests::testBasicWriting
void testBasicWriting()
Tests writing (and reading again) using basic features.
Definition passwordfiletests.cpp:153

PasswordFileTests::testExtendedWriting
void testExtendedWriting()
Tests writing (and reading again) using extended features.
Definition passwordfiletests.cpp:187

PasswordFileTests::testReading
void testReading()
Tests reading the testfiles testfile{1,2}.pwmgr.
Definition passwordfiletests.cpp:50

PasswordFileTests::tearDown
void tearDown() override
Definition passwordfiletests.cpp:43

cryptoexception.h

entry.h

CppUtilities
Definition utils.h:12

Io
Contains all IO related classes.
Definition cryptoexception.h:9

Io::flagsToString
PASSWORD_FILE_EXPORT std::string flagsToString(PasswordFileOpenFlags flags)
Returns a comma-separated string for the specified flags.
Definition passwordfile.cpp:790

passwordfile.h

CPPUNIT_TEST_SUITE_REGISTRATION
CPPUNIT_TEST_SUITE_REGISTRATION(PasswordFileTests)

utils.h