feat: RegisterTable support for InMemoryCatalog

Author: shuxu.li

test/in_memory_catalog_test.cc

@@ -19,6 +19,8 @@
 
 #include "iceberg/catalog/in_memory_catalog.h"
 
+#include <filesystem>
+
 #include <arrow/filesystem/localfs.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -27,17 +29,13 @@
 #include "iceberg/table.h"
 #include "iceberg/table_metadata.h"
 #include "matchers.h"
-#include "temp_file_test_base.h"
 #include "test_common.h"
 
 namespace iceberg {
 
 class InMemoryCatalogTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    // generate a unique temporary file path for the test
-    temp_filepath_ = GenerateUniqueTempFilePathWithSuffix(".metadata.json");
-
     file_io_ = std::make_shared<iceberg::arrow::ArrowFileSystemFileIO>(
         std::make_shared<::arrow::fs::LocalFileSystem>());
     std::unordered_map<std::string, std::string> properties = {{"prop1", "val1"}};
@@ -47,14 +45,38 @@ class InMemoryCatalogTest : public ::testing::Test {
 
   void TearDown() override {
     // Clean up the temporary files created for the table metadata
+    for (const auto& path : created_temp_paths_) {
+      std::error_code ec;
+      if (std::filesystem::is_directory(path, ec)) {
+        std::filesystem::remove_all(path, ec);
+      } else {
+        std::filesystem::remove(path, ec);
+      }
+    }
+  }
+
+  std::string GenerateTestTableLocation(std::string table_name) {
+    std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
+    const auto info = ::testing::UnitTest::GetInstance()->current_test_info();
+    auto table_location = std::format("{}iceberg_test_{}_{}/{}/", temp_dir.string(),
+                                      info->test_suite_name(), info->name(), table_name);
+    // generate a unique directory for the table
     std::error_code ec;
-    std::filesystem::remove_all(temp_filepath_, ec);
+    std::filesystem::create_directories(table_location, ec);
+    if (ec) {
+      throw std::runtime_error(
+          std::format("Failed to create temporary directory: {}, error message: {}",
+                      table_location, ec.message()));
+    }
+
+    created_temp_paths_.push_back(table_location);
+    return table_location;
   }
 
-  // Used to generate a unique temporary metadata path for the test table
-  std::string temp_filepath_;
   std::shared_ptr<FileIO> file_io_;
   std::shared_ptr<InMemoryCatalog> catalog_;
+  // Used to store temporary paths created during the test
+  std::vector<std::string> created_temp_paths_;
 };
 
 TEST_F(InMemoryCatalogTest, CatalogName) {
@@ -82,10 +104,12 @@ TEST_F(InMemoryCatalogTest, RegisterTable) {
   std::unique_ptr<TableMetadata> metadata;
   ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
 
-  auto status = TableMetadataUtil::Write(*file_io_, temp_filepath_, *metadata);
+  auto table_location = GenerateTestTableLocation(tableIdent.name);
+  auto metadata_location = std::format("{}v1.metadata.json", table_location);
+  auto status = TableMetadataUtil::Write(*file_io_, metadata_location, *metadata);
   EXPECT_THAT(status, IsOk());
 
-  auto table = catalog_->RegisterTable(tableIdent, temp_filepath_);
+  auto table = catalog_->RegisterTable(tableIdent, metadata_location);
   EXPECT_THAT(table, IsOk());
   ASSERT_EQ(table.value()->name().name, "t1");
   ASSERT_EQ(table.value()->location(), "s3://bucket/test/location");

test/temp_file_test_base.h

@@ -31,46 +31,6 @@
 
 namespace iceberg {
 
-/// \brief Get the test name for inclusion in the filename
-inline std::string TestInfo() {
-  if (const auto info = ::testing::UnitTest::GetInstance()->current_test_info(); info) {
-    return std::format("{}_{}", info->test_suite_name(), info->name());
-  }
-  return "unknown_test";
-}
-
-/// \brief Helper to generate a random alphanumeric string for unique filenames
-inline std::string GenerateRandomString(size_t length) {
-  const std::string_view chars =
-      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  std::uniform_int_distribution<> dist(0, static_cast<int>(chars.size() - 1));
-
-  std::string result;
-  result.reserve(length);
-  for (size_t i = 0; i < length; ++i) {
-    result += chars[dist(gen)];
-  }
-  return result;
-}
-
-/// \brief Generates a unique temporary filepath that works across platforms
-inline std::string GenerateUniqueTempFilePath() {
-  std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
-  std::string file_name =
-      std::format("iceberg_test_{}_{}.tmp", TestInfo(), GenerateRandomString(8));
-  return (temp_dir / file_name).string();
-}
-
-/// \brief Create a temporary filepath with the specified suffix/extension
-inline std::string GenerateUniqueTempFilePathWithSuffix(const std::string& suffix) {
-  std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
-  std::string file_name =
-      std::format("iceberg_test_{}_{}{}", TestInfo(), GenerateRandomString(8), suffix);
-  return (temp_dir / file_name).string();
-}
-
 /// A base class for tests that need to create and manage temporary files.
 /// Provides utilities for creating platform-independent temporary files
 /// and ensures proper cleanup after tests run.
@@ -123,6 +83,46 @@ class TempFileTestBase : public ::testing::Test {
     }
   }
 
+  /// \brief Generates a unique temporary filepath that works across platforms
+  std::string GenerateUniqueTempFilePath() const {
+    std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
+    std::string file_name =
+        std::format("iceberg_test_{}_{}.tmp", TestInfo(), GenerateRandomString(8));
+    return (temp_dir / file_name).string();
+  }
+
+  /// \brief Create a temporary filepath with the specified suffix/extension
+  std::string GenerateUniqueTempFilePathWithSuffix(const std::string& suffix) {
+    std::filesystem::path temp_dir = std::filesystem::temp_directory_path();
+    std::string file_name =
+        std::format("iceberg_test_{}_{}{}", TestInfo(), GenerateRandomString(8), suffix);
+    return (temp_dir / file_name).string();
+  }
+
+  /// \brief Helper to generate a random alphanumeric string for unique filenames
+  std::string GenerateRandomString(size_t length) const {
+    const std::string_view chars =
+        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<> dist(0, static_cast<int>(chars.size() - 1));
+
+    std::string result;
+    result.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      result += chars[dist(gen)];
+    }
+    return result;
+  }
+
+  /// \brief Get the test name for inclusion in the filename
+  std::string TestInfo() const {
+    if (const auto info = ::testing::UnitTest::GetInstance()->current_test_info(); info) {
+      return std::format("{}_{}", info->test_suite_name(), info->name());
+    }
+    return "unknown_test";
+  }
+
   /// \brief Creates a new temporary filepath and registers it for cleanup
   std::string CreateNewTempFilePath() {
     std::string filepath = GenerateUniqueTempFilePath();