alef 0.81.0

use super::*;
use crate::core::config::Language;

#[test]
fn ffi_error_code_variant_names_include_the_canonical_error_type() {
    assert_eq!(
        ffi_error_code_variant_name("sample::RequestError", "Unavailable"),
        "SampleRequestErrorUnavailable"
    );
    assert_ne!(
        ffi_error_code_variant_name("sample::RequestError", "Unavailable"),
        ffi_error_code_variant_name("sample::StorageError", "Unavailable")
    );
}

#[test]
fn ffi_error_code_variant_names_do_not_repeat_error_at_the_boundary() {
    assert_eq!(
        ffi_error_code_variant_name("sample::ParserError", "ErrorLanguageNotFound"),
        "SampleParserErrorLanguageNotFound"
    );
}

#[test]
fn ffi_error_code_variant_names_collapse_repeats_inside_the_type_path() {
    let cases = [
        // A module named after its error type is the common stutter source.
        (("sample::error::Error", "NotFound"), "SampleErrorNotFound"),
        (("sample_lib::error::Error", "NotFound"), "SampleLibErrorNotFound"),
        // Case differences alone do not make two consecutive words distinct.
        (("sample::Error::Error", "NotFound"), "SampleErrorNotFound"),
        // A repeat that is not adjacent carries meaning and is preserved.
        (("sample::error::Error", "QueryError"), "SampleErrorQueryError"),
        (("sample::error::codec::Error", "Decode"), "SampleErrorCodecErrorDecode"),
        // Paths without a repeat are untouched.
        (("sample::RequestError", "Unavailable"), "SampleRequestErrorUnavailable"),
    ];
    for ((error_type, variant), expected) in cases {
        assert_eq!(
            ffi_error_code_variant_name(error_type, variant),
            expected,
            "{error_type}::{variant}"
        );
    }
}

#[test]
fn ffi_error_code_variant_names_stay_distinct_across_sibling_error_types() {
    // Path collapsing must not erase the type that distinguishes two taxonomies.
    assert_ne!(
        ffi_error_code_variant_name("sample::error::Error", "NotFound"),
        ffi_error_code_variant_name("sample::storage::Error", "NotFound")
    );
}

#[test]
fn eliding_error_at_the_boundary_can_alias_two_variants_of_one_type() {
    // Documented limitation, unchanged from the previous implementation: a type
    // carrying both `ErrorFoo` and `Foo` folds onto a single name. C rejects the
    // duplicate enumerator at compile time, so this surfaces loudly rather than
    // silently mapping a code incorrectly. Deliberately not "fixed" by dropping the elision,
    // which would reintroduce the `ErrorError` stutter this pass removes. ~keep
    assert_eq!(
        ffi_error_code_variant_name("sample::error::Error", "ErrorFoo"),
        ffi_error_code_variant_name("sample::error::Error", "Foo")
    );
}

#[test]
fn ffi_builtin_error_code_prefix_namespaces_members_per_project() {
    assert_eq!(ffi_builtin_error_code_prefix("sample"), "SampleAlef");
    assert_eq!(ffi_builtin_error_code_prefix("ts_pack"), "TsPackAlef");
    assert_ne!(
        ffi_builtin_error_code_prefix("sample"),
        ffi_builtin_error_code_prefix("other")
    );
}

#[test]
fn serde_wire_name_applies_rename_all_strategies() {
    let cases = [
        ("HttpStatus", Some("lowercase"), "httpstatus"),
        ("HttpStatus", Some("UPPERCASE"), "HTTPSTATUS"),
        ("http_status", Some("PascalCase"), "HttpStatus"),
        ("http_status", Some("camelCase"), "httpStatus"),
        ("HttpStatus", Some("snake_case"), "http_status"),
        ("HttpStatus", Some("SCREAMING_SNAKE_CASE"), "HTTP_STATUS"),
        ("HttpStatus", Some("kebab-case"), "http-status"),
        ("HttpStatus", Some("SCREAMING-KEBAB-CASE"), "HTTP-STATUS"),
        ("HttpStatus", None, "HttpStatus"),
        ("HttpStatus", Some("unknown"), "HttpStatus"),
        ("Rdfa", Some("snake_case"), "rdfa"),
        ("HTMLParser", Some("snake_case"), "html_parser"),
    ];

    for (name, rename_all, expected) in cases {
        assert_eq!(
            apply_serde_rename_all(name, rename_all),
            expected,
            "rename_all={rename_all:?} name={name}"
        );
    }
}

