[unit test] Complete all providers unit tests #12

repertory/repertory_test/src/providers_test.cpp

@@ -698,6 +698,10 @@ static void get_file_fails_if_item_is_directory(const app_config &cfg,
 }
 
 static void get_file_list(const app_config &cfg, i_provider &provider) {
+  fmt::println("testing|{}|{}",
+               app_config::get_provider_name(provider.get_provider_type()),
+               __FUNCTION__);
+
   api_file_list list{};
   std::string marker;
   EXPECT_EQ(api_error::success, provider.get_file_list(list, marker));
@@ -724,6 +728,128 @@ static void get_file_list(const app_config &cfg, i_provider &provider) {
   }
 }
 
+static void get_file_size(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);
+
+    ASSERT_FALSE(list.empty());
+
+    std::uint64_t size{};
+    res = provider.get_file_size(list.front().api_path, size);
+    EXPECT_EQ(api_error::success, res);
+    EXPECT_EQ(utils::encryption::encrypting_reader::calculate_encrypted_size(
+                  7U, true),
+              size);
+    return;
+  }
+
+  auto &file = test::create_random_file(128U);
+  auto api_path =
+      fmt::format("/{}", utils::path::strip_to_file_name(file.get_path()));
+
+  stop_type stop_requested{false};
+  auto res = provider.upload_file(api_path, file.get_path(), stop_requested);
+  ASSERT_EQ(api_error::success, res);
+
+  std::uint64_t size{};
+  res = provider.get_file_size(api_path, size);
+  EXPECT_EQ(api_error::success, res);
+  EXPECT_EQ(*file.size(), size);
+
+  res = provider.remove_file(api_path);
+  EXPECT_EQ(api_error::success, res);
+}
+
+static void get_file_size_fails_if_path_not_found(i_provider &provider) {
+  fmt::println("testing|{}|{}",
+               app_config::get_provider_name(provider.get_provider_type()),
+               __FUNCTION__);
+
+  std::uint64_t size{};
+  auto res = provider.get_file_size("/cow/moose/dog/chicken", size);
+
+  EXPECT_EQ(api_error::item_not_found, res);
+  EXPECT_EQ(0U, size);
+}
+
+static void get_filesystem_item(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;
+
+    filesystem_item fsi{};
+    res = provider.get_filesystem_item(api_path, fsi);
+    EXPECT_EQ(api_error::success, res);
+
+    EXPECT_FALSE(fsi.is_directory);
+    EXPECT_EQ(api_path, fsi.api_path);
+
+    std::uint64_t size{};
+    res = provider.get_file_size(api_path, size);
+    ASSERT_EQ(api_error::success, res);
+    EXPECT_EQ(size, fsi.file_size);
+
+    return;
+  }
+
+  auto &src = test::create_random_file(128U);
+  auto api_path =
+      fmt::format("/{}", utils::path::strip_to_file_name(src.get_path()));
+
+  stop_type stop_requested{false};
+  auto res = provider.upload_file(api_path, src.get_path(), stop_requested);
+  ASSERT_EQ(api_error::success, res);
+
+  filesystem_item fsi{};
+  res = provider.get_filesystem_item(api_path, fsi);
+  EXPECT_EQ(api_error::success, res);
+  EXPECT_EQ(api_path, fsi.api_path);
+  EXPECT_FALSE(fsi.is_directory);
+  EXPECT_EQ(*src.size(), fsi.file_size);
+
+  res = provider.remove_file(api_path);
+  EXPECT_EQ(api_error::success, res);
+}
+
+static void get_filesystem_item_root_is_directory(i_provider &provider) {
+  fmt::println("testing|{}|{}",
+               app_config::get_provider_name(provider.get_provider_type()),
+               __FUNCTION__);
+
+  filesystem_item fsi{};
+  auto res = provider.get_filesystem_item("/", fsi);
+
+  EXPECT_EQ(api_error::success, res);
+  EXPECT_TRUE(fsi.is_directory);
+  EXPECT_EQ("/", fsi.api_path);
+}
+
+static void get_filesystem_item_fails_if_path_not_found(i_provider &provider) {
+  fmt::println("testing|{}|{}",
+               app_config::get_provider_name(provider.get_provider_type()),
+               __FUNCTION__);
+
+  filesystem_item fsi{};
+  auto res = provider.get_filesystem_item("/cow/moose/dog/chicken", fsi);
+  EXPECT_EQ(api_error::item_not_found, res);
+}
+
 static void run_tests(const app_config &cfg, i_provider &provider) {
   get_file_list(cfg, provider);
   ASSERT_FALSE(::testing::Test::HasFailure());
@@ -755,10 +881,15 @@ 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);
 
-  // TODO need to test read when file size changes for encrypt provider
-  /* get_file_list(provider);
   get_file_size(provider);
+  get_file_size_fails_if_path_not_found(provider);
+
   get_filesystem_item(provider);
+  get_filesystem_item_root_is_directory(provider);
+  get_filesystem_item_fails_if_path_not_found(provider);
+
+  // TODO need to test read when file size changes for encrypt provider
+  /*
   get_filesystem_item_and_file(provider);
   get_filesystem_item_from_source_path(provider);
   get_item_meta(provider);
@@ -825,7 +956,7 @@ TEST(providers_test, encrypt_provider) {
   event_system::instance().stop();
 }
 
-TEST(providers_test, s3_provider) {
+TEST(providers_test, s3_provider_unencrypted) {
   auto config_path =
       utils::path::combine(test::get_test_output_dir(), {"provider", "s3"});
 
@@ -838,7 +969,54 @@ TEST(providers_test, s3_provider) {
       app_config src_cfg(
           provider_type::s3,
           utils::path::combine(test::get_test_config_dir(), {"s3"}));
-      cfg.set_s3_config(src_cfg.get_s3_config());
+      auto s3_cfg = src_cfg.get_s3_config();
+      s3_cfg.encryption_token = "";
+      cfg.set_s3_config(s3_cfg);
+    }
+
+    curl_comm comm{cfg.get_s3_config()};
+
+    s3_provider provider{cfg, comm};
+    file_manager mgr(cfg, provider);
+
+    EXPECT_TRUE(provider.start(
+        [&provider](bool directory, api_file &file) -> api_error {
+          return provider_meta_handler(provider, directory, file);
+        },
+        &mgr));
+
+    mgr.start();
+
+    EXPECT_EQ(provider_type::s3, provider.get_provider_type());
+    EXPECT_FALSE(provider.is_read_only());
+    EXPECT_TRUE(provider.is_online());
+    EXPECT_FALSE(provider.is_rename_supported());
+
+    run_tests(cfg, provider);
+
+    provider.stop();
+    mgr.stop();
+  }
+
+  event_system::instance().stop();
+}
+
+TEST(providers_test, s3_provider_encrypted) {
+  auto config_path =
+      utils::path::combine(test::get_test_output_dir(), {"provider", "s3"});
+
+  console_consumer consumer{};
+  event_system::instance().start();
+
+  {
+    app_config cfg(provider_type::s3, config_path);
+    {
+      app_config src_cfg(
+          provider_type::s3,
+          utils::path::combine(test::get_test_config_dir(), {"s3"}));
+      auto s3_cfg = src_cfg.get_s3_config();
+      s3_cfg.encryption_token = "cow_moose_doge_chicken";
+      cfg.set_s3_config(s3_cfg);
     }
 
     curl_comm comm{cfg.get_s3_config()};