libgraphql-parser 0.0.5

//! Tests for Value Parsing from the GraphQL parser.
//!
//! These tests verify that the parser correctly parses different GraphQL value
//! types and constructs the appropriate AST nodes. Each test navigates to the
//! parsed value and pattern matches to verify the correct variant and content.
//!
//! Written by Claude Code, reviewed by a human.

use crate::ast;
use crate::tests::ast_utils::extract_query;
use crate::tests::ast_utils::first_arg_value;
use crate::tests::ast_utils::first_field;
use crate::tests::ast_utils::object_field_value;
use crate::tests::utils::parse_executable;

// =============================================================================
// Integer Value Tests
// =============================================================================

/// Verifies that positive integer values are parsed as Int with correct value.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Int-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_int() {
    let query = extract_query("query { field(arg: 123) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Int(iv) = value {
        assert_eq!(iv.value, 123);
    } else {
        panic!("Expected Int value, got: {value:?}");
    }
}

/// Verifies that negative integer values are parsed correctly.
///
/// Per GraphQL spec, integers may have a leading `-` sign:
/// <https://spec.graphql.org/September2025/#sec-Int-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_int_negative() {
    let query = extract_query("query { field(arg: -456) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Int(iv) = value {
        assert_eq!(iv.value, -456);
    } else {
        panic!("Expected Int value, got: {value:?}");
    }
}

// =============================================================================
// Float Value Tests
// =============================================================================

/// Verifies that float values are parsed as Float with correct value.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Float-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_float() {
    let query = extract_query("query { field(arg: 1.5) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Float(fv) = value {
        assert!((fv.value - 1.5).abs() < f64::EPSILON);
    } else {
        panic!("Expected Float value, got: {value:?}");
    }
}

// =============================================================================
// String Value Tests
// =============================================================================

/// Verifies that string values are parsed as String with correct content.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-String-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_string() {
    let query = extract_query(r#"query { field(arg: "hello") }"#);
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::String(sv) = value {
        assert_eq!(sv.value, "hello");
    } else {
        panic!("Expected String value, got: {value:?}");
    }
}

/// Verifies that escape sequences in strings are correctly processed.
///
/// Per GraphQL spec, strings support escape sequences like \n, \t, \", etc.:
/// <https://spec.graphql.org/September2025/#EscapedCharacter>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_string_with_escapes() {
    let query = extract_query(r#"query { field(arg: "hello\nworld") }"#);
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::String(sv) = value {
        // The parser should have converted \n to an actual newline
        assert!(sv.value.contains('\n') || sv.value.contains("\\n"));
    } else {
        panic!("Expected String value, got: {value:?}");
    }
}

// =============================================================================
// Boolean Value Tests
// =============================================================================

/// Verifies that `true` is parsed as Boolean(true).
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Boolean-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_boolean_true() {
    let query = extract_query("query { field(arg: true) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Boolean(bv) = value {
        assert!(bv.value);
    } else {
        panic!("Expected Boolean value, got: {value:?}");
    }
}

/// Verifies that `false` is parsed as Boolean(false).
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Boolean-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_boolean_false() {
    let query = extract_query("query { field(arg: false) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Boolean(bv) = value {
        assert!(!bv.value);
    } else {
        panic!("Expected Boolean value, got: {value:?}");
    }
}

// =============================================================================
// Null Value Tests
// =============================================================================

/// Verifies that `null` is parsed as the Null variant.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Null-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_null() {
    let query = extract_query("query { field(arg: null) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if !matches!(value, ast::Value::Null(_)) {
        panic!("Expected Null value, got: {value:?}");
    }
}

// =============================================================================
// Enum Value Tests
// =============================================================================