#[test]
fn serde_rename_wins_over_rename_all() {
    assert_eq!(
        serde_wire_name("content_type", Some("Content-Type"), Some("camelCase")),
        "Content-Type"
    );
    assert_eq!(
        wire_variant_value("HttpStatus", Some("http-status"), Some("snake_case")),
        "http-status"
    );
    assert_eq!(
        wire_variant_value("HttpStatus", None, Some("snake_case")),
        "http_status"
    );
}

// `EnumDef::rename_all_fields` cases the FIELD names of a struct-shaped variant's payload; it is
// a distinct serde namespace from `EnumDef::serde_rename_all`, which cases VARIANT names. A call
// site computing a struct-variant field's wire name must resolve it through `wire_field_name`
// with the field's own `serde_rename` and the enum's `rename_all_fields` -- never the enum's
// `serde_rename_all`, which is the exact confusion this precedence chain guards against. ~keep
#[test]
fn struct_variant_field_wire_name_prefers_field_rename_over_enum_rename_all_fields() {
    let field = crate::core::ir::FieldDef {
        name: "inner_radius".to_string(),
        serde_rename: Some("radius".to_string()),
        ..crate::core::ir::FieldDef::default()
    };
    let enum_def = crate::core::ir::EnumDef {
        rename_all_fields: Some("camelCase".to_string()),
        ..crate::core::ir::EnumDef::default()
    };

    assert_eq!(
        wire_field_name(
            &field.name,
            field.serde_rename.as_deref(),
            enum_def.rename_all_fields.as_deref()
        ),
        "radius",
        "an explicit field-level serde_rename must win over the enum's rename_all_fields"
    );
}

#[test]
fn struct_variant_field_wire_name_falls_back_to_rename_all_fields_without_field_rename() {
    let field = crate::core::ir::FieldDef {
        name: "inner_radius".to_string(),
        ..crate::core::ir::FieldDef::default()
    };
    let enum_def = crate::core::ir::EnumDef {
        rename_all_fields: Some("camelCase".to_string()),
        ..crate::core::ir::EnumDef::default()
    };

    assert_eq!(
        wire_field_name(
            &field.name,
            field.serde_rename.as_deref(),
            enum_def.rename_all_fields.as_deref()
        ),
        "innerRadius",
        "with no field-level rename, the enum's rename_all_fields must case the raw field name"
    );
}

#[test]
fn struct_variant_field_wire_name_falls_back_to_raw_name_with_no_rule_at_all() {
    let field = crate::core::ir::FieldDef {
        name: "inner_radius".to_string(),
        ..crate::core::ir::FieldDef::default()
    };
    let enum_def = crate::core::ir::EnumDef::default();

    assert_eq!(
        wire_field_name(
            &field.name,
            field.serde_rename.as_deref(),
            enum_def.rename_all_fields.as_deref()
        ),
        "inner_radius"
    );
}

