alef 0.83.0

Opinionated polyglot binding generator for Rust libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Regression coverage for `csharp_object_initializer`'s literal-construction behavior:
//! file-pointer fields, struct-typed collection element resolution, the `List<string>`
//! fallback when an element type cannot be resolved, and JSON-scalar wrapping. Type-name
//! casing behavior for the same function lives in `object_initializer_type_name_tests.rs`.

use super::setup::csharp_object_initializer;
use crate::core::ir::{FieldDef, TypeDef, TypeRef};
use std::collections::HashMap;

#[test]
fn native_initializer_reads_file_pointer_as_bytes() {
    let type_defs = [TypeDef {
        name: "Upload".into(),
        fields: vec![FieldDef {
            name: "content".into(),
            ty: TypeRef::Bytes,
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    }];
    let files = [crate::e2e::fixture::FixtureDocsFileInput {
        field: "/content".into(),
        path: "guide.pdf".into(),
    }];
    let rendered = csharp_object_initializer(
        serde_json::json!({"content": "guide.pdf"}).as_object().expect("object"),
        "Upload",
        &HashMap::new(),
        &HashMap::new(),
        &type_defs,
        &files,
        "",
    );
    assert!(
        rendered.contains("Content = System.IO.File.ReadAllBytes(\"guide.pdf\")"),
        "{rendered}"
    );
}

#[test]
fn object_initializer_uses_struct_element_type_for_object_valued_collections() {
    let type_defs = [
        TypeDef {
            name: "ChatCompletionRequest".into(),
            fields: vec![FieldDef {
                name: "messages".into(),
                ty: TypeRef::Vec(Box::new(TypeRef::Named("Message".into()))),
                ..FieldDef::default()
            }],
            ..TypeDef::default()
        },
        TypeDef {
            name: "Message".into(),
            fields: vec![],
            ..TypeDef::default()
        },
    ];
    let rendered = csharp_object_initializer(
        serde_json::json!({"messages": [{"role": "user", "content": "hi"}]})
            .as_object()
            .expect("object"),
        "ChatCompletionRequest",
        &HashMap::new(),
        &HashMap::new(),
        &type_defs,
        &[],
        "",
    );
    assert_eq!(
        rendered,
        "new ChatCompletionRequest { Messages = new List<Message>() { JsonSerializer.Deserialize<Message>(\"{\\\"content\\\":\\\"hi\\\",\\\"role\\\":\\\"user\\\"}\", ConfigOptions)! } }",
        "{rendered}"
    );
}

#[test]
fn object_initializer_uses_struct_element_type_for_string_valued_collections() {
    // `RerankDocument` wraps a bare string on the wire (a single-field newtype), so
    // the fixture value is a plain JSON string — not an object — even though the
    // struct's real element type is `RerankDocument`, not `string`.
    let type_defs = [TypeDef {
        name: "RerankRequest".into(),
        fields: vec![FieldDef {
            name: "documents".into(),
            ty: TypeRef::Vec(Box::new(TypeRef::Named("RerankDocument".into()))),
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    }];
    let rendered = csharp_object_initializer(
        serde_json::json!({"documents": ["Artificial intelligence is..."]})
            .as_object()
            .expect("object"),
        "RerankRequest",
        &HashMap::new(),
        &HashMap::new(),
        &type_defs,
        &[],
        "",
    );
    assert_eq!(
        rendered,
        "new RerankRequest { Documents = new List<RerankDocument>() { JsonSerializer.Deserialize<RerankDocument>(\"\\\"Artificial intelligence is...\\\"\", ConfigOptions)! } }",
        "{rendered}"
    );
}

#[test]
fn object_initializer_falls_back_to_list_string_for_unresolvable_element_type() {
    // No type_defs entry for the owning struct: the element type genuinely cannot
    // be resolved, so the historical `List<string>` fallback is correct here.
    let rendered = csharp_object_initializer(
        serde_json::json!({"tags": ["a", "b"]}).as_object().expect("object"),
        "Unregistered",
        &HashMap::new(),
        &HashMap::new(),
        &[],
        &[],
        "",
    );
    assert_eq!(
        rendered, "new Unregistered { Tags = new List<string>() { \"a\", \"b\" } }",
        "{rendered}"
    );
}

#[test]
fn object_initializer_wraps_json_scalar_fields_in_json_element_deserialize() {
    // `CreateResponseRequest.Input` binds to `JsonElement?` in C# (an untagged
    // union field represented as arbitrary JSON), but a bare scalar fixture value
    // used to be emitted as a plain string literal, which doesn't satisfy the
    // generated `JsonElement?` property.
    let type_defs = [TypeDef {
        name: "CreateResponseRequest".into(),
        fields: vec![FieldDef {
            name: "input".into(),
            ty: TypeRef::Optional(Box::new(TypeRef::Json)),
            ..FieldDef::default()
        }],
        ..TypeDef::default()
    }];
    let rendered = csharp_object_initializer(
        serde_json::json!({"input": "Say hello"}).as_object().expect("object"),
        "CreateResponseRequest",
        &HashMap::new(),
        &HashMap::new(),
        &type_defs,
        &[],
        "",
    );
    assert_eq!(
        rendered,
        "new CreateResponseRequest { Input = JsonSerializer.Deserialize<JsonElement>(\"\\\"Say hello\\\"\", ConfigOptions)! }",
        "{rendered}"
    );
}