29780499551

Committed 20 Jul 2026 09:31PM UTC coverage: 74.193% (+4.4%) from 69.813%

Build # 29780499551

Build Type

Pull #70

github

Committed by

web-flow

Commit Message

Merge 8a1565b6d into 617b201e5

Pull Request Pull Request #70: refactoring & bug fixes

Coverage Stats

5906 of 7474 new or added lines in 69 files covered. (79.02%)

86 existing lines in 23 files now uncovered.

37388 of 50393 relevant lines covered (74.19%)

26807.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.07

/src/execution/error_handler.rs

// Error handling for test execution

use apif_grpc_transport::GrpcError;
use prost::Message;
use prost_types::Any;
use serde_json::{Map, Value, json};

#[derive(Clone, PartialEq, Message)]
struct GoogleRpcStatus {
    #[prost(int32, tag = "1")]
    code: i32,
    #[prost(string, tag = "2")]
    message: String,
    #[prost(message, repeated, tag = "3")]
    details: Vec<Any>,
}

#[derive(Clone, PartialEq, Message)]
struct GoogleRpcErrorInfo {
    #[prost(string, tag = "1")]
    reason: String,
    #[prost(string, tag = "2")]
    domain: String,
    #[prost(map = "string, string", tag = "3")]
    metadata: std::collections::HashMap<String, String>,
}

#[derive(Clone, PartialEq, Message)]
struct GoogleRpcBadRequest {
    #[prost(message, repeated, tag = "1")]
    field_violations: Vec<GoogleRpcBadRequestFieldViolation>,
}

#[derive(Clone, PartialEq, Message)]
struct GoogleRpcBadRequestFieldViolation {
    #[prost(string, tag = "1")]
    field: String,
    #[prost(string, tag = "2")]
    description: String,
}

/// Error handler for gRPC test execution
pub struct ErrorHandler;

/// Normalize field names in `actual` to match `expected` key naming (camelCase ↔ snake_case).
fn normalize_field_names(
    actual: &Map<String, Value>,
    expected: &Map<String, Value>,
) -> Map<String, Value> {
    let mut result = actual.clone();
    for (exp_key, exp_val) in expected {
        if !result.contains_key(exp_key) {
            // Try to find a key that differs only by underscores/case
            let normalized_key = result
                .keys()
                .find(|k| {
                    let k_norm = k.replace('_', "").to_lowercase();
                    let exp_norm = exp_key.replace('_', "").to_lowercase();
                    k_norm == exp_norm && *k != exp_key.as_str()
                })
                .cloned();
            if let Some(found) = normalized_key {
                let val = result.remove(&found).unwrap_or(Value::Null);
                let val = match (exp_val, val.clone()) {
                    (Value::Object(exp_obj), Value::Object(act_obj)) => {
                        Value::Object(normalize_field_names(&act_obj, exp_obj))
                    }
                    _ => val,
                };
                result.insert(exp_key.clone(), val);
            }
        }
    }
    result
}

impl ErrorHandler {
    /// Check if error matches expected error
    pub fn error_matches_expected(error_text: &str, expected: &Value) -> bool {
        Self::message_matches_error_text(error_text, expected)
            && Self::code_matches_error_text(error_text, expected)
            && expected.get("details").is_none()
    }

    /// Check if GrpcError matches expected error JSON (supports details)
    pub fn status_matches_expected(status: &GrpcError, expected: &Value) -> bool {
        Self::status_matches_expected_with_options(status, expected, false)
    }

    /// Check if GrpcError matches expected error JSON, optionally as partial subset.
    pub fn status_matches_expected_with_options(
        status: &GrpcError,
        expected: &Value,
        partial: bool,
    ) -> bool {
        if !partial && !Self::status_has_no_unexpected_top_level_fields(status, expected) {
            return false;
        }

        if partial {
            let actual = Self::status_to_json(status);
            return Self::is_subset_match(&actual, expected);
        }

        if !Self::message_matches_status(status, expected)
            || !Self::code_matches_status(status, expected)
        {
            return false;
        }

        let expects_details = expected.get("details").is_some();
        if !expects_details {
            return status.details().is_empty()
                || status.details() == b"[]"
                || status.details() == b"{}";
        }

        let actual_details = match Self::decode_status_details(status.details()) {
            Some(d) => d,
            None => match Self::decode_json_details(status.details()) {
                Some(d) => d,
                None => return false,
            },
        };

        Self::compare_details(expected, actual_details).is_none()
    }