/// `rename_all` (variant names) and `rename_all_fields` (struct-variant field names) are
/// independent serde container attributes: an enum may set either, both, or neither, and one
/// must never influence the other's resolved value. ~keep
#[test]
fn rename_all_and_rename_all_fields_are_independent() {
    let variant_name_only = crate::core::ir::EnumDef {
        serde_rename_all: Some("SCREAMING_SNAKE_CASE".to_string()),
        ..crate::core::ir::EnumDef::default()
    };
    assert_eq!(variant_name_only.rename_all_fields, None);

    let field_name_only = crate::core::ir::EnumDef {
        rename_all_fields: Some("kebab-case".to_string()),
        ..crate::core::ir::EnumDef::default()
    };
    assert_eq!(field_name_only.serde_rename_all, None);

    let both = crate::core::ir::EnumDef {
        serde_rename_all: Some("SCREAMING_SNAKE_CASE".to_string()),
        rename_all_fields: Some("camelCase".to_string()),
        ..crate::core::ir::EnumDef::default()
    };
    assert_eq!(
        wire_variant_value("InnerRadius", None, both.serde_rename_all.as_deref()),
        "INNER_RADIUS",
        "serde_rename_all still governs variant-name casing when both are set"
    );
    assert_eq!(
        wire_field_name("inner_radius", None, both.rename_all_fields.as_deref()),
        "innerRadius",
        "rename_all_fields still governs field-name casing when both are set"
    );
}

#[test]
fn public_identifiers_are_separate_from_wire_names() {
    assert_eq!(
        public_field_name(Language::Node, "content_type", Some("contentTypeOverride")),
        "contentTypeOverride"
    );
    assert_eq!(
        wire_field_name("content_type", Some("Content-Type"), Some("camelCase")),
        "Content-Type"
    );
}

#[test]
fn public_host_identifier_applies_language_casing_and_keywords() {
    let cases = [
        (Language::Python, PublicIdentifierKind::Field, "class", "class_"),
        (
            Language::Node,
            PublicIdentifierKind::Function,
            "request_url",
            "requestUrl",
        ),
        (
            Language::Go,
            PublicIdentifierKind::Function,
            "request_url",
            "RequestURL",
        ),
        (
            Language::Go,
            PublicIdentifierKind::Parameter,
            "request_url",
            "requestURL",
        ),
        (
            Language::Csharp,
            PublicIdentifierKind::Method,
            "graphql_route",
            "GraphQLRoute",
        ),
        (
            Language::Ruby,
            PublicIdentifierKind::EnumVariant,
            "HTTPStatus",
            "http_status",
        ),
    ];

    for (lang, kind, name, expected) in cases {
        assert_eq!(public_host_identifier(lang, kind, name), expected);
    }
}

#[test]
fn identifier_context_controls_escaping() {
    assert_eq!(
        escape_identifier_for(Language::Swift, "protocol", IdentifierContext::SwiftSource),
        "`protocol`"
    );
    assert_eq!(
        escape_identifier_for(Language::Swift, "protocol", IdentifierContext::SwiftRustShim),
        "protocol_"
    );
    assert_eq!(
        escape_identifier_for(Language::Kotlin, "object", IdentifierContext::KotlinSource),
        "`object`"
    );
    assert_eq!(
        escape_identifier_for(Language::Kotlin, "object", IdentifierContext::KotlinRustBridge),
        "object_"
    );
    assert_eq!(
        escape_identifier_for(Language::Rust, "type", IdentifierContext::InternalRust),
        "r#type"
    );
}

#[test]
fn dart_identifier_context_handles_core_types_and_tuple_fields() {
    assert_eq!(dart_type_identifier("List", Some("NodeContent")), "NodeContentList");
    assert_eq!(dart_type_identifier("List", None), "ListNode");
    assert_eq!(dart_value_identifier("required"), "required_");
    assert_eq!(dart_tuple_field_identifier("0"), "field0");
}

#[test]
fn abi_symbol_components_are_sanitized_and_joined() {
    assert_eq!(
        abi_symbol_from_components(["my-lib", "HTTPStatus", "Content-Type", "2xx"]),
        "my_lib_httpstatus_content_type_2xx"
    );
    assert_eq!(abi_symbol("ffi", "HTTPStatus"), "ffi_http_status");
}

#[test]
fn identifier_validation_is_contextual() {
    assert!(validate_identifier(Language::Swift, "`protocol`", IdentifierContext::SwiftSource).is_ok());
    assert!(validate_identifier(Language::Rust, "r#type", IdentifierContext::InternalRust).is_ok());
    assert!(validate_identifier(Language::Node, "requestUrl", IdentifierContext::PublicMember).is_ok());
    assert!(validate_identifier(Language::Node, "Content-Type", IdentifierContext::PublicMember).is_err());
    assert!(validate_identifier(Language::Node, "Content-Type", IdentifierContext::Wire).is_ok());
}

