[unit test] Complete all providers unit tests #12

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

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->set_item_meta(api_path, {
-                                       { META_GID,
+                                          {META_UID, std::to_string(getuid())},
-                                         std::to_string(getgid()) }});
+                                          {META_GID, std::to_string(getgid())},
+                                      });
     std::this_thread::sleep_for(SLEEP_SECONDS);
 
     unlink_file_and_test(file_path);

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{};
+    auto source_path =
-    std::string marker;
+        utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"});
-    auto res = provider.get_file_list(list, marker);
+    auto src_size = utils::file::file{source_path}.size();
-    ASSERT_EQ(res, api_error::success);
+    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 api_path{};
-    std::string marker;
+    EXPECT_EQ(
-    auto res = provider.get_file_list(list, marker);
+        api_error::success,
-    ASSERT_EQ(api_error::success, res);
+        provider.get_api_path_from_source(
-    ASSERT_FALSE(list.empty());
+            utils::path::combine(cfg.get_encrypt_config().path, {"test.txt"}),
-
+            api_path));
-    auto api_path = list.front().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,
+    auto src_size = utils::file::file{source_path}.size();
-                                                                          true);
+    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
+
-  /*
+  remove_file_fails_if_file_not_found(provider);
-  get_item_meta(provider);
+  remove_file_fails_if_item_is_directory(provider);
-  get_item_meta2(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);
+  get_total_drive_space(provider);
-  is_file(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) {