BlockStorage/repertory
1
0
Fork 0
Code Issues 3 Pull Requests Releases 9 Wiki Activity

v2.0.4-rc (#37)
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source 
# Changelog

## v2.0.4-rc

### BREAKING CHANGES

* `renterd` v2.0.0+ is now required. Prior versions will fail to mount.

### Issues

* \#35 [bug] Low frequency check is set to '0' instead of 1 hour by default
* \#36 [bug] Max cache size bytes is set to '0' by default

### Changes from v2.0.3-rc

* Added Sia API version check prior to mounting
* Added back `-cv` (check version) CLI option
* Continue documentation updates
* Fixed setting `ApiAuth` via `set_value_by_name`
* Fixed setting `HostConfig.ApiUser` via `set_value_by_name`
* Fixed setting `HostConfig.Path` via `set_value_by_name`
* Fixed setting `HostConfig.Protocol` via `set_value_by_name`
* Improved ring buffer read-ahead
* Integrated `renterd` version 2.0.0
* Prefer using local cache file when opening files
* Refactored `app_config` unit tests
* Refactored polling to be more accurate on scheduling tasks

Reviewed-on: #37
This commit is contained in:
sgraves76
2025-02-22 09:48:00 -06:00
parent fa439c634f
commit 24418ba03d
48 changed files with 2141 additions and 1200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
repertory/repertory_test/include/fixtures/fuse_fixture.hpp
View File

@@ -268,8 +268,8 @@ public:
return file_path;
}
static auto create_file_and_test(std::string &file_name,
mode_t perms) -> std::string {
static auto create_file_and_test(std::string &file_name, mode_t perms)
-> std::string {
file_name += std::to_string(++provider_idx);
auto file_path = utils::path::combine(mount_location, {file_name});
@@ -287,7 +287,7 @@ public:
EXPECT_TRUE(utils::file::file(file_path).exists());
EXPECT_FALSE(utils::file::directory(file_path).exists());
struct stat64 unix_st {};
struct stat64 unix_st{};
EXPECT_EQ(0, stat64(file_path.c_str(), &unix_st));
EXPECT_EQ(getgid(), unix_st.st_gid);
EXPECT_EQ(getuid(), unix_st.st_uid);
@@ -299,8 +299,8 @@ public:
return create_file_and_test(file_name, ACCESSPERMS);
}
static auto create_directory_and_test(std::string &dir_name,
mode_t perms) -> std::string {
static auto create_directory_and_test(std::string &dir_name, mode_t perms)
-> std::string {
dir_name += std::to_string(++provider_idx);
auto dir_path = utils::path::combine(mount_location, {dir_name});
@@ -309,7 +309,7 @@ public:
EXPECT_TRUE(utils::file::directory(dir_path).exists());
EXPECT_FALSE(utils::file::file(dir_path).exists());
struct stat64 unix_st {};
struct stat64 unix_st{};
EXPECT_EQ(0, stat64(dir_path.c_str(), &unix_st));
EXPECT_EQ(getgid(), unix_st.st_gid);
EXPECT_EQ(getuid(), unix_st.st_uid);
@@ -410,9 +410,9 @@ std::string fuse_test<provider_t>::mount_location;
template <typename provider_t>
std::string fuse_test<provider_t>::mount_location2;
using fuse_provider_types = ::testing::Types<local_s3, remote_s3>;
// using fuse_provider_types =
// ::testing::Types<local_s3, remote_s3, local_sia, remote_sia>;
// using fuse_provider_types = ::testing::Types<local_s3, remote_s3>;
using fuse_provider_types =
::testing::Types<local_s3, remote_s3, local_sia, remote_sia>;
} // namespace repertory
#endif // !defined(_WIN32)

4
repertory/repertory_test/include/mocks/mock_provider.hpp
View File

@@ -36,6 +36,10 @@ private:
const bool allow_rename_;
public:
MOCK_METHOD(bool, check_version,
(std::string & required_version, std::string &returned_version),
(const, override));
MOCK_METHOD(api_error, create_directory,
(const std::string &api_path, api_meta_map &meta), (override));

763
repertory/repertory_test/src/app_config_test.cpp Normal file
View File

@@ -0,0 +1,763 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include "test_common.hpp"
#include "app_config.hpp"
#include "utils/path.hpp"
namespace repertory {
class app_config_test : public ::testing::Test {
public:
static std::atomic<std::uint64_t> idx;
std::string encrypt_directory;
std::string remote_directory;
std::string s3_directory;
std::string sia_directory;
void SetUp() override {
encrypt_directory = utils::path::combine(test::get_test_output_dir(),
{
"app_config_test",
"encrypt",
std::to_string(++idx),
});
remote_directory = utils::path::combine(test::get_test_output_dir(),
{
"app_config_test",
"remote",
std::to_string(++idx),
});
s3_directory = utils::path::combine(test::get_test_output_dir(),
{
"app_config_test",
"s3",
std::to_string(++idx),
});
sia_directory = utils::path::combine(test::get_test_output_dir(),
{
"app_config_test",
"sia",
std::to_string(++idx),
});
}
};
static void remove_unused_types(auto &data, provider_type prov) {
switch (prov) {
case provider_type::encrypt:
data.erase(JSON_DOWNLOAD_TIMEOUT_SECS);
data.erase(JSON_ENABLE_DOWNLOAD_TIMEOUT);
data.erase(JSON_EVICTION_DELAY_MINS);
data.erase(JSON_EVICTION_USE_ACCESS_TIME);
data.erase(JSON_HOST_CONFIG);
data.erase(JSON_MAX_CACHE_SIZE_BYTES);
data.erase(JSON_MAX_UPLOAD_COUNT);
data.erase(JSON_ONLINE_CHECK_RETRY_SECS);
data.erase(JSON_PREFERRED_DOWNLOAD_TYPE);
data.erase(JSON_REMOTE_CONFIG);
data.erase(JSON_RETRY_READ_COUNT);
data.erase(JSON_RING_BUFFER_FILE_SIZE);
data.erase(JSON_S3_CONFIG);
data.erase(JSON_SIA_CONFIG);
break;
case provider_type::remote:
data.erase(JSON_DATABASE_TYPE);
data.erase(JSON_DOWNLOAD_TIMEOUT_SECS);
data.erase(JSON_ENABLE_DOWNLOAD_TIMEOUT);
data.erase(JSON_ENCRYPT_CONFIG);
data.erase(JSON_EVICTION_DELAY_MINS);
data.erase(JSON_EVICTION_USE_ACCESS_TIME);
data.erase(JSON_HIGH_FREQ_INTERVAL_SECS);
data.erase(JSON_HOST_CONFIG);
data.erase(JSON_LOW_FREQ_INTERVAL_SECS);
data.erase(JSON_MAX_CACHE_SIZE_BYTES);
data.erase(JSON_MAX_UPLOAD_COUNT);
data.erase(JSON_MED_FREQ_INTERVAL_SECS);
data.erase(JSON_ONLINE_CHECK_RETRY_SECS);
data.erase(JSON_PREFERRED_DOWNLOAD_TYPE);
data.erase(JSON_REMOTE_MOUNT);
data.erase(JSON_RETRY_READ_COUNT);
data.erase(JSON_RING_BUFFER_FILE_SIZE);
data.erase(JSON_S3_CONFIG);
data.erase(JSON_SIA_CONFIG);
break;
case provider_type::s3:
data.erase(JSON_ENCRYPT_CONFIG);
data.erase(JSON_HOST_CONFIG);
data.erase(JSON_REMOTE_CONFIG);
data.erase(JSON_SIA_CONFIG);
break;
case provider_type::sia:
data.erase(JSON_ENCRYPT_CONFIG);
data.erase(JSON_REMOTE_CONFIG);
data.erase(JSON_S3_CONFIG);
break;
default:
return;
}
}
std::atomic<std::uint64_t> app_config_test::idx{0U};
static void defaults_tests(const json &json_data, provider_type prov) {
json json_defaults = {
{JSON_API_PORT, app_config::default_rpc_port(prov)},
{JSON_API_USER, std::string{REPERTORY}},
{JSON_DOWNLOAD_TIMEOUT_SECS, default_download_timeout_secs},
{JSON_DATABASE_TYPE, database_type::rocksdb},
{JSON_ENABLE_DOWNLOAD_TIMEOUT, true},
{JSON_ENABLE_DRIVE_EVENTS, false},
#if defined(_WIN32)
{JSON_ENABLE_MOUNT_MANAGER, false},
#endif // defined(_WIN32)
{JSON_ENCRYPT_CONFIG, encrypt_config{}},
{JSON_EVENT_LEVEL, event_level::info},
{JSON_EVICTION_DELAY_MINS, default_eviction_delay_mins},
{JSON_EVICTION_USE_ACCESS_TIME, false},
{JSON_HIGH_FREQ_INTERVAL_SECS, default_high_freq_interval_secs},
{JSON_HOST_CONFIG, host_config{}},
{JSON_LOW_FREQ_INTERVAL_SECS, default_low_freq_interval_secs},
{JSON_MAX_CACHE_SIZE_BYTES, default_max_cache_size_bytes},
{JSON_MAX_UPLOAD_COUNT, default_max_upload_count},
{JSON_MED_FREQ_INTERVAL_SECS, default_med_freq_interval_secs},
{JSON_ONLINE_CHECK_RETRY_SECS, default_online_check_retry_secs},
{JSON_PREFERRED_DOWNLOAD_TYPE, download_type::default_},
{JSON_REMOTE_CONFIG, remote::remote_config{}},
{JSON_REMOTE_MOUNT, remote::remote_mount{}},
{JSON_RETRY_READ_COUNT, default_retry_read_count},
{JSON_RING_BUFFER_FILE_SIZE, default_ring_buffer_file_size},
{JSON_S3_CONFIG, s3_config{}},
{JSON_SIA_CONFIG, sia_config{}},
{JSON_TASK_WAIT_MS, default_task_wait_ms},
{JSON_VERSION, REPERTORY_CONFIG_VERSION},
};
remove_unused_types(json_defaults, prov);
switch (prov) {
case provider_type::encrypt:
json_defaults[JSON_REMOTE_MOUNT][JSON_API_PORT] =
app_config::default_remote_api_port(prov);
break;
json_defaults[JSON_REMOTE_MOUNT][JSON_API_PORT] =
app_config::default_remote_api_port(prov);
break;
case provider_type::sia:
json_defaults[JSON_HOST_CONFIG][JSON_API_PORT] =
app_config::default_api_port(prov);
json_defaults[JSON_HOST_CONFIG][JSON_AGENT_STRING] =
app_config::default_agent_name(prov);
json_defaults[JSON_REMOTE_MOUNT][JSON_API_PORT] =
app_config::default_remote_api_port(prov);
break;
default:
return;
}
fmt::println("testing default|{}-{}", app_config::get_provider_name(prov),
JSON_API_AUTH);
ASSERT_EQ(std::size_t(default_api_auth_size),
json_data.at(JSON_API_AUTH).get<std::string>().size());
for (const auto &[key, value] : json_defaults.items()) {
fmt::println("testing default|{}-{}", app_config::get_provider_name(prov),
key);
EXPECT_EQ(value, json_data.at(key));
}
}
template <typename get_t, typename set_t, typename val_t>
static void test_getter_setter(app_config &cfg, get_t getter, set_t setter,
val_t val1, val_t val2, const std::string &key,
const std::string &val_str) {
(cfg.*setter)(val1);
ASSERT_TRUE((cfg.*getter)() == val1);
(cfg.*setter)(val2);
ASSERT_TRUE((cfg.*getter)() == val2);
if (key.empty()) {
return;
}
EXPECT_STREQ(val_str.c_str(), cfg.set_value_by_name(key, val_str).c_str());
}
static void common_tests(app_config &config, provider_type prov) {
ASSERT_EQ(config.get_provider_type(), prov);
std::map<std::string_view, std::function<void(app_config &)>> methods{
{JSON_API_AUTH,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_api_auth,
&app_config::set_api_auth, "", "auth",
JSON_API_AUTH, "auth2");
}},
{JSON_API_PORT,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_api_port,
&app_config::set_api_port, std::uint16_t{0U},
std::uint16_t{1024U}, JSON_API_PORT, "1025");
}},
{JSON_API_USER,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_api_user,
&app_config::set_api_user, "", "user",
JSON_API_USER, "user2");
}},
{JSON_DOWNLOAD_TIMEOUT_SECS,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_download_timeout_secs,
&app_config::set_download_timeout_secs,
std::uint8_t{min_download_timeout_secs + 1U},
std::uint8_t{min_download_timeout_secs + 2U},
JSON_DOWNLOAD_TIMEOUT_SECS,
std::to_string(min_download_timeout_secs + 2U));
cfg.set_download_timeout_secs(min_download_timeout_secs - 1U);
EXPECT_EQ(min_download_timeout_secs, cfg.get_download_timeout_secs());
}},
{JSON_DATABASE_TYPE,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_database_type,
&app_config::set_database_type,
database_type::rocksdb, database_type::sqlite,
JSON_DATABASE_TYPE, "rocksdb");
}},
{JSON_ENABLE_DOWNLOAD_TIMEOUT,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_enable_download_timeout,
&app_config::set_enable_download_timeout, true,
false, JSON_ENABLE_DOWNLOAD_TIMEOUT, "1");
}},
{JSON_ENABLE_DRIVE_EVENTS,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_enable_drive_events,
&app_config::set_enable_drive_events, true, false,
JSON_ENABLE_DRIVE_EVENTS, "1");
}},
#if defined(_WIN32)
{JSON_ENABLE_MOUNT_MANAGER,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_enable_mount_manager,
&app_config::set_enable_mount_manager, true, false,
JSON_ENABLE_MOUNT_MANAGER, "1");
}},
#endif // defined(_WIN32)
{JSON_ENCRYPT_CONFIG,
[](app_config &cfg) {
encrypt_config cfg1{};
cfg1.encryption_token = "1";
cfg1.path = "2";
encrypt_config cfg2{};
cfg2.encryption_token = "2";
cfg2.path = "1";
ASSERT_NE(cfg1, cfg2);
test_getter_setter(cfg, &app_config::get_encrypt_config,
&app_config::set_encrypt_config, cfg1, cfg2, "",
"");
encrypt_config cfg3{};
cfg3.encryption_token = "3";
cfg3.path = "4";
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_ENCRYPT_CONFIG, JSON_ENCRYPTION_TOKEN),
cfg3.encryption_token);
EXPECT_STREQ(cfg3.encryption_token.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_ENCRYPT_CONFIG, JSON_PATH), cfg3.path);
EXPECT_STREQ(cfg3.path.c_str(), value.c_str());
}},
{JSON_EVENT_LEVEL,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_event_level,
&app_config::set_event_level, event_level::critical,
event_level::debug, JSON_EVENT_LEVEL, "info");
}},
{JSON_EVICTION_DELAY_MINS,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_eviction_delay_mins,
&app_config::set_eviction_delay_mins,
std::uint32_t{0U}, std::uint32_t{1U},
JSON_EVICTION_DELAY_MINS, "2");
}},
{JSON_EVICTION_USE_ACCESS_TIME,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_eviction_uses_accessed_time,
&app_config::set_eviction_uses_accessed_time, true,
false, JSON_EVICTION_USE_ACCESS_TIME, "1");
}},
{JSON_HIGH_FREQ_INTERVAL_SECS,
[](app_config &cfg) {
test_getter_setter(
cfg, &app_config::get_high_frequency_interval_secs,
&app_config::set_high_frequency_interval_secs,
std::uint16_t{default_high_freq_interval_secs + 1U},
std::uint16_t{default_high_freq_interval_secs + 2U},
JSON_HIGH_FREQ_INTERVAL_SECS,
std::to_string(default_high_freq_interval_secs + 3U));
cfg.set_high_frequency_interval_secs(0U);
EXPECT_EQ(1U, cfg.get_high_frequency_interval_secs());
}},
{JSON_HOST_CONFIG,
[](app_config &cfg) {
host_config cfg1{};
cfg1.agent_string = "1";
cfg1.api_password = "2";
cfg1.api_user = "3";
cfg1.api_port = 4U;
cfg1.host_name_or_ip = "5";
cfg1.path = "6";
cfg1.protocol = "http";
cfg1.timeout_ms = 8U;
host_config cfg2{};
cfg2.agent_string = "9";
cfg2.api_password = "10";
cfg2.api_user = "11";
cfg2.api_port = 12U;
cfg2.host_name_or_ip = "13";
cfg2.path = "14";
cfg2.protocol = "https";
cfg2.timeout_ms = 16U;
ASSERT_NE(cfg1, cfg2);
test_getter_setter(cfg, &app_config::get_host_config,
&app_config::set_host_config, cfg1, cfg2, "", "");
host_config cfg3{};
cfg3.agent_string = "17";
cfg3.api_password = "18";
cfg3.api_user = "19";
cfg3.api_port = 20U;
cfg3.host_name_or_ip = "21";
cfg3.path = "22";
cfg3.protocol = "http";
cfg3.timeout_ms = 24;
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_AGENT_STRING),
cfg3.agent_string);
EXPECT_STREQ(cfg3.agent_string.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_PASSWORD),
cfg3.api_password);
EXPECT_STREQ(cfg3.api_password.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_USER),
cfg3.api_user);
EXPECT_STREQ(cfg3.api_user.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_API_PORT),
std::to_string(cfg3.api_port));
EXPECT_STREQ(std::to_string(cfg3.api_port).c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_HOST_NAME_OR_IP),
cfg3.host_name_or_ip);
EXPECT_STREQ(cfg3.host_name_or_ip.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_PATH), cfg3.path);
EXPECT_STREQ(cfg3.path.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_PROTOCOL),
cfg3.protocol);
EXPECT_STREQ(cfg3.protocol.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_HOST_CONFIG, JSON_TIMEOUT_MS),
std::to_string(cfg3.timeout_ms));
EXPECT_STREQ(std::to_string(cfg3.timeout_ms).c_str(), value.c_str());
}},
{JSON_LOW_FREQ_INTERVAL_SECS,
[](app_config &cfg) {
test_getter_setter(
cfg, &app_config::get_low_frequency_interval_secs,
&app_config::set_low_frequency_interval_secs,
std::uint16_t{default_low_freq_interval_secs + 1U},
std::uint16_t{default_low_freq_interval_secs + 2U},
JSON_LOW_FREQ_INTERVAL_SECS,
std::to_string(default_low_freq_interval_secs + 3U));
cfg.set_low_frequency_interval_secs(0U);
EXPECT_EQ(1U, cfg.get_low_frequency_interval_secs());
}},
{JSON_MAX_CACHE_SIZE_BYTES,
[](app_config &cfg) {
test_getter_setter(
cfg, &app_config::get_max_cache_size_bytes,
&app_config::set_max_cache_size_bytes, min_cache_size_bytes + 1U,
min_cache_size_bytes + 2U, JSON_MAX_CACHE_SIZE_BYTES,
std::to_string(min_cache_size_bytes + 3U));
cfg.set_max_cache_size_bytes(min_cache_size_bytes - 1U);
EXPECT_EQ(min_cache_size_bytes, cfg.get_max_cache_size_bytes());
}},
{JSON_MAX_UPLOAD_COUNT,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_max_upload_count,
&app_config::set_max_upload_count, std::uint8_t{1U},
std::uint8_t{2U}, JSON_MAX_UPLOAD_COUNT, "3");
cfg.set_max_upload_count(0U);
EXPECT_EQ(1U, cfg.get_max_upload_count());
}},
{JSON_MED_FREQ_INTERVAL_SECS,
[](app_config &cfg) {
test_getter_setter(
cfg, &app_config::get_med_frequency_interval_secs,
&app_config::set_med_frequency_interval_secs,
std::uint16_t{default_med_freq_interval_secs + 1U},
std::uint16_t{default_med_freq_interval_secs + 2U},
JSON_MED_FREQ_INTERVAL_SECS,
std::to_string(default_med_freq_interval_secs + 3U));
cfg.set_med_frequency_interval_secs(0U);
EXPECT_EQ(1U, cfg.get_med_frequency_interval_secs());
}},
{JSON_ONLINE_CHECK_RETRY_SECS,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_online_check_retry_secs,
&app_config::set_online_check_retry_secs,
std::uint16_t{min_online_check_retry_secs + 1U},
std::uint16_t{min_online_check_retry_secs + 2U},
JSON_ONLINE_CHECK_RETRY_SECS,
std::to_string(min_online_check_retry_secs + 3U));
cfg.set_online_check_retry_secs(min_online_check_retry_secs - 1U);
EXPECT_EQ(min_online_check_retry_secs,
cfg.get_online_check_retry_secs());
}},
{JSON_PREFERRED_DOWNLOAD_TYPE,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_preferred_download_type,
&app_config::set_preferred_download_type,
download_type::direct, download_type::default_,
JSON_PREFERRED_DOWNLOAD_TYPE, "ring_buffer");
}},
{JSON_REMOTE_CONFIG,
[](app_config &cfg) {
remote::remote_config remote_cfg1{};
remote_cfg1.api_port = 1U;
remote_cfg1.encryption_token = "2";
remote_cfg1.host_name_or_ip = "3";
remote_cfg1.max_connections = 4U;
remote_cfg1.recv_timeout_ms = 5U;
remote_cfg1.send_timeout_ms = 6U;
remote::remote_config remote_cfg2{};
remote_cfg1.api_port = 6U;
remote_cfg1.encryption_token = "5";
remote_cfg1.host_name_or_ip = "4";
remote_cfg1.max_connections = 3U;
remote_cfg1.recv_timeout_ms = 2U;
remote_cfg1.send_timeout_ms = 1U;
ASSERT_NE(remote_cfg1, remote_cfg2);
test_getter_setter(cfg, &app_config::get_remote_config,
&app_config::set_remote_config, remote_cfg1,
remote_cfg2, "", "");
remote::remote_config remote_cfg3{};
remote_cfg1.api_port = 7U;
remote_cfg1.encryption_token = "8";
remote_cfg1.host_name_or_ip = "9";
remote_cfg1.max_connections = 10U;
remote_cfg1.recv_timeout_ms = 11U;
remote_cfg1.send_timeout_ms = 12U;
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_API_PORT),
std::to_string(remote_cfg3.api_port));
EXPECT_STREQ(std::to_string(remote_cfg3.api_port).c_str(),
value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_ENCRYPTION_TOKEN),
remote_cfg3.encryption_token);
EXPECT_STREQ(remote_cfg3.encryption_token.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_HOST_NAME_OR_IP),
remote_cfg3.host_name_or_ip);
EXPECT_STREQ(remote_cfg3.host_name_or_ip.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_MAX_CONNECTIONS),
std::to_string(remote_cfg3.max_connections));
EXPECT_STREQ(std::to_string(remote_cfg3.max_connections).c_str(),
value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_RECV_TIMEOUT_MS),
std::to_string(remote_cfg3.recv_timeout_ms));
EXPECT_STREQ(std::to_string(remote_cfg3.recv_timeout_ms).c_str(),
value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_CONFIG, JSON_SEND_TIMEOUT_MS),
std::to_string(remote_cfg3.send_timeout_ms));
EXPECT_STREQ(std::to_string(remote_cfg3.send_timeout_ms).c_str(),
value.c_str());
}},
{JSON_REMOTE_MOUNT,
[](app_config &cfg) {
remote::remote_mount mnt_cfg1{};
mnt_cfg1.api_port = 1U;
mnt_cfg1.client_pool_size = 2U;
mnt_cfg1.enable = false;
mnt_cfg1.encryption_token = "3";
remote::remote_mount mnt_cfg2{};
mnt_cfg2.api_port = 3U;
mnt_cfg2.client_pool_size = 4U;
mnt_cfg2.enable = true;
mnt_cfg2.encryption_token = "5";
ASSERT_NE(mnt_cfg1, mnt_cfg2);
test_getter_setter(cfg, &app_config::get_remote_mount,
&app_config::set_remote_mount, mnt_cfg1, mnt_cfg2,
"", "");
remote::remote_mount mnt_cfg3{};
mnt_cfg3.api_port = 9U;
mnt_cfg3.client_pool_size = 10U;
mnt_cfg3.enable = false;
mnt_cfg3.encryption_token = "11";
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_API_PORT),
std::to_string(mnt_cfg3.api_port));
EXPECT_STREQ(std::to_string(mnt_cfg3.api_port).c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_CLIENT_POOL_SIZE),
std::to_string(mnt_cfg3.client_pool_size));
EXPECT_STREQ(std::to_string(mnt_cfg3.client_pool_size).c_str(),
value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_REMOTE_MOUNT, JSON_ENABLE_REMOTE_MOUNT),
utils::string::from_bool(mnt_cfg3.enable));
EXPECT_STREQ(utils::string::from_bool(mnt_cfg3.enable).c_str(),
value.c_str());
}},
{JSON_RETRY_READ_COUNT,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_retry_read_count,
&app_config::set_retry_read_count,
std::uint16_t{min_retry_read_count + 1U},
std::uint16_t{min_retry_read_count + 2U},
JSON_RETRY_READ_COUNT,
std::to_string(min_retry_read_count + 3U));
cfg.set_retry_read_count(min_retry_read_count - 1U);
EXPECT_EQ(min_retry_read_count, cfg.get_retry_read_count());
}},
{JSON_RING_BUFFER_FILE_SIZE,
[](app_config &cfg) {
test_getter_setter(cfg, &app_config::get_ring_buffer_file_size,
&app_config::set_ring_buffer_file_size,
std::uint16_t{min_ring_buffer_file_size + 1U},
std::uint16_t{min_ring_buffer_file_size + 2U},
JSON_RING_BUFFER_FILE_SIZE,
std::to_string(min_ring_buffer_file_size + 3U));
cfg.set_ring_buffer_file_size(min_ring_buffer_file_size - 1U);
EXPECT_EQ(min_ring_buffer_file_size, cfg.get_ring_buffer_file_size());
cfg.set_ring_buffer_file_size(max_ring_buffer_file_size + 1U);
EXPECT_EQ(max_ring_buffer_file_size, cfg.get_ring_buffer_file_size());
}},
{JSON_S3_CONFIG,
[](auto &&cfg) {
s3_config cfg1{};
cfg1.access_key = "1";
cfg1.bucket = "2";
cfg1.encryption_token = "3";
cfg1.region = "4";
cfg1.secret_key = "5";
cfg1.timeout_ms = 6U;
cfg1.url = "7";
cfg1.use_path_style = false;
cfg1.use_region_in_url = false;
s3_config cfg2{};
cfg2.access_key = "8";
cfg2.bucket = "9";
cfg2.encryption_token = "10";
cfg2.region = "11";
cfg2.secret_key = "12";
cfg2.timeout_ms = 13U;
cfg2.url = "14";
cfg2.use_path_style = true;
cfg2.use_region_in_url = true;
ASSERT_NE(cfg1, cfg2);
test_getter_setter(cfg, &app_config::get_s3_config,
&app_config::set_s3_config, cfg1, cfg2, "", "");
s3_config cfg3{};
cfg3.access_key = "8";
cfg3.bucket = "9";
cfg3.encryption_token = "10";
cfg3.region = "11";
cfg3.secret_key = "12";
cfg3.timeout_ms = 13U;
cfg3.url = "14";
cfg3.use_path_style = true;
cfg3.use_region_in_url = true;
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_ACCESS_KEY),
cfg3.access_key);
EXPECT_STREQ(cfg3.access_key.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_BUCKET), cfg3.bucket);
EXPECT_STREQ(cfg3.bucket.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_ENCRYPTION_TOKEN),
cfg3.encryption_token);
EXPECT_STREQ(cfg3.encryption_token.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_REGION), cfg3.region);
EXPECT_STREQ(cfg3.region.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_SECRET_KEY),
cfg3.secret_key);
EXPECT_STREQ(cfg3.secret_key.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_TIMEOUT_MS),
std::to_string(cfg3.timeout_ms));
EXPECT_STREQ(std::to_string(cfg3.timeout_ms).c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_URL), cfg3.url);
EXPECT_STREQ(cfg3.url.c_str(), value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_USE_PATH_STYLE),
utils::string::from_bool(cfg3.use_path_style));
EXPECT_STREQ(utils::string::from_bool(cfg3.use_path_style).c_str(),
value.c_str());
value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_S3_CONFIG, JSON_USE_REGION_IN_URL),
utils::string::from_bool(cfg3.use_region_in_url));
EXPECT_STREQ(utils::string::from_bool(cfg3.use_region_in_url).c_str(),
value.c_str());
}},
{JSON_SIA_CONFIG,
[](app_config &cfg) {
sia_config cfg1{};
cfg1.bucket = "1";
sia_config cfg2{};
cfg2.bucket = "2";
ASSERT_NE(cfg1, cfg2);
test_getter_setter(cfg, &app_config::get_sia_config,
&app_config::set_sia_config, cfg1, cfg2, "", "");
sia_config cfg3{};
cfg3.bucket = "3";
auto value = cfg.set_value_by_name(
fmt::format("{}.{}", JSON_SIA_CONFIG, JSON_BUCKET), cfg3.bucket);
EXPECT_STREQ(cfg3.bucket.c_str(), value.c_str());
}},
{JSON_TASK_WAIT_MS,
[](app_config &cfg) {
test_getter_setter(
cfg, &app_config::get_task_wait_ms, &app_config::set_task_wait_ms,
std::uint16_t{min_task_wait_ms + 1U},
std::uint16_t{min_task_wait_ms + 2U}, JSON_TASK_WAIT_MS,
std::to_string(min_task_wait_ms + 3U));
cfg.set_task_wait_ms(min_task_wait_ms - 1U);
EXPECT_EQ(min_task_wait_ms, cfg.get_task_wait_ms());
}},
};
remove_unused_types(methods, prov);
for (const auto &[key, test_function] : methods) {
fmt::println("testing setting|{}-{}", app_config::get_provider_name(prov),
key);
test_function(config);
}
}
TEST_F(app_config_test, encrypt_config) {
app_config config(provider_type::encrypt, encrypt_directory);
defaults_tests(config.get_json(), provider_type::encrypt);
common_tests(config, provider_type::encrypt);
}
TEST_F(app_config_test, remote_config) {
app_config config(provider_type::remote, remote_directory);
defaults_tests(config.get_json(), provider_type::remote);
common_tests(config, provider_type::remote);
}
TEST_F(app_config_test, s3_config) {
app_config config(provider_type::s3, s3_directory);
defaults_tests(config.get_json(), provider_type::s3);
common_tests(config, provider_type::s3);
}
TEST_F(app_config_test, sia_config) {
app_config config(provider_type::sia, sia_directory);
defaults_tests(config.get_json(), provider_type::sia);
common_tests(config, provider_type::sia);
}
} // namespace repertory

