rustango-cms 0.4.0

A page-tree content management system for Rust, built on rustango
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
//! Tests for the unified widget renderer — `_widget.html` Tera
//! macro driven by `Widget` + `WidgetKind`. Renders every kind
//! against a stubbed context and asserts the expected HTML element
//! lands in the body, using the framework's
//! `rustango::test_assertions::*` helpers consistently with the
//! rest of the suite.

use axum::response::{Html, IntoResponse, Response};
use rustango::test_assertions::{assert_contains, assert_not_contains};
use rustango_cms::admin;
use rustango_cms::{Widget, WidgetKind};
use tera::{Context, Tera};

fn fresh_tera() -> Tera {
    let mut tera = Tera::default();
    admin::register_templates(&mut tera).expect("register_templates");
    tera
}

/// Render the macro `widget::render(w)` against a stubbed
/// `_test.html` that imports it. Wraps in a `Response` for the
/// framework's assert helpers.
fn render_widget(tera: &Tera, w: &Widget) -> Response {
    let mut t = tera.clone();
    t.add_raw_template(
        "_test.html",
        "{% import \"rcms_admin/_widget.html\" as widget %}\
         {{ widget::render(w=w) }}",
    )
    .expect("add stub template");
    let mut ctx = Context::new();
    ctx.insert("w", w);
    // The i18n epic (#523) made `LANG` mandatory in the widget macro
    // (`translate(locale=LANG)` on chooser placeholders etc.).
    ctx.insert("LANG", "en");
    // Custom-widget branch reads `custom_html` directly off `w`, so
    // no `custom_widgets` context map needed here.
    let html = t.render("_test.html", &ctx).expect("render _test.html");
    Html(html).into_response()
}

#[tokio::test]
async fn text_renders_as_input_type_text() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Text, "title", "Title");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="text""#).await;
}

#[tokio::test]
async fn model_chooser_emits_slug_as_chooser_kind() {
    // #421 pt 2 — the registered chooser slug (custom_name) becomes
    // data-chooser-kind, which cms-ux.js routes to /cms-admin/__chooser/<slug>.
    let tera = fresh_tera();
    let w = Widget::model_chooser("author_id", "Author", "author");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"data-chooser-kind="author""#).await;
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"name="author_id""#).await;
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"data-chooser-input"#).await;
}

#[tokio::test]
async fn model_chooser_with_value_shows_id() {
    let tera = fresh_tera();
    let w = Widget::model_chooser("author_id", "Author", "author").with_value("42");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"value="42""#).await;
    let res = render_widget(&tera, &w);
    assert_contains(res, "#42").await;
}

#[tokio::test]
async fn textarea_renders_as_textarea_element() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Textarea, "body", "Body");
    let res = render_widget(&tera, &w);
    assert_contains(res, "<textarea").await;
}

#[tokio::test]
async fn markdown_renders_with_markdown_data_attr() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Markdown, "body", "Body");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"data-widget-mode="markdown""#).await;
}

#[tokio::test]
async fn richtext_renders_without_the_markdown_toolbar() {
    // #856 — the TipTap editor brings its own toolbar; a markdown toolbar
    // on the same field showed a second one above it.
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::RichText, "body", "Body");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"data-widget-mode="richtext""#).await;
    let res = render_widget(&tera, &w);
    assert_not_contains(res, "data-md-toolbar-for").await;
}

#[tokio::test]
async fn email_renders_as_input_type_email() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Email, "addr", "Email");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="email""#).await;
}

#[tokio::test]
async fn url_renders_as_input_type_url() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Url, "site", "Website");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="url""#).await;
}

#[tokio::test]
async fn tel_renders_as_input_type_tel() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Tel, "phone", "Phone");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="tel""#).await;
}

#[tokio::test]
async fn password_renders_as_input_type_password() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Password, "pwd", "Password");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="password""#).await;
}

#[tokio::test]
async fn hidden_renders_as_input_type_hidden_with_no_label() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Hidden, "csrf", "CSRF").with_value("abc");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="hidden""#).await;
    // Hidden widgets MUST NOT render their label — that's the
    // whole point of being hidden.
    let res2 = render_widget(&tera, &w);
    assert_not_contains(res2, "<label").await;
}