    /// Convert GrpcError details to JSON array
    pub fn status_details_json(status: &GrpcError) -> Value {
        match Self::decode_status_details(status.details()) {
            Some(details) => Value::Array(details),
            None => Value::Null,
        }
    }

    /// Convert GrpcError to JSON object for diff output
    pub fn status_to_json(status: &GrpcError) -> Value {
        let mut obj = Map::with_capacity(3);
        obj.insert("code".into(), Value::from(status.code() as i64));
        obj.insert("message".into(), Value::from(status.message()));

        if let Some(details) = Self::decode_status_details(status.details())
            && !details.is_empty()
        {
            obj.insert("details".into(), Value::Array(details));
        } else if let Some(details) = Self::decode_json_details(status.details())
            && !details.is_empty()
        {
            obj.insert("details".into(), Value::Array(details));
        }

        Value::Object(obj)
    }

    /// Try to decode details as raw JSON array bytes (ConnectRPC style).
    fn decode_json_details(raw: &[u8]) -> Option<Vec<Value>> {
        if raw.is_empty() {
            return Some(Vec::new());
        }
        serde_json::from_slice::<Vec<Value>>(raw).ok()
    }

    /// Returns a human-readable mismatch reason for GrpcError comparison
    pub fn status_mismatch_reason(status: &GrpcError, expected: &Value) -> Option<String> {
        Self::status_mismatch_reason_with_options(status, expected, false)
    }

    /// Returns mismatch reason for GrpcError comparison with optional partial mode.
    pub fn status_mismatch_reason_with_options(
        status: &GrpcError,
        expected: &Value,
        partial: bool,
    ) -> Option<String> {
        if !partial
            && let Some(reason) = Self::status_unexpected_top_level_field_reason(status, expected)
        {
            return Some(reason);
        }

        if partial {
            let actual = Self::status_to_json(status);
            return Self::subset_mismatch_reason(&actual, expected, "$");
        }

        if !Self::message_matches_status(status, expected) {
            let actual = status.message();
            if let Some(expected_msg) = expected.get("message").and_then(|v| v.as_str()) {
                return Some(format!(
                    "message mismatch: expected '{}', got '{}'",
                    expected_msg, actual
                ));
            }
            if expected.is_string()
                && let Some(s) = expected.as_str()
            {
                return Some(format!(
                    "message mismatch: expected '{}', got '{}'",
                    s, actual
                ));
            }
            return Some("message mismatch".to_string());
        }

        if !Self::code_matches_status(status, expected) {
            if let Some(code) = expected.get("code").and_then(|v| v.as_i64()) {
                let expected_name = Self::grpc_code_name_from_numeric(code).unwrap_or("Unknown");
                return Some(format!(
                    "code mismatch: expected {} ({}), got {} ({:?})",
                    code,
                    expected_name,
                    status.code() as i64,
                    status.code()
                ));
            }
            return Some("code mismatch".to_string());
        }

        let actual_details = match Self::decode_status_details(status.details()) {
            Some(details) => details,
            None => match Self::decode_json_details(status.details()) {
                Some(details) => details,
                None => return Some("cannot decode gRPC status details".to_string()),
            },
        };

        Self::compare_details(expected, actual_details)
    }

    fn is_subset_match(actual: &Value, expected: &Value) -> bool {
        Self::subset_mismatch_reason(actual, expected, "$").is_none()
    }

    fn status_has_no_unexpected_top_level_fields(status: &GrpcError, expected: &Value) -> bool {
        Self::status_unexpected_top_level_field_reason(status, expected).is_none()
    }

