iso8583_codec_rs/

lib.rs

pub mod bitmap;
pub mod codec;
pub mod error;
pub mod field_spec;
pub mod iso8583;
pub mod mti;
pub mod validation;

pub use error::{Iso8583Error, Result};
pub use field_spec::LoadedSpec;
pub use validation::{ValidationError, ValidationResult};

/// Parse an ISO 8583 message from a hex-encoded string into a JSON value.
///
/// The spec defines the field layout (encoding, prefix, padding, composite types).
/// Returns a JSON object with `mti` and `fields` keys.
pub fn parse(hex_message: &str, spec: &LoadedSpec) -> Result<serde_json::Value> {
    iso8583::parse(hex_message, spec)
}

/// Serialize a JSON value into a hex-encoded ISO 8583 message string.
///
/// The JSON must have `mti` (string) and `fields` (object with `de{NNN}_{name}` keys).
pub fn publish(message: &serde_json::Value, spec: &LoadedSpec) -> Result<String> {
    iso8583::publish(message, spec)
}

/// Load a specification from a JSON string.
pub fn load_spec(json: &str) -> Result<LoadedSpec> {
    LoadedSpec::from_json(json)
}

/// Validate an ISO 8583 message against the specification.
///
/// Checks MTI format, mandatory fields, per-field format/length/pattern, and response codes.
/// Returns a `ValidationResult` containing all errors found (non-fatal, accumulated).
pub fn validate(message: &serde_json::Value, spec: &LoadedSpec) -> ValidationResult {
    validation::validate(message, spec)
}