#[tokio::test]
async fn number_renders_as_input_type_number_with_step() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Integer, "count", "Count");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="number""#).await;
    let res2 = render_widget(&tera, &w);
    assert_contains(res2, r#"step="1""#).await;
}

#[tokio::test]
async fn float_uses_step_any() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Float, "price", "Price");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"step="any""#).await;
}

#[tokio::test]
async fn range_renders_as_input_type_range_with_min_max() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Range, "vol", "Volume")
        .with_min(0.0)
        .with_max(100.0);
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="range""#).await;
    let res2 = render_widget(
        &tera,
        &Widget::new(WidgetKind::Range, "vol", "Volume")
            .with_min(0.0)
            .with_max(100.0),
    );
    assert_contains(res2, r#"max="100""#).await;
}

#[tokio::test]
async fn boolean_renders_as_checkbox() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Boolean, "active", "Active");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="checkbox""#).await;
}

#[tokio::test]
async fn boolean_with_value_on_renders_checked() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Boolean, "active", "Active").with_value("on");
    let res = render_widget(&tera, &w);
    assert_contains(res, "checked").await;
}

#[tokio::test]
async fn date_renders_as_input_type_date() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Date, "go_live", "Go live");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="date""#).await;
}

#[tokio::test]
async fn time_renders_as_input_type_time() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Time, "open", "Open");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="time""#).await;
}

#[tokio::test]
async fn datetime_renders_as_datetime_local() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Datetime, "starts", "Starts");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="datetime-local""#).await;
}

#[tokio::test]
async fn datetimetz_renders_paired_datetime_and_tz_select() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::DatetimeTz, "starts", "Starts");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="datetime-local""#).await;
    let res2 = render_widget(
        &tera,
        &Widget::new(WidgetKind::DatetimeTz, "starts", "Starts"),
    );
    assert_contains(res2, "America/New_York").await;
}

#[tokio::test]
async fn color_renders_as_input_type_color() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Color, "tint", "Tint").with_value("#ff8800");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="color""#).await;
    let res2 = render_widget(
        &tera,
        &Widget::new(WidgetKind::Color, "tint", "Tint").with_value("#ff8800"),
    );
    assert_contains(res2, "#ff8800").await;
}

#[tokio::test]
async fn color_without_a_value_falls_back_to_black() {
    // #851 — an unsaved colour field carries `""`; `type="color"` rejects
    // `value=""`, so the widget must fall back to a valid `#rrggbb`.
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Color, "tint", "Tint");
    let res = render_widget(&tera, &w);
    assert_contains(res, r##"value="#000000""##).await;
    let res = render_widget(&tera, &w);
    assert_not_contains(res, r#"value="""#).await;
}

#[tokio::test]
async fn file_renders_as_input_type_file() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::File, "doc", "Document");
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="file""#).await;
}

#[tokio::test]
async fn mediapicker_renders_as_media_chooser() {
    // The mediapicker widget is the shared media-picker dialog trigger:
    // a hidden input carrying the media id (FIRST control in the wrapper —
    // stream serialization takes the first input) + a "Choose an image…"
    // button wired via data-chooser-kind="media". Legacy `options` are
    // ignored by this arm (the picker fetches its own data).
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::MediaPicker, "hero", "Hero")
        .with_options([("1", "Banner one"), ("2", "Banner two")]);
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"data-chooser-kind="media""#).await;
    let res2 = render_widget(&tera, &Widget::new(WidgetKind::MediaPicker, "hero", "Hero"));
    assert_contains(res2, r#"name="hero""#).await;
    let res3 = render_widget(&tera, &Widget::new(WidgetKind::MediaPicker, "hero", "Hero"));
    assert_contains(res3, "data-chooser-open").await;
}

#[tokio::test]
async fn radio_renders_one_input_type_radio_per_option() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Radio, "size", "Size").with_options([
        ("s", "Small"),
        ("m", "Medium"),
        ("l", "Large"),
    ]);
    let res = render_widget(&tera, &w);
    assert_contains(res, r#"type="radio""#).await;
    let res2 = render_widget(
        &tera,
        &Widget::new(WidgetKind::Radio, "size", "Size").with_options([
            ("s", "Small"),
            ("m", "Medium"),
            ("l", "Large"),
        ]),
    );
    assert_contains(res2, "Medium").await;
}