    fn status_unexpected_top_level_field_reason(
        status: &GrpcError,
        expected: &Value,
    ) -> Option<String> {
        let Value::Object(expected_obj) = expected else {
            return None;
        };
        let Value::Object(actual_obj) = Self::status_to_json(status) else {
            return None;
        };

        for key in actual_obj.keys() {
            if key == "details" && !expected_obj.contains_key("details") {
                return Some(format!(
                    "backend returned details, but ERROR.details is missing in gctf; actual details: {}",
                    Self::status_details_json(status)
                ));
            }
            if !expected_obj.contains_key(key) {
                return Some(format!(
                    "unexpected field in actual error: '{}' is present but missing in ERROR section (use partial=true or ASSERTS)",
                    key
                ));
            }
        }

        None
    }

    fn subset_mismatch_reason(actual: &Value, expected: &Value, path: &str) -> Option<String> {
        match (actual, expected) {
            (Value::Object(act_map), Value::Object(exp_map)) => {
                for (k, exp_val) in exp_map {
                    let key_path = format!("{}.{}", path, k);
                    let Some(act_val) = act_map.get(k) else {
                        return Some(format!("partial mismatch: missing key '{}'", key_path));
                    };
                    if let Some(reason) = Self::subset_mismatch_reason(act_val, exp_val, &key_path)
                    {
                        return Some(reason);
                    }
                }
                None
            }
            (Value::Array(act_arr), Value::Array(exp_arr)) => {
                let mut used_actual = vec![false; act_arr.len()];
                for (exp_idx, exp_item) in exp_arr.iter().enumerate() {
                    let mut matched = false;
                    for (act_idx, act_item) in act_arr.iter().enumerate() {
                        if used_actual[act_idx] {
                            continue;
                        }
                        if Self::subset_mismatch_reason(act_item, exp_item, path).is_none() {
                            used_actual[act_idx] = true;
                            matched = true;
                            break;
                        }
                    }

                    if !matched {
                        return Some(format!(
                            "partial mismatch: expected array item at '{}[{}]' not found",
                            path, exp_idx
                        ));
                    }
                }
                None
            }
            _ => {
                if actual == expected {
                    None
                } else {
                    Some(format!(
                        "partial mismatch at '{}': expected {}, got {}",
                        path, expected, actual
                    ))
                }
            }
        }
    }

    fn message_matches_error_text(error_text: &str, expected: &Value) -> bool {
        if let Some(expected_msg) = expected.get("message").and_then(|v| v.as_str()) {
            if !error_text.contains(expected_msg) {
                return false;
            }
        } else if expected.is_string()
            && let Some(s) = expected.as_str()
            && !error_text.contains(s)
        {
            return false;
        }

        true
    }

    fn message_matches_status(status: &GrpcError, expected: &Value) -> bool {
        if let Some(expected_msg) = expected.get("message").and_then(|v| v.as_str()) {
            return status.message() == expected_msg;
        }

        if expected.is_string()
            && let Some(s) = expected.as_str()
        {
            return status.message() == s;
        }

        true
    }

    fn code_matches_error_text(error_text: &str, expected: &Value) -> bool {
        if let Some(code) = expected.get("code").and_then(|v| v.as_i64())
            && let Some(code_name) = Self::grpc_code_name_from_numeric(code)
        {
            let status_marker = format!("status: {}", code_name);
            if !error_text.contains(&status_marker)
                && !error_text.contains(&format!("code: {}", code))
            {
                return false;
            }
        }

        true
    }

    fn code_matches_status(status: &GrpcError, expected: &Value) -> bool {
        if let Some(code) = expected.get("code").and_then(|v| v.as_i64()) {
            return status.code() as i64 == code;
        }
        true
    }

