Add evaluation gherkin tests

Signed-off-by: Eren Atas <[email protected]>

Author: erenatas

crates/flagd/src/resolver/in_process/storage/connector/grpc.rs

@@ -28,7 +28,7 @@ pub struct GrpcStreamConnector {
     retry_backoff_max_ms: u32,
     retry_grace_period: u32,
     stream_deadline_ms: u32,
-    authority: String, // desired authority, e.g. "b-features-api.service"
+    authority: String,   // desired authority, e.g. "b-features-api.service"
     provider_id: String, // provider identifier for sync requests
 }
 
@@ -53,7 +53,10 @@ impl GrpcStreamConnector {
             retry_grace_period: options.retry_grace_period,
             stream_deadline_ms: options.stream_deadline_ms,
             authority,
-            provider_id: options.provider_id.clone().unwrap_or_else(|| "rust-flagd-provider".to_string()),
+            provider_id: options
+                .provider_id
+                .clone()
+                .unwrap_or_else(|| "rust-flagd-provider".to_string()),
         }
     }
 

crates/flagd/src/resolver/rpc.rs

@@ -85,6 +85,27 @@ fn convert_proto_metadata(metadata: prost_types::Struct) -> FlagMetadata {
     FlagMetadata { values }
 }
 
+/// Maps gRPC status codes to OpenFeature error codes
+///
+/// This ensures consistent error handling across different resolver types
+/// and proper conformance with the OpenFeature specification.
+fn map_grpc_status_to_error_code(status: &tonic::Status) -> EvaluationErrorCode {
+    use tonic::Code;
+    match status.code() {
+        Code::NotFound => EvaluationErrorCode::FlagNotFound,
+        Code::InvalidArgument => EvaluationErrorCode::InvalidContext,
+        Code::Unauthenticated | Code::PermissionDenied => {
+            EvaluationErrorCode::General("authentication/authorization error".to_string())
+        }
+        Code::FailedPrecondition => EvaluationErrorCode::TypeMismatch,
+        Code::DeadlineExceeded | Code::Cancelled => {
+            EvaluationErrorCode::General("request timeout or cancelled".to_string())
+        }
+        Code::Unavailable => EvaluationErrorCode::General("service unavailable".to_string()),
+        _ => EvaluationErrorCode::General(format!("{:?}", status.code())),
+    }
+}
+
 pub struct RpcResolver {
     client: ClientType,
     metadata: OnceLock<ProviderMetadata>,
@@ -214,7 +235,7 @@ impl FeatureProvider for RpcResolver {
             Err(status) => {
                 error!(flag_key, error = %status, "failed to resolve boolean flag");
                 Err(EvaluationError {
-                    code: EvaluationErrorCode::General(status.code().to_string()),
+                    code: map_grpc_status_to_error_code(&status),
                     message: Some(status.message().to_string()),
                 })
             }
@@ -247,7 +268,7 @@ impl FeatureProvider for RpcResolver {
             Err(status) => {
                 error!(flag_key, error = %status, "failed to resolve string flag");
                 Err(EvaluationError {
-                    code: EvaluationErrorCode::General(status.code().to_string()),
+                    code: map_grpc_status_to_error_code(&status),
                     message: Some(status.message().to_string()),
                 })
             }
@@ -280,7 +301,7 @@ impl FeatureProvider for RpcResolver {
             Err(status) => {
                 error!(flag_key, error = %status, "failed to resolve float flag");
                 Err(EvaluationError {
-                    code: EvaluationErrorCode::General(status.code().to_string()),
+                    code: map_grpc_status_to_error_code(&status),
                     message: Some(status.message().to_string()),
                 })
             }
@@ -313,7 +334,7 @@ impl FeatureProvider for RpcResolver {
             Err(status) => {
                 error!(flag_key, error = %status, "failed to resolve integer flag");
                 Err(EvaluationError {
-                    code: EvaluationErrorCode::General(status.code().to_string()),
+                    code: map_grpc_status_to_error_code(&status),
                     message: Some(status.message().to_string()),
                 })
             }
@@ -346,7 +367,7 @@ impl FeatureProvider for RpcResolver {
             Err(status) => {
                 error!(flag_key, error = %status, "failed to resolve struct flag");
                 Err(EvaluationError {
-                    code: EvaluationErrorCode::General(status.code().to_string()),
+                    code: map_grpc_status_to_error_code(&status),
                     message: Some(status.message().to_string()),
                 })
             }
@@ -765,4 +786,44 @@ mod tests {
         // Clean shutdown
         server_handle.abort();
     }
+
+    #[test]
+    fn test_grpc_error_code_mapping() {
+        use tonic::Code;
+
+        // Test NOT_FOUND -> FlagNotFound
+        let status = tonic::Status::new(Code::NotFound, "Flag not found");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::FlagNotFound));
+
+        // Test INVALID_ARGUMENT -> InvalidContext
+        let status = tonic::Status::new(Code::InvalidArgument, "Invalid context");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::InvalidContext));
+
+        // Test UNAUTHENTICATED -> General
+        let status = tonic::Status::new(Code::Unauthenticated, "Not authenticated");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::General(_)));
+
+        // Test PERMISSION_DENIED -> General
+        let status = tonic::Status::new(Code::PermissionDenied, "Access denied");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::General(_)));
+
+        // Test FAILED_PRECONDITION -> TypeMismatch
+        let status = tonic::Status::new(Code::FailedPrecondition, "Type mismatch");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::TypeMismatch));
+
+        // Test DEADLINE_EXCEEDED -> General
+        let status = tonic::Status::new(Code::DeadlineExceeded, "Timeout");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::General(_)));
+
+        // Test UNAVAILABLE -> General
+        let status = tonic::Status::new(Code::Unavailable, "Service unavailable");
+        let error_code = map_grpc_status_to_error_code(&status);
+        assert!(matches!(error_code, EvaluationErrorCode::General(_)));
+    }
 }

crates/flagd/tests/gherkin_config_test.rs

@@ -27,20 +27,20 @@ impl ConfigWorld {
         // 1. The test is protected by #[serial_test::serial]
         // 2. This prevents test pollution between scenarios
         // 3. We clear env vars that were set in previous scenarios
-        
+
         // Clear env vars that were set in the previous scenario
         for key in self.env_vars.keys() {
             unsafe {
                 std::env::remove_var(key);
             }
         }
-        
+
         // Also explicitly clear FLAGD_OFFLINE_FLAG_SOURCE_PATH because it can affect resolver type
         // via FlagdOptions::default() logic, even if not tracked in world.env_vars
         unsafe {
             std::env::remove_var("FLAGD_OFFLINE_FLAG_SOURCE_PATH");
         }
-        
+
         self.env_vars.clear();
         self.options = FlagdOptions::default();
         self.provider = None;
@@ -302,7 +302,7 @@ async fn check_option_value(
         _ => None,
     };
     let expected = convert_type(&option_type, &value);
-    
+
     // For resolver type, do case-insensitive comparison since enum normalizes to lowercase
     let actual_normalized = if option == "resolver" {
         actual.as_ref().map(|v| v.to_lowercase())
@@ -314,8 +314,12 @@ async fn check_option_value(
     } else {
         expected.clone()
     };
-    
-    assert_eq!(actual_normalized, expected_normalized, "Option '{}' value mismatch", option);
+
+    assert_eq!(
+        actual_normalized, expected_normalized,
+        "Option '{}' value mismatch",
+        option
+    );
 }
 
 #[test(tokio::test)]