#[tokio::test]
async fn select_renders_as_select_dropdown() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Select, "country", "Country")
        .with_options([("us", "United States"), ("uk", "United Kingdom")]);
    let res = render_widget(&tera, &w);
    assert_contains(res, "<select").await;
}

#[tokio::test]
async fn checkboxes_renders_multivalue_hidden_input_and_per_option_checkboxes() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Checkboxes, "tags", "Tags")
        .with_options([("a", "Alpha"), ("b", "Bravo")]);
    let res = render_widget(&tera, &w);
    // The multi-value contract — one hidden field that holds the
    // JSON-array string.
    assert_contains(res, r#"data-widget-multivalue="checkboxes""#).await;
    let res2 = render_widget(
        &tera,
        &Widget::new(WidgetKind::Checkboxes, "tags", "Tags")
            .with_options([("a", "Alpha"), ("b", "Bravo")]),
    );
    assert_contains(res2, r#"type="hidden""#).await;
}

#[tokio::test]
async fn multiselect_renders_native_select_multiple_with_hidden_companion() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::MultiSelect, "tags", "Tags").with_options([
        ("a", "Alpha"),
        ("b", "Bravo"),
        ("c", "Charlie"),
    ]);
    let res = render_widget(&tera, &w);
    assert_contains(res, "<select multiple").await;
}

#[tokio::test]
async fn required_renders_required_attr() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Text, "title", "Title").required();
    let res = render_widget(&tera, &w);
    assert_contains(res, "required").await;
}

#[tokio::test]
async fn read_only_renders_readonly_attr() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Text, "slug", "Slug")
        .with_value("locked")
        .read_only();
    let res = render_widget(&tera, &w);
    assert_contains(res, "readonly").await;
}

#[tokio::test]
async fn help_text_renders_under_input() {
    let tera = fresh_tera();
    let w = Widget::new(WidgetKind::Text, "slug", "Slug").with_help("Lowercase, hyphens only.");
    let res = render_widget(&tera, &w);
    assert_contains(res, "Lowercase, hyphens only.").await;
}

#[tokio::test]
async fn unknown_custom_name_surfaces_inline_error() {
    let tera = fresh_tera();
    let w = Widget::custom("unregistered_name", "loc", "Location");
    let res = render_widget(&tera, &w);
    // The macro's custom-widget branch emits a visible error when
    // `custom_html` is empty (registration missing). Editors see
    // this so misconfiguration is debuggable in-editor.
    assert_contains(res, "has no registered template").await;
}

#[tokio::test]
async fn custom_widget_html_renders_safely() {
    let tera = fresh_tera();
    let mut w = Widget::custom("latlng", "loc", "Location");
    // The admin handler stamps `custom_html` after looking up the
    // registered template; this test injects it directly to assert
    // the macro emits the HTML through `| safe`.
    w.custom_html = "<div class=\"map-preview\">42, -71</div>".to_owned();
    let res = render_widget(&tera, &w);
    assert_contains(res, "map-preview").await;
}

#[test]
fn widget_kind_as_tag_round_trips_via_serde() {
    // The macro's `{% if w.kind == "datetime" %}` checks depend on
    // `WidgetKind` serializing to its `as_tag()` form. Pin that
    // contract here so a refactor of either side surfaces.
    for kind in [
        WidgetKind::Text,
        WidgetKind::Textarea,
        WidgetKind::Markdown,
        WidgetKind::RichText,
        WidgetKind::Email,
        WidgetKind::Url,
        WidgetKind::Tel,
        WidgetKind::Password,
        WidgetKind::Hidden,
        WidgetKind::Number,
        WidgetKind::Integer,
        WidgetKind::Float,
        WidgetKind::Range,
        WidgetKind::Boolean,
        WidgetKind::Date,
        WidgetKind::Time,
        WidgetKind::Datetime,
        WidgetKind::DatetimeTz,
        WidgetKind::Color,
        WidgetKind::File,
        WidgetKind::MediaPicker,
        WidgetKind::Radio,
        WidgetKind::Select,
        WidgetKind::Checkboxes,
        WidgetKind::MultiSelect,
        WidgetKind::ModelChooser,
        WidgetKind::Custom,
    ] {
        let json = serde_json::to_string(&kind).expect("serialize");
        assert_eq!(
            json,
            format!("\"{}\"", kind.as_tag()),
            "WidgetKind serde does not match as_tag() for {kind:?}",
        );
    }
}