    fn compare_details(expected: &Value, actual_details: Vec<Value>) -> Option<String> {
        if let Some(expected_details) = expected.get("details") {
            let expected_array = match expected_details.as_array() {
                Some(array) => array,
                None => return Some("expected ERROR.details must be an array".to_string()),
            };

            if expected_array.len() != actual_details.len() {
                return Some(format!(
                    "details mismatch: expected {} item(s), got {}",
                    expected_array.len(),
                    actual_details.len()
                ));
            }

            for (idx, (exp, act)) in expected_array.iter().zip(actual_details.iter()).enumerate() {
                // Enrich actual with @type from expected if missing
                let enriched = if let (Value::Object(exp_obj), Value::Object(act_obj)) = (exp, act)
                    && exp_obj.contains_key("@type")
                    && !act_obj.contains_key("@type")
                {
                    let mut enriched = act_obj.clone();
                    if let Some(type_val) = exp_obj.get("@type") {
                        enriched.insert("@type".to_string(), type_val.clone());
                    }
                    Value::Object(enriched)
                } else {
                    act.clone()
                };

                if exp == &enriched {
                    continue;
                }

                // Try field-name normalization: snake_case ↔ camelCase
                if let (Value::Object(exp_obj), Value::Object(act_obj)) = (exp, &enriched) {
                    let norm_act = normalize_field_names(act_obj, exp_obj);
                    if exp == &Value::Object(norm_act) {
                        continue;
                    }
                }

                return Some(format!(
                    "details mismatch at index {}: expected {} but got {}",
                    idx, exp, act
                ));
            }

            return None;
        }

        if expected.is_object() && !actual_details.is_empty() {
            return Some(format!(
                "backend returned details, but ERROR.details is missing in gctf; actual details: {}",
                Value::Array(actual_details)
            ));
        }

        None
    }

    fn decode_status_details(raw: &[u8]) -> Option<Vec<Value>> {
        if raw.is_empty() {
            return Some(Vec::new());
        }

        let status = GoogleRpcStatus::decode(raw).ok()?;
        Some(status.details.into_iter().map(Self::any_to_json).collect())
    }

    fn any_to_json(any: Any) -> Value {
        let type_url = any.type_url;
        let value = any.value;

        if type_url.ends_with("/google.rpc.ErrorInfo") {
            if let Ok(info) = GoogleRpcErrorInfo::decode(value.as_slice()) {
                let mut metadata = Map::new();
                for (k, v) in info.metadata {
                    metadata.insert(k, Value::String(v));
                }

                return json!({
                    "@type": type_url,
                    "reason": info.reason,
                    "domain": info.domain,
                    "metadata": metadata,
                });
            }

            return json!({
                "@type": type_url,
                "_decodeError": "failed to decode ErrorInfo",
                "_valueHex": Self::hex_encode(value.as_slice()),
            });
        }

        if type_url.ends_with("/google.rpc.BadRequest") {
            if let Ok(bad_request) = GoogleRpcBadRequest::decode(value.as_slice()) {
                let field_violations = bad_request
                    .field_violations
                    .into_iter()
                    .map(|violation| {
                        json!({
                            "field": violation.field,
                            "description": violation.description,
                        })
                    })
                    .collect::<Vec<_>>();

                return json!({
                    "@type": type_url,
                    "fieldViolations": field_violations,
                });
            }

            return json!({
                "@type": type_url,
                "_decodeError": "failed to decode BadRequest",
                "_valueHex": Self::hex_encode(value.as_slice()),
            });
        }

        json!({
            "@type": type_url,
            "_valueHex": Self::hex_encode(value.as_slice()),
        })
    }

    fn hex_encode(bytes: &[u8]) -> String {
        const HEX: &[u8; 16] = b"0123456789abcdef";
        let mut output = String::with_capacity(bytes.len() * 2);
        for byte in bytes {
            output.push(HEX[(byte >> 4) as usize] as char);
            output.push(HEX[(byte & 0x0f) as usize] as char);
        }
        output
    }