#[test]
fn name_collision_detection_groups_distinct_originals() {
    let collisions = detect_name_collisions(["foo_bar", "fooBar", "baz"], |name| {
        public_host_identifier(Language::Node, PublicIdentifierKind::Field, name)
    });

    assert_eq!(
        collisions,
        vec![NameCollision {
            generated: "fooBar".to_string(),
            originals: vec!["foo_bar".to_string(), "fooBar".to_string()],
        }]
    );
}

#[test]
fn test_to_go_name_html_initialism() {
    assert_eq!(to_go_name("html"), "HTML");
}

#[test]
fn test_to_go_name_url_initialism() {
    assert_eq!(to_go_name("url"), "URL");
}

#[test]
fn test_to_go_name_id_initialism() {
    assert_eq!(to_go_name("id"), "ID");
}

#[test]
fn test_to_go_name_plain_word() {
    assert_eq!(to_go_name("links"), "Links");
}

#[test]
fn test_to_go_name_user_id() {
    assert_eq!(to_go_name("user_id"), "UserID");
}

#[test]
fn test_to_go_name_request_url() {
    assert_eq!(to_go_name("request_url"), "RequestURL");
}

#[test]
fn test_to_go_name_http_status() {
    assert_eq!(to_go_name("http_status"), "HTTPStatus");
}

#[test]
fn test_to_go_name_json_body() {
    assert_eq!(to_go_name("json_body"), "JSONBody");
}

#[test]
fn test_go_param_name_base_url() {
    assert_eq!(go_param_name("base_url"), "baseURL");
}

#[test]
fn test_go_param_name_user_id() {
    assert_eq!(go_param_name("user_id"), "userID");
}

#[test]
fn test_go_param_name_api_key() {
    assert_eq!(go_param_name("api_key"), "apiKey");
}

#[test]
fn test_go_param_name_plain() {
    assert_eq!(go_param_name("json"), "json");
}

#[test]
fn go_package_name_from_module_takes_the_last_segment() {
    let cases = [
        ("github.com/org/my-lib", "mylib"),
        ("binding", "binding"),
        ("example.invalid/samplecrate", "samplecrate"),
        ("", "binding"),
    ];
    for (module_path, expected) in cases {
        assert_eq!(
            go_package_name_from_module(module_path),
            expected,
            "module_path={module_path:?}"
        );
    }
}

// Table-driven regression for the bug where the e2e/docs Go snippet generator referenced the
// raw Rust-side error type name while the Go backend's own error generator
// (`gen_go_error_struct`, which calls this exact function) strips the package prefix -- a
// leading case-insensitive match of the Go package name is removed from the Rust error type
// name to avoid revive's stutter lint. Any caller that re-derives this rule instead of calling
// `go_error_type_name` can drift from what the Go backend actually declares; this test pins the
// shared rule itself. ~keep
#[test]
fn go_error_type_name_strips_a_matching_package_prefix() {
    let cases = [
        // Real-world shape: crate `error_type = "SampleCrateError"`, Go package `samplecrate`.
        ("SampleCrateError", "samplecrate", "Error"),
        ("SampleLlmError", "samplellm", "Error"),
        // No overlap between the error type and the package name: left untouched.
        ("ConversionError", "converter", "ConversionError"),
        // Negative control: an unrelated error name sharing no prefix with the package.
        ("ParseError", "samplecrate", "ParseError"),
        // Exact match (type name equals package name with no suffix) is not stripped -- the
        // `len() > pkg_lower.len()` guard exists so a package literally named after its own
        // error type is left with a non-empty identifier.
        ("Error", "error", "Error"),
        // Empty package name: nothing to strip.
        ("Error", "", "Error"),
    ];
    for (error_name, pkg_name, expected) in cases {
        assert_eq!(
            go_error_type_name(error_name, pkg_name),
            expected,
            "error_name={error_name:?} pkg_name={pkg_name:?}"
        );
    }
}

