[Unit Test] SQLite mini-ORM unit tests and cleanup #14

repertory/librepertory/src/file_manager/file_manager.cpp

@@ -355,10 +355,6 @@ auto file_manager::get_stored_downloads() const -> std::vector<json> {
   std::vector<json> ret;
   if (not provider_.is_direct_only()) {
     auto result = db::db_select{*db_.get(), resume_table}.go();
-    if (not result.ok()) {
-      return ret;
-    }
-
     while (result.has_row()) {
       try {
         std::optional<db::db_select::row> row;
@@ -382,30 +378,27 @@ auto file_manager::get_stored_downloads() const -> std::vector<json> {
 auto file_manager::handle_file_rename(const std::string &from_api_path,
                                       const std::string &to_api_path)
     -> api_error {
-  auto should_upload{false};
   std::string source_path{};
   auto file_iter = open_file_lookup_.find(from_api_path);
   if (file_iter != open_file_lookup_.end()) {
     source_path = file_iter->second->get_source_path();
   }
 
-  if (not should_upload) {
-    should_upload = upload_lookup_.contains(from_api_path);
-    if (should_upload) {
-      if (source_path.empty()) {
-        source_path = upload_lookup_.at(from_api_path)->get_source_path();
-      }
-    } else {
-      auto result = db::db_select{*db_.get(), upload_table}
-                        .column("source_path")
-                        .where("api_path")
-                        .equals(from_api_path)
-                        .go();
-      std::optional<db::db_select::row> row;
-      should_upload = result.get_row(row) && row.has_value();
-      if (should_upload && source_path.empty()) {
-        source_path = row->get_column("source_path").get_value<std::string>();
-      }
+  auto should_upload{upload_lookup_.contains(from_api_path)};
+  if (should_upload) {
+    if (source_path.empty()) {
+      source_path = upload_lookup_.at(from_api_path)->get_source_path();
+    }
+  } else {
+    auto result = db::db_select{*db_.get(), upload_table}
+                      .column("source_path")
+                      .where("api_path")
+                      .equals(from_api_path)
+                      .go();
+    std::optional<db::db_select::row> row;
+    should_upload = result.get_row(row) && row.has_value();
+    if (should_upload && source_path.empty()) {
+      source_path = row->get_column("source_path").get_value<std::string>();
     }
   }
 
@@ -570,6 +563,11 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
                     .where("api_path")
                     .equals(api_path)
                     .go();
+  if (not result.ok()) {
+    utils::error::raise_api_path_error(function_name, api_path,
+                                       api_error::error,
+                                       "failed to remove from resume table");
+  }
 
   res = provider_.remove_file(api_path);
   if (res != api_error::success) {
@@ -602,6 +600,10 @@ void file_manager::remove_upload(const std::string &api_path) {
 }
 
 void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
+  static constexpr const std::string_view function_name{
+      static_cast<const char *>(__FUNCTION__),
+  };
+
   if (provider_.is_direct_only()) {
     return;
   }
@@ -615,11 +617,21 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
                     .where("api_path")
                     .equals(api_path)
                     .go();
+  if (not result.ok()) {
+    utils::error::raise_api_path_error(function_name, api_path,
+                                       api_error::error,
+                                       "failed to remove from upload table");
+  }
 
   result = db::db_delete{*db_.get(), upload_active_table}
                .where("api_path")
                .equals(api_path)
                .go();
+  if (not result.ok()) {
+    utils::error::raise_api_path_error(
+        function_name, api_path, api_error::error,
+        "failed to remove from upload_active table");
+  }
 
   if (upload_lookup_.find(api_path) != upload_lookup_.end()) {
     upload_lookup_.at(api_path)->cancel();
@@ -964,6 +976,10 @@ void file_manager::store_resume(const i_open_file &file) {
 
 void file_manager::swap_renamed_items(std::string from_api_path,
                                       std::string to_api_path, bool directory) {
+  static constexpr const std::string_view function_name{
+      static_cast<const char *>(__FUNCTION__),
+  };
+
   auto file_iter = open_file_lookup_.find(from_api_path);
   if (file_iter != open_file_lookup_.end()) {
     auto ptr = std::move(open_file_lookup_[from_api_path]);
@@ -981,6 +997,11 @@ void file_manager::swap_renamed_items(std::string from_api_path,
                     .where("api_path")
                     .equals(from_api_path)
                     .go();
+  if (not result.ok()) {
+    utils::error::raise_api_path_error(function_name, to_api_path,
+                                       api_error::error,
+                                       "failed to update resume table");
+  }
 }
 
 void file_manager::upload_completed(const file_upload_completed &evt) {
@@ -1001,7 +1022,7 @@ void file_manager::upload_completed(const file_upload_completed &evt) {
         utils::error::raise_api_path_error(
             function_name, evt.get_api_path().get<std::string>(),
             evt.get_source().get<std::string>(),
-            "failed to remove from to upload_active table");
+            "failed to remove from upload_active table");
       }
     } else {
       bool exists{};

repertory/repertory_test/src/database_test.cpp

@@ -53,6 +53,80 @@ public:
   }
 };
 
+static void common_insert(sqlite3 &db, bool dump = false) {
+  auto query = db::db_insert{db, "table"}
+                   .column_value("column1", "test0")
+                   .column_value("column2", "test1");
+  if (dump) {
+    std::cout << query.dump() << std::endl;
+  }
+
+  auto res = query.go();
+  EXPECT_TRUE(res.ok());
+}
+
+static void common_select(sqlite3 &db, std::string value1, std::string value2,
+                          bool dump = false) {
+  auto query = db::db_select{db, "table"};
+  if (dump) {
+    std::cout << query.dump() << std::endl;
+  }
+
+  auto res = query.go();
+  EXPECT_TRUE(res.ok());
+  EXPECT_TRUE(res.has_row());
+
+  std::size_t row_count{};
+  while (res.has_row()) {
+    std::optional<db::db_select::row> row;
+    EXPECT_TRUE(res.get_row(row));
+    EXPECT_TRUE(row.has_value());
+    if (row.has_value()) {
+      auto columns = row.value().get_columns();
+      EXPECT_EQ(std::size_t(2U), columns.size());
+      EXPECT_STREQ("column1", columns[0U].get_name().c_str());
+      EXPECT_STREQ(value1.c_str(),
+                   columns[0U].get_value<std::string>().c_str());
+      EXPECT_STREQ("column2", columns[1U].get_name().c_str());
+      EXPECT_STREQ(value2.c_str(),
+                   columns[1U].get_value<std::string>().c_str());
+      for (auto &&column : columns) {
+        std::cout << column.get_index() << ':';
+        std::cout << column.get_name() << ':';
+        std::cout << column.get_value<std::string>() << std::endl;
+      }
+    }
+    ++row_count;
+  }
+
+  EXPECT_EQ(std::size_t(1U), row_count);
+}
+
+static void common_delete(sqlite3 &db, bool dump = false) {
+  {
+    auto query = db::db_delete{db, "table"};
+    if (dump) {
+      std::cout << query.dump() << std::endl;
+    }
+
+    auto res = query.go();
+    EXPECT_TRUE(res.ok());
+  }
+
+  {
+    auto query = db::db_select{db, "table"};
+    auto res = query.go();
+    EXPECT_TRUE(res.ok());
+
+    std::size_t row_count{};
+    while (res.has_row()) {
+      ++row_count;
+    }
+
+    EXPECT_EQ(std::size_t(0U), row_count);
+  }
+}
+
 TEST_F(database_test, db_delete_query) {
   auto query = db::db_delete{*db3.get(), "table"};
   auto query_str = query.dump();
@@ -143,23 +217,47 @@ TEST_F(database_test, db_update_query) {
       query_str.c_str());
 }
 
-// auto res = query.go();
-//
-// EXPECT_TRUE(res.ok());
-// EXPECT_TRUE(res.has_row());
-// std::size_t row_count{};
-// while (res.has_row()) {
-//   std::optional<db::db_select::row> row;
-//   EXPECT_TRUE(res.get_row(row));
-//   EXPECT_TRUE(row.has_value());
-//   if (row.has_value()) {
-//     for (const auto &column : row.value().get_columns()) {
-//       std::cout << column.get_index() << ':';
-//       std::cout << column.get_name() << ':';
-//       std::cout << column.get_value<std::string>() << std::endl;
-//     }
-//   }
-//   ++row_count;
-// }
-// EXPECT_EQ(std::size_t(1U), row_count);
+TEST_F(database_test, insert_select_delete) {
+  common_insert(*db3.get(), true);
+
+  common_select(*db3.get(), "test0", "test1", true);
+
+  common_delete(*db3.get(), true);
+}
+
+TEST_F(database_test, insert_update_delete) {
+  common_insert(*db3.get());
+
+  {
+    auto query = db::db_update{*db3.get(), "table"}
+                     .column_value("column1", "moose")
+                     .where("column1")
+                     .equals("test0");
+    std::cout << query.dump() << std::endl;
+    auto res = query.go();
+    EXPECT_TRUE(res.ok());
+  }
+
+  common_select(*db3.get(), "moose", "test1");
+
+  common_delete(*db3.get());
+}
+
+TEST_F(database_test, insert_or_replace_and_delete) {
+  common_insert(*db3.get());
+
+  {
+    auto query = db::db_insert{*db3.get(), "table"}
+                     .or_replace()
+                     .column_value("column1", "test0")
+                     .column_value("column2", "moose");
+    std::cout << query.dump() << std::endl;
+    auto res = query.go();
+    EXPECT_TRUE(res.ok());
+  }
+
+  common_select(*db3.get(), "test0", "moose");
+
+  common_delete(*db3.get());
+}
 } // namespace repertory