    /// Get gRPC code name from numeric code
    pub fn grpc_code_name_from_numeric(code: i64) -> Option<&'static str> {
        match code {
            0 => Some("OK"),
            1 => Some("Cancelled"),
            2 => Some("Unknown"),
            3 => Some("InvalidArgument"),
            4 => Some("DeadlineExceeded"),
            5 => Some("NotFound"),
            6 => Some("AlreadyExists"),
            7 => Some("PermissionDenied"),
            8 => Some("ResourceExhausted"),
            9 => Some("FailedPrecondition"),
            10 => Some("Aborted"),
            11 => Some("OutOfRange"),
            12 => Some("Unimplemented"),
            13 => Some("Internal"),
            14 => Some("Unavailable"),
            15 => Some("DataLoss"),
            16 => Some("Unauthenticated"),
            _ => None,
        }
    }

    /// Format error message for display
    pub fn format_error_message(_error_text: &str, expected: &Value) -> String {
        let mut parts = Vec::new();

        if let Some(msg) = expected.get("message").and_then(|v| v.as_str()) {
            parts.push(format!("expected message: {}", msg));
        }

        if let Some(code) = expected.get("code").and_then(|v| v.as_i64()) {
            if let Some(code_name) = Self::grpc_code_name_from_numeric(code) {
                parts.push(format!("expected code: {} ({})", code, code_name));
            } else {
                parts.push(format!("expected code: {}", code));
            }
        }

        if expected.get("details").is_some() {
            parts.push("expected details".to_string());
        }

        if parts.is_empty() {
            "error expected".to_string()
        } else {
            parts.join(", ")
        }
    }

    /// Check if error text contains expected code
    pub fn error_contains_code(error_text: &str, expected_code: i64) -> bool {
        if let Some(code_name) = Self::grpc_code_name_from_numeric(expected_code) {
            error_text.contains(&format!("status: {}", code_name))
                || error_text.contains(&format!("code: {}", expected_code))
        } else {
            error_text.contains(&format!("code: {}", expected_code))
        }
    }

    /// Check if error text contains expected message
    pub fn error_contains_message(error_text: &str, expected_message: &str) -> bool {
        error_text.contains(expected_message)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use prost::Message;
    use serde_json::json;
    fn status_with_details() -> GrpcError {
        let error_info = GoogleRpcErrorInfo {
            reason: "API_DISABLED".to_string(),
            domain: "your.service.com".to_string(),
            metadata: std::collections::HashMap::from([
                ("service".to_string(), "your.service.com".to_string()),
                ("consumer".to_string(), "projects/123".to_string()),
            ]),
        };

        let bad_request = GoogleRpcBadRequest {
            field_violations: vec![GoogleRpcBadRequestFieldViolation {
                field: "name".to_string(),
                description: "Name must be at least 3 characters".to_string(),
            }],
        };

        let status_proto = GoogleRpcStatus {
            code: 3, // InvalidArgument
            message: "Invalid argument provided".to_string(),
            details: vec![
                Any {
                    type_url: "type.googleapis.com/google.rpc.ErrorInfo".to_string(),
                    value: error_info.encode_to_vec(),
                },
                Any {
                    type_url: "type.googleapis.com/google.rpc.BadRequest".to_string(),
                    value: bad_request.encode_to_vec(),
                },
            ],
        };

        GrpcError::with_details(3, "Invalid argument provided", status_proto.encode_to_vec())
    }

    fn status_without_details() -> GrpcError {
        GrpcError::new(3, "Invalid argument provided")
    }

    #[test]
    fn test_error_matches_expected_message() {
        let error_text = "Error: status: NotFound, message: Resource not found";
        let expected = json!({"message": "Resource not found"});

        assert!(ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_error_matches_expected_code() {
        let error_text = "Error: status: NotFound, message: Resource not found";
        let expected = json!({"code": 5});

        assert!(ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_error_matches_expected_both() {
        let error_text = "Error: status: NotFound, message: Resource not found";
        let expected = json!({"code": 5, "message": "Resource not found"});

        assert!(ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_error_matches_expected_wrong_message() {
        let error_text = "Error: status: NotFound, message: Resource not found";
        let expected = json!({"message": "Wrong message"});

        assert!(!ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_error_matches_expected_wrong_code() {
        let error_text = "Error: status: NotFound, message: Resource not found";
        let expected = json!({"code": 3});

        assert!(!ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_grpc_code_name_from_numeric() {
        assert_eq!(ErrorHandler::grpc_code_name_from_numeric(0), Some("OK"));
        assert_eq!(
            ErrorHandler::grpc_code_name_from_numeric(5),
            Some("NotFound")
        );
        assert_eq!(
            ErrorHandler::grpc_code_name_from_numeric(13),
            Some("Internal")
        );
        assert_eq!(ErrorHandler::grpc_code_name_from_numeric(999), None);
    }

    #[test]
    fn test_format_error_message() {
        let expected = json!({"code": 5, "message": "Resource not found"});
        let formatted = ErrorHandler::format_error_message("", &expected);

        assert!(formatted.contains("expected message: Resource not found"));
        assert!(formatted.contains("expected code: 5 (NotFound)"));
    }

    #[test]
    fn test_error_contains_code() {
        let error_text = "Error: status: NotFound, code: 5";

        assert!(ErrorHandler::error_contains_code(error_text, 5));
        assert!(!ErrorHandler::error_contains_code(error_text, 3));
    }

    #[test]
    fn test_error_contains_message() {
        let error_text = "Error: Resource not found";

        assert!(ErrorHandler::error_contains_message(
            error_text,
            "Resource not found"
        ));
        assert!(!ErrorHandler::error_contains_message(
            error_text,
            "Wrong message"
        ));
    }

    #[test]
    fn test_error_matches_expected_string() {
        let error_text = "Error: Resource not found";
        let expected = json!("Resource not found");

        assert!(ErrorHandler::error_matches_expected(error_text, &expected));
    }

    #[test]
    fn test_status_matches_expected_with_details() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided",
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.ErrorInfo",
                    "reason": "API_DISABLED",
                    "domain": "your.service.com",
                    "metadata": {
                        "service": "your.service.com",
                        "consumer": "projects/123"
                    }
                },
                {
                    "@type": "type.googleapis.com/google.rpc.BadRequest",
                    "fieldViolations": [
                        {
                            "field": "name",
                            "description": "Name must be at least 3 characters"
                        }
                    ]
                }
            ]
        });

        assert!(ErrorHandler::status_matches_expected(&status, &expected));
    }

    #[test]
    fn test_status_matches_expected_with_wrong_details() {
        let status = status_with_details();
        let expected = json!({
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.ErrorInfo",
                    "reason": "WRONG_REASON"
                }
            ]
        });

        assert!(!ErrorHandler::status_matches_expected(&status, &expected));
    }

    #[test]
    fn test_status_matches_expected_fails_when_actual_has_unexpected_details() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided"
        });

        assert!(!ErrorHandler::status_matches_expected(&status, &expected));
    }

    #[test]
    fn test_status_matches_expected_fails_when_expected_requires_details() {
        let status = status_without_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided",
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.ErrorInfo",
                    "reason": "API_DISABLED"
                }
            ]
        });

        assert!(!ErrorHandler::status_matches_expected(&status, &expected));
    }

    #[test]
    fn test_status_matches_expected_passes_when_no_details_on_both_sides() {
        let status = status_without_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided"
        });

        assert!(ErrorHandler::status_matches_expected(&status, &expected));
    }

    #[test]
    fn test_status_matches_expected_rejects_partial_message_match() {
        let status = status_without_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument"
        });

        assert!(!ErrorHandler::status_matches_expected(&status, &expected));
        let reason = ErrorHandler::status_mismatch_reason(&status, &expected).unwrap();
        assert!(reason.contains("expected 'Invalid argument'"));
        assert!(reason.contains("got 'Invalid argument provided'"));
    }

    #[test]
    fn test_status_matches_expected_partial_allows_subset_top_level_fields() {
        let status = status_with_details();
        let expected = json!({
            "code": 3
        });

        assert!(ErrorHandler::status_matches_expected_with_options(
            &status, &expected, true
        ));
    }

    #[test]
    fn test_status_matches_expected_partial_allows_subset_details_payload() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.ErrorInfo",
                    "reason": "API_DISABLED"
                }
            ]
        });

        assert!(ErrorHandler::status_matches_expected_with_options(
            &status, &expected, true
        ));
    }

    #[test]
    fn test_status_matches_expected_partial_fails_when_expected_detail_item_missing() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.DebugInfo",
                    "detail": "not-present"
                }
            ]
        });

        assert!(!ErrorHandler::status_matches_expected_with_options(
            &status, &expected, true
        ));
        let reason = ErrorHandler::status_mismatch_reason_with_options(&status, &expected, true)
            .expect("partial mismatch reason");
        assert!(reason.contains("expected array item"));
    }

    #[test]
    fn test_status_matches_expected_strict_fails_when_message_omitted() {
        let status = status_without_details();
        let expected = json!({
            "code": 3
        });

        assert!(!ErrorHandler::status_matches_expected_with_options(
            &status, &expected, false
        ));
        let reason = ErrorHandler::status_mismatch_reason_with_options(&status, &expected, false)
            .expect("strict mismatch reason");
        assert!(reason.contains("unexpected field"));
        assert!(reason.contains("message"));
    }

    #[test]
    fn test_status_matches_expected_partial_passes_when_message_omitted() {
        let status = status_without_details();
        let expected = json!({
            "code": 3
        });

        assert!(ErrorHandler::status_matches_expected_with_options(
            &status, &expected, true
        ));
    }

    #[test]
    fn test_status_matches_expected_strict_allows_missing_details_when_not_present_in_actual() {
        let status = status_without_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided"
        });

        assert!(ErrorHandler::status_matches_expected_with_options(
            &status, &expected, false
        ));
    }

    #[test]
    fn test_status_mismatch_reason_for_unexpected_details() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided"
        });

        let reason = ErrorHandler::status_mismatch_reason(&status, &expected).unwrap();
        assert!(reason.contains("ERROR.details is missing"));
        assert!(reason.contains("actual details"));
        assert!(reason.contains("type.googleapis.com/google.rpc.ErrorInfo"));
    }

    #[test]
    fn test_status_mismatch_reason_for_missing_required_details() {
        let status = status_without_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided",
            "details": [
                {"@type": "type.googleapis.com/google.rpc.ErrorInfo"}
            ]
        });

        let reason = ErrorHandler::status_mismatch_reason(&status, &expected).unwrap();
        assert!(reason.contains("details mismatch"));
    }

    #[test]
    fn test_status_to_json_contains_details() {
        let status = status_with_details();
        let json = ErrorHandler::status_to_json(&status);
        assert_eq!(json["code"], 3);
        assert_eq!(json["message"], "Invalid argument provided");
        assert!(json.get("details").is_some());
    }

    #[test]
    fn test_status_matches_expected_fails_when_details_field_is_missing_in_expected_object() {
        let status = status_with_details();
        let expected = json!({
            "code": 3,
            "message": "Invalid argument provided",
            "details": [
                {
                    "@type": "type.googleapis.com/google.rpc.ErrorInfo",
                    "reason": "API_DISABLED",
                    "domain": "your.service.com",
                    "metadata": {
                        "service": "your.service.com",
                        "consumer": "projects/123"
                    }
                },
                {
                    "@type": "type.googleapis.com/google.rpc.BadRequest",
                    "fieldViolations": [
                        {
                            "description": "Name must be at least 3 characters"
                        }
                    ]
                }
            ]
        });

        assert!(!ErrorHandler::status_matches_expected(&status, &expected));
        let reason = ErrorHandler::status_mismatch_reason(&status, &expected).unwrap();
        assert!(reason.contains("details mismatch at index 1"));
    }
}

gripmock / grpctestify-rust / 29780499551

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous