From 1214e777d51e36ce2975de32f18d8bb26e691340 Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Wed, 17 Sep 2025 10:06:32 -0500 Subject: [PATCH] [unit test] Complete all providers unit tests #12 --- CHANGELOG.md | 1 + .../include/fixtures/drive_fixture.hpp | 12 +- .../repertory_test/src/providers_test.cpp | 536 ++++++++++++++++-- 3 files changed, 508 insertions(+), 41 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fae90bb..1fc36a8b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ ### Issues +* \#12 [unit test] Complete all providers unit tests * \#33 Complete initial v2.0 documentation * \#34 Add macOS support * \#38 Pinning a file should automatically initiate a download to cache diff --git a/repertory/repertory_test/include/fixtures/drive_fixture.hpp b/repertory/repertory_test/include/fixtures/drive_fixture.hpp index 9fd72885..c1fc99d8 100644 --- a/repertory/repertory_test/include/fixtures/drive_fixture.hpp +++ b/repertory/repertory_test/include/fixtures/drive_fixture.hpp @@ -463,7 +463,10 @@ public: auto api_path = utils::path::create_api_path(file_name); [[maybe_unused]] auto res = - meta->set_item_meta(api_path, {{META_UID, "0"}, {META_GID, "0"}}); + meta->set_item_meta(api_path, { + {META_UID, "0"}, + {META_GID, "0"}, + }); std::this_thread::sleep_for(SLEEP_SECONDS); return file_path; @@ -486,9 +489,10 @@ public: utils::path::strip_to_file_name(file_path)); [[maybe_unused]] auto res = - meta->set_item_meta(api_path, {{META_UID, std::to_string(getuid())}, - { META_GID, - std::to_string(getgid()) }}); + meta->set_item_meta(api_path, { + {META_UID, std::to_string(getuid())}, + {META_GID, std::to_string(getgid())}, + }); std::this_thread::sleep_for(SLEEP_SECONDS); unlink_file_and_test(file_path); diff --git a/repertory/repertory_test/src/providers_test.cpp b/repertory/repertory_test/src/providers_test.cpp index 27e03a8c..946fe069 100644 --- a/repertory/repertory_test/src/providers_test.cpp +++ b/repertory/repertory_test/src/providers_test.cpp @@ -728,24 +728,26 @@ static void get_file_list(const app_config &cfg, i_provider &provider) { } } -static void get_file_size(i_provider &provider) { +static void get_file_size(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) { - api_file_list list{}; - std::string marker; - auto res = provider.get_file_list(list, marker); - ASSERT_EQ(res, api_error::success); + auto source_path = + utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}); + auto src_size = utils::file::file{source_path}.size(); + EXPECT_TRUE(src_size.has_value()); - ASSERT_FALSE(list.empty()); + std::string api_path{}; + EXPECT_EQ(api_error::success, + provider.get_api_path_from_source(source_path, api_path)); std::uint64_t size{}; - res = provider.get_file_size(list.front().api_path, size); + auto res = provider.get_file_size(api_path, size); EXPECT_EQ(api_error::success, res); EXPECT_EQ(utils::encryption::encrypting_reader::calculate_encrypted_size( - 6U, true), + src_size.value(), true), size); return; } @@ -774,28 +776,27 @@ static void get_file_size_fails_if_path_not_found(i_provider &provider) { __FUNCTION__); std::uint64_t size{}; - auto res = provider.get_file_size("/cow/moose/dog/chicken", size); + auto res = provider.get_file_size("/cow/moose/doge/chicken", size); EXPECT_EQ(api_error::item_not_found, res); EXPECT_EQ(0U, size); } -static void get_filesystem_item(i_provider &provider) { +static void get_filesystem_item(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) { - api_file_list list{}; - std::string marker; - auto res = provider.get_file_list(list, marker); - ASSERT_EQ(api_error::success, res); - ASSERT_FALSE(list.empty()); - - auto api_path = list.front().api_path; + std::string api_path{}; + EXPECT_EQ( + api_error::success, + provider.get_api_path_from_source( + utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}), + api_path)); filesystem_item fsi{}; - res = provider.get_filesystem_item(api_path, false, fsi); + auto res = provider.get_filesystem_item(api_path, false, fsi); EXPECT_EQ(api_error::success, res); EXPECT_FALSE(fsi.directory); @@ -852,7 +853,8 @@ get_filesystem_item_fails_if_file_is_not_found(i_provider &provider) { __FUNCTION__); filesystem_item fsi{}; - auto res = provider.get_filesystem_item("/cow/moose/dog/chicken", false, fsi); + auto res = + provider.get_filesystem_item("/cow/moose/doge/chicken", false, fsi); EXPECT_EQ(api_error::item_not_found, res); } @@ -863,7 +865,7 @@ get_filesystem_item_fails_if_directory_is_not_found(i_provider &provider) { __FUNCTION__); filesystem_item fsi{}; - auto res = provider.get_filesystem_item("/cow/moose/dog/chicken", true, fsi); + auto res = provider.get_filesystem_item("/cow/moose/doge/chicken", true, fsi); EXPECT_EQ(api_error::directory_not_found, res); } @@ -879,8 +881,11 @@ static void get_filesystem_item_from_source_path(const app_config &cfg, if (provider.get_provider_type() == provider_type::encrypt) { source_path = utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}); - size = utils::encryption::encrypting_reader::calculate_encrypted_size(6U, - true); + auto src_size = utils::file::file{source_path}.size(); + EXPECT_TRUE(src_size.has_value()); + + size = utils::encryption::encrypting_reader::calculate_encrypted_size( + src_size.value(), true); } else { size = 128U; auto &file = test::create_random_file(size); @@ -924,9 +929,464 @@ static void get_filesystem_item_from_source_path_fails_if_file_is_not_found( EXPECT_EQ(api_error::item_not_found, res); } +static void get_and_set_item_meta_with_upload_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) { + std::string api_path{}; + EXPECT_EQ( + api_error::success, + provider.get_api_path_from_source( + utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}), + api_path)); + + std::string val{}; + EXPECT_EQ(api_error::success, + provider.get_item_meta(api_path, META_SOURCE, val)); + EXPECT_FALSE(val.empty()); + EXPECT_TRUE(utils::file::file{val}.exists()); + + val.clear(); + EXPECT_EQ(api_error::success, + provider.get_item_meta(api_path, META_DIRECTORY, val)); + EXPECT_FALSE(utils::string::to_bool(val)); + return; + } + + auto &file = test::create_random_file(128U); + const auto api_path = + fmt::format("/{}", utils::path::strip_to_file_name(file.get_path())); + create_file(provider, api_path); + + stop_type stop_requested{false}; + ASSERT_EQ(api_error::success, + provider.upload_file(api_path, file.get_path(), stop_requested)); + + auto size_str = std::to_string(*file.size()); + EXPECT_EQ(api_error::success, + provider.set_item_meta(api_path, META_SIZE, size_str)); + EXPECT_EQ(api_error::success, + provider.set_item_meta(api_path, META_SOURCE, file.get_path())); + + std::string val{}; + EXPECT_EQ(api_error::success, + provider.get_item_meta(api_path, META_SIZE, val)); + EXPECT_STREQ(size_str.c_str(), val.c_str()); + + val.clear(); + EXPECT_EQ(api_error::success, + provider.get_item_meta(api_path, META_SOURCE, val)); + EXPECT_STREQ(file.get_path().c_str(), val.c_str()); + + EXPECT_EQ(api_error::success, provider.remove_file(api_path)); +} + +static void get_and_set_item_meta2_with_upload_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) { + std::string api_path{}; + EXPECT_EQ( + api_error::success, + provider.get_api_path_from_source( + utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}), + api_path)); + + api_meta_map meta{}; + EXPECT_EQ(api_error::success, provider.get_item_meta(api_path, meta)); + EXPECT_TRUE(meta.contains(META_SOURCE)); + EXPECT_TRUE(meta.contains(META_DIRECTORY)); + EXPECT_FALSE(utils::string::to_bool(meta[META_DIRECTORY])); + return; + } + + auto &file = test::create_random_file(64U); + const auto api_path = + fmt::format("/{}", utils::path::strip_to_file_name(file.get_path())); + create_file(provider, api_path); + + stop_type stop_requested{false}; + ASSERT_EQ(api_error::success, + provider.upload_file(api_path, file.get_path(), stop_requested)); + + api_meta_map to_set{ + {META_SIZE, std::to_string(*file.size())}, + {META_SOURCE, file.get_path()}, + }; + EXPECT_EQ(api_error::success, provider.set_item_meta(api_path, to_set)); + + api_meta_map meta{}; + EXPECT_EQ(api_error::success, provider.get_item_meta(api_path, meta)); + EXPECT_STREQ(std::to_string(*file.size()).c_str(), meta[META_SIZE].c_str()); + EXPECT_STREQ(file.get_path().c_str(), meta[META_SOURCE].c_str()); + EXPECT_FALSE(utils::string::to_bool(meta[META_DIRECTORY])); + + EXPECT_EQ(api_error::success, provider.remove_file(api_path)); +} + +static void get_item_meta_fails_if_path_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + std::string out{}; + EXPECT_EQ(api_error::item_not_found, + provider.get_item_meta("/cow/moose/doge/chicken", META_SIZE, out)); + EXPECT_TRUE(out.empty()); +} + +static void get_item_meta2_fails_if_path_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + api_meta_map meta{}; + EXPECT_EQ(api_error::item_not_found, + provider.get_item_meta("/cow/moose/doge/chicken", meta)); + EXPECT_TRUE(meta.empty()); +} + +static void is_file_fails_if_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + bool exists{}; + auto res = provider.is_file("/cow/moose/doge/chicken", exists); + + EXPECT_EQ(api_error::success, res); + EXPECT_FALSE(exists); +} + +static void is_directory_fails_if_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + bool exists{}; + auto res = provider.is_directory("/cow/moose/doge/chicken", exists); + + EXPECT_EQ(api_error::success, res); + EXPECT_FALSE(exists); +} + +static void remove_file_fails_if_file_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + auto res = provider.remove_file("/cow/moose/doge/chicken"); + if (provider.is_read_only()) { + EXPECT_EQ(api_error::not_implemented, res); + return; + } + EXPECT_EQ(api_error::item_not_found, res); +} + +static void remove_file_fails_if_item_is_directory(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.remove_file("/dir01")); + return; + } + + create_directory(provider, "/dir01"); + EXPECT_EQ(api_error::directory_exists, provider.remove_file("/dir01")); + EXPECT_EQ(api_error::success, provider.remove_directory("/dir01")); +} + +static void +remove_directory_fails_if_directory_not_found(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + const auto res = provider.remove_directory("/cow/moose/doge/chicken"); + if (provider.is_read_only()) { + EXPECT_EQ(api_error::not_implemented, res); + return; + } + EXPECT_EQ(api_error::item_not_found, res); +} + +static void remove_directory_fails_if_item_is_file(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.remove_directory("/pt01.txt")); + return; + } + + create_file(provider, "/pt01.txt"); + EXPECT_EQ(api_error::item_not_found, provider.remove_directory("/pt01.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/pt01.txt")); +} + +static void get_pinned_files(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + if (provider.is_read_only()) { + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_TRUE(pinned.empty()); + return; + } + + create_file(provider, "/pin01.txt"); + create_file(provider, "/pin02.txt"); + create_file(provider, "/nopin01.txt"); + + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin01.txt", META_PINNED, "true")); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin02.txt", META_PINNED, "true")); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/nopin01.txt", META_PINNED, "false")); + + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_EQ(std::size_t(2U), pinned.size()); + + const auto has_path = [&](std::string_view path) { + return std::ranges::any_of( + pinned, [&](const api_file &file) { return file.api_path == path; }); + }; + + EXPECT_TRUE(has_path("/pin01.txt")); + EXPECT_TRUE(has_path("/pin02.txt")); + EXPECT_FALSE(has_path("/nopin01.txt")); + + EXPECT_EQ(api_error::success, provider.remove_file("/pin01.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/pin02.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/nopin01.txt")); +} + +static void remove_pin_updates_pinned_files(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + if (provider.is_read_only()) { + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_TRUE(pinned.empty()); + return; + } + + create_file(provider, "/pin01.txt"); + create_file(provider, "/pin02.txt"); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin01.txt", META_PINNED, "true")); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin02.txt", META_PINNED, "true")); + + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_EQ(std::size_t(2U), pinned.size()); + + const auto has_path = [&](std::string_view path) { + return std::ranges::any_of( + pinned, [&](const api_file &file) { return file.api_path == path; }); + }; + + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin02.txt", META_PINNED, "false")); + pinned.clear(); + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_EQ(std::size_t(1U), pinned.size()); + EXPECT_TRUE(has_path("/pin01.txt")); + EXPECT_FALSE(has_path("/pin02.txt")); + + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin01.txt", META_PINNED, "false")); + pinned.clear(); + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_TRUE(pinned.empty()); + + EXPECT_EQ(api_error::success, provider.remove_file("/pin01.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/pin02.txt")); +} + +static void remove_file_updates_pinned_files(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + if (provider.is_read_only()) { + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_TRUE(pinned.empty()); + return; + } + + create_file(provider, "/pin_keep.txt"); + create_file(provider, "/pin_delete.txt"); + create_file(provider, "/nopin.txt"); + + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin_keep.txt", META_PINNED, "true")); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/pin_delete.txt", META_PINNED, "true")); + EXPECT_EQ(api_error::success, + provider.set_item_meta("/nopin.txt", META_PINNED, "false")); + + api_file_list pinned{}; + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_EQ(std::size_t(2U), pinned.size()); + + const auto has_path = [&](std::string_view path) { + return std::ranges::any_of( + pinned, [&](const api_file &file) { return file.api_path == path; }); + }; + + EXPECT_TRUE(has_path("/pin_keep.txt")); + EXPECT_TRUE(has_path("/pin_delete.txt")); + EXPECT_FALSE(has_path("/nopin.txt")); + + EXPECT_EQ(api_error::success, provider.remove_file("/pin_delete.txt")); + + pinned.clear(); + EXPECT_EQ(api_error::success, provider.get_pinned_files(pinned)); + EXPECT_EQ(std::size_t(1U), pinned.size()); + EXPECT_TRUE(has_path("/pin_keep.txt")); + EXPECT_FALSE(has_path("/pin_delete.txt")); + + EXPECT_EQ(api_error::success, provider.remove_file("/pin_keep.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/nopin.txt")); +} + +static void get_total_item_count(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + if (provider.is_read_only()) { + std::uint64_t count{}; + EXPECT_EQ(api_error::success, provider.get_total_item_count(count)); + EXPECT_EQ(3U, count); + return; + } + + std::uint64_t before{}; + EXPECT_EQ(api_error::success, provider.get_total_item_count(before)); + + create_file(provider, "/count01.txt"); + create_file(provider, "/count02.txt"); + + std::uint64_t mid{}; + EXPECT_EQ(api_error::success, provider.get_total_item_count(mid)); + EXPECT_EQ(before + 2U, mid); + + EXPECT_EQ(api_error::success, provider.remove_file("/count01.txt")); + EXPECT_EQ(api_error::success, provider.remove_file("/count02.txt")); + + std::uint64_t after{}; + EXPECT_EQ(api_error::success, provider.get_total_item_count(after)); + EXPECT_EQ(before, after); +} + +static void get_used_drive_space(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + if (provider.is_read_only()) { + api_file_list list{}; + std::string marker; + EXPECT_EQ(api_error::success, provider.get_file_list(list, marker)); + + std::uint64_t sum_sizes{}; + for (const auto &file : list) { + std::uint64_t size{}; + EXPECT_EQ(api_error::success, + provider.get_file_size(file.api_path, size)); + sum_sizes += size; + } + + std::uint64_t used{}; + EXPECT_EQ(api_error::success, provider.get_used_drive_space(used)); + EXPECT_EQ(sum_sizes, used); + return; + } + + std::uint64_t before{}; + EXPECT_EQ(api_error::success, provider.get_used_drive_space(before)); + + auto &file1 = test::create_random_file(96U); + auto &file2 = test::create_random_file(128U); + + auto api_path1 = + fmt::format("/{}", utils::path::strip_to_file_name(file1.get_path())); + auto api_path2 = + fmt::format("/{}", utils::path::strip_to_file_name(file2.get_path())); + + create_file(provider, api_path1); + create_file(provider, api_path2); + + stop_type stop_requested{false}; + ASSERT_EQ(api_error::success, + provider.upload_file(api_path1, file1.get_path(), stop_requested)); + ASSERT_EQ(api_error::success, + provider.upload_file(api_path2, file2.get_path(), stop_requested)); + + EXPECT_EQ(api_error::success, + provider.set_item_meta(api_path1, META_SIZE, + std::to_string(*file1.size()))); + EXPECT_EQ(api_error::success, + provider.set_item_meta(api_path2, META_SIZE, + std::to_string(*file2.size()))); + + std::uint64_t mid{}; + EXPECT_EQ(api_error::success, provider.get_used_drive_space(mid)); + EXPECT_EQ(before + *file1.size() + *file2.size(), mid); + + EXPECT_EQ(api_error::success, provider.remove_file(api_path1)); + EXPECT_EQ(api_error::success, provider.remove_file(api_path2)); + + std::uint64_t after{}; + EXPECT_EQ(api_error::success, provider.get_used_drive_space(after)); + EXPECT_EQ(before, after); +} + +static void get_total_drive_space(i_provider &provider) { + fmt::println("testing|{}|{}", + app_config::get_provider_name(provider.get_provider_type()), + __FUNCTION__); + + std::uint64_t total{}; + auto res_total = provider.get_total_drive_space(total); + EXPECT_EQ(api_error::success, res_total); + + std::uint64_t used{}; + EXPECT_EQ(api_error::success, provider.get_used_drive_space(used)); + + if (total != 0U) { + EXPECT_GE(total, used); + } +} + static void run_tests(const app_config &cfg, i_provider &provider) { get_file_list(cfg, provider); - ASSERT_FALSE(::testing::Test::HasFailure()); + + get_and_set_item_meta_with_upload_file(cfg, provider); + get_and_set_item_meta2_with_upload_file(cfg, provider); + get_item_meta_fails_if_path_not_found(provider); + get_item_meta2_fails_if_path_not_found(provider); + + is_file_fails_if_not_found(provider); + is_directory_fails_if_not_found(provider); can_create_and_remove_directory(provider); can_create_and_remove_file(provider); @@ -955,34 +1415,36 @@ static void run_tests(const app_config &cfg, i_provider &provider) { get_file_fails_if_file_not_found(provider); get_file_fails_if_item_is_directory(cfg, provider); - get_file_size(provider); + get_file_size(cfg, provider); get_file_size_fails_if_path_not_found(provider); - get_filesystem_item(provider); + get_filesystem_item(cfg, provider); get_filesystem_item_root_is_directory(provider); get_filesystem_item_fails_if_file_is_not_found(provider); get_filesystem_item_fails_if_directory_is_not_found(provider); get_filesystem_item_from_source_path(cfg, provider); get_filesystem_item_from_source_path_fails_if_file_is_not_found(provider); - // TODO need to test read when file size changes for encrypt provider - /* - get_item_meta(provider); - get_item_meta2(provider); + + remove_file_fails_if_file_not_found(provider); + remove_file_fails_if_item_is_directory(provider); + remove_directory_fails_if_directory_not_found(provider); + remove_directory_fails_if_item_is_file(provider); + get_pinned_files(provider); - get_total_drive_space(provider); + remove_pin_updates_pinned_files(provider); + remove_file_updates_pinned_files(provider); + get_total_item_count(provider); get_used_drive_space(provider); - is_directory(provider); - is_file(provider); + get_total_drive_space(provider); + + // TODO need to test read when file size changes for encrypt provider + /* read_file_bytes(provider); - remove_directory(provider); - remove_file(provider); remove_item_meta(provider); rename_file(provider); - set_item_meta(provider); - set_item_meta2(provider); - upload_file(provider); */ + */ } TEST(providers_test, encrypt_provider) {