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

//! Regression coverage for Elixir wildcard-field assertion traversal.
//!
//! Split out of `assertions.rs`, which is over the 1000-line cap and may not grow.

use super::render_assertion;
use crate::e2e::field_access::FieldResolver;
use crate::e2e::fixture::Assertion;
use std::collections::{HashMap, HashSet};

fn array_resolver(field: &str) -> FieldResolver {
    let result_fields: HashSet<String> = [field.to_string()].into_iter().collect();
    let array_fields: HashSet<String> = [field.to_string()].into_iter().collect();
    FieldResolver::new(
        &HashMap::new(),
        &HashSet::new(),
        &result_fields,
        &array_fields,
        &HashSet::new(),
    )
}

fn render(assertion: &Assertion, resolver: &FieldResolver) -> String {
    let mut out = String::new();
    render_assertion(
        &mut out,
        assertion,
        "result",
        resolver,
        "Sample",
        &HashSet::new(),
        &HashMap::new(),
        false,
        false,
        false,
        false,
    );
    out
}

fn contains_on(field: &str) -> Assertion {
    Assertion {
        assertion_type: "contains".to_string(),
        field: Some(field.to_string()),
        value: Some(serde_json::Value::String("beta".to_string())),
        ..Default::default()
    }
}

#[test]
fn elixir_wildcard_contains_quantifies_over_every_element() {
    let out = render(&contains_on("items[].name"), &array_resolver("items"));
    assert_eq!(
        out,
        "      assert Enum.any?((result.items || []), fn e -> String.contains?(to_string(e.name), \"beta\") end)\n",
        "got: {out}"
    );
}

/// Regression lock: an explicit numeric index is a different, correct feature and must
/// keep its exact `Enum.at/2` lowering (also pinned by tests/e2e_field_path_array.rs). ~keep
#[test]
fn elixir_explicit_index_still_lowers_to_enum_at() {
    let out = render(&contains_on("items[0].name"), &array_resolver("items"));
    assert!(out.contains("Enum.at(result.items, 0).name"), "got: {out}");
    assert!(!out.contains("Enum.any?"), "got: {out}");
}

/// CANARY. A code-generator unit test cannot execute Elixir, so it cannot literally run
/// a fixture whose only match lives in element 1. The observable proxy is exact: the
/// pre-fix renderer emitted `Enum.at(result.items, 0).name`, a lookup pinned to element
/// 0, so a value present only at element 1 could never be seen. This asserts no
/// positional lookup survives and the predicate is quantified over the whole list; it
/// fails against the pre-fix code, where `Enum.at(result.items, 0)` is present. ~keep
#[test]
fn elixir_wildcard_match_in_a_non_first_element_is_not_pinned_to_element_zero() {
    let mut assertion = contains_on("items[].name");
    assertion.value = Some(serde_json::Value::String("only-in-element-1".to_string()));
    let out = render(&assertion, &array_resolver("items"));
    assert!(!out.contains("Enum.at("), "index-pinned lookup survived: {out}");
    assert!(out.contains("Enum.any?((result.items || [])"), "got: {out}");
    assert!(out.contains("to_string(e.name)"), "got: {out}");
}

/// `wildcard_split` consumes the first `[].` only, so before the guard the `Enum.any?`
/// ranged over `pages` while its body read `Enum.at(e.links, 0).url` — a whole-array
/// claim that only ever inspected element zero of the inner list. Pre-guard this test
/// fails: the skip line is absent and `Enum.at(e.links, 0)` is present. ~keep
#[test]
fn nested_wildcard_should_emit_a_visible_skip_rather_than_an_index_zero_check() {
    let out = render(&contains_on("pages[].links[].url"), &array_resolver("pages"));
    assert_eq!(
        out, "      # skipped: nested array-wildcard field 'pages[].links[].url' not supported\n",
        "got: {out}"
    );
}