refactor(test): unify test resource

src/iceberg/test/CMakeLists.txt

@@ -85,8 +85,7 @@ add_iceberg_test(table_test
                  table_test.cc
                  table_metadata_builder_test.cc
                  table_requirement_test.cc
-                 table_update_test.cc
-                 test_common.cc)
+                 table_update_test.cc)
 
 add_iceberg_test(expression_test
                  SOURCES
@@ -98,7 +97,6 @@ add_iceberg_test(expression_test
 
 add_iceberg_test(json_serde_test
                  SOURCES
-                 test_common.cc
                  json_internal_test.cc
                  metadata_serde_test.cc
                  schema_json_test.cc)
@@ -126,8 +124,7 @@ if(ICEBERG_BUILD_BUNDLE)
                    avro_schema_test.cc
                    avro_stream_test.cc
                    manifest_list_versions_test.cc
-                   manifest_writer_versions_test.cc
-                   test_common.cc)
+                   manifest_writer_versions_test.cc)
 
   add_iceberg_test(arrow_test
                    USE_BUNDLE
@@ -138,18 +135,13 @@ if(ICEBERG_BUILD_BUNDLE)
                    metadata_io_test.cc
                    struct_like_test.cc)
 
-  add_iceberg_test(catalog_test
-                   USE_BUNDLE
-                   SOURCES
-                   test_common.cc
-                   in_memory_catalog_test.cc)
+  add_iceberg_test(catalog_test USE_BUNDLE SOURCES in_memory_catalog_test.cc)
 
   add_iceberg_test(eval_expr_test
                    USE_BUNDLE
                    SOURCES
                    eval_expr_test.cc
-                   evaluator_test.cc
-                   test_common.cc)
+                   evaluator_test.cc)
 
   add_iceberg_test(parquet_test
                    USE_BUNDLE

src/iceberg/test/in_memory_catalog_test.cc

@@ -31,15 +31,14 @@
 #include "iceberg/table_metadata.h"
 #include "iceberg/test/matchers.h"
 #include "iceberg/test/mock_catalog.h"
-#include "iceberg/test/test_common.h"
+#include "iceberg/test/test_resource.h"
 
 namespace iceberg {
 
 class InMemoryCatalogTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    file_io_ = std::make_shared<iceberg::arrow::ArrowFileSystemFileIO>(
-        std::make_shared<::arrow::fs::LocalFileSystem>());
+    file_io_ = arrow::ArrowFileSystemFileIO::MakeLocalFileIO();
     std::unordered_map<std::string, std::string> properties = {{"prop1", "val1"}};
     catalog_ = std::make_shared<InMemoryCatalog>("test_catalog", file_io_,
                                                  "/tmp/warehouse/", properties);
@@ -103,8 +102,8 @@ TEST_F(InMemoryCatalogTest, TableExists) {
 TEST_F(InMemoryCatalogTest, RegisterTable) {
   TableIdentifier tableIdent{.ns = {}, .name = "t1"};
 
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(auto metadata,
+                         ReadTableMetadataFromResource("TableMetadataV2Valid.json"));
 
   auto table_location = GenerateTestTableLocation(tableIdent.name);
   auto metadata_location = std::format("{}v1.metadata.json", table_location);

src/iceberg/test/meson.build

@@ -52,7 +52,6 @@ iceberg_tests = {
             'table_requirement_test.cc',
             'table_test.cc',
             'table_update_test.cc',
-            'test_common.cc',
         ),
     },
     'expression_test': {
@@ -69,7 +68,6 @@ iceberg_tests = {
             'json_internal_test.cc',
             'metadata_serde_test.cc',
             'schema_json_test.cc',
-            'test_common.cc',
         ),
     },
     'util_test': {

src/iceberg/test/metadata_serde_test.cc

@@ -32,7 +32,7 @@
 #include "iceberg/statistics_file.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/test/matchers.h"
-#include "iceberg/test/test_common.h"
+#include "iceberg/test/test_resource.h"
 #include "iceberg/transform.h"
 #include "iceberg/type.h"
 
@@ -42,7 +42,7 @@ namespace {
 
 void ReadTableMetadataExpectError(const std::string& file_name,
                                   const std::string& expected_error_substr) {
-  auto result = ReadTableMetadata(file_name);
+  auto result = ReadTableMetadataFromResource(file_name);
   ASSERT_FALSE(result.has_value()) << "Expected parsing to fail for " << file_name;
   EXPECT_THAT(result, HasErrorMessage(expected_error_substr));
 }
@@ -90,8 +90,8 @@ void AssertSnapshotById(const TableMetadata& metadata, int64_t snapshot_id,
 }  // namespace
 
 TEST(MetadataSerdeTest, DeserializeV1Valid) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(auto metadata,
+                         ReadTableMetadataFromResource("TableMetadataV1Valid.json"));
 
   auto expected_schema = std::make_shared<Schema>(
       std::vector<SchemaField>{SchemaField::MakeRequired(1, "x", int64()),
@@ -132,8 +132,8 @@ TEST(MetadataSerdeTest, DeserializeV1Valid) {
 }
 
 TEST(MetadataSerdeTest, DeserializeV2Valid) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(auto metadata,
+                         ReadTableMetadataFromResource("TableMetadataV2Valid.json"));
 
   auto expected_schema_1 = std::make_shared<Schema>(
       std::vector<SchemaField>{SchemaField(/*field_id=*/1, "x", int64(),
@@ -224,9 +224,8 @@ TEST(MetadataSerdeTest, DeserializeV2Valid) {
 }
 
 TEST(MetadataSerdeTest, DeserializeV2ValidMinimal) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(
-      ReadTableMetadata("TableMetadataV2ValidMinimal.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(
+      auto metadata, ReadTableMetadataFromResource("TableMetadataV2ValidMinimal.json"));
 
   auto expected_schema = std::make_shared<Schema>(
       std::vector<SchemaField>{SchemaField::MakeRequired(1, "x", int64()),
@@ -281,9 +280,8 @@ TEST(MetadataSerdeTest, DeserializeV2ValidMinimal) {
 }
 
 TEST(MetadataSerdeTest, DeserializeStatisticsFiles) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(
-      ReadTableMetadata("TableMetadataStatisticsFiles.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(
+      auto metadata, ReadTableMetadataFromResource("TableMetadataStatisticsFiles.json"));
 
   auto expected_schema = std::make_shared<Schema>(
       std::vector<SchemaField>{SchemaField(/*field_id=*/1, "x", int64(),
@@ -353,9 +351,9 @@ TEST(MetadataSerdeTest, DeserializeStatisticsFiles) {
 }
 
 TEST(MetadataSerdeTest, DeserializePartitionStatisticsFiles) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(
-      ReadTableMetadata("TableMetadataPartitionStatisticsFiles.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(
+      auto metadata,
+      ReadTableMetadataFromResource("TableMetadataPartitionStatisticsFiles.json"));
 
   TableMetadata expected{
       .format_version = 2,

src/iceberg/test/table_test.cc

@@ -32,13 +32,14 @@
 #include "iceberg/schema.h"
 #include "iceberg/snapshot.h"
 #include "iceberg/table_metadata.h"
-#include "iceberg/test/test_common.h"
+#include "iceberg/test/matchers.h"
+#include "iceberg/test/test_resource.h"
 
 namespace iceberg {
 
 TEST(Table, TableV1) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV1Valid.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(auto metadata,
+                         ReadTableMetadataFromResource("TableMetadataV1Valid.json"));
   TableIdentifier tableIdent{.ns = {}, .name = "test_table_v1"};
   Table table(tableIdent, std::move(metadata), "s3://bucket/test/location/meta/", nullptr,
               nullptr);
@@ -76,8 +77,8 @@ TEST(Table, TableV1) {
 }
 
 TEST(Table, TableV2) {
-  std::unique_ptr<TableMetadata> metadata;
-  ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
+  ICEBERG_UNWRAP_OR_FAIL(auto metadata,
+                         ReadTableMetadataFromResource("TableMetadataV2Valid.json"));
   TableIdentifier tableIdent{.ns = {}, .name = "test_table_v2"};
 
   Table table(tableIdent, std::move(metadata), "s3://bucket/test/location/meta/", nullptr,

src/iceberg/test/test_common.h → src/iceberg/test/test_resource.h

@@ -19,25 +19,39 @@
 
 #pragma once
 
+#include <filesystem>
+#include <fstream>
 #include <memory>
+#include <sstream>
 #include <string>
 
+#include <nlohmann/json.hpp>
+
+#include "iceberg/json_internal.h"
 #include "iceberg/result.h"
-#include "iceberg/type_fwd.h"
+#include "iceberg/table_metadata.h"
+#include "iceberg/test/test_config.h"
 
 namespace iceberg {
 
 /// \brief Get the full path to a resource file in the test resources directory
-std::string GetResourcePath(const std::string& file_name);
-
-/// \brief Read a JSON file from the test resources directory
-void ReadJsonFile(const std::string& file_name, std::string* content);
-
-/// \brief Read table metadata from a JSON file in the test resources directory
-void ReadTableMetadata(const std::string& file_name,
-                       std::unique_ptr<TableMetadata>* metadata);
+static std::string GetResourcePath(const std::string& file_name) {
+  return std::string(ICEBERG_TEST_RESOURCES) + "/" + file_name;
+}
 
 /// \brief Read table metadata from a JSON file and return the Result directly
-Result<std::unique_ptr<TableMetadata>> ReadTableMetadata(const std::string& file_name);
+static Result<std::unique_ptr<TableMetadata>> ReadTableMetadataFromResource(
+    const std::string& file_name) {
+  std::filesystem::path path{GetResourcePath(file_name)};
+  if (!std::filesystem::exists(path)) {
+    return InvalidArgument("File does not exist: {}", path.string());
+  }
+
+  std::ifstream file(path);
+  std::stringstream buffer;
+  buffer << file.rdbuf();
+
+  return TableMetadataFromJson(nlohmann::json::parse(buffer.str()));
+}
 
 }  // namespace iceberg