/// Look up a DE 39 response code description.
///
/// Returns `Some(description)` for known codes (e.g. `"00"` → `"Approved"`), `None` otherwise.
pub fn lookup_response_code(code: &str) -> Option<&'static str> {
    validation::lookup_response_code(code)
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn default_spec() -> LoadedSpec {
        let spec_json = include_str!("../specifications/fields.json");
        load_spec(spec_json).expect("failed to load spec")
    }

    #[test]
    fn test_load_spec() {
        let spec = default_spec();
        assert_eq!(spec.version, "1987");
        assert!(spec.get_field(2).is_some());
        assert!(spec.get_field(3).is_some());
        assert!(spec.get_field(128).is_some());
    }

    #[test]
    fn test_simple_round_trip() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de011_system_trace_audit_number": "123456",
                "de041_card_acceptor_terminal_id": "TERM0001"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["mti"], "0200");
        assert_eq!(
            parsed["fields"]["de002_primary_account_number"],
            "4111111111111111"
        );
        assert_eq!(parsed["fields"]["de003_processing_code"], "000000");
        assert_eq!(parsed["fields"]["de004_amount_transaction"], "000000001000");
        assert_eq!(
            parsed["fields"]["de011_system_trace_audit_number"],
            "123456"
        );
        assert_eq!(
            parsed["fields"]["de041_card_acceptor_terminal_id"],
            "TERM0001"
        );
    }

    #[test]
    fn test_round_trip_with_llvar_fields() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "123456",
                "de032_acquiring_institution_id_code": "123456",
                "de035_track_2_data": "4111111111111111D2512101123400001",
                "de037_retrieval_reference_number": "425612000001",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de043_card_acceptor_name_location": "ACME STORE          NEW YORK     NY US"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["mti"], "0200");
        assert_eq!(
            parsed["fields"]["de002_primary_account_number"],
            "4111111111111111"
        );
        assert_eq!(
            parsed["fields"]["de035_track_2_data"],
            "4111111111111111D2512101123400001"
        );
        assert_eq!(
            parsed["fields"]["de037_retrieval_reference_number"],
            "425612000001"
        );
        // Fixed-length field should be padded to 40 chars
        let name_loc = parsed["fields"]["de043_card_acceptor_name_location"]
            .as_str()
            .unwrap();
        assert_eq!(name_loc.len(), 40);
    }

    #[test]
    fn test_composite_ordered_field() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de022_pos_entry_mode": {
                    "pan_entry_mode": "05",
                    "pin_entry_capability": "1"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["mti"], "0200");
        let pos = &parsed["fields"]["de022_pos_entry_mode"];
        assert_eq!(pos["pan_entry_mode"], "05");
        assert_eq!(pos["pin_entry_capability"], "1");
    }

    #[test]
    fn test_composite_tlv_field() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de055_emv_data": {
                    "9F26": "AABBCCDD11223344",
                    "9F27": "80",
                    "9F10": "0102030405"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["mti"], "0200");
        let emv = &parsed["fields"]["de055_emv_data"];
        assert_eq!(emv["9F26"], "AABBCCDD11223344");
        assert_eq!(emv["9F27"], "80");
        assert_eq!(emv["9F10"], "0102030405");
    }

    #[test]
    fn test_secondary_bitmap_fields() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de070_network_management_information_code": "301"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["mti"], "0200");
        assert_eq!(
            parsed["fields"]["de070_network_management_information_code"],
            "301"
        );
    }

    #[test]
    fn test_binary_field_round_trip() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de052_pin_data": "1234567890ABCDEF"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(parsed["fields"]["de052_pin_data"], "1234567890ABCDEF");
    }

    #[test]
    fn test_parse_invalid_hex() {
        let spec = default_spec();
        let result = parse("ZZZZ", &spec);
        assert!(result.is_err());
    }

    #[test]
    fn test_parse_too_short() {
        let spec = default_spec();
        // Only 2 hex chars = 1 byte, not enough for MTI
        let result = parse("30", &spec);
        assert!(result.is_err());
    }

    // -----------------------------------------------------------------------
    // Network-specific spec loading tests
    // -----------------------------------------------------------------------

    fn visa_spec() -> LoadedSpec {
        let spec_json = include_str!("../specifications/visa_base1.json");
        load_spec(spec_json).expect("failed to load Visa BASE I spec")
    }

    fn mastercard_spec() -> LoadedSpec {
        let spec_json = include_str!("../specifications/mastercard_mip.json");
        load_spec(spec_json).expect("failed to load Mastercard MIP spec")
    }

    #[test]
    fn test_load_visa_spec() {
        let spec = visa_spec();
        assert_eq!(spec.version, "2003");
        assert_eq!(spec.defaults.encoding, "ebcdic");
        assert_eq!(spec.defaults.prefix_encoding, "bcd");
        assert_eq!(spec.defaults.bitmap_encoding, "binary");
        assert_eq!(spec.defaults.mti_encoding, "bcd");
        assert_eq!(spec.defaults.max_bitmaps, 3);
        assert!(spec.get_field(2).is_some());
        assert!(spec.get_field(48).is_some());
        assert!(spec.get_field(62).is_some());
        assert!(spec.get_field(128).is_some());

        // Verify DE 48 is a bitmap composite with proper config
        let de48 = spec.get_field(48).unwrap();
        assert_eq!(de48.field_type, field_spec::FieldType::Composite);
        assert_eq!(de48.composite_type, Some(field_spec::CompositeType::Bitmap));
        assert!(de48.bitmap.is_some());
        let bm = de48.bitmap.as_ref().unwrap();
        assert_eq!(bm.length, 4);
        assert_eq!(bm.encoding, "binary");
    }

    #[test]
    fn test_load_mastercard_spec() {
        let spec = mastercard_spec();
        assert_eq!(spec.version, "2003");
        assert_eq!(spec.defaults.encoding, "ebcdic");
        assert_eq!(spec.defaults.prefix_encoding, "bcd");
        assert_eq!(spec.defaults.bitmap_encoding, "binary");
        assert_eq!(spec.defaults.mti_encoding, "ascii");
        assert_eq!(spec.defaults.max_bitmaps, 2);
        assert!(spec.get_field(2).is_some());
        assert!(spec.get_field(61).is_some());
        assert!(spec.get_field(128).is_some());

        // Verify DE 61 is an ordered composite
        let de61 = spec.get_field(61).unwrap();
        assert_eq!(de61.field_type, field_spec::FieldType::Composite);
        assert_eq!(
            de61.composite_type,
            Some(field_spec::CompositeType::Ordered)
        );
        assert!(de61.subfields.is_some());
        assert_eq!(de61.subfields.as_ref().unwrap().len(), 12);
    }

    #[test]
    fn test_visa_bcd_mti_round_trip() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de011_system_trace_audit_number": "123456",
                "de025_pos_condition_code": "00"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        assert_eq!(parsed["mti"], "0100");
        assert_eq!(parsed["fields"]["de003_processing_code"], "000000");
        assert_eq!(parsed["fields"]["de004_amount_transaction"], "000000001000");
        assert_eq!(
            parsed["fields"]["de011_system_trace_audit_number"],
            "123456"
        );
        assert_eq!(parsed["fields"]["de025_pos_condition_code"], "00");
    }

    #[test]
    fn test_visa_ebcdic_string_fields() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de037_retrieval_reference_number": "425612000001",
                "de038_authorization_id_response": "ABC123",
                "de039_response_code": "00",
                "de041_card_acceptor_terminal_id": "TERM0001"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        assert_eq!(
            parsed["fields"]["de037_retrieval_reference_number"],
            "425612000001"
        );
        assert_eq!(
            parsed["fields"]["de038_authorization_id_response"],
            "ABC123"
        );
        assert_eq!(parsed["fields"]["de039_response_code"], "00");
        assert_eq!(
            parsed["fields"]["de041_card_acceptor_terminal_id"],
            "TERM0001"
        );
    }

    #[test]
    fn test_visa_llvar_bcd_prefix() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        assert_eq!(
            parsed["fields"]["de002_primary_account_number"],
            "4111111111111111"
        );
    }

    #[test]
    fn test_visa_bitmap_composite_round_trip() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de062_custom_payment_service": {
                    "authorization_characteristics": "A",
                    "transaction_id": "123456789012345"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        let de62 = &parsed["fields"]["de062_custom_payment_service"];
        assert_eq!(de62["authorization_characteristics"], "A");
        assert_eq!(de62["transaction_id"], "123456789012345");
    }

    #[test]
    fn test_mastercard_ascii_mti_round_trip() {
        let spec = mastercard_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de011_system_trace_audit_number": "123456",
                "de025_pos_condition_code": "00"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("mc publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("mc parse failed");

        assert_eq!(parsed["mti"], "0100");
        assert_eq!(parsed["fields"]["de003_processing_code"], "000000");
        assert_eq!(parsed["fields"]["de004_amount_transaction"], "000000001000");
    }

    #[test]
    fn test_mastercard_ordered_composite_de61() {
        let spec = mastercard_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de061_pos_data": {
                    "pos_terminal_attendance": "1",
                    "reserved": "0",
                    "pos_terminal_location": "0",
                    "pos_cardholder_presence": "0",
                    "pos_card_presence": "0",
                    "pos_card_capture": "0",
                    "pos_transaction_status": "0",
                    "pos_transaction_security": "0",
                    "reserved2": "0",
                    "cardholder_activated_terminal": "2",
                    "pos_card_data_terminal_input": "1",
                    "pos_authorization_life_cycle": "00"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("mc publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("mc parse failed");

        let de61 = &parsed["fields"]["de061_pos_data"];
        assert_eq!(de61["pos_terminal_attendance"], "1");
        assert_eq!(de61["cardholder_activated_terminal"], "2");
        assert_eq!(de61["pos_card_data_terminal_input"], "1");
    }

    #[test]
    fn test_mastercard_ebcdic_string_fields() {
        let spec = mastercard_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de037_retrieval_reference_number": "425612000001",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 "
            }
        });

        let hex_encoded = publish(&message, &spec).expect("mc publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("mc parse failed");

        assert_eq!(
            parsed["fields"]["de037_retrieval_reference_number"],
            "425612000001"
        );
        assert_eq!(
            parsed["fields"]["de041_card_acceptor_terminal_id"],
            "TERM0001"
        );
    }

    #[test]
    fn test_visa_full_auth_round_trip() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000005000",
                "de007_transmission_date_time": "0101120000",
                "de011_system_trace_audit_number": "000001",
                "de014_expiration_date": "2512",
                "de022_pos_entry_mode": {
                    "pan_entry_mode": "05",
                    "pin_entry_capability": "1"
                },
                "de025_pos_condition_code": "00",
                "de037_retrieval_reference_number": "000000000001",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de049_currency_code_transaction": "840"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa full auth publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa full auth parse failed");

        assert_eq!(parsed["mti"], "0100");
        assert_eq!(
            parsed["fields"]["de002_primary_account_number"],
            "4111111111111111"
        );
        assert_eq!(parsed["fields"]["de004_amount_transaction"], "000000005000");
        assert_eq!(parsed["fields"]["de049_currency_code_transaction"], "840");
        let pos = &parsed["fields"]["de022_pos_entry_mode"];
        assert_eq!(pos["pan_entry_mode"], "05");
        assert_eq!(pos["pin_entry_capability"], "1");
    }

    #[test]
    fn test_mastercard_full_auth_round_trip() {
        let spec = mastercard_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de002_primary_account_number": "5500000000000004",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000002500",
                "de007_transmission_date_time": "0315093000",
                "de011_system_trace_audit_number": "000042",
                "de014_expiration_date": "2612",
                "de022_pos_entry_mode": {
                    "pan_entry_mode": "05",
                    "pin_entry_capability": "1"
                },
                "de025_pos_condition_code": "00",
                "de037_retrieval_reference_number": "000000000042",
                "de041_card_acceptor_terminal_id": "TERM0002",
                "de042_card_acceptor_id_code": "MC_MERCHANT001 ",
                "de049_currency_code_transaction": "840"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("mc full auth publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("mc full auth parse failed");

        assert_eq!(parsed["mti"], "0100");
        assert_eq!(
            parsed["fields"]["de002_primary_account_number"],
            "5500000000000004"
        );
        assert_eq!(parsed["fields"]["de004_amount_transaction"], "000000002500");
        assert_eq!(parsed["fields"]["de049_currency_code_transaction"], "840");
    }

    // -----------------------------------------------------------------------
    // Original tests
    // -----------------------------------------------------------------------

    // -----------------------------------------------------------------------
    // Validation tests
    // -----------------------------------------------------------------------

    #[test]
    fn test_validate_valid_message() {
        let spec = default_spec();
        let message = json!({
            "mti": "0100",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000005000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "000001",
                "de014_expiration_date": "2512",
                "de022_pos_entry_mode": { "pan_entry_mode": "05", "pin_entry_capability": "1" },
                "de025_pos_condition_code": "00",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de049_currency_code_transaction": "840"
            }
        });
        let result = validate(&message, &spec);
        assert!(
            result.is_valid(),
            "expected valid but got errors: {:?}",
            result.errors
        );
    }

    #[test]
    fn test_validate_missing_mandatory_fields() {
        let spec = default_spec();
        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "000001",
                "de014_expiration_date": "2512",
                "de022_pos_entry_mode": { "pan_entry_mode": "05", "pin_entry_capability": "1" },
                "de025_pos_condition_code": "00",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de049_currency_code_transaction": "840"
            }
        });
        let result = validate(&message, &spec);
        let mandatory_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "mandatory")
            .collect();
        assert_eq!(mandatory_errors.len(), 2); // missing DE 2 and DE 4
        assert!(mandatory_errors.iter().any(|e| e.de == 2));
        assert!(mandatory_errors.iter().any(|e| e.de == 4));
    }

    #[test]
    fn test_validate_numeric_format_error() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "00ABC0001000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "123456",
                "de022_pos_entry_mode": { "pan_entry_mode": "05", "pin_entry_capability": "1" },
                "de025_pos_condition_code": "00",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de049_currency_code_transaction": "840"
            }
        });
        let result = validate(&message, &spec);
        let format_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "format" && e.de == 4)
            .collect();
        assert_eq!(format_errors.len(), 1);
    }

    #[test]
    fn test_validate_length_exceeded() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de002_primary_account_number": "41111111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "123456",
                "de022_pos_entry_mode": { "pan_entry_mode": "05", "pin_entry_capability": "1" },
                "de025_pos_condition_code": "00",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de049_currency_code_transaction": "840"
            }
        });
        let result = validate(&message, &spec);
        let len_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "length" && e.de == 2)
            .collect();
        assert_eq!(len_errors.len(), 1);
    }

    #[test]
    fn test_validate_fixed_length_mismatch() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "00"
            }
        });
        let result = validate(&message, &spec);
        let len_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "length" && e.de == 3)
            .collect();
        assert_eq!(len_errors.len(), 1);
    }

    #[test]
    fn test_validate_date_pattern_invalid() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de007_transmission_date_time": "1325143052"
            }
        });
        let result = validate(&message, &spec);
        let pattern_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "pattern" && e.de == 7)
            .collect();
        assert_eq!(pattern_errors.len(), 1);
    }

    #[test]
    fn test_validate_date_pattern_valid() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de007_transmission_date_time": "0725143052"
            }
        });
        let result = validate(&message, &spec);
        let pattern_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "pattern" && e.de == 7)
            .collect();
        assert_eq!(pattern_errors.len(), 0);
    }

    #[test]
    fn test_validate_response_code_valid() {
        let spec = default_spec();
        let message = json!({
            "mti": "0210",
            "fields": {
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000001000",
                "de007_transmission_date_time": "0725143052",
                "de011_system_trace_audit_number": "123456",
                "de039_response_code": "00"
            }
        });
        let result = validate(&message, &spec);
        let rc_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "response_code")
            .collect();
        assert_eq!(rc_errors.len(), 0);
    }

    #[test]
    fn test_validate_response_code_unknown() {
        let spec = default_spec();
        let message = json!({
            "mti": "0210",
            "fields": {
                "de039_response_code": "ZZ"
            }
        });
        let result = validate(&message, &spec);
        let rc_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "response_code")
            .collect();
        assert_eq!(rc_errors.len(), 1);
    }

    #[test]
    fn test_validate_invalid_mti() {
        let spec = default_spec();
        let message = json!({
            "mti": "0090",
            "fields": {}
        });
        let result = validate(&message, &spec);
        let mti_errors: Vec<_> = result.errors.iter().filter(|e| e.rule == "mti").collect();
        assert!(!mti_errors.is_empty());
    }

    #[test]
    fn test_validate_missing_mti() {
        let spec = default_spec();
        let message = json!({
            "fields": {}
        });
        let result = validate(&message, &spec);
        assert!(!result.is_valid());
        assert_eq!(result.errors[0].rule, "mti");
    }

    #[test]
    fn test_validate_multiple_errors() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "00",
                "de004_amount_transaction": "00ABC0001000",
                "de007_transmission_date_time": "1325143052"
            }
        });
        let result = validate(&message, &spec);
        assert!(result.errors.len() >= 3);
    }

    #[test]
    fn test_validate_composite_skipped() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de022_pos_entry_mode": { "pan_entry_mode": "05", "pin_entry_capability": "1" }
            }
        });
        let result = validate(&message, &spec);
        let de22_errors: Vec<_> = result.errors.iter().filter(|e| e.de == 22).collect();
        assert_eq!(de22_errors.len(), 0);
    }

    #[test]
    fn test_lookup_response_code() {
        assert_eq!(lookup_response_code("00"), Some("Approved"));
        assert_eq!(lookup_response_code("51"), Some("Insufficient Funds"));
        assert_eq!(lookup_response_code("ZZ"), None);
    }

    #[test]
    fn test_validate_no_mti_rules() {
        let spec = default_spec();
        let message = json!({
            "mti": "0300",
            "fields": {
                "de003_processing_code": "000000"
            }
        });
        let result = validate(&message, &spec);
        let mandatory_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "mandatory")
            .collect();
        assert_eq!(mandatory_errors.len(), 0);
    }

    #[test]
    fn test_validate_yymm_pattern() {
        let spec = default_spec();
        let message = json!({
            "mti": "0200",
            "fields": {
                "de014_expiration_date": "2513"
            }
        });
        let result = validate(&message, &spec);
        let pattern_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.rule == "pattern" && e.de == 14)
            .collect();
        assert_eq!(pattern_errors.len(), 1);
    }

    // -----------------------------------------------------------------------
    // Original tests (continued)
    // -----------------------------------------------------------------------

    // -----------------------------------------------------------------------
    // Phase 1: Bitmap composite unknown subfield handling
    // -----------------------------------------------------------------------

    #[test]
    fn test_bitmap_composite_unknown_subfield_with_default() {
        let spec = visa_spec();
        // DE 48 now has default_subfield configured, so unknown bits should work
        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de048_additional_data_private": {
                    "additional_pos_data": "12345678901234567890123456",
                    "merchant_category_override": "5411"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        let de48 = &parsed["fields"]["de048_additional_data_private"];
        assert_eq!(de48["additional_pos_data"], "12345678901234567890123456");
        assert_eq!(de48["merchant_category_override"], "5411");
    }

    // -----------------------------------------------------------------------
    // Phase 2: Expanded Visa subfields
    // -----------------------------------------------------------------------

    #[test]
    fn test_visa_expanded_de62_subfields() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de062_custom_payment_service": {
                    "authorization_characteristics": "A",
                    "transaction_id": "123456789012345",
                    "validation_code": "ABCD",
                    "market_specific_data": "H"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa parse failed");

        let de62 = &parsed["fields"]["de062_custom_payment_service"];
        assert_eq!(de62["authorization_characteristics"], "A");
        assert_eq!(de62["transaction_id"], "123456789012345");
        assert_eq!(de62["validation_code"], "ABCD");
        assert_eq!(de62["market_specific_data"], "H");
    }

    // -----------------------------------------------------------------------
    // Phase 3: x+n field type
    // -----------------------------------------------------------------------

    #[test]
    fn test_xn_field_round_trip() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de028_amount_transaction_fee": "C00000150"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(
            parsed["fields"]["de028_amount_transaction_fee"],
            "C00000150"
        );
    }

    #[test]
    fn test_xn_field_debit_round_trip() {
        let spec = default_spec();

        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de028_amount_transaction_fee": "D00000200"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        assert_eq!(
            parsed["fields"]["de028_amount_transaction_fee"],
            "D00000200"
        );
    }

    #[test]
    fn test_validate_xn_format() {
        let spec = default_spec();

        // Valid x+n
        let message = json!({
            "mti": "0200",
            "fields": {
                "de028_amount_transaction_fee": "C00000150"
            }
        });
        let result = validate(&message, &spec);
        let xn_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| e.de == 28 && e.rule == "format")
            .collect();
        assert_eq!(xn_errors.len(), 0);

        // Invalid x+n (starts with X instead of C/D)
        let message_bad = json!({
            "mti": "0200",
            "fields": {
                "de028_amount_transaction_fee": "X00000150"
            }
        });
        let result_bad = validate(&message_bad, &spec);
        let xn_errors_bad: Vec<_> = result_bad
            .errors
            .iter()
            .filter(|e| e.de == 28 && e.rule == "format")
            .collect();
        assert!(xn_errors_bad.len() >= 1);
    }

    // -----------------------------------------------------------------------
    // Phase 4: MTI version 9
    // -----------------------------------------------------------------------

    #[test]
    fn test_mti_version_9() {
        let spec = default_spec();

        let message = json!({
            "mti": "9100",
            "fields": {
                "de003_processing_code": "000000"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");
        assert_eq!(parsed["mti"], "9100");

        // Validate should accept version 9
        let result = validate(&message, &spec);
        let mti_errors: Vec<_> = result.errors.iter().filter(|e| e.rule == "mti").collect();
        assert_eq!(mti_errors.len(), 0);
    }

    #[test]
    fn test_classify_mti_version_9() {
        let c = mti::classify_mti("9100").unwrap();
        assert_eq!(c.version, "Private/Test");
        assert_eq!(c.message_class, "Authorization");
        assert_eq!(c.function, "Request");
    }

    // -----------------------------------------------------------------------
    // Phase 5: TLV 3-byte tags, PDS composite
    // -----------------------------------------------------------------------

    #[test]
    fn test_tlv_3byte_tag_round_trip() {
        let spec = default_spec();

        // Use a 3-byte tag: 9F8101 (second byte has bit 8 set)
        let message = json!({
            "mti": "0200",
            "fields": {
                "de003_processing_code": "000000",
                "de055_emv_data": {
                    "9F26": "AABBCCDD11223344",
                    "9F8101": "FF"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("parse failed");

        let emv = &parsed["fields"]["de055_emv_data"];
        assert_eq!(emv["9F26"], "AABBCCDD11223344");
        assert_eq!(emv["9F8101"], "FF");
    }

    #[test]
    fn test_mastercard_pds_round_trip() {
        let spec = mastercard_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de048_additional_data_private": {
                    "0043": "12345",
                    "0023": "ABCDE"
                }
            }
        });

        let hex_encoded = publish(&message, &spec).expect("mc pds publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("mc pds parse failed");

        let de48 = &parsed["fields"]["de048_additional_data_private"];
        assert_eq!(de48["0023"], "ABCDE");
        assert_eq!(de48["0043"], "12345");
    }

    // -----------------------------------------------------------------------
    // Phase 6: Response codes, tertiary bitmap fields
    // -----------------------------------------------------------------------

    #[test]
    fn test_new_response_codes() {
        assert_eq!(lookup_response_code("16"), Some("Approved, Update Track 3"));
        assert_eq!(lookup_response_code("17"), Some("Customer Cancellation"));
        assert_eq!(lookup_response_code("20"), Some("Invalid Response"));
        assert_eq!(lookup_response_code("22"), Some("Suspected Malfunction"));
        assert_eq!(
            lookup_response_code("35"),
            Some("Contact Acquirer, Pick Up")
        );
        assert_eq!(
            lookup_response_code("37"),
            Some("Call Acquirer Security, Pick Up")
        );
        assert_eq!(lookup_response_code("42"), Some("No Universal Account"));
        assert_eq!(lookup_response_code("50"), Some("Do Not Renew"));
        assert_eq!(lookup_response_code("60"), Some("Contact Acquirer"));
        assert_eq!(lookup_response_code("66"), Some("Acquirer Response Error"));
        assert_eq!(lookup_response_code("67"), Some("Hard Capture, Pick Up"));
        assert_eq!(lookup_response_code("90"), Some("Cutoff in Progress"));
        assert_eq!(lookup_response_code("99"), Some("Reserved for Private Use"));
    }

    #[test]
    fn test_visa_tertiary_bitmap_field_round_trip() {
        let spec = visa_spec();

        let message = json!({
            "mti": "0100",
            "fields": {
                "de003_processing_code": "000000",
                "de130_reserved_private_130": "TESTDATA"
            }
        });

        let hex_encoded = publish(&message, &spec).expect("visa tertiary publish failed");
        let parsed = parse(&hex_encoded, &spec).expect("visa tertiary parse failed");

        assert_eq!(parsed["fields"]["de130_reserved_private_130"], "TESTDATA");
    }

    #[test]
    fn test_authorization_request_response_pattern() {
        let spec = default_spec();

        // Authorization request 0100
        let request = json!({
            "mti": "0100",
            "fields": {
                "de002_primary_account_number": "4111111111111111",
                "de003_processing_code": "000000",
                "de004_amount_transaction": "000000005000",
                "de007_transmission_date_time": "0101120000",
                "de011_system_trace_audit_number": "000001",
                "de014_expiration_date": "2512",
                "de022_pos_entry_mode": {
                    "pan_entry_mode": "05",
                    "pin_entry_capability": "1"
                },
                "de025_pos_condition_code": "00",
                "de026_pos_capture_code": "12",
                "de037_retrieval_reference_number": "000000000001",
                "de041_card_acceptor_terminal_id": "TERM0001",
                "de042_card_acceptor_id_code": "MERCHANT000001 ",
                "de043_card_acceptor_name_location": "ACME STORE          NEW YORK     NY US  ",
                "de049_currency_code_transaction": "840"
            }
        });

        let hex_req = publish(&request, &spec).expect("publish request failed");
        let parsed_req = parse(&hex_req, &spec).expect("parse request failed");
        assert_eq!(parsed_req["mti"], "0100");
        assert_eq!(
            parsed_req["fields"]["de002_primary_account_number"],
            "4111111111111111"
        );
    }
}