feat: add generic is_feature_supported and is_feature_enabled methods to TableConfiguration (#1405)

## What changes are proposed in this pull request?

This PR adds generic `is_feature_supported()` and `is_feature_enabled()`
methods to `TableConfiguration`, utilizing FeatureInfo added previously


## How was this change tested?
<!--
Please make sure to add test cases that check the changes thoroughly
including negative and positive cases if possible.
If it was tested in a way different from regular unit tests, please
clarify how you tested, ideally via a reproducible test documented in
the PR description.
-->

New tests

Author: DrakeLin

kernel/src/table_configuration.rs

@@ -17,7 +17,7 @@ use crate::schema::variant_utils::validate_variant_type_feature_support;
 use crate::schema::{InvariantChecker, SchemaRef};
 use crate::table_features::{
     column_mapping_mode, validate_schema_column_mapping, validate_timestamp_ntz_feature_support,
-    ColumnMappingMode, TableFeature,
+    ColumnMappingMode, EnablementCheck, FeatureInfo, FeatureType, TableFeature,
 };
 use crate::table_properties::TableProperties;
 use crate::utils::require;
@@ -435,6 +435,99 @@ impl TableConfiguration {
     pub(crate) fn should_write_row_tracking(&self) -> bool {
         self.is_row_tracking_supported() && !self.is_row_tracking_suspended()
     }
+
+    /// Returns true if the protocol uses legacy reader version (< 3)
+    #[allow(dead_code)]
+    fn is_legacy_reader_version(&self) -> bool {
+        self.protocol.min_reader_version() < 3
+    }
+
+    /// Returns true if the protocol uses legacy writer version (< 7)
+    #[allow(dead_code)]
+    fn is_legacy_writer_version(&self) -> bool {
+        self.protocol.min_writer_version() < 7
+    }
+
+    /// Helper to check if a feature is present in a feature list.
+    fn has_feature(features: Option<&[TableFeature]>, feature: &TableFeature) -> bool {
+        features
+            .map(|features| features.contains(feature))
+            .unwrap_or(false)
+    }
+
+    /// Helper method to check if a feature is supported based on its FeatureInfo.
+    /// This checks protocol versions and feature lists but does NOT check enablement properties.
+    #[allow(dead_code)]
+    fn is_feature_info_supported(&self, feature: &TableFeature, info: &FeatureInfo) -> bool {
+        match info.feature_type {
+            FeatureType::Writer => {
+                if self.is_legacy_writer_version() {
+                    // Legacy writer: protocol writer version meets minimum requirement
+                    self.protocol.min_writer_version() >= info.min_writer_version
+                } else {
+                    // Table features writer: feature is in writer_features list
+                    Self::has_feature(self.protocol.writer_features(), feature)
+                }
+            }
+            FeatureType::ReaderWriter => {
+                let reader_supported = if self.is_legacy_reader_version() {
+                    // Legacy reader: protocol reader version meets minimum requirement
+                    self.protocol.min_reader_version() >= info.min_reader_version
+                } else {
+                    // Table features reader: feature is in reader_features list
+                    Self::has_feature(self.protocol.reader_features(), feature)
+                };
+
+                let writer_supported = if self.is_legacy_writer_version() {
+                    // Legacy writer: protocol writer version meets minimum requirement
+                    self.protocol.min_writer_version() >= info.min_writer_version
+                } else {
+                    // Table features writer: feature is in writer_features list
+                    Self::has_feature(self.protocol.writer_features(), feature)
+                };
+
+                reader_supported && writer_supported
+            }
+            FeatureType::Unknown => false,
+        }
+    }
+
+    /// Helper method to check if a feature is enabled based on its FeatureInfo.
+    /// This checks both protocol support and enablement via table properties.
+    #[allow(dead_code)]
+    fn is_feature_info_enabled(&self, feature: &TableFeature, info: &FeatureInfo) -> bool {
+        if !self.is_feature_info_supported(feature, info) {
+            return false;
+        }
+
+        match info.enablement_check {
+            EnablementCheck::AlwaysIfSupported => true,
+            EnablementCheck::EnabledIf(check_fn) => check_fn(&self.table_properties),
+        }
+    }
+
+    /// Generic method to check if a feature is supported in the protocol.
+    /// This does NOT check if the feature is enabled via table properties.
+    #[allow(dead_code)]
+    pub(crate) fn is_feature_supported(&self, feature: &TableFeature) -> bool {
+        let Some(info) = feature.info() else {
+            return false;
+        };
+        self.is_feature_info_supported(feature, info)
+    }
+
+    /// Generic method to check if a feature is enabled.
+    ///
+    /// A feature is enabled if:
+    /// 1. It is supported in the protocol
+    /// 2. The enablement check passes
+    #[allow(dead_code)]
+    pub(crate) fn is_feature_enabled(&self, feature: &TableFeature) -> bool {
+        let Some(info) = feature.info() else {
+            return false;
+        };
+        self.is_feature_info_enabled(feature, info)
+    }
 }
 
 #[cfg(test)]
@@ -445,7 +538,9 @@ mod test {
 
     use crate::actions::{Metadata, Protocol};
     use crate::schema::{DataType, StructField, StructType};
-    use crate::table_features::{FeatureType, TableFeature};
+    use crate::table_features::{
+        EnablementCheck, FeatureInfo, FeatureType, KernelSupport, TableFeature,
+    };
     use crate::table_properties::TableProperties;
     use crate::utils::test_utils::assert_result_error_with_message;
     use crate::Error;
@@ -456,7 +551,7 @@ mod test {
         props_to_enable: &[&str],
         features: &[TableFeature],
     ) -> TableConfiguration {
-        create_mock_table_config_with_version(props_to_enable, features.into(), 3, 7)
+        create_mock_table_config_with_version(props_to_enable, Some(features), 3, 7)
     }
 
     fn create_mock_table_config_with_version(
@@ -479,25 +574,51 @@ mod test {
             ),
         )
         .unwrap();
-        let reader_features = features_opt.map(|features| {
-            features
+
+        let (reader_features_opt, writer_features_opt) = if let Some(features) = features_opt {
+            let reader_features = features
                 .iter()
                 .filter(|feature| matches!(feature.feature_type(), FeatureType::ReaderWriter))
-        });
-        let writer_features = features_opt.map(|features| {
-            features.iter().filter(|feature| {
-                matches!(
-                    feature.feature_type(),
-                    FeatureType::Writer | FeatureType::ReaderWriter
-                )
-            })
-        });
+                .cloned()
+                .collect::<Vec<_>>();
+            let writer_features = features
+                .iter()
+                .filter(|feature| {
+                    matches!(
+                        feature.feature_type(),
+                        FeatureType::Writer | FeatureType::ReaderWriter
+                    )
+                })
+                .cloned()
+                .collect::<Vec<_>>();
+            (
+                // Only add reader_features if reader >= 3 (non-legacy reader mode)
+                // Protocol requires Some (even if empty) when reader = 3
+                if min_reader_version >= 3 {
+                    Some(reader_features)
+                } else {
+                    None
+                },
+                // Only add writer_features if writer >= 7 (non-legacy writer mode)
+                // Protocol requires Some (even if empty) when writer = 7
+                if min_writer_version >= 7 {
+                    Some(writer_features)
+                } else {
+                    None
+                },
+            )
+        } else {
+            (None, None)
+        };
+
+        let reader_features_iter = reader_features_opt.as_ref().map(|f| f.iter());
+        let writer_features_iter = writer_features_opt.as_ref().map(|f| f.iter());
 
         let protocol = Protocol::try_new(
             min_reader_version,
             min_writer_version,
-            reader_features,
-            writer_features,
+            reader_features_iter,
+            writer_features_iter,
         )
         .unwrap();
         let table_root = Url::try_from("file:///").unwrap();
@@ -966,4 +1087,184 @@ mod test {
             "Should succeed when VARIANT is used with required features"
         );
     }
+
+    #[test]
+    fn test_is_feature_supported_returns_false_without_info() {
+        // is_feature_supported should return false for features without FeatureInfo
+        let config = create_mock_table_config(&[], &[TableFeature::DeletionVectors]);
+        assert!(!config.is_feature_supported(&TableFeature::unknown("futureFeature")));
+    }
+
+    #[test]
+    fn test_is_feature_enabled_returns_false_without_info() {
+        // is_feature_enabled should return false for features without FeatureInfo
+        let config = create_mock_table_config(&[], &[TableFeature::DeletionVectors]);
+        assert!(!config.is_feature_enabled(&TableFeature::unknown("futureFeature")));
+    }
+
+    #[test]
+    fn test_is_feature_info_supported_writer() {
+        // Use ColumnMapping (a ReaderWriter feature) with custom FeatureInfo as Writer type
+        let feature = TableFeature::ColumnMapping;
+
+        // Custom FeatureInfo that treats ColumnMapping as Writer-only with min_writer_version = 2
+        let custom_feature_info = FeatureInfo {
+            name: "columnMapping",
+            min_reader_version: 1,
+            min_writer_version: 2,
+            feature_type: FeatureType::Writer,
+            feature_requirements: &[],
+            read_support: KernelSupport::Supported,
+            write_support: KernelSupport::Supported,
+            enablement_check: EnablementCheck::AlwaysIfSupported,
+        };
+
+        // Test with legacy protocol writer v2 - should be supported
+        let config = create_mock_table_config_with_version(&[], None, 1, 2);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with legacy protocol writer v1 - should NOT be supported
+        let config = create_mock_table_config_with_version(&[], None, 1, 1);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with asymmetric: reader=2 (legacy), writer=7 (non-legacy)
+        // For this to work with a Writer-only FeatureInfo, we need a real Writer-only feature
+        // Use AppendOnly instead of ColumnMapping for the 2,7 test cases
+        let writer_only_feature = TableFeature::AppendOnly;
+        let writer_only_info = FeatureInfo {
+            name: "appendOnly",
+            min_reader_version: 1,
+            min_writer_version: 2,
+            feature_type: FeatureType::Writer,
+            feature_requirements: &[],
+            read_support: KernelSupport::Supported,
+            write_support: KernelSupport::Supported,
+            enablement_check: EnablementCheck::AlwaysIfSupported,
+        };
+
+        // reader=2 (legacy), writer=7 (non-legacy) - feature in list, should be supported
+        let config =
+            create_mock_table_config_with_version(&[], Some(&[TableFeature::AppendOnly]), 2, 7);
+        assert!(config.is_feature_info_supported(&writer_only_feature, &writer_only_info));
+
+        // reader=2 (legacy), writer=7 (non-legacy) - feature NOT in list, should NOT be supported
+        // Use ChangeDataFeed which is also a Writer-only feature
+        let config =
+            create_mock_table_config_with_version(&[], Some(&[TableFeature::ChangeDataFeed]), 2, 7);
+        assert!(!config.is_feature_info_supported(&writer_only_feature, &writer_only_info));
+
+        // Test with protocol reader=3, writer=7 (both non-legacy) - feature in list, should be supported
+        let config = create_mock_table_config(&[], &[TableFeature::ColumnMapping]);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with protocol reader=3, writer=7 (both non-legacy) - feature NOT in list, should NOT be supported
+        let config = create_mock_table_config(&[], &[TableFeature::DeletionVectors]);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+    }
+
+    #[test]
+    fn test_is_feature_info_supported_reader_writer() {
+        // Use ColumnMapping (a real ReaderWriter feature) with custom FeatureInfo
+        // ColumnMapping is a legacy feature (reader=2, writer=5) which makes it ideal for
+        // testing both legacy mode (version checks) and non-legacy mode (feature list checks)
+        let feature = TableFeature::ColumnMapping;
+
+        // Custom FeatureInfo that requires reader=2, writer=5
+        let custom_feature_info = FeatureInfo {
+            name: "columnMapping",
+            min_reader_version: 2,
+            min_writer_version: 5,
+            feature_type: FeatureType::ReaderWriter,
+            feature_requirements: &[],
+            read_support: KernelSupport::Supported,
+            write_support: KernelSupport::Supported,
+            enablement_check: EnablementCheck::AlwaysIfSupported,
+        };
+
+        // Test with sufficient versions (legacy mode) - should be supported
+        let config = create_mock_table_config_with_version(&[], None, 2, 5);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with insufficient reader version - should NOT be supported
+        let config = create_mock_table_config_with_version(&[], None, 1, 5);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with insufficient writer version - should NOT be supported
+        let config = create_mock_table_config_with_version(&[], None, 2, 4);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with asymmetric: reader=2 (legacy), writer=7 (non-legacy)
+        // ReaderWriter features CANNOT be enabled in this protocol state (protocol validation)
+        // But we still need to test that the code correctly identifies them as NOT supported
+        // Create a table with only Writer-only features (e.g., AppendOnly)
+        let config =
+            create_mock_table_config_with_version(&[], Some(&[TableFeature::AppendOnly]), 2, 7);
+        // ColumnMapping (ReaderWriter) should NOT be supported because:
+        // - reader=2 (legacy) checks version: 2 >= 2 ✓ (reader_supported = true)
+        // - writer=7 (non-legacy) checks list: ColumnMapping not in writer_features ✗ (writer_supported = false)
+        // - Result: false (requires BOTH to be true)
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with non-legacy mode (3,7) - feature in list, should be supported
+        let config = create_mock_table_config(&[], &[TableFeature::ColumnMapping]);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+
+        // Test with non-legacy mode (3,7) - feature NOT in list, should NOT be supported
+        let config = create_mock_table_config(&[], &[TableFeature::DeletionVectors]);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+    }
+
+    #[test]
+    fn test_is_feature_info_enabled_with_custom_property_check() {
+        // Create a custom feature with a property check function
+        let custom_feature_info = FeatureInfo {
+            name: "customPropertyFeature",
+            min_reader_version: 1,
+            min_writer_version: 2,
+            feature_type: FeatureType::Writer,
+            feature_requirements: &[],
+            read_support: KernelSupport::Supported,
+            write_support: KernelSupport::Supported,
+            enablement_check: EnablementCheck::EnabledIf(|props| props.append_only == Some(true)),
+        };
+
+        let feature = TableFeature::unknown("customPropertyFeature");
+
+        // Test when property check fails - should be supported but not enabled
+        let config = create_mock_table_config_with_version(&[], None, 1, 2);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+        assert!(!config.is_feature_info_enabled(&feature, &custom_feature_info));
+
+        // Test when property check passes - should be both supported and enabled
+        let config = create_mock_table_config_with_version(&["delta.appendOnly"], None, 1, 2);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+        assert!(config.is_feature_info_enabled(&feature, &custom_feature_info));
+    }
+
+    #[test]
+    fn test_is_feature_info_enabled_always_if_supported() {
+        // Create a custom feature that's always enabled if supported
+        let custom_feature_info = FeatureInfo {
+            name: "alwaysEnabledFeature",
+            min_reader_version: 1,
+            min_writer_version: 3,
+            feature_type: FeatureType::Writer,
+            feature_requirements: &[],
+            read_support: KernelSupport::Supported,
+            write_support: KernelSupport::Supported,
+            enablement_check: EnablementCheck::AlwaysIfSupported,
+        };
+
+        let feature = TableFeature::unknown("alwaysEnabledFeature");
+
+        // Test when supported - should be both supported and enabled
+        let config = create_mock_table_config_with_version(&[], None, 1, 3);
+        assert!(config.is_feature_info_supported(&feature, &custom_feature_info));
+        assert!(config.is_feature_info_enabled(&feature, &custom_feature_info));
+
+        // Test when not supported - should be neither supported nor enabled
+        let config = create_mock_table_config_with_version(&[], None, 1, 2);
+        assert!(!config.is_feature_info_supported(&feature, &custom_feature_info));
+        assert!(!config.is_feature_info_enabled(&feature, &custom_feature_info));
+    }
 }