8
repertory/repertory_test/src/atomic_test.cpp
View File

@@ -24,7 +24,7 @@
#include "types/repertory.hpp"
namespace repertory {
TEST(atomic, atomic_primitive) {
TEST(atomic_test, atomic_primitive) {
atomic<std::uint16_t> value;
value = 5U;
EXPECT_EQ(5U, static_cast<std::uint16_t>(value));
@@ -35,7 +35,7 @@ TEST(atomic, atomic_primitive) {
EXPECT_EQ(6U, value.load());
}
TEST(atomic, atomic_primitive_equality) {
TEST(atomic_test, atomic_primitive_equality) {
atomic<std::uint16_t> value1{5U};
atomic<std::uint16_t> value2{5U};
EXPECT_EQ(value1, value1);
@@ -45,7 +45,7 @@ TEST(atomic, atomic_primitive_equality) {
EXPECT_EQ(static_cast<std::uint16_t>(value2), 5U);
}
TEST(atomic, atomic_primitive_inequality) {
TEST(atomic_test, atomic_primitive_inequality) {
atomic<std::uint16_t> value1{5U};
atomic<std::uint16_t> value2{6U};
EXPECT_NE(value1, value2);
@@ -53,7 +53,7 @@ TEST(atomic, atomic_primitive_inequality) {
EXPECT_NE(static_cast<std::uint16_t>(value2), 5U);
}
TEST(atomic, atomic_struct) {
TEST(atomic_test, atomic_struct) {
atomic<encrypt_config> value{
encrypt_config{
.encryption_token = "token",

696
repertory/repertory_test/src/config_test.cpp
View File

@@ -1,696 +0,0 @@
/*
Copyright <2018-2025> <scott.e.graves@protonmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#include "test_common.hpp"
#include "app_config.hpp"
#include "events/event_system.hpp"
#include "utils/common.hpp"
#include "utils/file_utils.hpp"
#include "utils/path.hpp"
namespace repertory {
class config_test : public ::testing::Test {
public:
console_consumer cs;
static std::atomic<std::uint64_t> idx;
std::string s3_directory;
std::string sia_directory;
void SetUp() override {
s3_directory = utils::path::combine(test::get_test_output_dir(),
{
"config_test",
"s3",
std::to_string(++idx),
});
sia_directory = utils::path::combine(test::get_test_output_dir(),
{
"config_test",
"sia",
std::to_string(++idx),
});
event_system::instance().start();
}
void TearDown() override {
event_system::instance().stop();
}
};
std::atomic<std::uint64_t> config_test::idx{0U};
TEST_F(config_test, api_path) {
std::string original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_api_auth();
EXPECT_EQ(48U, original_value.size());
}
}
TEST_F(config_test, api_auth) {
std::string original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_api_auth();
config.set_api_auth(original_value.substr(0, 20));
EXPECT_EQ(original_value.substr(0, 20), config.get_api_auth());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value.substr(0, 20), config.get_api_auth());
}
}
TEST_F(config_test, api_port) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_api_port();
config.set_api_port(original_value + 5);
EXPECT_EQ(original_value + 5, config.get_api_port());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5, config.get_api_port());
}
}
TEST_F(config_test, api_user) {
std::string original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_api_user();
config.set_api_user(original_value.substr(0, 2));
EXPECT_EQ(original_value.substr(0, 2), config.get_api_user());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value.substr(0, 2), config.get_api_user());
}
}
TEST_F(config_test, download_timeout_secs) {
std::uint8_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_download_timeout_secs();
config.set_download_timeout_secs(original_value + 5);
EXPECT_EQ(original_value + 5, config.get_download_timeout_secs());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5, config.get_download_timeout_secs());
}
}
TEST_F(config_test, enable_download_timeout) {
bool original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_enable_download_timeout();
config.set_enable_download_timeout(not original_value);
EXPECT_EQ(not original_value, config.get_enable_download_timeout());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(not original_value, config.get_enable_download_timeout());
}
}
TEST_F(config_test, enable_drive_events) {
bool original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_enable_drive_events();
config.set_enable_drive_events(not original_value);
EXPECT_EQ(not original_value, config.get_enable_drive_events());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(not original_value, config.get_enable_drive_events());
}
}
#if defined(_WIN32)
TEST_F(config_test, enable_mount_manager) {
bool original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_enable_mount_manager();
config.set_enable_mount_manager(not original_value);
EXPECT_EQ(not original_value, config.get_enable_mount_manager());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(not original_value, config.get_enable_mount_manager());
}
}
#endif
TEST_F(config_test, event_level) {
{
app_config config(provider_type::sia, sia_directory);
config.set_event_level(event_level::debug);
EXPECT_EQ(event_level::debug, config.get_event_level());
config.set_event_level(event_level::warn);
EXPECT_EQ(event_level::warn, config.get_event_level());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(event_level::warn, config.get_event_level());
}
}
TEST_F(config_test, eviction_delay_mins) {
std::uint32_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_eviction_delay_mins();
config.set_eviction_delay_mins(original_value + 5);
EXPECT_EQ(original_value + 5, config.get_eviction_delay_mins());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5, config.get_eviction_delay_mins());
}
}
TEST_F(config_test, eviction_uses_accessed_time) {
bool original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_eviction_uses_accessed_time();
config.set_eviction_uses_accessed_time(not original_value);
EXPECT_EQ(not original_value, config.get_eviction_uses_accessed_time());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(not original_value, config.get_eviction_uses_accessed_time());
}
}
TEST_F(config_test, high_frequency_interval_secs) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_high_frequency_interval_secs();
config.set_high_frequency_interval_secs(original_value + 5U);
EXPECT_EQ(original_value + 5U, config.get_high_frequency_interval_secs());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5U, config.get_high_frequency_interval_secs());
}
}
TEST_F(config_test, low_frequency_interval_secs) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_low_frequency_interval_secs();
config.set_low_frequency_interval_secs(original_value + 5U);
EXPECT_EQ(original_value + 5U, config.get_low_frequency_interval_secs());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5U, config.get_low_frequency_interval_secs());
}
}
TEST_F(config_test, med_frequency_interval_secs) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_med_frequency_interval_secs();
config.set_med_frequency_interval_secs(original_value + 5U);
EXPECT_EQ(original_value + 5U, config.get_med_frequency_interval_secs());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5U, config.get_med_frequency_interval_secs());
}
}
TEST_F(config_test, max_cache_size_bytes) {
{
app_config config(provider_type::sia, sia_directory);
config.set_max_cache_size_bytes(100 * 1024 * 1024);
EXPECT_EQ(100U * 1024 * 1024, config.get_max_cache_size_bytes());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(100U * 1024 * 1024, config.get_max_cache_size_bytes());
}
}
TEST_F(config_test, max_upload_count) {
{
app_config config(provider_type::sia, sia_directory);
config.set_max_upload_count(8U);
EXPECT_EQ(std::uint8_t(8U), config.get_max_upload_count());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(std::uint8_t(8U), config.get_max_upload_count());
}
{
app_config config(provider_type::sia, sia_directory);
config.set_max_upload_count(0U);
EXPECT_EQ(std::uint8_t(1U), config.get_max_upload_count());
}
}
TEST_F(config_test, online_check_retry_secs) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_online_check_retry_secs();
config.set_online_check_retry_secs(original_value + 1);
EXPECT_EQ(original_value + 1, config.get_online_check_retry_secs());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 1, config.get_online_check_retry_secs());
}
}
TEST_F(config_test, online_check_retry_secs_minimum_value) {
{
app_config config(provider_type::sia, sia_directory);
config.set_online_check_retry_secs(14);
EXPECT_EQ(15, config.get_online_check_retry_secs());
}
}
TEST_F(config_test, orphaned_file_retention_days) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_orphaned_file_retention_days();
config.set_orphaned_file_retention_days(original_value + 1);
EXPECT_EQ(original_value + 1, config.get_orphaned_file_retention_days());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 1, config.get_orphaned_file_retention_days());
}
}
TEST_F(config_test, orphaned_file_retention_days_minimum_value) {
{
app_config config(provider_type::sia, sia_directory);
config.set_orphaned_file_retention_days(0);
EXPECT_EQ(1, config.get_orphaned_file_retention_days());
}
}
TEST_F(config_test, orphaned_file_retention_days_maximum_value) {
{
app_config config(provider_type::sia, sia_directory);
config.set_orphaned_file_retention_days(32);
EXPECT_EQ(31, config.get_orphaned_file_retention_days());
}
}
TEST_F(config_test, get_cache_directory) {
{
app_config config(provider_type::sia, sia_directory);
EXPECT_STREQ(utils::path::combine(sia_directory, {"cache"}).c_str(),
config.get_cache_directory().c_str());
}
}
TEST_F(config_test, get_config_file_path) {
{
const auto config_file = utils::path::absolute(
utils::path::combine(sia_directory, {"config.json"}));
app_config config(provider_type::sia, sia_directory);
EXPECT_STREQ(config_file.c_str(), config.get_config_file_path().c_str());
}
}
TEST_F(config_test, get_data_directory) {
{
app_config config(provider_type::sia, sia_directory);
EXPECT_STREQ(sia_directory.c_str(), config.get_data_directory().c_str());
}
}
TEST_F(config_test, get_log_directory) {
{
app_config config(provider_type::sia, sia_directory);
EXPECT_STREQ(utils::path::combine(sia_directory, {"logs"}).c_str(),
config.get_log_directory().c_str());
}
}
TEST_F(config_test, ring_buffer_file_size) {
std::uint16_t original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_ring_buffer_file_size();
config.set_ring_buffer_file_size(original_value + 5u);
EXPECT_EQ(original_value + 5u, config.get_ring_buffer_file_size());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 5u, config.get_ring_buffer_file_size());
}
}
TEST_F(config_test, ring_buffer_file_size_minimum_size) {
{
app_config config(provider_type::sia, sia_directory);
config.set_ring_buffer_file_size(63u);
EXPECT_EQ(64u, config.get_ring_buffer_file_size());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(64u, config.get_ring_buffer_file_size());
}
}
TEST_F(config_test, ring_buffer_file_size_maximum_size) {
{
app_config config(provider_type::sia, sia_directory);
config.set_ring_buffer_file_size(1025u);
EXPECT_EQ(1024u, config.get_ring_buffer_file_size());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(1024u, config.get_ring_buffer_file_size());
}
}
TEST_F(config_test, preferred_download_type) {
download_type original_value;
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_preferred_download_type();
config.set_preferred_download_type(download_type::ring_buffer);
EXPECT_NE(original_value, config.get_preferred_download_type());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_NE(original_value, config.get_preferred_download_type());
}
}
TEST_F(config_test, default_agent_name) {
EXPECT_STREQ("Sia-Agent",
app_config::default_agent_name(provider_type::sia).c_str());
}
TEST_F(config_test, default_api_port) {
EXPECT_EQ(9980U, app_config::default_api_port(provider_type::sia));
}
TEST_F(config_test, default_data_directory) {
const std::array<std::string, 1U> data_directory = {
app_config::default_data_directory(provider_type::sia),
};
#if defined(_WIN32)
const auto local_app_data = utils::get_environment_variable("localappdata");
#endif
#if defined(__linux__)
const auto local_app_data =
utils::path::combine(utils::get_environment_variable("HOME"), {".local"});
#endif
#if defined(__APPLE__)
const auto local_app_data = utils::path::combine(
utils::get_environment_variable("HOME"), {"Library/Application Support"});
#endif
auto expected_directory =
utils::path::combine(local_app_data, {"/repertory2/sia"});
EXPECT_STREQ(expected_directory.c_str(), data_directory[0].c_str());
}
TEST_F(config_test, default_rpc_port) {
EXPECT_EQ(10000U, app_config::default_rpc_port(provider_type::sia));
}
TEST_F(config_test, get_provider_display_name) {
EXPECT_STREQ(
"Sia", app_config::get_provider_display_name(provider_type::sia).c_str());
}
TEST_F(config_test, get_provider_name) {
EXPECT_STREQ("sia",
app_config::get_provider_name(provider_type::sia).c_str());
}
TEST_F(config_test, get_version) {
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(REPERTORY_CONFIG_VERSION, config.get_version());
}
}
// TEST_F(config_test, enable_remote_mount) {
// bool original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_enable_remote_mount();
// config.set_enable_remote_mount(not original_value);
// EXPECT_EQ(not original_value, config.get_enable_remote_mount());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(not original_value, config.get_enable_remote_mount());
// }
// }
// TEST_F(config_test, is_remote_mount) {
// bool original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_is_remote_mount();
// config.set_is_remote_mount(not original_value);
// EXPECT_EQ(not original_value, config.get_is_remote_mount());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(not original_value, config.get_is_remote_mount());
// }
// }
// TEST_F(config_test, enable_remote_mount_fails_if_remote_mount_is_true) {
// app_config config(provider_type::sia, sia_directory);
// config.set_is_remote_mount(true);
// config.set_enable_remote_mount(true);
// EXPECT_FALSE(config.get_enable_remote_mount());
// EXPECT_TRUE(config.get_is_remote_mount());
// }
// TEST_F(config_test, set_is_remote_mount_fails_if_enable_remote_mount_is_true)
// {
// app_config config(provider_type::sia, sia_directory);
// config.set_enable_remote_mount(true);
// config.set_is_remote_mount(true);
// EXPECT_FALSE(config.get_is_remote_mount());
// EXPECT_TRUE(config.get_enable_remote_mount());
// }
// TEST_F(config_test, remote_host_name_or_ip) {
// {
// app_config config(provider_type::sia, sia_directory);
// config.set_remote_host_name_or_ip("my.host.name");
// EXPECT_STREQ("my.host.name",
// config.get_remote_host_name_or_ip().c_str());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_STREQ("my.host.name",
// config.get_remote_host_name_or_ip().c_str());
// }
// }
// TEST_F(config_test, remote_api_port) {
// std::uint16_t original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_remote_api_port();
// config.set_remote_api_port(original_value + 5);
// EXPECT_EQ(original_value + 5, config.get_remote_api_port());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(original_value + 5, config.get_remote_api_port());
// }
// }
// TEST_F(config_test, remote_receive_timeout_secs) {
// std::uint16_t original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_remote_receive_timeout_secs();
// config.set_remote_receive_timeout_secs(original_value + 5);
// EXPECT_EQ(original_value + 5, config.get_remote_receive_timeout_secs());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(original_value + 5, config.get_remote_receive_timeout_secs());
// }
// }
// TEST_F(config_test, remote_send_timeout_secs) {
// std::uint16_t original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_remote_send_timeout_secs();
// config.set_remote_send_timeout_secs(original_value + 5);
// EXPECT_EQ(original_value + 5, config.get_remote_send_timeout_secs());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(original_value + 5, config.get_remote_send_timeout_secs());
// }
// }
// TEST_F(config_test, remote_encryption_token) {
// {
// app_config config(provider_type::sia, sia_directory);
// config.set_remote_encryption_token("myToken");
// EXPECT_STREQ("myToken", config.get_remote_encryption_token().c_str());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_STREQ("myToken", config.get_remote_encryption_token().c_str());
// }
// }
//
// TEST_F(config_test, remote_client_pool_size) {
// std::uint8_t original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_remote_client_pool_size();
// config.set_remote_client_pool_size(original_value + 5);
// EXPECT_EQ(original_value + 5, config.get_remote_client_pool_size());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(original_value + 5, config.get_remote_client_pool_size());
// }
// }
//
// TEST_F(config_test, remote_client_pool_size_minimum_value) {
// {
// app_config config(provider_type::sia, sia_directory);
// config.set_remote_client_pool_size(0);
// EXPECT_EQ(5, config.get_remote_client_pool_size());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(5, config.get_remote_client_pool_size());
// }
// }
// TEST_F(config_test, remote_max_connections) {
// std::uint8_t original_value{};
// {
// app_config config(provider_type::sia, sia_directory);
// original_value = config.get_remote_max_connections();
// config.set_remote_max_connections(original_value + 5);
// EXPECT_EQ(original_value + 5, config.get_remote_max_connections());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(original_value + 5, config.get_remote_max_connections());
// }
// }
// TEST_F(config_test, remote_max_connections_minimum_value) {
// {
// app_config config(provider_type::sia, sia_directory);
// config.set_remote_max_connections(0);
// EXPECT_EQ(1, config.get_remote_max_connections());
// }
// {
// app_config config(provider_type::sia, sia_directory);
// EXPECT_EQ(1, config.get_remote_max_connections());
// }
// }
TEST_F(config_test, retry_read_count) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_retry_read_count();
config.set_retry_read_count(original_value + 1);
EXPECT_EQ(original_value + 1, config.get_retry_read_count());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 1, config.get_retry_read_count());
}
}
TEST_F(config_test, retry_read_count_minimum_value) {
{
app_config config(provider_type::sia, sia_directory);
config.set_retry_read_count(1);
EXPECT_EQ(2, config.get_retry_read_count());
}
}
TEST_F(config_test, task_wait_ms) {
std::uint16_t original_value{};
{
app_config config(provider_type::sia, sia_directory);
original_value = config.get_task_wait_ms();
config.set_task_wait_ms(original_value + 1U);
EXPECT_EQ(original_value + 1U, config.get_task_wait_ms());
}
{
app_config config(provider_type::sia, sia_directory);
EXPECT_EQ(original_value + 1U, config.get_task_wait_ms());
}
}
TEST_F(config_test, task_wait_ms_minimum_value) {
{
app_config config(provider_type::sia, sia_directory);
config.set_task_wait_ms(1U);
EXPECT_EQ(50U, config.get_task_wait_ms());
}
}
TEST_F(config_test, can_set_database_type) {
{
app_config config(provider_type::sia, sia_directory);
config.set_database_type(database_type::rocksdb);
EXPECT_EQ(database_type::rocksdb, config.get_database_type());
config.set_database_type(database_type::sqlite);
EXPECT_EQ(database_type::sqlite, config.get_database_type());
config.set_database_type(database_type::rocksdb);
EXPECT_EQ(database_type::rocksdb, config.get_database_type());
}
}
} // namespace repertory

8
repertory/repertory_test/src/curl_comm_test.cpp
View File

@@ -25,7 +25,7 @@
#include "types/repertory.hpp"
namespace repertory {
TEST(curl_comm, can_create_s3_host_config) {
TEST(curl_comm_test, can_create_s3_host_config) {
s3_config config{};
config.bucket = "repertory";
config.url = "https://s3.test.com";
@@ -37,7 +37,7 @@ TEST(curl_comm, can_create_s3_host_config) {
EXPECT_TRUE(hc.path.empty());
}
TEST(curl_comm, can_create_s3_host_config_with_path_style) {
TEST(curl_comm_test, can_create_s3_host_config_with_path_style) {
s3_config config{};
config.bucket = "repertory";
config.url = "https://s3.test.com";
@@ -49,7 +49,7 @@ TEST(curl_comm, can_create_s3_host_config_with_path_style) {
EXPECT_STREQ("/repertory", hc.path.c_str());
}
TEST(curl_comm, can_create_s3_host_config_with_region) {
TEST(curl_comm_test, can_create_s3_host_config_with_region) {
s3_config config{};
config.bucket = "repertory";
config.url = "https://s3.test.com";
@@ -62,7 +62,7 @@ TEST(curl_comm, can_create_s3_host_config_with_region) {
EXPECT_TRUE(hc.path.empty());
}
TEST(curl_comm, can_create_s3_host_config_with_region_and_path_style) {
TEST(curl_comm_test, can_create_s3_host_config_with_region_and_path_style) {
s3_config config{};
config.bucket = "repertory";
config.url = "https://s3.test.com";

76
repertory/repertory_test/src/json_serialize_test.cpp
View File

@@ -25,7 +25,7 @@
#include "types/repertory.hpp"
namespace repertory {
TEST(json_serialize, can_handle_directory_item) {
TEST(json_serialize_test, can_handle_directory_item) {
directory_item cfg{
"api", "parent", true, 2U, {{META_DIRECTORY, "true"}},
};
@@ -47,7 +47,7 @@ TEST(json_serialize, can_handle_directory_item) {
}
}
TEST(json_serialize, can_handle_encrypt_config) {
TEST(json_serialize_test, can_handle_encrypt_config) {
encrypt_config cfg{
"token",
"path",
@@ -65,7 +65,7 @@ TEST(json_serialize, can_handle_encrypt_config) {
}
}
TEST(json_serialize, can_handle_host_config) {
TEST(json_serialize_test, can_handle_host_config) {
host_config cfg{
"agent", "pwd", "user", 1024U, "host", "path", "http", 11U,
};
@@ -94,7 +94,7 @@ TEST(json_serialize, can_handle_host_config) {
}
}
TEST(json_serialize, can_handle_remote_config) {
TEST(json_serialize_test, can_handle_remote_config) {
remote::remote_config cfg{
1024U, "token", "host", 11U, 20U, 21U,
};
@@ -120,7 +120,7 @@ TEST(json_serialize, can_handle_remote_config) {
}
}
TEST(json_serialize, can_handle_remote_mount) {
TEST(json_serialize_test, can_handle_remote_mount) {
remote::remote_mount cfg{1024U, 21U, true, "token"};
json data(cfg);
@@ -139,7 +139,7 @@ TEST(json_serialize, can_handle_remote_mount) {
}
}
TEST(json_serialize, can_handle_s3_config) {
TEST(json_serialize_test, can_handle_s3_config) {
s3_config cfg{
"access", "bucket", "token", "region", "secret", 31U, "url", true, false,
};
@@ -170,7 +170,7 @@ TEST(json_serialize, can_handle_s3_config) {
}
}
TEST(json_serialize, can_handle_sia_config) {
TEST(json_serialize_test, can_handle_sia_config) {
sia_config cfg{
"bucket",
};
@@ -184,7 +184,7 @@ TEST(json_serialize, can_handle_sia_config) {
}
}
TEST(json_serialize, can_handle_atomic) {
TEST(json_serialize_test, can_handle_atomic) {
atomic<sia_config> cfg({
"bucket",
});
@@ -198,7 +198,7 @@ TEST(json_serialize, can_handle_atomic) {
}
}
TEST(json_serialize, can_handle_database_type) {
TEST(json_serialize_test, can_handle_database_type) {
json data(database_type::rocksdb);
EXPECT_EQ(database_type::rocksdb, data.get<database_type>());
EXPECT_STREQ("rocksdb", data.get<std::string>().c_str());
@@ -208,7 +208,7 @@ TEST(json_serialize, can_handle_database_type) {
EXPECT_STREQ("sqlite", data.get<std::string>().c_str());
}
TEST(json_serialize, can_handle_download_type) {
TEST(json_serialize_test, can_handle_download_type) {
json data(download_type::direct);
EXPECT_EQ(download_type::direct, data.get<download_type>());
EXPECT_STREQ("direct", data.get<std::string>().c_str());
@@ -222,7 +222,33 @@ TEST(json_serialize, can_handle_download_type) {
EXPECT_STREQ("ring_buffer", data.get<std::string>().c_str());
}
TEST(json_serialize, can_handle_atomic_database_type) {
TEST(json_serialize_test, can_handle_event_level) {
json data(event_level{event_level::critical});
EXPECT_EQ(event_level::critical, data.get<event_level>());
EXPECT_STREQ("critical", data.get<std::string>().c_str());
data = event_level(event_level::error);
EXPECT_EQ(event_level::error, data.get<event_level>());
EXPECT_STREQ("error", data.get<std::string>().c_str());
data = event_level(event_level::warn);
EXPECT_EQ(event_level::warn, data.get<event_level>());
EXPECT_STREQ("warn", data.get<std::string>().c_str());
data = event_level(event_level::info);
EXPECT_EQ(event_level::info, data.get<event_level>());
EXPECT_STREQ("info", data.get<std::string>().c_str());
data = event_level(event_level::debug);
EXPECT_EQ(event_level::debug, data.get<event_level>());
EXPECT_STREQ("debug", data.get<std::string>().c_str());
data = event_level(event_level::trace);
EXPECT_EQ(event_level::trace, data.get<event_level>());
EXPECT_STREQ("trace", data.get<std::string>().c_str());
}
TEST(json_serialize_test, can_handle_atomic_database_type) {
json data(atomic<database_type>{database_type::rocksdb});
EXPECT_EQ(database_type::rocksdb, data.get<atomic<database_type>>());
EXPECT_STREQ("rocksdb", data.get<std::string>().c_str());
@@ -232,7 +258,7 @@ TEST(json_serialize, can_handle_atomic_database_type) {
EXPECT_STREQ("sqlite", data.get<std::string>().c_str());
}
TEST(json_serialize, can_handle_atomic_download_type) {
TEST(json_serialize_test, can_handle_atomic_download_type) {
json data(atomic<download_type>{download_type::direct});
EXPECT_EQ(download_type::direct, data.get<atomic<download_type>>());
EXPECT_STREQ("direct", data.get<std::string>().c_str());
@@ -245,4 +271,30 @@ TEST(json_serialize, can_handle_atomic_download_type) {
EXPECT_EQ(download_type::ring_buffer, data.get<atomic<download_type>>());
EXPECT_STREQ("ring_buffer", data.get<std::string>().c_str());
}
TEST(json_serialize_test, can_handle_atomic_event_level) {
json data(atomic<event_level>{event_level::critical});
EXPECT_EQ(event_level::critical, data.get<atomic<event_level>>());
EXPECT_STREQ("critical", data.get<std::string>().c_str());
data = atomic<event_level>(event_level::error);
EXPECT_EQ(event_level::error, data.get<atomic<event_level>>());
EXPECT_STREQ("error", data.get<std::string>().c_str());
data = atomic<event_level>(event_level::warn);
EXPECT_EQ(event_level::warn, data.get<atomic<event_level>>());
EXPECT_STREQ("warn", data.get<std::string>().c_str());
data = atomic<event_level>(event_level::info);
EXPECT_EQ(event_level::info, data.get<atomic<event_level>>());
EXPECT_STREQ("info", data.get<std::string>().c_str());
data = atomic<event_level>(event_level::debug);
EXPECT_EQ(event_level::debug, data.get<atomic<event_level>>());
EXPECT_STREQ("debug", data.get<std::string>().c_str());
data = atomic<event_level>(event_level::trace);
EXPECT_EQ(event_level::trace, data.get<atomic<event_level>>());
EXPECT_STREQ("trace", data.get<std::string>().c_str());
}
} // namespace repertory

6
repertory/repertory_test/src/lock_data_test.cpp
View File

@@ -24,7 +24,7 @@
#include "platform/platform.hpp"
namespace repertory {
TEST(lock_data, lock_and_unlock) {
TEST(lock_data_test, lock_and_unlock) {
{
lock_data l(provider_type::sia, "1");
EXPECT_EQ(lock_result::success, l.grab_lock());
@@ -50,7 +50,7 @@ TEST(lock_data, lock_and_unlock) {
}
#if defined(_WIN32)
TEST(lock_data, set_and_unset_mount_state) {
TEST(lock_data_test, set_and_unset_mount_state) {
lock_data l(provider_type::sia, "1");
EXPECT_TRUE(l.set_mount_state(true, "C:", 99));
@@ -83,7 +83,7 @@ TEST(lock_data, set_and_unset_mount_state) {
mount_state["Remote2"].dump().c_str());
}
#else
TEST(lock_data, set_and_unset_mount_state) {
TEST(lock_data_test, set_and_unset_mount_state) {
lock_data l(provider_type::sia, "1");
EXPECT_TRUE(l.set_mount_state(true, "/mnt/1", 99));

2
repertory/repertory_test/src/packet_test.cpp
View File

@@ -24,7 +24,7 @@
#include "comm/packet/packet.hpp"
namespace repertory {
TEST(packet, encrypt_and_decrypt) {
TEST(packet_test, encrypt_and_decrypt) {
packet test_packet;
test_packet.encode("test");
test_packet.encrypt("moose");

203
repertory/repertory_test/src/providers_test.cpp
View File

@@ -19,8 +19,6 @@
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#if 0
#include "test_common.hpp"
#include "comm/curl/curl_comm.hpp"
@@ -99,8 +97,6 @@ const auto create_directory = [](repertory::i_provider &provider,
repertory::utils::string::to_bool(meta2[repertory::META_PINNED]));
EXPECT_EQ(std::uint64_t(0U),
repertory::utils::string::to_uint64(meta2[repertory::META_SIZE]));
EXPECT_STREQ((api_path + "_src").c_str(),
meta2[repertory::META_SOURCE].c_str());
EXPECT_EQ(getuid(), static_cast<uid_t>(repertory::utils::string::to_uint32(
meta2[repertory::META_UID])));
EXPECT_EQ(date + 4U, repertory::utils::string::to_uint64(
@@ -178,6 +174,9 @@ const auto decrypt_parts = [](const repertory::app_config &cfg,
namespace repertory {
static void can_create_and_remove_directory(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
api_meta_map meta{};
EXPECT_EQ(api_error::not_implemented,
@@ -196,6 +195,9 @@ static void can_create_and_remove_directory(i_provider &provider) {
}
static void create_directory_fails_if_already_exists(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -210,6 +212,9 @@ static void create_directory_fails_if_already_exists(i_provider &provider) {
static void
create_directory_fails_if_file_already_exists(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -223,6 +228,9 @@ create_directory_fails_if_file_already_exists(i_provider &provider) {
}
static void create_directory_clone_source_meta(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
EXPECT_EQ(api_error::not_implemented,
provider.create_directory_clone_source_meta("/moose", "/moose"));
@@ -257,6 +265,9 @@ static void create_directory_clone_source_meta(i_provider &provider) {
static void create_directory_clone_source_meta_fails_if_already_exists(
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -272,6 +283,9 @@ static void create_directory_clone_source_meta_fails_if_already_exists(
static void create_directory_clone_source_meta_fails_if_directory_not_found(
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -282,6 +296,9 @@ static void create_directory_clone_source_meta_fails_if_directory_not_found(
static void create_directory_clone_source_meta_fails_if_file_already_exists(
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -297,6 +314,9 @@ static void create_directory_clone_source_meta_fails_if_file_already_exists(
}
static void can_create_and_remove_file(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
api_meta_map meta{};
EXPECT_EQ(api_error::not_implemented,
@@ -317,6 +337,9 @@ static void can_create_and_remove_file(i_provider &provider) {
}
static void create_file_fails_if_already_exists(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -331,6 +354,9 @@ static void create_file_fails_if_already_exists(i_provider &provider) {
static void
create_file_fails_if_directory_already_exists(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.is_read_only()) {
return;
}
@@ -345,9 +371,12 @@ create_file_fails_if_directory_already_exists(i_provider &provider) {
static void get_api_path_from_source(const app_config &cfg,
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
const auto source_path =
utils::path::combine("./test_date/encrypt", {"test.txt"});
auto source_path =
utils::path::combine("./test_input/encrypt", {"test.txt"});
std::string api_path{};
EXPECT_EQ(api_error::success,
@@ -376,6 +405,9 @@ static void get_api_path_from_source(const app_config &cfg,
static void
get_api_path_from_source_fails_if_file_not_found(const app_config &cfg,
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
std::string source_path{};
if (provider.get_provider_type() == provider_type::encrypt) {
source_path = utils::path::combine(cfg.get_encrypt_config().path,
@@ -391,28 +423,50 @@ get_api_path_from_source_fails_if_file_not_found(const app_config &cfg,
EXPECT_TRUE(api_path.empty());
}
static void get_directory_item_count(const app_config &cfg,
static void get_directory_item_count(const app_config & /* cfg */,
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
EXPECT_EQ(std::size_t(2U), provider.get_directory_item_count("/"));
EXPECT_EQ(std::size_t(0U), provider.get_directory_item_count("/not_found"));
const auto source_path =
auto source_path =
utils::path::combine(test::get_test_input_dir(), {"encrypt", "sub10"});
std::string api_path{};
EXPECT_EQ(api_error::success,
provider.get_api_path_from_source(source_path, api_path));
EXPECT_EQ(std::size_t(1U), provider.get_directory_item_count(api_path));
return;
}
}
static void get_directory_items(const app_config &cfg, i_provider &provider) {
create_file(provider, "/pt01.txt");
create_file(provider, "/pt02.txt");
create_directory(provider, "/dir01");
create_directory(provider, "/dir02");
directory_item_list list{};
EXPECT_EQ(api_error::success, provider.get_directory_items("/", list));
check_forced_dirs(list);
EXPECT_GE(list.size(), std::size_t(6U));
EXPECT_EQ(api_error::success, provider.remove_file("/pt01.txt"));
EXPECT_EQ(api_error::success, provider.remove_file("/pt02.txt"));
EXPECT_EQ(api_error::success, provider.remove_directory("/dir01"));
EXPECT_EQ(api_error::success, provider.remove_directory("/dir02"));
}
static void get_directory_items(const app_config &cfg, i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
directory_item_list list{};
EXPECT_EQ(api_error::success, provider.get_directory_items("/", list));
check_forced_dirs(list);
EXPECT_EQ(std::size_t(4U), list.size());
directory_item_list list_decrypted{list.begin() + 2U, list.end()};
@@ -443,7 +497,7 @@ static void get_directory_items(const app_config &cfg, i_provider &provider) {
EXPECT_EQ(std::size_t(46U), file->size);
#endif
const auto source_path =
auto source_path =
utils::path::combine(cfg.get_encrypt_config().path, {"sub10"});
std::string api_path{};
EXPECT_EQ(api_error::success,
@@ -472,11 +526,58 @@ static void get_directory_items(const app_config &cfg, i_provider &provider) {
#else
EXPECT_EQ(std::size_t(45U), file2->size);
#endif
return;
}
create_file(provider, "/pt01.txt");
create_file(provider, "/pt02.txt");
create_directory(provider, "/dir01");
create_directory(provider, "/dir02");
directory_item_list list{};
EXPECT_EQ(api_error::success, provider.get_directory_items("/", list));
check_forced_dirs(list);
EXPECT_GE(list.size(), std::size_t(6U));
auto iter = std::ranges::find_if(
list, [](auto &&item) -> bool { return item.api_path == "/pt01.txt"; });
EXPECT_NE(iter, list.end());
EXPECT_STREQ("/", (*iter).api_parent.c_str());
EXPECT_FALSE((*iter).directory);
EXPECT_EQ(std::uint64_t{0U}, (*iter).size);
iter = std::ranges::find_if(
list, [](auto &&item) -> bool { return item.api_path == "/pt02.txt"; });
EXPECT_NE(iter, list.end());
EXPECT_STREQ("/", (*iter).api_parent.c_str());
EXPECT_FALSE((*iter).directory);
EXPECT_EQ(std::uint64_t{0U}, (*iter).size);
iter = std::ranges::find_if(
list, [](auto &&item) -> bool { return item.api_path == "/dir01"; });
EXPECT_NE(iter, list.end());
EXPECT_STREQ("/", (*iter).api_parent.c_str());
EXPECT_TRUE((*iter).directory);
EXPECT_EQ(std::uint64_t{0U}, (*iter).size);
iter = std::ranges::find_if(
list, [](auto &&item) -> bool { return item.api_path == "/dir02"; });
EXPECT_NE(iter, list.end());
EXPECT_STREQ("/", (*iter).api_parent.c_str());
EXPECT_TRUE((*iter).directory);
EXPECT_EQ(std::uint64_t{0U}, (*iter).size);
EXPECT_EQ(api_error::success, provider.remove_file("/pt01.txt"));
EXPECT_EQ(api_error::success, provider.remove_file("/pt02.txt"));
EXPECT_EQ(api_error::success, provider.remove_directory("/dir01"));
EXPECT_EQ(api_error::success, provider.remove_directory("/dir02"));
}
static void
get_directory_items_fails_if_directory_not_found(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
directory_item_list list{};
EXPECT_EQ(api_error::directory_not_found,
provider.get_directory_items("/not_found", list));
@@ -485,8 +586,11 @@ get_directory_items_fails_if_directory_not_found(i_provider &provider) {
static void get_directory_items_fails_if_item_is_file(const app_config &cfg,
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
const auto source_path =
auto source_path =
utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"});
std::string api_path{};
@@ -497,12 +601,24 @@ static void get_directory_items_fails_if_item_is_file(const app_config &cfg,
EXPECT_EQ(api_error::item_exists,
provider.get_directory_items(api_path, list));
EXPECT_TRUE(list.empty());
return;
}
create_file(provider, "/pt01.txt");
directory_item_list list{};
EXPECT_EQ(api_error::item_exists,
provider.get_directory_items("/pt01.txt", list));
EXPECT_EQ(api_error::success, provider.remove_file("/pt01.txt"));
}
static void get_file(const app_config &cfg, i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
const auto source_path =
auto source_path =
utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"});
std::string api_path{};
@@ -522,18 +638,43 @@ static void get_file(const app_config &cfg, i_provider &provider) {
EXPECT_EQ(std::size_t(46U), file.file_size);
#endif
EXPECT_STREQ(source_path.c_str(), file.source_path.c_str());
return;
}
create_file(provider, "/pt01.txt");
api_file file{};
EXPECT_EQ(api_error::success, provider.get_file("/pt01.txt", file));
EXPECT_STREQ("/pt01.txt", file.api_path.c_str());
EXPECT_STREQ("/", file.api_parent.c_str());
EXPECT_LT(utils::time::get_time_now() - (utils::time::NANOS_PER_SECOND * 5U),
file.accessed_date);
EXPECT_LT(utils::time::get_time_now() - (utils::time::NANOS_PER_SECOND * 5U),
file.changed_date);
EXPECT_LT(utils::time::get_time_now() - (utils::time::NANOS_PER_SECOND * 5U),
file.creation_date);
EXPECT_LT(utils::time::get_time_now() - (utils::time::NANOS_PER_SECOND * 5U),
file.modified_date);
EXPECT_EQ(api_error::success, provider.remove_file("/pt01.txt"));
}
static void get_file_fails_if_file_not_found(i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
api_file file{};
EXPECT_EQ(api_error::item_not_found, provider.get_file("/not_found", file));
}
static void get_file_fails_if_item_is_directory(const app_config &cfg,
i_provider &provider) {
fmt::println("testing|{}|{}",
app_config::get_provider_name(provider.get_provider_type()),
__FUNCTION__);
if (provider.get_provider_type() == provider_type::encrypt) {
const auto source_path =
auto source_path =
utils::path::combine(cfg.get_encrypt_config().path, {"sub10"});
std::string api_path{};
@@ -542,7 +683,15 @@ static void get_file_fails_if_item_is_directory(const app_config &cfg,
api_file file{};
EXPECT_EQ(api_error::directory_exists, provider.get_file(api_path, file));
return;
}
create_directory(provider, "/dir01");
api_file file{};
EXPECT_EQ(api_error::directory_exists, provider.get_file("/dir01", file));
EXPECT_EQ(api_error::success, provider.remove_directory("/dir01"));
}
static void get_file_list(const app_config &cfg, i_provider &provider) {
@@ -593,7 +742,6 @@ static void run_tests(const app_config &cfg, i_provider &provider) {
get_api_path_from_source(cfg, provider);
get_api_path_from_source_fails_if_file_not_found(cfg, provider);
// TODO: continue here
get_directory_items(cfg, provider);
get_directory_items_fails_if_directory_not_found(provider);
get_directory_items_fails_if_item_is_file(cfg, provider);
@@ -629,17 +777,16 @@ static void run_tests(const app_config &cfg, i_provider &provider) {
upload_file(provider); */
}
TEST(providers, encrypt_provider) {
const auto config_path =
utils::path::combine(test::get_test_output_dir(), {"encrypt_provider"});
TEST(providers_test, encrypt_provider) {
auto config_path = utils::path::combine(test::get_test_output_dir(),
{"provider", "encrypt"});
console_consumer consumer{};
event_system::instance().start();
{
app_config cfg(provider_type::encrypt, config_path);
const auto encrypt_path =
auto encrypt_path =
utils::path::combine(test::get_test_input_dir(), {"encrypt"});
EXPECT_STREQ(
@@ -673,9 +820,9 @@ TEST(providers, encrypt_provider) {
event_system::instance().stop();
}
TEST(providers, s3_provider) {
const auto config_path =
utils::path::combine(test::get_test_output_dir(), {"s3_provider"});
TEST(providers_test, s3_provider) {
auto config_path =
utils::path::combine(test::get_test_output_dir(), {"provider", "s3"});
console_consumer consumer{};
event_system::instance().start();
@@ -685,7 +832,7 @@ TEST(providers, s3_provider) {
{
app_config src_cfg(
provider_type::s3,
utils::path::combine(test::get_test_config_dir(), {"storj"}));
utils::path::combine(test::get_test_config_dir(), {"s3"}));
cfg.set_s3_config(src_cfg.get_s3_config());
}
@@ -713,9 +860,9 @@ TEST(providers, s3_provider) {
event_system::instance().stop();
}
TEST(providers, sia_provider) {
const auto config_path =
utils::path::combine(test::get_test_output_dir(), {"sia_provider"});
TEST(providers_test, sia_provider) {
auto config_path =
utils::path::combine(test::get_test_output_dir(), {"sia", "provider"});
console_consumer consumer{};
event_system::instance().start();
@@ -753,5 +900,3 @@ TEST(providers, sia_provider) {
event_system::instance().stop();
}
} // namespace repertory
#endif // 0

6
repertory/repertory_test/src/upload_test.cpp
View File

@@ -29,7 +29,7 @@
namespace repertory {
static constexpr const std::size_t test_chunk_size{1024U};
TEST(upload, can_upload_a_valid_file) {
TEST(upload_test, can_upload_a_valid_file) {
console_consumer con;
event_system::instance().start();
@@ -71,7 +71,7 @@ TEST(upload, can_upload_a_valid_file) {
event_system::instance().stop();
}
TEST(upload, can_cancel_upload) {
TEST(upload_test, can_cancel_upload) {
console_consumer con;
event_system::instance().start();
@@ -135,7 +135,7 @@ TEST(upload, can_cancel_upload) {
event_system::instance().stop();
}
TEST(upload, can_stop_upload) {
TEST(upload_test, can_stop_upload) {
console_consumer con;
event_system::instance().start();

4
repertory/repertory_test/src/utils_test.cpp
View File

@@ -25,7 +25,7 @@
#include "utils/file.hpp"
namespace repertory {
TEST(utils, convert_api_date) {
TEST(utils_test, convert_api_date) {
#if defined(_WIN32)
auto file_time = utils::time::unix_time_to_filetime(
s3_provider::convert_api_date("2009-10-12T17:50:30.111Z"));
@@ -63,7 +63,7 @@ TEST(utils, convert_api_date) {
#endif // defined(_WIN32)
}
TEST(utils, generate_sha256) {
TEST(utils_test, generate_sha256) {
auto res = utils::file::file{__FILE__}.sha256();
EXPECT_TRUE(res.has_value());
if (res.has_value()) {