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/set_filter_state.rs

@@ -21,7 +21,7 @@ use serde::{Deserialize, Serialize};
 use super::super::is_default;
 
 /// 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 +36,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,
@@ -88,7 +88,7 @@ pub enum FormatString {
     /// Plain text format string with command operators
     /// Example: "%REQ(:authority)%"
     Text(CompactString),
-    
+
     /// Structured format (JSON, etc.) - future extension
     Structured {
         format: CompactString,
@@ -101,60 +101,53 @@ pub enum FormatString {
 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 +158,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 +194,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),