#[test]
fn pascal_to_snake_normal_case() {
    assert_eq!(pascal_to_snake("MyType"), "my_type");
}

#[test]
fn pascal_to_snake_rdfa() {
    assert_eq!(pascal_to_snake("Rdfa"), "rdfa");
}

#[test]
fn pascal_to_snake_html_parser() {
    assert_eq!(pascal_to_snake("HTMLParser"), "html_parser");
}

#[test]
fn pascal_to_snake_xml_http_request() {
    assert_eq!(pascal_to_snake("XMLHttpRequest"), "xml_http_request");
}

#[test]
fn pascal_to_snake_io_error() {
    assert_eq!(pascal_to_snake("IOError"), "io_error");
}

#[test]
fn pascal_to_snake_url_path() {
    assert_eq!(pascal_to_snake("URLPath"), "url_path");
}

#[test]
fn pascal_to_snake_jsonld_all_caps() {
    assert_eq!(pascal_to_snake("JSONLD"), "jsonld");
}

#[test]
fn pascal_to_snake_camel_case() {
    assert_eq!(pascal_to_snake("myField"), "my_field");
}

#[test]
fn pascal_to_snake_already_snake() {
    assert_eq!(pascal_to_snake("already_snake"), "already_snake");
}

#[test]
fn pascal_to_snake_empty() {
    assert_eq!(pascal_to_snake(""), "");
}

#[test]
fn pascal_to_screaming_snake_rdfa() {
    assert_eq!(pascal_to_screaming_snake("Rdfa"), "RDFA");
}

#[test]
fn pascal_to_screaming_snake_html_parser() {
    assert_eq!(pascal_to_screaming_snake("HTMLParser"), "HTML_PARSER");
}

#[test]
fn pascal_to_screaming_snake_my_type() {
    assert_eq!(pascal_to_screaming_snake("MyType"), "MY_TYPE");
}

#[test]
fn test_to_csharp_name_graphql_route_config() {
    assert_eq!(to_csharp_name("graphql_route_config"), "GraphQLRouteConfig");
}

#[test]
fn test_to_csharp_name_http_status_no_acronym() {
    assert_eq!(to_csharp_name("http_status"), "HttpStatus");
}

#[test]
fn test_to_csharp_name_to_json_no_acronym() {
    assert_eq!(to_csharp_name("to_json"), "ToJson");
}

#[test]
fn test_to_csharp_name_plain() {
    assert_eq!(to_csharp_name("my_field"), "MyField");
}

#[test]
fn test_csharp_type_name_heck_corrupted() {
    assert_eq!(csharp_type_name("GraphQlRouteConfig"), "GraphQLRouteConfig");
}

#[test]
fn test_csharp_type_name_already_correct() {
    assert_eq!(csharp_type_name("GraphQLRouteConfig"), "GraphQLRouteConfig");
}

#[test]
fn test_csharp_type_name_http_status_no_acronym() {
    assert_eq!(csharp_type_name("HttpStatus"), "HttpStatus");
}

#[test]
fn test_csharp_type_name_three_letter_acronyms() {
    assert_eq!(csharp_type_name("Uri"), "Uri");
    assert_eq!(csharp_type_name("URI"), "Uri");
    assert_eq!(csharp_type_name("Xml"), "Xml");
    assert_eq!(csharp_type_name("XML"), "Xml");
    assert_eq!(csharp_type_name("Json"), "Json");
    assert_eq!(csharp_type_name("JSON"), "Json");
}

/// `node_type_name` must be the identity function: the NAPI-RS `.d.ts` emitter never applies
/// the Rust-side `Js` wrapper prefix to a TypeScript type name, on the declaration side or the
/// reference side. Table-driven so a future accidental prefix-adding edit fails immediately.
#[test]
fn node_type_name_never_adds_the_js_wrapper_prefix() {
    let cases = [
        ("Message", "Message"),
        ("ChatCompletionRequest", "ChatCompletionRequest"),
        ("StopSequence", "StopSequence"),
        ("Js", "Js"),
    ];
    for (input, expected) in cases {
        assert_eq!(node_type_name(input), expected, "node_type_name({input:?})");
    }
}