/// Verifies that enum values (names that aren't keywords) are parsed correctly.
///
/// Per GraphQL spec, enum values are names that are not `true`, `false`, or
/// `null`:
/// <https://spec.graphql.org/September2025/#sec-Enum-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_enum() {
    let query = extract_query("query { field(arg: ACTIVE) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Enum(ev) = value {
        assert_eq!(ev.value, "ACTIVE");
    } else {
        panic!("Expected Enum value, got: {value:?}");
    }
}

/// Verifies that keywords like `type` can be used as enum values.
///
/// Per GraphQL spec, enum values can be any name except `true`, `false`,
/// `null`. Keywords like `type`, `query`, `mutation` are valid enum values:
/// <https://spec.graphql.org/September2025/#sec-Enum-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_enum_looks_like_keyword() {
    let query = extract_query("query { field(arg: type) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Enum(ev) = value {
        assert_eq!(ev.value, "type");
    } else {
        panic!("Expected Enum value, got: {value:?}");
    }
}

// =============================================================================
// List Value Tests
// =============================================================================

/// Verifies that empty list `[]` is parsed as an empty List.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-List-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_list_empty() {
    let query = extract_query("query { field(arg: []) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::List(lv) = value {
        assert!(lv.values.is_empty());
    } else {
        panic!("Expected List value, got: {value:?}");
    }
}

/// Verifies that simple list `[1, 2, 3]` is parsed with correct elements.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-List-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_list_simple() {
    let query = extract_query("query { field(arg: [1, 2, 3]) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::List(lv) = value {
        assert_eq!(lv.values.len(), 3);
        if let ast::Value::Int(iv) = &lv.values[0] {
            assert_eq!(iv.value, 1);
        } else {
            panic!("Expected first element to be Int");
        }
        if let ast::Value::Int(iv) = &lv.values[1] {
            assert_eq!(iv.value, 2);
        } else {
            panic!("Expected second element to be Int");
        }
        if let ast::Value::Int(iv) = &lv.values[2] {
            assert_eq!(iv.value, 3);
        } else {
            panic!("Expected third element to be Int");
        }
    } else {
        panic!("Expected List value, got: {value:?}");
    }
}

/// Verifies that nested lists `[[1], [2]]` are parsed correctly.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-List-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_list_nested() {
    let query = extract_query("query { field(arg: [[1], [2]]) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::List(outer) = value {
        assert_eq!(outer.values.len(), 2);
        if let ast::Value::List(inner1) = &outer.values[0] {
            assert_eq!(inner1.values.len(), 1);
            if let ast::Value::Int(iv) = &inner1.values[0] {
                assert_eq!(iv.value, 1);
            }
        } else {
            panic!("Expected first element to be a List");
        }
        if let ast::Value::List(inner2) = &outer.values[1] {
            assert_eq!(inner2.values.len(), 1);
            if let ast::Value::Int(iv) = &inner2.values[0] {
                assert_eq!(iv.value, 2);
            }
        } else {
            panic!("Expected second element to be a List");
        }
    } else {
        panic!("Expected List value, got: {value:?}");
    }
}

/// Verifies that mixed-type lists `[1, "two", true]` are parsed correctly.
///
/// Per GraphQL spec, list values have no type constraint at parse level:
/// <https://spec.graphql.org/September2025/#sec-List-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_list_mixed_types() {
    let query = extract_query(r#"query { field(arg: [1, "two", true]) }"#);
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::List(lv) = value {
        assert_eq!(lv.values.len(), 3);
        assert!(matches!(&lv.values[0], ast::Value::Int(_)));
        assert!(matches!(&lv.values[1], ast::Value::String(_)));
        assert!(
            matches!(&lv.values[2], ast::Value::Boolean(bv) if bv.value)
        );
    } else {
        panic!("Expected List value, got: {value:?}");
    }
}

// =============================================================================
// Object Value Tests
// =============================================================================

/// Verifies that empty object `{}` is parsed as an empty Object.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Input-Object-Values>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_object_empty() {
    let query = extract_query("query { field(arg: {}) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Object(ov) = value {
        assert!(ov.fields.is_empty());
    } else {
        panic!("Expected Object value, got: {value:?}");
    }
}

