horcrux/test/integration-test.cpp

#include "gtest/gtest.h"
#include "test.h"
#include "horcrux.h"

using namespace horcrux;

TEST(IntegrationTest, EndToEndEncryptDecrypt){
    auto buf = generic_read_file(image);

    //Prepare encrypt operation
    auto in = FsPlainInput(image);
    auto cipher = AES256_CBC();
    auto out = FsCryptoOutput(folder, 3);

    // Perform encrypt operation
    out.write(cipher.encrypt(in.read()));

    //Prepare decrypt operation
    auto in2 = FsCryptoInput(get_created_filenames(out));
    //Perform decrypt operation
    auto buf2 = cipher.decrypt(in2.read());

    //check outcome
    EXPECT_EQ(buf, buf2);

    auto out2 = FsPlainOutput(noexist);
    out2.write(cipher.decrypt(in2.read()));

    auto buf3 = generic_read_file(noexist);
    EXPECT_EQ(buf, buf3);

    delete_created_files(out);
    std::filesystem::remove(noexist);
}

TEST(IntegrationTest, HorcruxOptions){
    HorcruxOptions options {
        .mode = Mode::kEncrypt,
        .count = -1,
        .input = {noexist},
        .output = {image}
    };
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.count = 1;
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.input = {image};
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.output = {folder};
    options.count = 0;
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.count = 2;
    EXPECT_NO_THROW(Horcrux {options});
    options.mode = Mode::kDecrypt;
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.input = {image, text};
    options.count = 1;
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.output = {noexist};
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.count = 2;
    EXPECT_THROW(Horcrux {options}, std::invalid_argument);
    options.base64_key = to_base64(generate_random(32));
    EXPECT_NO_THROW(Horcrux {options});
}
TEST(IntegrationTest, HorcruxEncryptiDecrypt) {
    HorcruxOptions options {
        .mode = Mode::kEncrypt,
        .count = 3,
        .input = {image},
        .output = {folder}
    };
    Horcrux enc{options};

    enc.run();
    auto key = enc.key();

    HorcruxOptions options2 {
        .mode = Mode::kDecrypt,
        .count = 3,
        .input = {get_encrypted_files(folder, image)},
        .output = {noexist},
        .base64_key = key
    };

    Horcrux dec{options2};
    dec.run();

    //Compare input and ouput files
    EXPECT_EQ(generic_read_file(image), generic_read_file(noexist));
    std::filesystem::remove(noexist);
    std::for_each(options2.input.begin(), options2.input.end(), [](auto& p){
            std::filesystem::remove(p);});
}
TEST(IntegrationTest, arguments){
    EXPECT_THROW(
            parse_arguments({"horcrux", "create", "-n", "4", "input_file"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "pippo", "-n", "4", "input_file"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "create", "-n", "4", "input_file", "output_file", "garbage"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "create", "-h", "4", "input_file", "output_file"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "create", "-n", "boh", "input_file", "output_file"}),
            std::invalid_argument);
    EXPECT_NO_THROW(
            parse_arguments({"horcrux", "create", "-n", "4", "input_file", "output_file"}));
    EXPECT_THROW(
            parse_arguments({"horcrux", "load", "-n", "4", "input_file"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "load", "-k", "lshgflushlgkjusghl", "input_file"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "load", "-r", "lshgflushlgkjusghl", "input", "input", "output"}),
            std::invalid_argument);
    EXPECT_THROW(
            parse_arguments({"horcrux", "load", "-k", "lshgflushlgkjusghl", "input"}),
            std::invalid_argument);
    EXPECT_NO_THROW(
            parse_arguments({"horcrux", "load", "-k", "lshgflushlgkjusghl", "input", "output"}));
    EXPECT_NO_THROW(
            parse_arguments({"horcrux", "load", "-k", "lshgflushlgkjusghl", "input", "input", "output"}));
}