BlockStorage/repertory
1
0
Fork 0
Code Issues 7 Pull Requests Releases 6 Wiki Activity

unit tests and fixes
All checks were successful
BlockStorage/repertory/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Scott E. Graves 2024-12-21 08:35:38 -06:00
parent 1e69f793e2
commit 1511603b6a
9 changed files with 315 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.cspell/words.txt
View File

@ -161,6 +161,7 @@ openssldir
pkgconfig
plarge_integer
plex
println
project_enable_fontconfig
project_enable_gtkmm
project_enable_libdsm

4
repertory/librepertory/include/file_manager/cache_size_mgr.hpp
View File

@ -45,7 +45,7 @@ private:
private:
app_config *cfg_{nullptr};
std::uint64_t cache_size_{0U};
std::mutex mtx_;
mutable std::mutex mtx_;
std::condition_variable notify_;
stop_type stop_requested_{false};
@ -58,6 +58,8 @@ public:
[[nodiscard]] auto shrink(std::uint64_t size) -> api_error;
[[nodiscard]] auto size() const -> std::uint64_t;
void stop();
};
} // namespace repertory

1
repertory/librepertory/include/types/repertory.hpp
View File

@ -175,6 +175,7 @@ enum class api_error {
bad_address,
buffer_overflow,
buffer_too_small,
cache_not_initialized,
comm_error,
decryption_error,
directory_end_of_files,

9
repertory/librepertory/src/file_manager/cache_size_mgr.cpp
View File

@ -49,7 +49,7 @@ auto cache_size_mgr::expand(std::uint64_t size) -> api_error {
unique_mutex_lock lock(mtx_);
if (cfg_ == nullptr) {
return api_error::error;
return api_error::cache_not_initialized;
}
cache_size_ += size;
@ -98,7 +98,7 @@ auto cache_size_mgr::shrink(std::uint64_t size) -> api_error {
if (cache_size_ >= size) {
cache_size_ -= size;
} else {
event_system::instance().raise<max_cache_size_reached>(cache_size_, size);
event_system::instance().raise<invalid_cache_size>(cache_size_, size);
cache_size_ = 0U;
}
@ -107,6 +107,11 @@ auto cache_size_mgr::shrink(std::uint64_t size) -> api_error {
return stop_requested_ ? api_error::error : api_error::success;
}
auto cache_size_mgr::size() const -> std::uint64_t {
mutex_lock lock(mtx_);
return cache_size_;
}
void cache_size_mgr::stop() {
if (stop_requested_) {
return;

12
repertory/librepertory/src/file_manager/open_file.cpp
View File

@ -89,9 +89,17 @@ open_file::open_file(std::uint64_t chunk_size, std::uint8_t chunk_timeout,
false);
auto file_size = nf_->size();
if (provider_.is_read_only() || file_size == fsi.size) {
if (provider_.is_read_only() || file_size.value() == fsi.size) {
read_state_.set(0U, read_state_.size(), true);
} else if (not nf_->truncate(fsi.size)) {
} else if (nf_->truncate(fsi.size)) {
if (file_size.value() > fsi.size) {
set_api_error(
cache_size_mgr::instance().shrink(file_size.value() - fsi.size));
} else {
set_api_error(
cache_size_mgr::instance().expand(fsi.size - file_size.value()));
}
} else {
set_api_error(api_error::os_error);
}
}

3
repertory/librepertory/src/rpc/server/full_server.cpp
View File

@ -24,6 +24,7 @@
#include "app_config.hpp"
#include "events/event_system.hpp"
#include "events/events.hpp"
#include "file_manager/cache_size_mgr.hpp"
#include "file_manager/i_file_manager.hpp"
#include "providers/i_provider.hpp"
#include "types/repertory.hpp"
@ -54,7 +55,7 @@ void full_server::handle_get_drive_information(const httplib::Request & /*req*/,
utils::file::directory(get_config().get_cache_directory()).size();
res.set_content(
json({
{"cache_space_used", dir_size},
{"cache_space_used", cache_size_mgr::instance().size()},
{"drive_space_total", provider_.get_total_drive_space()},
{"drive_space_used", provider_.get_used_drive_space()},
{"item_count", provider_.get_total_item_count()},

9
repertory/librepertory/src/types/repertory.cpp
View File

@ -25,8 +25,8 @@
#include "utils/string.hpp"
namespace repertory {
auto database_type_from_string(std::string type, database_type default_type)
-> database_type {
auto database_type_from_string(std::string type,
database_type default_type) -> database_type {
type = utils::string::to_lower(utils::string::trim(type));
if (type == "rocksdb") {
return database_type::rocksdb;
@ -50,8 +50,8 @@ auto database_type_to_string(const database_type &type) -> std::string {
}
}
auto download_type_from_string(std::string type, download_type default_type)
-> download_type {
auto download_type_from_string(std::string type,
download_type default_type) -> download_type {
type = utils::string::to_lower(utils::string::trim(type));
if (type == "direct") {
return download_type::direct;
@ -87,6 +87,7 @@ static const std::unordered_map<api_error, std::string> LOOKUP = {
{api_error::bad_address, "bad_address"},
{api_error::buffer_overflow, "buffer_overflow"},
{api_error::buffer_too_small, "buffer_too_small"},
{api_error::cache_not_initialized, "cache_not_initialized"},
{api_error::comm_error, "comm_error"},
{api_error::decryption_error, "decryption_error"},
{api_error::directory_end_of_files, "directory_end_of_files"},

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

@ -22,6 +22,7 @@
#include "test_common.hpp"
#include "app_config.hpp"
#include "file_manager/cache_size_mgr.hpp"
#include "file_manager/events.hpp"
#include "file_manager/file_manager.hpp"
#include "file_manager/i_open_file.hpp"
@ -51,7 +52,7 @@ auto file_manager::open(std::shared_ptr<i_closeable_open_file> of,
class file_manager_test : public ::testing::Test {
public:
console_consumer c;
console_consumer con_consumer;
std::unique_ptr<app_config> cfg;
mock_provider mp;
static std::atomic<std::size_t> inst;
@ -67,6 +68,8 @@ protected:
cfg = std::make_unique<app_config>(provider_type::sia, file_manager_dir);
cfg->set_enable_download_timeout(false);
cache_size_mgr::instance().initialize(cfg.get());
}
void TearDown() override { event_system::instance().stop(); }
@ -696,7 +699,8 @@ TEST_F(file_manager_test, can_evict_file) {
data_buffer data{{0, 1, 1}};
std::size_t bytes_written{};
EXPECT_EQ(api_error::success, open_file->write(0U, data, bytes_written));
auto res = open_file->write(0U, data, bytes_written);
EXPECT_EQ(api_error::success, res);
auto opt_size = utils::file::file{source_path}.size();
EXPECT_TRUE(opt_size.has_value());

526
repertory/repertory_test/src/open_file_test.cpp
View File

@ -21,6 +21,8 @@
*/
#include "test_common.hpp"
#include "app_config.hpp"
#include "file_manager/cache_size_mgr.hpp"
#include "file_manager/open_file.hpp"
#include "mocks/mock_provider.hpp"
#include "mocks/mock_upload_manager.hpp"
@ -29,190 +31,219 @@
#include "utils/path.hpp"
namespace repertory {
static constexpr const std::size_t test_chunk_size = 1024u;
static constexpr const std::size_t test_chunk_size{1024U};
static void test_closeable_open_file(const open_file &o, bool directory,
const api_error &e, std::uint64_t size,
class open_file_test : public ::testing::Test {
public:
console_consumer con_consumer;
std::unique_ptr<app_config> cfg;
static std::atomic<std::size_t> inst;
mock_provider provider;
mock_upload_manager upload_mgr;
protected:
void SetUp() override {
event_system::instance().start();
auto open_file_dir = repertory::utils::path::combine(
repertory::test::get_test_output_dir(),
{"open_file_test" + std::to_string(++inst)});
cfg = std::make_unique<app_config>(provider_type::sia, open_file_dir);
cache_size_mgr::instance().initialize(cfg.get());
}
void TearDown() override { event_system::instance().stop(); }
};
std::atomic<std::size_t> open_file_test::inst{0U};
static void test_closeable_open_file(const open_file &file, bool directory,
const api_error &err, std::uint64_t size,
const std::string &source_path) {
EXPECT_EQ(directory, o.is_directory());
EXPECT_EQ(e, o.get_api_error());
EXPECT_EQ(std::size_t(0u), o.get_open_file_count());
EXPECT_EQ(std::uint64_t(size), o.get_file_size());
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
EXPECT_TRUE(o.can_close());
EXPECT_EQ(directory, file.is_directory());
EXPECT_EQ(err, file.get_api_error());
EXPECT_EQ(std::size_t(0U), file.get_open_file_count());
EXPECT_EQ(std::uint64_t(size), file.get_file_size());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_TRUE(file.can_close());
}
static void validate_write(open_file &o, std::size_t offset, data_buffer data,
std::size_t bytes_written) {
static void validate_write(open_file &file, std::size_t offset,
data_buffer data, std::size_t bytes_written) {
EXPECT_EQ(data.size(), bytes_written);
data_buffer read_data{};
EXPECT_EQ(api_error::success, o.read(data.size(), offset, read_data));
EXPECT_EQ(api_error::success, file.read(data.size(), offset, read_data));
EXPECT_TRUE(std::equal(data.begin(), data.end(), read_data.begin()));
}
TEST(open_file, properly_initializes_state_for_0_byte_file) {
TEST_F(open_file_test, properly_initializes_state_for_0_byte_file) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = 0u;
fsi.size = 0U;
fsi.source_path = source_path;
open_file o(test_chunk_size, 0U, fsi, mp, um);
EXPECT_EQ(std::size_t(0u), o.get_read_state().size());
EXPECT_FALSE(o.is_modified());
EXPECT_EQ(test_chunk_size, o.get_chunk_size());
}
TEST(open_file, properly_initializes_state_based_on_chunk_size) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = 8u;
fsi.source_path = source_path;
EXPECT_CALL(um, remove_resume)
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
open_file o(1u, 0U, fsi, mp, um);
EXPECT_EQ(std::size_t(8u), o.get_read_state().size());
EXPECT_TRUE(o.get_read_state().none());
EXPECT_FALSE(o.is_modified());
EXPECT_CALL(mp, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce(Return(api_error::success));
EXPECT_EQ(std::size_t(1u), o.get_chunk_size());
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
EXPECT_EQ(std::size_t(0U), file.get_read_state().size());
EXPECT_FALSE(file.is_modified());
EXPECT_EQ(test_chunk_size, file.get_chunk_size());
}
TEST(open_file, will_not_change_source_path_for_0_byte_file) {
TEST_F(open_file_test, properly_initializes_state_based_on_chunk_size) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = 0u;
fsi.size = 8U;
fsi.source_path = source_path;
open_file o(0u, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, 0u, source_path);
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
o.close();
EXPECT_EQ(api_error::success, o.get_api_error());
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
EXPECT_TRUE(utils::file::file(fsi.source_path).exists());
open_file file(1U, 0U, fsi, provider, upload_mgr);
EXPECT_EQ(std::size_t(8U), file.get_read_state().size());
EXPECT_TRUE(file.get_read_state().none());
EXPECT_FALSE(file.is_modified());
EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce(Return(api_error::success));
EXPECT_EQ(std::size_t(1U), file.get_chunk_size());
}
TEST(open_file, will_change_source_path_if_file_size_is_greater_than_0) {
TEST_F(open_file_test, will_not_change_source_path_for_0_byte_file) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.directory = false;
fsi.api_path = "/test.txt";
fsi.size = 0U;
fsi.source_path = source_path;
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
open_file file(0U, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, 0U, source_path);
file.close();
EXPECT_EQ(api_error::success, file.get_api_error());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_TRUE(utils::file::file(fsi.source_path).exists());
}
TEST_F(open_file_test, will_change_source_path_if_file_size_is_greater_than_0) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size;
fsi.source_path = source_path;
EXPECT_CALL(um, remove_resume)
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
EXPECT_CALL(mp, set_item_meta(fsi.api_path, META_SOURCE, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce([&fsi](const std::string &, const std::string &,
const std::string &source_path2) -> api_error {
EXPECT_STRNE(fsi.source_path.c_str(), source_path2.c_str());
return api_error::success;
});
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, test_chunk_size,
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, test_chunk_size,
source_path);
o.close();
EXPECT_EQ(api_error::download_stopped, o.get_api_error());
EXPECT_STRNE(source_path.c_str(), o.get_source_path().c_str());
file.close();
EXPECT_EQ(api_error::download_stopped, file.get_api_error());
EXPECT_STRNE(source_path.c_str(), file.get_source_path().c_str());
EXPECT_FALSE(utils::file::file(source_path).exists());
}
TEST(open_file,
will_not_change_source_path_if_file_size_matches_existing_source) {
TEST_F(open_file_test,
will_not_change_source_path_if_file_size_matches_existing_source) {
auto &rf = test::create_random_file(test_chunk_size);
const auto source_path = rf.get_path();
rf.close();
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size;
fsi.source_path = source_path;
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, test_chunk_size,
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, test_chunk_size,
source_path);
o.close();
EXPECT_EQ(api_error::success, o.get_api_error());
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
file.close();
EXPECT_EQ(api_error::success, file.get_api_error());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_TRUE(utils::file::file(source_path).exists());
}
TEST(open_file, write_with_incomplete_download) {
TEST_F(open_file_test, write_with_incomplete_download) {
const auto source_path = test::generate_test_file_name("test");
auto &nf = test::create_random_file(test_chunk_size * 2u);
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 2u;
fsi.source_path = source_path;
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, test_chunk_size * 2u,
source_path);
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success,
test_chunk_size * 2u, source_path);
EXPECT_CALL(mp, set_item_meta(fsi.api_path, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
.WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
@ -220,7 +251,7 @@ TEST(open_file, write_with_incomplete_download) {
return api_error::success;
});
EXPECT_CALL(mp, read_file_bytes)
EXPECT_CALL(provider, read_file_bytes)
.WillRepeatedly([&nf](const std::string & /* api_path */,
std::size_t size, std::uint64_t offset,
data_buffer &data,
@ -229,7 +260,7 @@ TEST(open_file, write_with_incomplete_download) {
return api_error::download_stopped;
}
if (offset == 0u) {
if (offset == 0U) {
std::size_t bytes_read{};
data.resize(size);
auto ret = nf.read(data, offset, &bytes_read) ? api_error::success
@ -244,11 +275,12 @@ TEST(open_file, write_with_incomplete_download) {
return api_error::download_stopped;
});
EXPECT_CALL(um, remove_upload).WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(upload_mgr, remove_upload)
.WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(um, store_resume)
EXPECT_CALL(upload_mgr, store_resume)
.Times(2)
.WillRepeatedly([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
@ -257,55 +289,53 @@ TEST(open_file, write_with_incomplete_download) {
data_buffer data = {10, 9, 8};
std::size_t bytes_written{};
EXPECT_EQ(api_error::success, o.write(0u, data, bytes_written));
validate_write(o, 0u, data, bytes_written);
EXPECT_EQ(api_error::success, file.write(0U, data, bytes_written));
validate_write(file, 0U, data, bytes_written);
const auto test_state = [&]() {
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_FALSE(o.can_close());
EXPECT_FALSE(file.can_close());
EXPECT_TRUE(o.is_modified());
EXPECT_TRUE(file.is_modified());
EXPECT_TRUE(o.get_read_state(0u));
EXPECT_FALSE(o.get_read_state(1u));
EXPECT_TRUE(file.get_read_state(0U));
EXPECT_FALSE(file.get_read_state(1u));
};
test_state();
o.close();
file.close();
nf.close();
test_state();
EXPECT_EQ(api_error::download_incomplete, o.get_api_error());
EXPECT_EQ(api_error::download_incomplete, file.get_api_error());
EXPECT_TRUE(utils::file::file(fsi.source_path).exists());
}
TEST(open_file, write_new_file) {
TEST_F(open_file_test, write_new_file) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = 0u;
fsi.size = 0U;
fsi.source_path = source_path;
EXPECT_CALL(um, store_resume).WillOnce([&fsi](const i_open_file &o) {
EXPECT_EQ(fsi.api_path, o.get_api_path());
EXPECT_EQ(fsi.source_path, o.get_source_path());
});
EXPECT_CALL(upload_mgr, store_resume)
.WillOnce([&fsi](const i_open_file &file) {
EXPECT_EQ(fsi.api_path, file.get_api_path());
EXPECT_EQ(fsi.source_path, file.get_source_path());
});
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, 0u, source_path);
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, 0U, source_path);
data_buffer data = {10, 9, 8};
EXPECT_CALL(mp, set_item_meta(fsi.api_path, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
.WillOnce([&data](const std::string &,
const api_meta_map &meta) -> api_error {
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
@ -322,62 +352,62 @@ TEST(open_file, write_new_file) {
return api_error::success;
});
EXPECT_CALL(um, remove_upload).WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(upload_mgr, remove_upload)
.WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(um, queue_upload).WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(upload_mgr, queue_upload)
.WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
std::size_t bytes_written{};
EXPECT_EQ(api_error::success, o.write(0u, data, bytes_written));
EXPECT_EQ(api_error::success, file.write(0U, data, bytes_written));
const auto test_state = [&]() {
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_FALSE(o.can_close());
EXPECT_TRUE(o.is_modified());
EXPECT_FALSE(file.can_close());
EXPECT_TRUE(file.is_modified());
EXPECT_TRUE(o.get_read_state(0u));
EXPECT_EQ(std::size_t(1u), o.get_read_state().size());
EXPECT_EQ(data.size(), o.get_file_size());
EXPECT_TRUE(file.get_read_state(0U));
EXPECT_EQ(std::size_t(1u), file.get_read_state().size());
EXPECT_EQ(data.size(), file.get_file_size());
};
test_state();
o.close();
file.close();
test_state();
EXPECT_EQ(api_error::success, o.get_api_error());
EXPECT_EQ(api_error::success, file.get_api_error());
EXPECT_TRUE(utils::file::file(fsi.source_path).exists());
}
TEST(open_file, write_new_file_multiple_chunks) {
TEST_F(open_file_test, write_new_file_multiple_chunks) {
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = 0u;
fsi.size = 0U;
fsi.source_path = source_path;
EXPECT_CALL(um, store_resume).WillOnce([&fsi](const i_open_file &o) {
EXPECT_EQ(fsi.api_path, o.get_api_path());
EXPECT_EQ(fsi.source_path, o.get_source_path());
});
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, 0u, source_path);
EXPECT_CALL(upload_mgr, store_resume)
.WillOnce([&fsi](const i_open_file &file) {
EXPECT_EQ(fsi.api_path, file.get_api_path());
EXPECT_EQ(fsi.source_path, file.get_source_path());
});
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, 0U, source_path);
data_buffer data = {10, 9, 8};
EXPECT_CALL(mp, set_item_meta(fsi.api_path, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
.WillOnce([&data](const std::string &,
const api_meta_map &meta) -> api_error {
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
@ -410,153 +440,159 @@ TEST(open_file, write_new_file_multiple_chunks) {
return api_error::success;
});
EXPECT_CALL(um, remove_upload).WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(upload_mgr, remove_upload)
.WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(um, queue_upload).WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(upload_mgr, queue_upload)
.WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
std::size_t bytes_written{};
EXPECT_EQ(api_error::success, o.write(0u, data, bytes_written));
EXPECT_EQ(api_error::success, o.write(test_chunk_size, data, bytes_written));
EXPECT_EQ(api_error::success, file.write(0U, data, bytes_written));
EXPECT_EQ(api_error::success,
file.write(test_chunk_size, data, bytes_written));
const auto test_state = [&]() {
EXPECT_STREQ(source_path.c_str(), o.get_source_path().c_str());
EXPECT_STREQ(source_path.c_str(), file.get_source_path().c_str());
EXPECT_FALSE(o.can_close());
EXPECT_TRUE(o.is_modified());
EXPECT_FALSE(file.can_close());
EXPECT_TRUE(file.is_modified());
EXPECT_EQ(std::size_t(2u), o.get_read_state().size());
for (std::size_t i = 0u; i < 2u; i++) {
EXPECT_TRUE(o.get_read_state(i));
EXPECT_EQ(std::size_t(2u), file.get_read_state().size());
for (std::size_t i = 0U; i < 2u; i++) {
EXPECT_TRUE(file.get_read_state(i));
}
EXPECT_EQ(data.size() + test_chunk_size, o.get_file_size());
EXPECT_EQ(data.size() + test_chunk_size, file.get_file_size());
};
test_state();
o.close();
file.close();
test_state();
EXPECT_EQ(api_error::success, o.get_api_error());
EXPECT_EQ(api_error::success, file.get_api_error());
EXPECT_TRUE(utils::file::file(fsi.source_path).exists());
}
TEST(open_file, resize_file_to_0_bytes) {
auto &rf = test::create_random_file(test_chunk_size * 4u);
const auto source_path = rf.get_path();
rf.close();
TEST_F(open_file_test, resize_file_to_0_bytes) {
auto &r_file = test::create_random_file(test_chunk_size * 4U);
const auto source_path = r_file.get_path();
r_file.close();
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 4u;
fsi.size = test_chunk_size * 4U;
fsi.source_path = source_path;
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, fsi.size, source_path);
EXPECT_CALL(mp, set_item_meta(fsi.api_path, _))
EXPECT_EQ(api_error::success, cache_size_mgr::instance().expand(fsi.size));
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, fsi.size,
source_path);
EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
.WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_SIZE).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
EXPECT_EQ(std::size_t(0u),
EXPECT_EQ(std::size_t(0U),
utils::string::to_size_t(meta.at(META_SIZE)));
return api_error::success;
});
EXPECT_CALL(um, remove_upload).WillOnce([&fsi](const std ::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(upload_mgr, remove_upload)
.WillOnce([&fsi](const std ::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(um, queue_upload).WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(um, store_resume).WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(upload_mgr, queue_upload)
.WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(upload_mgr, store_resume)
.WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_EQ(api_error::success, o.resize(0u));
EXPECT_EQ(api_error::success, file.resize(0U));
EXPECT_EQ(std::size_t(0u), o.get_file_size());
EXPECT_FALSE(o.can_close());
EXPECT_TRUE(o.is_modified());
EXPECT_EQ(std::size_t(0U), file.get_file_size());
EXPECT_FALSE(file.can_close());
EXPECT_TRUE(file.is_modified());
EXPECT_EQ(std::size_t(0u), o.get_read_state().size());
EXPECT_EQ(std::size_t(0U), file.get_read_state().size());
}
TEST(open_file, resize_file_by_full_chunk) {
auto &rf = test::create_random_file(test_chunk_size * 4u);
const auto source_path = rf.get_path();
rf.close();
TEST_F(open_file_test, resize_file_by_full_chunk) {
auto &r_file = test::create_random_file(test_chunk_size * 4U);
const auto source_path = r_file.get_path();
r_file.close();
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
fsi.size = test_chunk_size * 4u;
fsi.size = test_chunk_size * 4U;
fsi.source_path = source_path;
EXPECT_CALL(um, store_resume).WillOnce([&fsi](const i_open_file &o) {
EXPECT_EQ(fsi.api_path, o.get_api_path());
EXPECT_EQ(fsi.source_path, o.get_source_path());
});
EXPECT_EQ(api_error::success, cache_size_mgr::instance().expand(fsi.size));
open_file o(test_chunk_size, 0U, fsi, mp, um);
test_closeable_open_file(o, false, api_error::success, fsi.size, source_path);
EXPECT_CALL(mp, set_item_meta(fsi.api_path, _))
EXPECT_CALL(upload_mgr, store_resume)
.WillOnce([&fsi](const i_open_file &file) {
EXPECT_EQ(fsi.api_path, file.get_api_path());
EXPECT_EQ(fsi.source_path, file.get_source_path());
});
open_file file(test_chunk_size, 0U, fsi, provider, upload_mgr);
test_closeable_open_file(file, false, api_error::success, fsi.size,
source_path);
EXPECT_CALL(provider, set_item_meta(fsi.api_path, _))
.WillOnce([](const std::string &, const api_meta_map &meta) -> api_error {
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_CHANGED).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_MODIFIED).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_SIZE).empty()));
EXPECT_NO_THROW(EXPECT_FALSE(meta.at(META_WRITTEN).empty()));
EXPECT_EQ(std::size_t(test_chunk_size * 3u),
EXPECT_EQ(std::size_t(test_chunk_size * 3U),
utils::string::to_size_t(meta.at(META_SIZE)));
return api_error::success;
});
EXPECT_CALL(um, remove_upload).WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(upload_mgr, remove_upload)
.WillOnce([&fsi](const std::string &api_path) {
EXPECT_EQ(fsi.api_path, api_path);
});
EXPECT_CALL(um, queue_upload).WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_CALL(upload_mgr, queue_upload)
.WillOnce([&fsi](const i_open_file &cur_file) {
EXPECT_EQ(fsi.api_path, cur_file.get_api_path());
EXPECT_EQ(fsi.source_path, cur_file.get_source_path());
});
EXPECT_EQ(api_error::success, o.resize(test_chunk_size * 3u));
EXPECT_EQ(api_error::success, file.resize(test_chunk_size * 3U));
EXPECT_EQ(std::size_t(test_chunk_size * 3u), o.get_file_size());
EXPECT_FALSE(o.can_close());
EXPECT_TRUE(o.is_modified());
EXPECT_EQ(std::size_t(3u), o.get_read_state().size());
EXPECT_EQ(std::size_t(test_chunk_size * 3U), file.get_file_size());
EXPECT_FALSE(file.can_close());
EXPECT_TRUE(file.is_modified());
EXPECT_EQ(std::size_t(3U), file.get_read_state().size());
}
TEST(open_file, can_add_handle) {
TEST_F(open_file_test, can_add_handle) {
event_system::instance().start();
console_consumer c;
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
@ -582,9 +618,9 @@ TEST(open_file, can_add_handle) {
EXPECT_STREQ("1", ee.get_handle().get<std::string>().c_str());
});
EXPECT_CALL(mp, set_item_meta(fsi.api_path, META_SOURCE, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce(Return(api_error::success));
EXPECT_CALL(um, remove_resume)
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
@ -594,7 +630,7 @@ TEST(open_file, can_add_handle) {
event_capture capture(
{"filesystem_item_opened", "filesystem_item_handle_opened"});
open_file o(test_chunk_size, 0U, fsi, mp, um);
open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr);
#if defined(_WIN32)
o.add(1u, {});
EXPECT_EQ(nullptr, o.get_open_data(1u).directory_buffer);
@ -608,17 +644,14 @@ TEST(open_file, can_add_handle) {
event_system::instance().stop();
}
TEST(open_file, can_remove_handle) {
TEST_F(open_file_test, can_remove_handle) {
event_system::instance().start();
console_consumer c;
const auto source_path =
test::generate_test_file_name("file_manager_open_file_test");
mock_provider mp;
mock_upload_manager um;
EXPECT_CALL(mp, is_read_only()).WillRepeatedly(Return(false));
EXPECT_CALL(provider, is_read_only()).WillRepeatedly(Return(false));
filesystem_item fsi;
fsi.api_path = "/test.txt";
@ -644,13 +677,13 @@ TEST(open_file, can_remove_handle) {
EXPECT_STREQ("1", ee.get_handle().get<std::string>().c_str());
});
EXPECT_CALL(um, remove_resume)
EXPECT_CALL(upload_mgr, remove_resume)
.WillOnce(
[&fsi](const std::string &api_path, const std::string &source_path2) {
EXPECT_EQ(fsi.api_path, api_path);
EXPECT_EQ(fsi.source_path, source_path2);
});
EXPECT_CALL(mp, set_item_meta(fsi.api_path, META_SOURCE, _))
EXPECT_CALL(provider, set_item_meta(fsi.api_path, META_SOURCE, _))
.WillOnce(Return(api_error::success));
event_capture capture({
@ -660,7 +693,7 @@ TEST(open_file, can_remove_handle) {
"filesystem_item_closed",
});
open_file o(test_chunk_size, 0U, fsi, mp, um);
open_file o(test_chunk_size, 0U, fsi, provider, upload_mgr);
#if defined(_WIN32)
o.add(1u, {});
#else
@ -673,12 +706,13 @@ TEST(open_file, can_remove_handle) {
event_system::instance().stop();
}
TEST(open_file,
can_read_locally_after_write_with_file_size_greater_than_existing_size) {}
TEST_F(open_file_test,
can_read_locally_after_write_with_file_size_greater_than_existing_size) {
}
TEST(open_file, test_valid_download_chunks) {}
TEST_F(open_file_test, test_valid_download_chunks) {}
TEST(open_file, test_full_download_with_partial_chunk) {}
TEST_F(open_file_test, test_full_download_with_partial_chunk) {}
TEST(open_file, source_is_read_after_full_download) {}
TEST_F(open_file_test, source_is_read_after_full_download) {}
} // namespace repertory