/// `qualified_type_path` is the single decision point for "does this name already carry a
/// package". Table-driven: every emitter that prefixes a JVM/.NET package onto a configured type
/// name routes through here, so a regression in any row doubles a package prefix in generated code.
#[test]
fn qualified_type_path_prefixes_bare_names_and_leaves_qualified_ones_alone() {
    let cases = [
        (
            "dev.sample.bindings",
            "SampleClient",
            "dev.sample.bindings.SampleClient",
        ),
        (
            "dev.sample.bindings",
            "dev.sample.bindings.SampleClient",
            "dev.sample.bindings.SampleClient",
        ),
        (
            "dev.sample.bindings",
            "other.pkg.SampleClient",
            "other.pkg.SampleClient",
        ),
        ("dev.sample.bindings", "*", "dev.sample.bindings.*"),
        ("", "SampleClient", "SampleClient"),
    ];
    for (package, type_name, expected) in cases {
        assert_eq!(
            qualified_type_path(package, type_name),
            expected,
            "qualified_type_path({package:?}, {type_name:?})"
        );
    }
}

/// Moved here verbatim from an inline `mod duration_wire_tests` in `naming.rs` when
/// `naming::ts_property_key` was added: `naming.rs` sat at exactly the 1,000-line cap
/// `tests/file_size_ratchet.rs` enforces, so the `mod` declaration had to be paid for. Uses
/// absolute paths rather than `use super::*` so it does not depend on a glob-of-a-glob resolving.
mod duration_wire_tests {
    use crate::codegen::naming::field_uses_duration_map_wire;
    use crate::core::ir::{FieldDef, PrimitiveType, TypeRef};

    fn duration_field(serde_with: Option<&str>) -> FieldDef {
        FieldDef {
            ty: TypeRef::Duration,
            serde_with: serde_with.map(str::to_string),
            ..FieldDef::default()
        }
    }

    #[test]
    fn duration_field_without_serde_with_uses_the_derived_map_wire() {
        assert!(field_uses_duration_map_wire(&duration_field(None)));
    }

    #[test]
    fn duration_field_with_serde_with_uses_the_scalar_wire() {
        assert!(!field_uses_duration_map_wire(&duration_field(Some("duration_ms"))));
    }

    #[test]
    fn non_duration_field_never_uses_the_duration_map_wire() {
        let mut field = duration_field(None);
        field.ty = TypeRef::Primitive(PrimitiveType::U64);
        assert!(!field_uses_duration_map_wire(&field));
    }
}

#[test]
fn underscore_camel_case_capitalizes_only_after_an_underscore() {
    let cases = [
        ("hello_world", "helloWorld"),
        ("no_underscores_here", "noUnderscoresHere"),
        ("already", "already"),
        ("", ""),
        ("a_b_c", "aBC"),
        ("trailing_", "trailing"),
        ("double__underscore", "doubleUnderscore"),
    ];
    for (input, expected) in cases {
        assert_eq!(underscore_camel_case(input), expected, "input: {input}");
    }
}

#[test]
fn underscore_camel_case_preserves_case_that_heck_would_re_split() {
    // These are the cases the helper exists for. `to_node_name` (heck) re-splits an existing
    // case run and drops a leading underscore; a caller matching a name another generator
    // already emitted must not. If these two ever agree, the separate helper is pointless.
    let divergent = [
        ("my_URL", "myURL", "myUrl"),
        ("_raw", "Raw", "raw"),
        ("parse_HTML", "parseHTML", "parseHtml"),
    ];
    for (input, preserving, heck) in divergent {
        assert_eq!(underscore_camel_case(input), preserving, "input: {input}");
        assert_eq!(to_node_name(input), heck, "input: {input}");
        assert_ne!(underscore_camel_case(input), to_node_name(input), "input: {input}");
    }
}