tellaro-query-language 0.2.23

//! Encoding/decoding mutator tests - matching Python test_encoding_decoding_mutators.py
//!
//! Tests for base64 encode/decode and URL decode mutators.

use serde_json::json;
use tellaro_query_language::Tql;

// =============================================================================
// Base64 Encode Tests
// =============================================================================

#[test]
fn test_b64encode_basic_string() {
    let tql = Tql::new();
    let data = vec![json!({"message": "Hello, World!"})];

    // Base64 encode should work
    let results = tql
        .query(&data, "message | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64encode_empty_string() {
    let tql = Tql::new();
    let data = vec![json!({"value": ""})];

    // Empty string encodes to empty string
    let results = tql
        .query(&data, "value | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64encode_unicode() {
    let tql = Tql::new();
    let data = vec![
        json!({"message": "Hello \u{4e16}\u{754c}"}), // Hello 世界
    ];

    // Unicode strings should encode properly
    let results = tql
        .query(&data, "message | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64encode_special_characters() {
    let tql = Tql::new();
    let data = vec![json!({"value": "test@example.com"})];

    // Special characters should encode
    let results = tql
        .query(&data, "value | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64encode_number() {
    let tql = Tql::new();
    let data = vec![json!({"value": 12345})];

    // Numbers should be converted to string and encoded
    let results = tql
        .query(&data, "value | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64encode_boolean() {
    let tql = Tql::new();
    let data = vec![json!({"flag": true})];

    // Booleans should be converted to string and encoded
    let results = tql
        .query(&data, "flag | b64encode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Base64 Decode Tests
// =============================================================================

#[test]
fn test_b64decode_basic_string() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "SGVsbG8sIFdvcmxkIQ=="}), // "Hello, World!"
    ];

    // Base64 decode should work
    let results = tql
        .query(&data, "encoded | b64decode = 'Hello, World!'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64decode_with_proper_padding() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "SGVsbG8="}), // "Hello" with proper padding
    ];

    // Proper padding should decode correctly
    let results = tql
        .query(&data, "encoded | b64decode = 'Hello'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64decode_without_padding_fails_gracefully() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "SGVsbG8"}), // "Hello" without padding
    ];

    // Note: Rust's base64 decoder is stricter than Python's
    // Without proper padding, this will either error or return no match
    let result = tql.query(&data, "encoded | b64decode = 'Hello'");
    // Either fails or returns no match
    assert!(result.is_err() || result.unwrap().is_empty());
}

#[test]
fn test_b64decode_empty_string() {
    let tql = Tql::new();
    let data = vec![json!({"value": ""})];

    // Empty string decodes to empty string
    let results = tql
        .query(&data, "value | b64decode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64decode_unicode() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "SGVsbG8g5LiW55WM"}), // "Hello 世界"
    ];

    // Unicode decoding should work
    let results = tql
        .query(&data, "encoded | b64decode contains 'Hello'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_b64decode_invalid_input() {
    let tql = Tql::new();
    let data = vec![json!({"value": "not-valid-base64!!!"})];

    // Invalid base64 should be handled gracefully
    let result = tql.query(&data, "value | b64decode exists");
    // Should either succeed (returning original) or fail gracefully
    assert!(result.is_ok() || result.is_err());
}

// =============================================================================
// URL Decode Tests
// =============================================================================

#[test]
fn test_urldecode_basic_string() {
    let tql = Tql::new();
    let data = vec![json!({"url": "hello%20world"})];

    // URL decode %20 to space
    let results = tql
        .query(&data, "url | urldecode = 'hello world'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_special_characters() {
    let tql = Tql::new();
    let data = vec![json!({"value": "test%40example.com"})];

    // URL decode @ symbol
    let results = tql
        .query(&data, "value | urldecode = 'test@example.com'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_multiple_encodings() {
    let tql = Tql::new();
    let data = vec![
        json!({"value": "a%3Db%26c%3Dd"}), // a=b&c=d
    ];

    // Multiple URL encoded characters
    let results = tql
        .query(&data, "value | urldecode = 'a=b&c=d'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_plus_as_space() {
    let tql = Tql::new();
    let data = vec![json!({"value": "hello+world"})];

    // Plus sign treated as space in form encoding
    let results = tql
        .query(&data, "value | urldecode contains 'hello'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_unicode() {
    let tql = Tql::new();
    let data = vec![
        json!({"value": "%E4%B8%96%E7%95%8C"}), // 世界
    ];

    // UTF-8 URL encoding
    let results = tql
        .query(&data, "value | urldecode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_empty_string() {
    let tql = Tql::new();
    let data = vec![json!({"value": ""})];

    // Empty string stays empty
    let results = tql
        .query(&data, "value | urldecode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_no_encoding() {
    let tql = Tql::new();
    let data = vec![json!({"value": "plain-text"})];

    // String with no encoding stays the same
    let results = tql
        .query(&data, "value | urldecode = 'plain-text'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_urldecode_partial_encoding() {
    let tql = Tql::new();
    let data = vec![
        json!({"value": "hello%20world%21test"}), // hello world!test
    ];

    // Mixed encoded and plain text
    let results = tql
        .query(&data, "value | urldecode contains 'hello'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Hex Encode/Decode Tests
// =============================================================================

#[test]
fn test_hexencode_basic_string() {
    let tql = Tql::new();
    let data = vec![json!({"message": "Hello"})];

    // Hex encode should work
    let results = tql
        .query(&data, "message | hexencode exists")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_hexdecode_basic_string() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "48656c6c6f"}), // "Hello"
    ];

    // Hex decode should work
    let results = tql
        .query(&data, "encoded | hexdecode = 'Hello'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_hexdecode_uppercase() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "48454C4C4F"}), // "HELLO" in uppercase hex
    ];

    // Uppercase hex should decode
    let results = tql
        .query(&data, "encoded | hexdecode = 'HELLO'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Hash Mutator Tests
// =============================================================================

#[test]
fn test_md5_basic_string() {
    let tql = Tql::new();
    let data = vec![json!({"message": "hello"})];

    // MD5 hash should produce 32 character hex string
    let results = tql
        .query(&data, "message | md5 | length = 32")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_md5_known_hash() {
    let tql = Tql::new();
    let data = vec![json!({"message": "hello"})];

    // MD5 of "hello" is 5d41402abc4b2a76b9719d911017c592
    let results = tql
        .query(&data, "message | md5 = '5d41402abc4b2a76b9719d911017c592'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_sha256_basic_string() {
    let tql = Tql::new();
    let data = vec![json!({"message": "hello"})];

    // SHA256 hash should produce 64 character hex string
    let results = tql
        .query(&data, "message | sha256 | length = 64")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_sha256_known_hash() {
    let tql = Tql::new();
    let data = vec![json!({"message": "hello"})];

    // SHA256 of "hello"
    let results = tql
        .query(
            &data,
            "message | sha256 = '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'",
        )
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_md5_empty_string() {
    let tql = Tql::new();
    let data = vec![json!({"value": ""})];

    // MD5 of empty string
    let results = tql
        .query(&data, "value | md5 = 'd41d8cd98f00b204e9800998ecf8427e'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Chained Encoding Operations
// =============================================================================

#[test]
fn test_encode_decode_roundtrip() {
    let tql = Tql::new();
    let data = vec![json!({"message": "test message"})];

    // Encode then decode should return original
    let results = tql
        .query(&data, "message | b64encode | b64decode = 'test message'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_hex_roundtrip() {
    let tql = Tql::new();
    let data = vec![json!({"message": "test"})];

    // Hex encode then decode should return original
    let results = tql
        .query(&data, "message | hexencode | hexdecode = 'test'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

#[test]
fn test_lowercase_after_hash() {
    let tql = Tql::new();
    let data = vec![json!({"message": "HELLO"})];

    // Hash and then lowercase (hashes are already lowercase)
    let results = tql
        .query(&data, "message | md5 | lowercase | length = 32")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}

// =============================================================================
// Integration with Filtering
// =============================================================================

#[test]
fn test_b64decode_in_filter() {
    let tql = Tql::new();
    let data = vec![
        json!({"encoded": "YWRtaW4=", "name": "Admin User"}), // "admin"
        json!({"encoded": "dXNlcg==", "name": "Regular User"}), // "user"
    ];

    // Filter by decoded value
    let results = tql
        .query(&data, "encoded | b64decode = 'admin'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
    assert_eq!(results[0]["name"], "Admin User");
}

#[test]
fn test_hash_comparison() {
    let tql = Tql::new();
    let data = vec![
        json!({"password_hash": "5d41402abc4b2a76b9719d911017c592", "user": "alice"}),
        json!({"password_hash": "098f6bcd4621d373cade4e832627b4f6", "user": "bob"}),
    ];

    // Find user with known password hash (md5 of "hello")
    let results = tql
        .query(&data, "password_hash = '5d41402abc4b2a76b9719d911017c592'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
    assert_eq!(results[0]["user"], "alice");
}

#[test]
fn test_encoded_field_contains() {
    let tql = Tql::new();
    let data = vec![
        json!({"url": "https%3A%2F%2Fexample.com%2Fpath"}),
        json!({"url": "https%3A%2F%2Fother.com%2Fpath"}),
    ];

    // URL decode and check contains
    let results = tql
        .query(&data, "url | urldecode contains 'example.com'")
        .expect("Query should succeed");
    assert_eq!(results.len(), 1);
}