Add unit tests for PendingUpdate interface

Added comprehensive unit tests for the PendingUpdate interface including:
- Basic Apply() success and validation failure scenarios
- Commit() success and failure scenarios
- Base class polymorphism to verify PendingUpdate works correctly

These tests verify the interface compiles correctly and can be properly
implemented by subclasses.

Also restored builder pattern context in documentation to explain why
constructors are protected.

Renamed PendingUpdateBase to PendingUpdate and PendingUpdate<T> to
PendingUpdateTyped<T> for cleaner API. Now Transaction can use
std::vector<std::unique_ptr<PendingUpdate>> which is more intuitive.

Author: shangxinli

src/iceberg/pending_update.h

@@ -28,17 +28,17 @@
 
 namespace iceberg {
 
-/// \brief Non-template base class for table metadata changes
+/// \brief Base class for table metadata changes using builder pattern
 ///
 /// This base class allows storing different types of PendingUpdate operations
 /// in the same collection (e.g., in Transaction). It provides the common Commit()
 /// interface that all updates share.
 ///
 /// This matches the Java Iceberg pattern where BaseTransaction stores a
 /// List<PendingUpdate> without type parameters.
-class ICEBERG_EXPORT PendingUpdateBase {
+class ICEBERG_EXPORT PendingUpdate {
  public:
-  virtual ~PendingUpdateBase() = default;
+  virtual ~PendingUpdate() = default;
 
   /// \brief Apply and commit the pending changes to the table
   ///
@@ -53,18 +53,18 @@ class ICEBERG_EXPORT PendingUpdateBase {
   virtual Status Commit() = 0;
 
   // Non-copyable, movable
-  PendingUpdateBase(const PendingUpdateBase&) = delete;
-  PendingUpdateBase& operator=(const PendingUpdateBase&) = delete;
-  PendingUpdateBase(PendingUpdateBase&&) noexcept = default;
-  PendingUpdateBase& operator=(PendingUpdateBase&&) noexcept = default;
+  PendingUpdate(const PendingUpdate&) = delete;
+  PendingUpdate& operator=(const PendingUpdate&) = delete;
+  PendingUpdate(PendingUpdate&&) noexcept = default;
+  PendingUpdate& operator=(PendingUpdate&&) noexcept = default;
 
  protected:
-  PendingUpdateBase() = default;
+  PendingUpdate() = default;
 };
 
-/// \brief Template class for type-safe table metadata changes
+/// \brief Template class for type-safe table metadata changes using builder pattern
 ///
-/// PendingUpdate extends PendingUpdateBase with a type-safe Apply() method that
+/// PendingUpdateTyped extends PendingUpdate with a type-safe Apply() method that
 /// returns the specific result type for each operation. Subclasses implement
 /// specific types of table updates such as schema changes, property updates, or
 /// snapshot-producing operations like appends and deletes.
@@ -74,9 +74,9 @@ class ICEBERG_EXPORT PendingUpdateBase {
 ///
 /// \tparam T The type of result returned by Apply()
 template <typename T>
-class ICEBERG_EXPORT PendingUpdate : public PendingUpdateBase {
+class ICEBERG_EXPORT PendingUpdateTyped : public PendingUpdate {
  public:
-  ~PendingUpdate() override = default;
+  ~PendingUpdateTyped() override = default;
 
   /// \brief Apply the pending changes and return the uncommitted result
   ///
@@ -88,7 +88,7 @@ class ICEBERG_EXPORT PendingUpdate : public PendingUpdateBase {
   virtual Result<T> Apply() = 0;
 
  protected:
-  PendingUpdate() = default;
+  PendingUpdateTyped() = default;
 };
 
 }  // namespace iceberg

src/iceberg/test/CMakeLists.txt

@@ -83,7 +83,8 @@ add_iceberg_test(table_test
                  json_internal_test.cc
                  table_test.cc
                  schema_json_test.cc
-                 table_metadata_builder_test.cc)
+                 table_metadata_builder_test.cc
+                 pending_update_test.cc)
 
 add_iceberg_test(expression_test
                  SOURCES

src/iceberg/test/pending_update_test.cc

@@ -0,0 +1,99 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/pending_update.h"
+
+#include <gtest/gtest.h>
+
+#include "iceberg/result.h"
+#include "iceberg/test/matchers.h"
+
+namespace iceberg {
+
+// Mock implementation for testing the interface
+class MockSnapshot {};
+
+class MockPendingUpdate : public PendingUpdateTyped<MockSnapshot> {
+ public:
+  MockPendingUpdate() = default;
+
+  Result<MockSnapshot> Apply() override {
+    if (should_fail_) {
+      return ValidationFailed("Mock validation failed");
+    }
+    return MockSnapshot{};
+  }
+
+  Status Commit() override {
+    if (should_fail_commit_) {
+      return CommitFailed("Mock commit failed");
+    }
+    apply_called_ = true;
+    commit_called_ = true;
+    return {};
+  }
+
+  void SetShouldFail(bool fail) { should_fail_ = fail; }
+  void SetShouldFailCommit(bool fail) { should_fail_commit_ = fail; }
+  bool ApplyCalled() const { return apply_called_; }
+  bool CommitCalled() const { return commit_called_; }
+
+ private:
+  bool should_fail_ = false;
+  bool should_fail_commit_ = false;
+  bool apply_called_ = false;
+  bool commit_called_ = false;
+};
+
+TEST(PendingUpdateTest, ApplySuccess) {
+  MockPendingUpdate update;
+  auto result = update.Apply();
+  EXPECT_THAT(result, IsOk());
+}
+
+TEST(PendingUpdateTest, ApplyValidationFailed) {
+  MockPendingUpdate update;
+  update.SetShouldFail(true);
+  auto result = update.Apply();
+  EXPECT_THAT(result, IsError(ErrorKind::kValidationFailed));
+  EXPECT_THAT(result, HasErrorMessage("Mock validation failed"));
+}
+
+TEST(PendingUpdateTest, CommitSuccess) {
+  MockPendingUpdate update;
+  auto status = update.Commit();
+  EXPECT_THAT(status, IsOk());
+  EXPECT_TRUE(update.CommitCalled());
+}
+
+TEST(PendingUpdateTest, CommitFailed) {
+  MockPendingUpdate update;
+  update.SetShouldFailCommit(true);
+  auto status = update.Commit();
+  EXPECT_THAT(status, IsError(ErrorKind::kCommitFailed));
+  EXPECT_THAT(status, HasErrorMessage("Mock commit failed"));
+}
+
+TEST(PendingUpdateTest, BaseClassPolymorphism) {
+  std::unique_ptr<PendingUpdate> base_ptr = std::make_unique<MockPendingUpdate>();
+  auto status = base_ptr->Commit();
+  EXPECT_THAT(status, IsOk());
+}
+
+}  // namespace iceberg

src/iceberg/type_fwd.h

@@ -154,9 +154,9 @@ class TableRequirement;
 class TableMetadataBuilder;
 class TableUpdateContext;
 
-class PendingUpdateBase;
-template <typename T>
 class PendingUpdate;
+template <typename T>
+class PendingUpdateTyped;
 
 /// ----------------------------------------------------------------------------
 /// TODO: Forward declarations below are not added yet.