alef 0.81.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

use std::collections::{HashMap, HashSet};

use crate::core::ir::{FieldDef, TypeDef, TypeRef};
use crate::e2e::field_access::FieldResolver;
use crate::e2e::fixture::Assertion;

use super::assertions::render_assertion;

fn envelope_types(ty: TypeRef, optional: bool) -> Vec<TypeDef> {
    vec![
        TypeDef {
            name: "Envelope".into(),
            fields: vec![FieldDef {
                name: "details".into(),
                ty,
                optional,
                ..Default::default()
            }],
            ..Default::default()
        },
        TypeDef {
            name: "Details".into(),
            ..Default::default()
        },
    ]
}

fn envelope_resolver(types: &[TypeDef], optional: bool, array: bool) -> FieldResolver {
    let optional_fields = if optional {
        HashSet::from(["details".to_string()])
    } else {
        HashSet::new()
    };
    let array_fields = if array {
        HashSet::from(["details".to_string()])
    } else {
        HashSet::new()
    };
    FieldResolver::new(
        &HashMap::new(),
        &optional_fields,
        &HashSet::new(),
        &array_fields,
        &HashSet::new(),
    )
    .with_ir_result_fields(
        FieldResolver::ir_result_field_facts(types, "java"),
        Some("Envelope".into()),
    )
}

fn render(ty: TypeRef, optional: bool, array: bool, assertion_type: &str) -> String {
    let types = envelope_types(ty, optional);
    let resolver = envelope_resolver(&types, optional, array);
    let mut output = String::new();
    render_assertion(
        &mut output,
        &Assertion {
            assertion_type: assertion_type.into(),
            field: Some("details".into()),
            ..Default::default()
        },
        "result",
        "Envelope",
        &resolver,
        false,
        false,
        false,
        false,
        None,
        &HashSet::new(),
        &HashMap::new(),
        false,
        &HashSet::new(),
        true,
    );
    output
}

#[test]
fn bare_record_uses_nullability_checks() {
    assert_eq!(
        render(TypeRef::Named("Details".into()), false, false, "not_empty"),
        "        assertNotNull(result.details(), \"expected non-empty value\");\n"
    );
    assert_eq!(
        render(TypeRef::Named("Details".into()), false, false, "is_empty"),
        "        assertNull(result.details(), \"expected empty value\");\n"
    );
}

#[test]
fn record_collection_uses_collection_methods() {
    assert_eq!(
        render(
            TypeRef::Vec(Box::new(TypeRef::Named("Details".into()))),
            false,
            true,
            "not_empty"
        ),
        "        assertFalse(result.details().isEmpty(), \"expected non-empty value\");\n"
    );
}

#[test]
fn optional_record_uses_optional_presence() {
    assert_eq!(
        render(TypeRef::Named("Details".into()), true, false, "is_empty"),
        "        assertTrue(java.util.Optional.ofNullable(result.details()).isEmpty(), \"expected empty value\");\n"
    );
}