tablo-core 0.1.0

The core toolkit types for Tablo, a server-rendered admin toolkit on Topcoat and Toasty.
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

use std::collections::HashMap;

use super::*;
use crate::{
    form::FieldErrors,
    schema::{Group, Schema, Section},
    test_support::{DummyUser, cx},
};

#[tokio::test]
async fn fields_compose_in_a_tuple() {
    let cx = cx();
    let schema = Schema::new((
        Field::text(DummyUser::fields().name()),
        Field::text(DummyUser::fields().email()),
    ));
    let html = schema
        .render(&cx, Source::form(&HashMap::new(), &FieldErrors::new()))
        .await
        .unwrap()
        .single()
        .await
        .unwrap()
        .render(&cx);
    assert!(
        html.matches("data-slot=\"field\"").count() >= 2,
        "expected 2 fields (data-slot=field) in {html}"
    );
    assert_eq!(
        html.matches("role=\"alert\"").count(),
        0,
        "valid fields render no error slot in {html}"
    );
}

#[tokio::test]
async fn schema_composes_multiple_blocks() {
    let cx = cx();
    let schema = Schema::new((
        Section::new("A").schema(Field::text(DummyUser::fields().name())),
        Group::new().schema(Field::text(DummyUser::fields().email())),
    ));
    let html = schema
        .render(&cx, Source::form(&HashMap::new(), &FieldErrors::new()))
        .await
        .unwrap()
        .single()
        .await
        .unwrap()
        .render(&cx);
    // The assertions below check structure, not paint: each block
    // renders its own child, exactly once, and the section's title still
    // frames its field.
    assert!(html.contains("A"), "missing section title in {html}");
    assert_eq!(
        html.matches("data-slot=\"field\"").count(),
        2,
        "each block must render its own field, got {html}"
    );
    assert!(
        html.contains("name=\"name\"") && html.contains("name=\"email\""),
        "both block children must render, got {html}"
    );
    assert!(
        html.find("A").expect("the section title") < html.find("name=\"name\"").expect("its field"),
        "the section must frame the field it holds, got {html}"
    );
}

#[tokio::test]
async fn empty_schema_renders_empty() {
    let cx = cx();
    let schema = Schema::empty();
    let html = schema
        .render(&cx, Source::form(&HashMap::new(), &FieldErrors::new()))
        .await
        .unwrap()
        .single()
        .await
        .unwrap()
        .render(&cx);
    assert!(
        html.trim().is_empty(),
        "empty schema should render nothing, got {html}"
    );
}

/// A field inside nested blocks keeps its slot when the blocks join a
/// schema that already holds fields: every field renders under its own name.
#[tokio::test]
async fn nested_blocks_keep_their_field_slots() {
    let cx = cx();
    let schema = Schema::new((
        Field::text(DummyUser::fields().name()),
        Section::new("S").schema(Group::new().schema(Field::text(DummyUser::fields().email()))),
    ));
    assert_eq!(
        schema.fields().map(Field::name).collect::<Vec<_>>(),
        ["name", "email"],
        "the field list holds every field once, in declaration order"
    );
    let values = HashMap::from([
        ("name".to_string(), "Ada".to_string()),
        ("email".to_string(), "ada@example.com".to_string()),
    ]);
    let html = schema
        .render(&cx, Source::form(&values, &FieldErrors::new()))
        .await
        .unwrap()
        .single()
        .await
        .unwrap()
        .render(&cx);
    assert!(html.contains("value=\"Ada\""), "{html}");
    assert!(html.contains("value=\"ada@example.com\""), "{html}");
}