/// Verifies that simple object `{key: "value"}` is parsed correctly.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Input-Object-Values>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_object_simple() {
    let query = extract_query(r#"query { field(arg: {key: "value"}) }"#);
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Object(ov) = value {
        assert_eq!(ov.fields.len(), 1);
        let field_value =
            object_field_value(ov, "key").expect("Expected 'key' field");
        if let ast::Value::String(sv) = field_value {
            assert_eq!(sv.value, "value");
        } else {
            panic!("Expected String value for 'key' field");
        }
    } else {
        panic!("Expected Object value, got: {value:?}");
    }
}

/// Verifies that objects with multiple fields are parsed correctly.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Input-Object-Values>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_object_multiple_fields() {
    let query = extract_query("query { field(arg: {a: 1, b: 2, c: 3}) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Object(ov) = value {
        assert_eq!(ov.fields.len(), 3);
        assert!(ov.fields.iter().any(|f| f.name.value == "a"));
        assert!(ov.fields.iter().any(|f| f.name.value == "b"));
        assert!(ov.fields.iter().any(|f| f.name.value == "c"));
    } else {
        panic!("Expected Object value, got: {value:?}");
    }
}

/// Verifies that nested objects `{outer: {inner: 1}}` are parsed correctly.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#sec-Input-Object-Values>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_object_nested() {
    let query = extract_query("query { field(arg: {outer: {inner: 1}}) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Object(ov) = value {
        assert_eq!(ov.fields.len(), 1);
        let outer_value =
            object_field_value(ov, "outer").expect("Expected 'outer' field");
        if let ast::Value::Object(inner_ov) = outer_value {
            assert_eq!(inner_ov.fields.len(), 1);
            let inner_value =
                object_field_value(inner_ov, "inner").expect("Expected 'inner' field");
            if let ast::Value::Int(iv) = inner_value {
                assert_eq!(iv.value, 1);
            } else {
                panic!("Expected Int value for 'inner' field");
            }
        } else {
            panic!("Expected Object value for 'outer' field");
        }
    } else {
        panic!("Expected Object value, got: {value:?}");
    }
}

// =============================================================================
// Variable Value Tests
// =============================================================================

/// Verifies that variables `$var` are parsed as Variable.
///
/// Per GraphQL spec:
/// <https://spec.graphql.org/September2025/#Variable>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_variable() {
    let query = extract_query("query($var: Int) { field(arg: $var) }");
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::Variable(vv) = value {
        assert_eq!(vv.name.value, "var");
    } else {
        panic!("Expected Variable value, got: {value:?}");
    }
}

/// Verifies that variables in default values produce errors.
///
/// Per GraphQL spec, default values must be constant (no variables):
/// <https://spec.graphql.org/September2025/#sec-Input-Object-Values>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_variable_in_const_error() {
    let result = parse_executable("query($var: Int = $other) { field }");
    assert!(
        result.has_errors(),
        "Expected error for variable in default value"
    );
}

// =============================================================================
// Block String Value Tests
// =============================================================================

/// Verifies that block strings (triple-quoted) are parsed correctly.
///
/// Per GraphQL spec, block strings preserve formatting and handle indentation:
/// <https://spec.graphql.org/September2025/#sec-String-Value>
///
/// Written by Claude Code, reviewed by a human.
#[test]
fn value_block_string() {
    let query = extract_query(
        r#"query { field(arg: """multi
line
string""") }"#,
    );
    let field = first_field(&query.selection_set);
    let value = first_arg_value(field);

    if let ast::Value::String(sv) = value {
        // Block string should contain the multi-line content
        assert!(sv.value.contains("multi"));
        assert!(sv.value.contains("line"));
        assert!(sv.value.contains("string"));
    } else {
        panic!("Expected String value for block string, got: {value:?}");
    }
}