feat: add integration and pipeline tests for set_filter_state

- Add 3 integration tests for xDS config parsing (Istio waypoint)
- Add 5 HTTP pipeline tests for filter application
- Fix skip_if_empty to handle '-' default values
- Add :authority and :method pseudo-headers to RequestContext

Signed-off-by: Eeshu-Yadav <[email protected]>

Author: Eeshu-Yadav

orion-configuration/src/config/network_filters/http_connection_manager/http_filters.rs

@@ -67,7 +67,7 @@ pub enum HttpFilterType {
     /// Istio peer metadata filter (parsed but may not be executed)
     PeerMetadata(peer_metadata::PeerMetadataConfig),
     /// Envoy set filter state filter (parsed but may not be executed)
-    SetFilterState(set_filter_state::SetFilterStateConfig),
+    SetFilterState(set_filter_state::SetFilterState),
 }
 
 #[cfg(feature = "envoy-conversions")]
@@ -90,7 +90,6 @@ mod envoy_conversions {
                     local_ratelimit::v3::LocalRateLimit as EnvoyLocalRateLimit,
                     rbac::v3::{Rbac as EnvoyRbac, RbacPerRoute as EnvoyRbacPerRoute},
                     router::v3::Router as EnvoyRouter,
-                    set_filter_state::v3::Config as EnvoySetFilterStateConfig,
                 },
                 network::http_connection_manager::v3::{
                     http_filter::ConfigType as EnvoyConfigType, HttpFilter as EnvoyHttpFilter,
@@ -159,7 +158,7 @@ mod envoy_conversions {
         Router(EnvoyRouter),
         Ignored,
         PeerMetadata(super::peer_metadata::PeerMetadataConfig),
-        SetFilterState(super::set_filter_state::SetFilterStateConfig),
+        SetFilterState(super::set_filter_state::SetFilterState),
     }
 
     impl TryFrom<Any> for SupportedEnvoyFilter {
@@ -179,8 +178,8 @@ mod envoy_conversions {
                         url if url == super::peer_metadata::PeerMetadataConfig::TYPE_URL => {
                             super::peer_metadata::PeerMetadataConfig::from_typed_struct(&parsed).map(Self::PeerMetadata)
                         },
-                        url if url == super::set_filter_state::SetFilterStateConfig::TYPE_URL => {
-                            super::set_filter_state::SetFilterStateConfig::from_typed_struct(&parsed)
+                        url if url == super::set_filter_state::SetFilterState::TYPE_URL => {
+                            super::set_filter_state::SetFilterState::from_typed_struct(&parsed)
                                 .map(Self::SetFilterState)
                         },
                         _ => Err(GenericError::unsupported_variant(format!(
@@ -386,14 +385,17 @@ mod typed_struct_integration_tests {
 
     #[test]
     fn test_try_from_any_typed_struct_set_filter_state() {
-        // Build inner Struct for SetFilterStateConfig with one action
-        let mut action_fields = BTreeMap::new();
-        action_fields.insert("object_key".to_string(), Value { kind: Some(Kind::StringValue("test_key".to_string())) });
-
-        let mut list_values = Vec::new();
+        // Build inner Struct for SetFilterState with one action including format_string
         let mut struct_fields = BTreeMap::new();
         struct_fields.insert("object_key".to_string(), Value { kind: Some(Kind::StringValue("test_key".to_string())) });
+        struct_fields.insert(
+            "format_string".to_string(),
+            Value { kind: Some(Kind::StringValue("%REQ(:authority)%".to_string())) },
+        );
+
         let action_struct = Value { kind: Some(Kind::StructValue(Struct { fields: struct_fields })) };
+
+        let mut list_values = Vec::new();
         list_values.push(action_struct);
 
         let mut fields = BTreeMap::new();
@@ -403,7 +405,7 @@ mod typed_struct_integration_tests {
         );
 
         let typed_struct = TypedStruct {
-            type_url: super::set_filter_state::SetFilterStateConfig::TYPE_URL.to_string(),
+            type_url: super::set_filter_state::SetFilterState::TYPE_URL.to_string(),
             value: Some(Struct { fields }),
         };
 
@@ -415,8 +417,8 @@ mod typed_struct_integration_tests {
         let parsed = SupportedEnvoyFilter::try_from(any).expect("should parse typed struct");
         match parsed {
             SupportedEnvoyFilter::SetFilterState(cfg) => {
-                assert!(cfg.on_request_headers.is_some());
-                let actions = cfg.on_request_headers.unwrap();
+                assert!(!cfg.on_request_headers.is_empty());
+                let actions = &cfg.on_request_headers;
                 assert_eq!(actions.len(), 1);
                 assert_eq!(actions[0].object_key, "test_key");
             },

orion-configuration/src/config/network_filters/http_connection_manager/http_filters/filter_registry.rs

@@ -16,7 +16,7 @@
 //
 
 use super::peer_metadata::PeerMetadataConfig;
-use super::set_filter_state::SetFilterStateConfig;
+use super::set_filter_state::SetFilterState;
 use crate::config::common::GenericError;
 use crate::typed_struct::registry::{global_registry, GenericFilterParser};
 use crate::typed_struct::TypedStructFilter;
@@ -27,7 +27,7 @@ pub fn register_all_filters() -> Result<(), GenericError> {
     let peer_metadata_parser = GenericFilterParser::<PeerMetadataConfig>::new(PeerMetadataConfig::TYPE_URL);
     registry.register_dynamic(peer_metadata_parser)?;
 
-    let set_filter_state_parser = GenericFilterParser::<SetFilterStateConfig>::new(SetFilterStateConfig::TYPE_URL);
+    let set_filter_state_parser = GenericFilterParser::<SetFilterState>::new(SetFilterState::TYPE_URL);
     registry.register_dynamic(set_filter_state_parser)?;
 
     Ok(())
@@ -53,7 +53,7 @@ mod tests {
 
         let registry = global_registry();
         assert!(registry.is_supported(PeerMetadataConfig::TYPE_URL));
-        assert!(registry.is_supported(SetFilterStateConfig::TYPE_URL));
+        assert!(registry.is_supported(SetFilterState::TYPE_URL));
     }
 
     #[test]
@@ -63,6 +63,6 @@ mod tests {
 
         let registry = global_registry();
         assert!(registry.is_supported(PeerMetadataConfig::TYPE_URL));
-        assert!(registry.is_supported(SetFilterStateConfig::TYPE_URL));
+        assert!(registry.is_supported(SetFilterState::TYPE_URL));
     }
 }

orion-configuration/src/config/network_filters/http_connection_manager/http_filters/set_filter_state.rs

@@ -17,11 +17,14 @@
 
 use compact_str::CompactString;
 use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
 
 use super::super::is_default;
+use crate::config::common::GenericError;
+use crate::typed_struct::TypedStructFilter;
 
 /// Set Filter State HTTP filter configuration
-/// 
+///
 /// This filter dynamically sets filter state objects based on request data.
 /// Filter state can be used for routing decisions, metadata propagation,
 /// and internal connection handling.
@@ -36,33 +39,33 @@ pub struct SetFilterState {
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
 pub struct FilterStateValue {
     /// Filter state object key (required)
-    /// 
+    ///
     /// Examples:
     /// - "io.istio.connect_authority" (Istio HBONE)
     /// - "envoy.filters.listener.original_dst.local_ip"
     /// - "envoy.tcp_proxy.cluster"
     pub object_key: CompactString,
-    
+
     /// Optional factory key for object creation
     /// If not specified, object_key is used for factory lookup
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub factory_key: Option<CompactString>,
-    
+
     /// Format string to generate the value
     /// Supports Envoy substitution format strings like:
     /// - %REQ(:authority)% - Request header
     /// - %DOWNSTREAM_REMOTE_ADDRESS% - Client IP
     /// - %UPSTREAM_HOST% - Selected upstream
     pub format_string: FormatString,
-    
+
     /// Make this value read-only (cannot be overridden by other filters)
     #[serde(skip_serializing_if = "std::ops::Not::not", default)]
     pub read_only: bool,
-    
+
     /// Share with upstream internal connections
     #[serde(skip_serializing_if = "is_default", default)]
     pub shared_with_upstream: SharedWithUpstream,
-    
+
     /// Skip setting the value if it evaluates to empty string
     #[serde(skip_serializing_if = "std::ops::Not::not", default)]
     pub skip_if_empty: bool,
@@ -82,13 +85,12 @@ pub enum SharedWithUpstream {
 }
 
 /// Format string for generating filter state values
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
-#[serde(untagged)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 pub enum FormatString {
     /// Plain text format string with command operators
     /// Example: "%REQ(:authority)%"
     Text(CompactString),
-    
+
     /// Structured format (JSON, etc.) - future extension
     Structured {
         format: CompactString,
@@ -97,64 +99,100 @@ pub enum FormatString {
     },
 }
 
+impl<'de> Deserialize<'de> for FormatString {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        // Deserialize into a serde_json::Value first so we can support multiple input shapes
+        let v = JsonValue::deserialize(deserializer)?;
+
+        match v {
+            JsonValue::String(s) => Ok(FormatString::Text(CompactString::from(s))),
+            JsonValue::Object(mut map) => {
+                // Envoy typed struct may use nested `text_format_source: { inline_string: "..." }`
+                if let Some(tf_source) = map.remove("text_format_source") {
+                    if let Some(inline) = tf_source.get("inline_string") {
+                        if let Some(s) = inline.as_str() {
+                            return Ok(FormatString::Text(CompactString::from(s)));
+                        }
+                    }
+                    // Inline bytes or other specifiers not supported here
+                }
+
+                // Also accept a direct `text_format` field
+                if let Some(text_fmt) = map.remove("text_format") {
+                    if let Some(s) = text_fmt.as_str() {
+                        return Ok(FormatString::Text(CompactString::from(s)));
+                    }
+                }
+
+                // Structured form: look for `format` key
+                if let Some(format_field) = map.remove("format") {
+                    if let Some(s) = format_field.as_str() {
+                        let json_format = map.remove("json_format");
+                        return Ok(FormatString::Structured { format: CompactString::from(s), json_format });
+                    }
+                }
+
+                Err(serde::de::Error::custom("unsupported FormatString representation"))
+            },
+            other => Err(serde::de::Error::custom(format!("unexpected FormatString type: {:?}", other))),
+        }
+    }
+}
+
 #[cfg(feature = "envoy-conversions")]
 mod envoy_conversions {
     use super::*;
     use crate::config::common::*;
-    use orion_data_plane_api::envoy_data_plane_api::{
-        envoy::{
-            config::core::v3::SubstitutionFormatString as EnvoySubstitutionFormatString,
-            extensions::filters::{
-                common::set_filter_state::v3::{
-                    FilterStateValue as EnvoyFilterStateValue,
-                    filter_state_value::{
-                        Key as EnvoyKey, 
-                        Value as EnvoyValue,
-                        SharedWithUpstream as EnvoySharedWithUpstream
-                    },
+    use orion_data_plane_api::envoy_data_plane_api::envoy::{
+        config::core::v3::SubstitutionFormatString as EnvoySubstitutionFormatString,
+        extensions::filters::{
+            common::set_filter_state::v3::{
+                filter_state_value::{
+                    Key as EnvoyKey, SharedWithUpstream as EnvoySharedWithUpstream, Value as EnvoyValue,
                 },
-                http::set_filter_state::v3::Config as EnvoySetFilterStateConfig,
+                FilterStateValue as EnvoyFilterStateValue,
             },
+            http::set_filter_state::v3::Config as EnvoySetFilterStateConfig,
         },
     };
-    
+
     impl TryFrom<EnvoySetFilterStateConfig> for SetFilterState {
         type Error = GenericError;
-        
+
         fn try_from(envoy: EnvoySetFilterStateConfig) -> Result<Self, Self::Error> {
-            let on_request_headers = envoy.on_request_headers
+            let on_request_headers = envoy
+                .on_request_headers
                 .into_iter()
                 .map(FilterStateValue::try_from)
                 .collect::<Result<Vec<_>, _>>()
                 .with_node("on_request_headers")?;
-            
+
             Ok(Self { on_request_headers })
         }
     }
-    
+
     impl TryFrom<EnvoyFilterStateValue> for FilterStateValue {
         type Error = GenericError;
-        
+
         fn try_from(envoy: EnvoyFilterStateValue) -> Result<Self, Self::Error> {
             let object_key = match envoy.key {
                 Some(EnvoyKey::ObjectKey(key)) => CompactString::from(key),
                 None => return Err(GenericError::from_msg("missing object_key in FilterStateValue")),
             };
-            
-            let factory_key = if envoy.factory_key.is_empty() {
-                None
-            } else {
-                Some(envoy.factory_key.into())
-            };
-            
+
+            let factory_key = (!envoy.factory_key.is_empty()).then(|| envoy.factory_key.into());
+
             let format_string = match envoy.value {
                 Some(EnvoyValue::FormatString(fs)) => FormatString::try_from(fs).with_node("format_string")?,
                 None => return Err(GenericError::from_msg("missing format_string in FilterStateValue")),
             };
-            
-            let shared_with_upstream = SharedWithUpstream::try_from(envoy.shared_with_upstream)
-                .with_node("shared_with_upstream")?;
-            
+
+            let shared_with_upstream =
+                SharedWithUpstream::try_from(envoy.shared_with_upstream).with_node("shared_with_upstream")?;
+
             Ok(Self {
                 object_key,
                 factory_key,
@@ -165,34 +203,31 @@ mod envoy_conversions {
             })
         }
     }
-    
+
     impl TryFrom<EnvoySubstitutionFormatString> for FormatString {
         type Error = GenericError;
-        
+
         fn try_from(envoy: EnvoySubstitutionFormatString) -> Result<Self, Self::Error> {
             use orion_data_plane_api::envoy_data_plane_api::envoy::config::core::v3::{
-                substitution_format_string::Format,
-                data_source::Specifier,
+                data_source::Specifier, substitution_format_string::Format,
             };
-            
+
             match envoy.format {
                 Some(Format::TextFormat(text)) => Ok(FormatString::Text(text.into())),
-                Some(Format::TextFormatSource(source)) => {
-                    match source.specifier {
-                        Some(Specifier::InlineString(s)) => Ok(FormatString::Text(s.into())),
-                        Some(Specifier::InlineBytes(b)) => {
-                            let s = String::from_utf8(b)
-                                .map_err(|e| GenericError::from_msg(format!("Invalid UTF-8 in format string: {}", e)))?;
-                            Ok(FormatString::Text(s.into()))
-                        },
-                        Some(Specifier::Filename(_)) => {
-                            Err(GenericError::unsupported_variant("filename format strings not supported"))
-                        },
-                        Some(Specifier::EnvironmentVariable(_)) => {
-                            Err(GenericError::unsupported_variant("environment variable format strings not supported"))
-                        },
-                        None => Err(GenericError::from_msg("missing format string specifier")),
-                    }
+                Some(Format::TextFormatSource(source)) => match source.specifier {
+                    Some(Specifier::InlineString(s)) => Ok(FormatString::Text(s.into())),
+                    Some(Specifier::InlineBytes(b)) => {
+                        let s = String::from_utf8(b)
+                            .map_err(|e| GenericError::from_msg(format!("Invalid UTF-8 in format string: {}", e)))?;
+                        Ok(FormatString::Text(s.into()))
+                    },
+                    Some(Specifier::Filename(_)) => {
+                        Err(GenericError::unsupported_variant("filename format strings not supported"))
+                    },
+                    Some(Specifier::EnvironmentVariable(_)) => {
+                        Err(GenericError::unsupported_variant("environment variable format strings not supported"))
+                    },
+                    None => Err(GenericError::from_msg("missing format string specifier")),
                 },
                 Some(Format::JsonFormat(_)) => {
                     // JSON format not yet supported - would need structured logging
@@ -204,7 +239,7 @@ mod envoy_conversions {
     }
     impl TryFrom<i32> for SharedWithUpstream {
         type Error = GenericError;
-        
+
         fn try_from(value: i32) -> Result<Self, Self::Error> {
             match EnvoySharedWithUpstream::try_from(value) {
                 Ok(EnvoySharedWithUpstream::None) => Ok(Self::None),
@@ -216,6 +251,15 @@ mod envoy_conversions {
     }
 }
 
+impl TypedStructFilter for SetFilterState {
+    const TYPE_URL: &'static str = "type.googleapis.com/envoy.extensions.filters.http.set_filter_state.v3.Config";
+
+    fn from_json_value(value: JsonValue) -> Result<Self, GenericError> {
+        serde_json::from_value(value)
+            .map_err(|e| GenericError::from_msg_with_cause("Failed to deserialize SetFilterState from JSON", e))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;