Skip to main content

teamcraft/
templates.rs

1//! HTML templates (MiniJinja), embedded into the binary at compile time.
2
3use minijinja::Environment;
4
5use crate::util;
6
7macro_rules! embed {
8    ($($name:literal),* $(,)?) => {
9        &[$(($name, include_str!(concat!("../templates/", $name)))),*]
10    };
11}
12
13/// All templates, keyed by their path below `templates/`.
14pub const TEMPLATES: &[(&str, &str)] = embed![
15    "base.html",
16    "macros.html",
17    "login.html",
18    "error.html",
19    "dashboard.html",
20    "explorer.html",
21    "items/list.html",
22    "items/new.html",
23    "items/label.html",
24    "items/where_used.html",
25    "revisions/show.html",
26    "revisions/edit.html",
27    "revisions/bom.html",
28    "revisions/bom_compare.html",
29    "revisions/mass.html",
30    "materials.html",
31    "revisions/bom_from_references.html",
32    "revisions/save_as.html",
33    "revisions/simulation_compare.html",
34    "changes/list.html",
35    "changes/new.html",
36    "changes/show.html",
37    "requests/list.html",
38    "requests/new.html",
39    "requests/show.html",
40    "projects/list.html",
41    "projects/show.html",
42    "projects/access_review.html",
43    "projects/access_log.html",
44    "projects/season.html",
45    "files/preview.html",
46    "admin/users.html",
47    "admin/user_edit.html",
48    "admin/holdings.html",
49    "admin/audit.html",
50    "admin/attributes.html",
51    "admin/attribute_edit.html",
52    "admin/webhooks.html",
53    "admin/webhook_edit.html",
54    "admin/branding.html",
55    "admin/ai.html",
56    "desktop/authorize.html",
57    "formats.html",
58    "imports/upload.html",
59    "imports/preview.html",
60    "notifications.html",
61    "account.html",
62    "assistant.html",
63];
64
65pub fn environment(instance_name: &str) -> Result<Environment<'static>, minijinja::Error> {
66    let mut env = Environment::new();
67    for (name, source) in TEMPLATES {
68        env.add_template(name, source)?;
69    }
70    env.add_filter("dt", filter_dt);
71    env.add_filter("num", filter_num);
72    env.add_filter("fixed", filter_fixed);
73    env.add_filter("sig", filter_sig);
74    env.add_filter("filesize", filter_filesize);
75    env.add_filter("label", filter_label);
76    env.add_filter("urlencode", |value: String| util::pct_encode(&value));
77    env.add_filter("age", filter_age);
78    env.add_global("instance_name", instance_name.to_string());
79    env.add_global("version", env!("CARGO_PKG_VERSION"));
80    // cache busting of the embedded stylesheets, scripts and logos
81    env.add_global("assets", crate::assets::version());
82    Ok(env)
83}
84
85/// RFC 3339 timestamp → `2026-11-03 14:05 UTC`. (The browser script
86/// rewrites `<time>` elements into the viewer's local time zone.)
87fn filter_dt(value: Option<String>) -> String {
88    match value {
89        Some(v) => match chrono::DateTime::parse_from_rfc3339(&v) {
90            Ok(t) => t
91                .with_timezone(&chrono::Utc)
92                .format("%Y-%m-%d %H:%M UTC")
93                .to_string(),
94            Err(_) => v,
95        },
96        None => "—".to_string(),
97    }
98}
99
100/// RFC 3339 timestamp → its age now (`3 days`, `5 h`, `just now`), e.g.
101/// how long a lock has been held; `—` for none.
102fn filter_age(value: Option<String>) -> String {
103    match value
104        .as_deref()
105        .and_then(|v| chrono::DateTime::parse_from_rfc3339(v).ok())
106    {
107        Some(t) => crate::domain::format_age(
108            (chrono::Utc::now() - t.with_timezone(&chrono::Utc)).num_seconds(),
109        ),
110        None => "—".to_string(),
111    }
112}
113
114/// Number with up to `decimals` (default 3) decimals; `—` for none.
115fn filter_num(value: Option<f64>, decimals: Option<usize>) -> String {
116    match value {
117        Some(v) => util::format_number(v, decimals.unwrap_or(3)),
118        None => "—".to_string(),
119    }
120}
121
122/// A number with exactly `decimals` places (default 2), so a column of
123/// costs or masses lines up at the decimal point; `—` when missing.
124fn filter_fixed(value: Option<f64>, decimals: Option<usize>) -> String {
125    match value {
126        Some(v) => format!("{v:.prec$}", prec = decimals.unwrap_or(2)),
127        None => "—".to_string(),
128    }
129}
130
131/// A physical value with six significant digits (mass properties span
132/// grams to tonnes and 10⁻⁹ to 10⁶ kg·m²); exponent form outside
133/// 10⁻³ … 10⁷; `—` when missing.
134fn filter_sig(value: Option<f64>) -> String {
135    match value {
136        None => "—".to_string(),
137        Some(v) if !v.is_finite() => "—".to_string(),
138        Some(0.0) => "0".to_string(),
139        Some(v) if (1e-3..1e7).contains(&v.abs()) => {
140            let decimals = (5 - v.abs().log10().floor() as i32).clamp(0, 9) as usize;
141            util::format_number(v, decimals)
142        }
143        Some(v) => format!("{v:.5e}"),
144    }
145}
146
147fn filter_filesize(value: i64) -> String {
148    util::format_bytes(value)
149}
150
151/// `in_review` → `In Review`; a few codes have fixed labels (`in_work` → `WIP`).
152fn filter_label(value: Option<String>) -> String {
153    let Some(value) = value else {
154        return String::new();
155    };
156    match value.as_str() {
157        "in_work" => return "WIP".into(),
158        "editor" => return "CAD editor".into(),
159        _ => {}
160    }
161    value
162        .split('_')
163        .filter(|w| !w.is_empty())
164        .map(|w| {
165            let mut c = w.chars();
166            match c.next() {
167                Some(first) => first.to_uppercase().collect::<String>() + c.as_str(),
168                None => String::new(),
169            }
170        })
171        .collect::<Vec<_>>()
172        .join(" ")
173}
174
175#[cfg(test)]
176mod accessibility;
177
178#[cfg(test)]
179mod tests {
180    use super::*;
181    use serde_json::{json, Value};
182    use std::cell::RefCell;
183
184    thread_local! {
185        /// Every page [`render`] produced on this thread, for the checks that
186        /// run over all of them (`every_rendered_page_is_accessible`).
187        static RENDERED: RefCell<Vec<(String, String)>> = const { RefCell::new(Vec::new()) };
188    }
189
190    const ME: &str = "11111111-1111-4111-8111-111111111111";
191    const OTHER: &str = "22222222-2222-4222-8222-222222222222";
192    const TS: &str = "2026-11-03T14:05:59.123456Z";
193
194    fn me() -> Value {
195        json!({ "id": ME, "username": "max", "display_name": "Max Muster", "initials": "MM", "avatar": 3, "role": "admin", "skin": "arch", "is_admin": true, "can_edit": true })
196    }
197
198    /// The Files card hint of `revisions/show.html` (`kind` as
199    /// `domain::FilesHint::as_str`), shaped like `web::revisions::show` sends it.
200    fn files_hint(kind: &str) -> Value {
201        json!({ "kind": kind, "can_revise": kind == "frozen", "type_hint": "STEP, drawings, <reports>" })
202    }
203
204    fn revision(state: &str, checked_out: bool) -> Value {
205        json!({
206            "id": "33333333-3333-4333-8333-333333333333", "item_id": "44444444-4444-4444-8444-444444444444",
207            "item_number": "PRT-000001", "item_type": "part", "unit": "each", "seq": 2, "code": "B",
208            "state": state, "name": "Bracket <b>", "description": "line 1\nline 2", "material": "AlMg3",
209            "mass_kg": 0.125, "unit_cost": null,
210            "checked_out_by": if checked_out { json!(OTHER) } else { Value::Null },
211            "checked_out_by_name": if checked_out { json!("Erika") } else { Value::Null },
212            "checked_out_at": if checked_out { json!(TS) } else { Value::Null },
213            "created_by": ME, "created_by_name": "Max Muster",
214            "created_at": TS, "updated_at": TS, "released_at": null
215        })
216    }
217
218    fn item() -> Value {
219        json!({
220            "id": "44444444-4444-4444-8444-444444444444", "number": "PRT-000001", "item_type": "part",
221            "unit": "each", "project_id": null, "project_code": "ROCKET", "created_by": ME,
222            "created_by_name": "Max Muster", "created_at": TS,
223            "owner_id": ME, "owner_name": "Max Muster"
224        })
225    }
226
227    fn change(status: &str) -> Value {
228        json!({
229            "id": "55555555-5555-4555-8555-555555555555", "number": "CHG-000001", "title": "Release bracket",
230            "description": "why", "priority": "high", "status": status, "created_by": ME,
231            "created_by_name": "Max Muster", "created_at": TS, "updated_at": TS,
232            "submitted_at": TS, "closed_at": null
233        })
234    }
235
236    fn request(status: &str) -> Value {
237        json!({
238            "id": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", "number": "ECR-000001", "title": "Crack <at> the weld",
239            "description": "Problem\nproposal", "reason": "manufacturing", "priority": "high", "status": status,
240            "requested_by": OTHER, "requested_by_name": "Erika", "assignee": ME, "assignee_name": "Max Muster",
241            "assignee_username": "max", "decision_comment": "not now", "decided_by": ME,
242            "decided_by_name": "Max Muster", "decided_at": TS, "due_date": "2026-12-01", "created_at": TS,
243            "updated_at": TS, "closed_at": null, "item_count": 1
244        })
245    }
246
247    fn audit_entry() -> Value {
248        json!({ "id": 1, "at": TS, "user_id": ME, "username": "max", "action": "item.create",
249                "entity_type": "item", "entity_id": "44444444-4444-4444-8444-444444444444",
250                "summary": "Created Part PRT-000001", "details": {} })
251    }
252
253    fn user() -> Value {
254        json!({ "id": OTHER, "username": "erika", "display_name": "Erika", "email": null,
255                "auth_source": "local", "role": "editor", "active": true, "created_at": TS, "last_login_at": null,
256                "skin": "teamcraft" })
257    }
258
259    const ROCKET: &str = "66666666-6666-4666-8666-666666666666";
260
261    fn project() -> Value {
262        json!({ "id": ROCKET, "code": "ROCKET", "name": "Sounding rocket",
263                "description": "Rocketry", "active": true, "created_at": TS,
264                "oidc_group": "teamcraft-rocket", "member_count": 3, "created_by": ME })
265    }
266
267    fn roles() -> Value {
268        json!([{ "value": "viewer", "label": "Viewer" }, { "value": "editor", "label": "CAD editor" },
269               { "value": "admin", "label": "Admin" }])
270    }
271
272    fn page() -> Value {
273        json!({ "page": 1, "pages": 2, "total": 60, "prev": null, "next": 2 })
274    }
275
276    fn with_common(mut data: Value) -> Value {
277        let map = data.as_object_mut().unwrap();
278        map.insert("me".into(), me());
279        map.insert(
280            "flash".into(),
281            json!({ "kind": "success", "message": "Saved <ok>" }),
282        );
283        map.insert("local_login".into(), json!(true));
284        map.insert("skin".into(), json!("arch"));
285        map.insert("skin_scheme".into(), json!("dark"));
286        map.insert(
287            "branding".into(),
288            json!({ "wide": "aaaabbbbcccc", "square": "ddddeeeeffff" }),
289        );
290        data
291    }
292
293    fn render(env: &Environment<'static>, name: &str, data: Value) -> String {
294        let html = env
295            .get_template(name)
296            .unwrap_or_else(|e| panic!("{name}: {e:#}"))
297            .render(&data)
298            .unwrap_or_else(|e| panic!("{name}: {e:#}"));
299        RENDERED.with(|r| r.borrow_mut().push((name.to_string(), html.clone())));
300        html
301    }
302
303    /// Every page of `every_template_renders` – all templates in all the
304    /// states it renders – passes the accessibility checks
305    /// (`templates/accessibility.rs`).
306    #[test]
307    fn every_rendered_page_is_accessible() {
308        RENDERED.with(|r| r.borrow_mut().clear());
309        every_template_renders();
310        let pages = RENDERED.with(|r| r.take());
311        assert!(pages.len() > 60, "rendered pages: {}", pages.len());
312        let mut problems: Vec<String> = pages
313            .iter()
314            .flat_map(|(name, html)| accessibility::check(name, html))
315            .collect();
316        problems.sort();
317        problems.dedup();
318        assert!(
319            problems.is_empty(),
320            "{} accessibility problems:\n{}",
321            problems.len(),
322            problems.join("\n")
323        );
324    }
325
326    #[test]
327    fn every_template_renders() {
328        let env = environment("TeamCraft Test").expect("templates compile");
329        let bom_line = json!({
330            "id": "77777777-7777-4777-8777-777777777777", "parent_revision_id": "33333333-3333-4333-8333-333333333333",
331            "child_item_id": "88888888-8888-4888-8888-888888888888", "child_number": "PRT-000002",
332            "child_type": "part", "child_unit": "each", "find_number": 10, "quantity": 4.0, "notes": "M6",
333            "child_latest_revision_id": "99999999-9999-4999-8999-999999999999", "child_latest_code": "A",
334            "child_latest_state": "released", "child_name": "Bolt"
335        });
336        let version = |n: i32, comment: &str| {
337            json!({ "id": ME, "file_id": OTHER, "version": n, "sha256": "cd".repeat(32), "size_bytes": 1000,
338                    "content_type": "application/pdf", "comment": comment, "uploaded_by": ME,
339                    "uploaded_by_name": "Max", "uploaded_at": TS })
340        };
341        let file = json!({ "id": OTHER, "revision_id": ME, "filename": "nozzle.step", "content_type": "model/step",
342                           "size_bytes": 123456, "sha256": "ab".repeat(32), "uploaded_by": ME,
343                           "uploaded_by_name": "Max", "uploaded_at": TS, "version": 2, "preview": true, "folder": "rover/nozzle",
344                           "format": "step", "format_info": crate::cadformat::info("step"),
345                           "versions": [version(2, "wall 2.5 mm"), version(1, "")] });
346        let native = json!({ "id": ME, "revision_id": ME, "filename": "nozzle.SLDPRT",
347                             "content_type": "application/octet-stream", "size_bytes": 4096,
348                             "sha256": "ef".repeat(32), "uploaded_by": ME, "uploaded_by_name": "Max",
349                             "uploaded_at": TS, "version": 1, "preview": false, "format": "solidworks-part",
350                             "format_info": crate::cadformat::info("solidworks-part"),
351                             "versions": [version(1, "")] });
352        let unknown = json!({ "id": OTHER, "revision_id": ME, "filename": "notes.xyz",
353                              "content_type": "application/x-unknown", "size_bytes": 10,
354                              "sha256": "12".repeat(32), "uploaded_by": ME, "uploaded_by_name": "Max",
355                              "uploaded_at": TS, "version": 1, "preview": false, "format": "",
356                              "format_info": null, "versions": [version(1, "")] });
357        let impact = |resolution: Option<&str>| {
358            json!({ "id": ME, "item_id": ME, "item_number": "ASM-000001", "project_id": ROCKET,
359                    "project_code": "ROCKET", "revision_id": OTHER, "revision_code": "A",
360                    "revision_state": "released", "item_name": "Stage <1>", "source_item_id": OTHER,
361                    "source_number": "PRT-000001", "source_revision_id": ME, "source_code": "B",
362                    "source_name": "Bracket", "event": "released", "relation": "bom",
363                    "detail": "find no. 10", "change_id": ME, "change_number": "CHG-000002",
364                    "created_at": TS, "resolved_at": resolution.map(|_| TS), "resolution": resolution,
365                    "resolved_by_name": resolution.map(|_| "Erika"),
366                    "note": if resolution.is_some() { "fit unchanged <ok>" } else { "" } })
367        };
368        // services::impacts::DependentGroup: two sources on one dependent
369        let impact_group = || {
370            let mut obsolete = impact(None);
371            obsolete["id"] = json!(OTHER);
372            obsolete["source_number"] = json!("PRT-000002");
373            obsolete["event"] = json!("obsolete");
374            obsolete["relation"] = json!("file");
375            obsolete["detail"] = json!("Stage.SLDASM references Nut.SLDPRT");
376            obsolete["change_id"] = json!(null);
377            obsolete["change_number"] = json!(null);
378            json!({ "item_id": ME, "item_number": "ASM-000001", "item_name": "Stage <1>", "project_id": ROCKET,
379                    "project_code": "ROCKET", "revision_id": OTHER, "revision_code": "A",
380                    "revision_state": "released", "latest_at": TS, "impact_ids": format!("{ME},{OTHER}"),
381                    "impacts": [impact(None), obsolete] })
382        };
383        let references = json!({
384            "outgoing": [{ "id": ME, "from_revision_id": ME, "to_item_id": OTHER, "to_number": "PRT-000009",
385                           "to_type": "part", "kind": "drawing", "note": "sheet 2", "to_latest_revision_id": OTHER,
386                           "to_latest_code": "C", "to_latest_state": "released", "to_name": "Nozzle",
387                           "released_to_revision_id": OTHER, "released_to_code": "B", "created_at": TS }],
388            "incoming": [{ "reference_id": ME, "kind": "specification", "note": "", "from_revision_id": OTHER,
389                           "from_item_id": OTHER, "from_number": "DOC-000003", "from_code": "A",
390                           "from_name": "Welding spec", "from_state": "released", "released_to_code": "A" }],
391            "files": [{ "file_id": ME, "filename": "Stage.SLDASM", "format_kind": "assembly", "references": [
392                { "name": "bracket.sldprt", "matches": [{ "item_id": OTHER, "item_number": "PRT-000001",
393                  "item_name": "Bracket", "revision_id": OTHER, "revision_code": "B", "revision_state": "released",
394                  "file_id": OTHER, "filename": "Bracket.SLDPRT", "same_revision": false,
395                  "export_name": false }] },
396                { "name": "nozzle.stp", "matches": [{ "item_id": OTHER, "item_number": "PRT-000002",
397                  "item_name": "Nozzle", "revision_id": OTHER, "revision_code": "A", "revision_state": "in_work",
398                  "file_id": OTHER, "filename": "nozzle_v2.stp", "same_revision": false,
399                  "export_name": true }] },
400                { "name": "Bolt M6.SLDPRT", "matches": [] }] }],
401            "file_referrers": [{ "item_id": OTHER, "item_number": "DOC-000004", "revision_id": OTHER,
402                                 "revision_code": "A", "revision_state": "in_work", "item_name": "Stage drawing",
403                                 "file_id": OTHER, "filename": "Stage.SLDDRW", "referenced": "Stage.SLDASM",
404                                 "export_name": true }],
405            "suggestions": {
406                "bom": [{ "item_number": "PRT-000001", "item_name": "Bracket", "via": "Stage.SLDASM → Bracket.SLDPRT" }],
407                "drawing_of": [{ "item_number": "PRT-000007", "item_name": "Hub", "via": "Hub.SLDDRW → Hub.SLDPRT" }] },
408            "kinds": crate::domain::ReferenceKind::ALL.iter()
409                .map(|k| json!({ "value": k.as_str(), "label": k.label() })).collect::<Vec<_>>(),
410        });
411        let can_all = json!({ "edit": true, "checkout": true, "checkin": true, "cancel_checkout": true,
412                              "revise": true, "obsolete": true, "delete": true, "master": true, "owner": true,
413                              "add_to_change": true, "acknowledge": true });
414
415        let html = render(
416            &env,
417            "dashboard.html",
418            with_common(json!({
419                "stats": { "items": 3, "revisions_in_work": 1, "revisions_in_review": 0, "revisions_released": 2,
420                           "open_changes": 1, "files": 4, "stored_bytes": 2048 },
421                "checkouts": [revision("in_work", true)], "reviews": [change("in_review")],
422                "my_changes": [change("draft")], "activity": [audit_entry()], "impact_groups": [impact_group()],
423                "assigned_requests": [request("in_triage")], "my_requests": [request("new")],
424            })),
425        );
426        assert!(
427            html.contains("Requests assigned to me") && html.contains("due 2026-12-01"),
428            "change requests on the dashboard"
429        );
430        assert!(html.contains("Saved &lt;ok&gt;"), "flash is escaped");
431        assert!(html.contains("2 KiB"));
432        assert!(
433            html.contains("Dependents to check")
434                && html.contains("uses it in its BOM")
435                && html.contains("Stage &lt;1&gt;"),
436            "open impacts on the dashboard"
437        );
438        for expected in [
439            "2 changes to check",
440            "Acknowledge all…",
441            "/revisions/22222222-2222-4222-8222-222222222222/impacts/acknowledge",
442            "BOM line",
443            "CAD file reference",
444            "via <a class=\"mono\" href=\"/changes/",
445            "badge-obsolete",
446            "resolves all 2 as well",
447            "/revise",
448        ] {
449            assert!(html.contains(expected), "grouped impacts show {expected}");
450        }
451        assert_eq!(
452            html.matches("resolves all 2 as well").count(),
453            1,
454            "the revise hint once per group"
455        );
456
457        let entry = json!({ "item_id": ME, "number": "PRT-000001", "item_type": "part", "project_id": ROCKET,
458                            "project_code": "ROCKET", "revision_id": revision("in_work", true)["id"],
459                            "code": "A", "name": "Bracket <b>",
460                            "state": "in_work", "checked_out_by": ME, "checked_out_by_name": "Max Muster",
461                            "checked_out_at": TS, "updated_at": TS, "file_count": 2 });
462        let html = render(
463            &env,
464            "explorer.html",
465            with_common(json!({
466                "folders": [{ "id": ROCKET, "code": "ROCKET", "name": "Sounding rocket", "items": 3, "locked": 1 }],
467                "folder": ROCKET, "entries": [entry], "limit": 500, "q": "",
468                "selected": { "rev": revision("in_work", true), "files": [file.clone()],
469                              "file_groups": [{ "files": [file.clone()], "collapsed": false }],
470                              "can": { "checkout": false, "checkin": true, "cancel_checkout": true } },
471                "back": crate::util::pct_encode(&format!("/vault?folder={ROCKET}&rev={OTHER}")),
472                "max_upload_mb": 512,
473            })),
474        );
475        for expected in [
476            "Sounding rocket",
477            "Bracket &lt;b&gt;",
478            "Check in and release",
479            "/cancel-checkout?back=",
480            "?back=%2Fvault%3Ffolder%3D",
481            "enctype=\"multipart/form-data\"",
482            "class=\"selected\"",
483        ] {
484            assert!(html.contains(expected), "vault explorer shows {expected}");
485        }
486        let html = render(
487            &env,
488            "explorer.html",
489            with_common(
490                json!({ "folders": [], "folder": "mine", "entries": [], "limit": 500, "q": "",
491                                "selected": null, "back": "%2Fvault", "max_upload_mb": 512 }),
492            ),
493        );
494        assert!(html.contains("You have nothing checked out"));
495
496        // Save As and the BOM comparison
497        let html = render(
498            &env,
499            "revisions/save_as.html",
500            with_common(
501                json!({ "rev": revision("released", false), "projects": [project()],
502                                "file_count": 3, "line_count": 2 }),
503            ),
504        );
505        assert!(
506            html.contains("Copy the current files (3)") && html.contains("Copy the BOM (2 lines)")
507        );
508        assert!(html.contains("/save-as") && html.contains("ROCKET"));
509        let diff = |level: usize, change: &str, before: Value, after: Value| {
510            json!({ "level": level, "change": change, "child_item_id": OTHER, "child_number": "PRT-000002",
511                    "child_name": "Bolt <M6>", "unit": "each", "before": before, "after": after })
512        };
513        let values = |find: i32, qty: f64, rev: Value| json!({ "find_number": find, "quantity": qty, "notes": "", "revision": rev });
514        let diffs = json!([
515            diff(1, "added", Value::Null, values(10, 2.0, Value::Null)),
516            diff(1, "removed", values(20, 1.0, Value::Null), Value::Null),
517            diff(
518                1,
519                "changed",
520                values(30, 1.0, Value::Null),
521                values(30, 4.0, Value::Null)
522            )
523        ]);
524        let summary = json!({ "added": 1, "removed": 1, "changed": 1, "unchanged": 0 });
525        let html = render(
526            &env,
527            "revisions/bom_compare.html",
528            with_common(json!({
529                "rev": revision("in_work", false), "before": revision("released", false),
530                "after": revision("in_work", false), "revisions": [revision("in_work", false)],
531                "depth": "1", "rule": "latest", "diffs": diffs, "summary": summary,
532            })),
533        );
534        assert!(html.contains("1 added · 1 removed · 1 changed"));
535        assert!(html.contains("bom-diff-removed") && html.contains("Bolt &lt;M6&gt;"));
536        assert!(
537            !html.contains("<th scope=\"col\">Lvl</th>"),
538            "levels only over all levels"
539        );
540        let deep = render(
541            &env,
542            "revisions/bom_compare.html",
543            with_common(json!({
544                "rev": revision("in_work", false), "before": revision("released", false),
545                "after": revision("in_work", false), "revisions": [revision("in_work", false)],
546                "depth": "all", "rule": "as_released", "summary": summary,
547                "diffs": [diff(1, "changed", values(10, 1.0, json!("A")), values(10, 1.0, json!("B"))),
548                          diff(2, "added", Value::Null, values(10, 2.0, json!("A"))),
549                          diff(9, "removed", values(20, 1.0, Value::Null), Value::Null)],
550            })),
551        );
552        assert!(
553            deep.contains("<th scope=\"col\">Lvl</th>")
554                && deep.contains("indent-2")
555                && deep.contains("indent-deep")
556        );
557        assert!(
558            deep.contains("A → <strong>B</strong>"),
559            "a new child revision"
560        );
561        assert!(deep.contains("value=\"all\" selected"));
562
563        render(
564            &env,
565            "login.html",
566            json!({ "next": "/", "next_encoded": "%2F", "error": "bad", "oidc_name": "Single Sign-On",
567                                           "username": "max", "local_login": true, "flash": null }),
568        );
569        // first start without the setup link: where to find it
570        render(
571            &env,
572            "login.html",
573            json!({ "next": "/", "next_encoded": "%2F", "setup_needs_code": true, "local_login": true, "flash": null }),
574        );
575        render(
576            &env,
577            "error.html",
578            json!({ "status": 404, "reason": "Not Found", "message": "gone", "flash": null, "local_login": true }),
579        );
580        let html = render(
581            &env,
582            "error.html",
583            json!({ "status": 404, "reason": "Not Found", "message": "gone", "flash": null, "local_login": true,
584                    "branding": { "wide": "aaaabbbbcccc", "square": null } }),
585        );
586        assert!(html.contains("/branding/wide?v=aaaabbbbcccc"));
587        assert!(!html.contains("TeamCraft_Logo_White.svg"));
588
589        let html = render(
590            &env,
591            "items/list.html",
592            with_common(json!({
593                "items": [{ "id": ME, "number": "PRT-000001", "item_type": "part", "unit": "each", "project_code": null,
594                            "created_at": TS, "latest_revision_id": OTHER, "latest_code": "A", "latest_state": "in_work",
595                            "name": "Bracket", "matched_file": "bracket.step", "classification": "purchased",
596                            "attributes": { "vendor": "Bosch" } }],
597                "pagination": page(), "base_query": "q=a%20b",
598                "filter": { "q": "a b", "type": "part", "project": "", "state": "", "system": "creo",
599                            "class": "purchased", "attr": "vendor", "value": "Bo" },
600                "filter_error": "Length: 'abc' is not a number.",
601                "projects": [project()], "types": [{ "value": "part", "label": "Part" }],
602                "states": [{ "value": "in_work", "label": "In Work" }],
603                "systems": crate::cadformat::SYSTEMS,
604                "classifications": [{ "value": "make", "label": "In-house" }, { "value": "purchased", "label": "Purchased" }],
605                "attribute_defs": [{ "key": "vendor", "label": "Vendor", "unit": "", "active": true }],
606            })),
607        );
608        assert!(
609            html.contains("<option value=\"creo\" selected>PTC Creo"),
610            "CAD program filter"
611        );
612        assert!(
613            html.contains("<option value=\"vendor\" selected>Vendor"),
614            "attribute filter"
615        );
616        assert!(html.contains("badge-member\" title=\"Classification\">purchased"));
617        assert!(
618            html.contains("name=\"class\" value=\"purchased\""),
619            "saved searches keep the class"
620        );
621        assert!(html.contains("is not a number"), "filter errors are shown");
622
623        let html = render(
624            &env,
625            "formats.html",
626            with_common(
627                json!({ "systems": crate::cadformat::catalogue(), "previews": [".stl", ".step"] }),
628            ),
629        );
630        for expected in [
631            "SolidWorks assembly",
632            ".sldasm",
633            "NX part",
634            "Creo part",
635            ".catproduct",
636            "JT visualisation",
637            ".x_t",
638            "/items?system=inventor",
639            "by content",
640        ] {
641            assert!(html.contains(expected), "formats page lists {expected}");
642        }
643        render(
644            &env,
645            "items/new.html",
646            with_common(json!({
647                "form": { "item_type": "part", "number": "", "name": "", "description": "", "project_id": "",
648                          "unit": "each", "material": "", "mass_kg": "", "unit_cost": "" },
649                "error": "Name must not be empty.", "projects": [project()], "materials": [],
650                "types": [{ "value": "part", "label": "Part" }], "units": units(),
651            })),
652        );
653        // new simulation based on a revision
654        let html = render(
655            &env,
656            "items/new.html",
657            with_common(json!({
658                "form": { "item_type": "simulation", "number": "", "name": "Simulation – Bracket",
659                          "description": "Analysis.", "project_id": "", "basis": OTHER,
660                          "basis_role": "geometry", "unit": "", "material": "", "mass_kg": "",
661                          "unit_cost": "" },
662                "error": null, "projects": [project()], "materials": [],
663                "types": [{ "value": "simulation", "label": "Simulation" }], "units": units(),
664                "basis": { "revision_id": OTHER, "item_number": "PRT-000002", "code": "A",
665                           "label": "PRT-000002/A", "name": "Bracket <1>" },
666                "basis_roles": [{ "value": "geometry", "label": "Geometry" }],
667                "basis_other_group": true, "number_hint": "SIM-000007",
668            })),
669        );
670        assert!(html.contains("PRT-000002") && html.contains("SIM-000007"));
671        assert!(html.contains("Bracket &lt;1&gt;"));
672        assert!(!html.contains("name=\"mass_kg\""));
673
674        // alternates, supersession and replace in assemblies
675        let linked = |number: &str, restricted: bool| {
676            json!({ "item_id": OTHER, "number": number, "item_type": "part", "name": "Bolt <M6>",
677                    "latest_revision_id": OTHER, "latest_code": "B", "latest_state": "released",
678                    "note": "second <source>", "created_by_name": "Erika", "created_at": TS,
679                    "two_way": true, "restricted": restricted })
680        };
681        let usage = |level: i32, state: &str| {
682            json!({ "level": level, "child_number": "PRT-000001", "line_id": ME, "parent_revision_id": OTHER,
683                    "parent_item_id": ME, "parent_number": "ASM-000001", "parent_code": "A",
684                    "parent_name": "Stage <1>", "parent_state": state, "find_number": 10, "quantity": 2.0,
685                    "released_child_code": null })
686        };
687        let plan_row = |action: &str, label: &str| {
688            json!({ "line_id": ME, "find_number": 10, "quantity": 4.0, "parent_item_id": ME,
689                    "parent_number": "ASM-000003", "parent_revision_id": OTHER, "parent_code": "B",
690                    "parent_name": "Frame <2>", "parent_state": "in_work", "checked_out_by_name": "Max",
691                    "action": action, "action_label": label })
692        };
693        let html = render(
694            &env,
695            "items/label.html",
696            with_common(json!({
697                "rev": revision("released", false),
698                "url": "https://plm.example.org/i/PRT-000001",
699            })),
700        );
701        // (MiniJinja escapes `/` in text as `&#x2f;`)
702        assert!(
703            html.contains("qr.svg") && html.contains("plm.example.org"),
704            "{html}"
705        );
706        for (with_plan, restricted) in [(true, false), (false, true)] {
707            let html = render(
708                &env,
709                "items/where_used.html",
710                with_common(json!({
711                    "item": item(), "latest": revision("released", false), "levels": 25,
712                    "level_options": [{ "value": 1, "label": "1 level" }, { "value": 25, "label": "All levels" }],
713                    "rows": [usage(1, "released"), usage(2, "in_work")], "truncated": with_plan, "hidden": 2,
714                    "successor": linked("PRT-000002", restricted), "alternates": [linked("PRT-000003", false)],
715                    "with": "PRT-000002",
716                    "plan": if with_plan { json!({
717                        "old_item_id": ME, "old_number": "PRT-000001", "new_item_id": OTHER,
718                        "new_number": "PRT-000002", "replaced": 1, "hidden": 1,
719                        "rows": [plan_row("replace", "will be replaced"),
720                                 plan_row("checked_out", "checked out by somebody else")],
721                    }) } else { Value::Null },
722                    "plan_error": if with_plan { Value::Null } else { json!("Item 'X' not <found>.") },
723                    "can_replace": true,
724                })),
725            );
726            assert!(html.contains("Stage &lt;1&gt;"), "names are escaped");
727            assert!(html.contains("+2 assemblies"), "hidden count");
728            assert_eq!(html.contains("Replace in 1 BOM line"), with_plan);
729            assert_eq!(html.contains("(Max)"), with_plan, "who has it checked out");
730            assert_eq!(html.contains("not &lt;found&gt;"), !with_plan);
731            assert_eq!(html.contains("Restricted item"), restricted);
732        }
733
734        for (state, checked_out) in [("in_work", true), ("in_work", false), ("released", false)] {
735            let source = json!({ "file_id": OTHER, "filename": "nozzle.step", "sha256": "cd".repeat(32), "format": "step" });
736            let similar = if checked_out {
737                json!({ "status": "pending", "message": "computing", "source": source,
738                        "signature": null, "ignore_scale": false, "candidates": [] })
739            } else {
740                json!({ "status": "ready", "message": null, "source": source, "ignore_scale": false,
741                        "signature": { "extents": [120.0, 40.0, 8.0], "area": 1.0, "volume": null, "closed": false, "triangles": 12 },
742                        "candidates": [{
743                            "item_id": ME, "item_number": "PRT-000007", "item_type": "part", "project_code": "ROCKET",
744                            "revision_id": OTHER, "revision_code": "B", "state": "released", "name": "Nozzle <i>",
745                            "file_id": OTHER, "filename": "old-nozzle.stl", "identical": false,
746                            "score": 91, "shape": 94, "size": 97, "extents": [118.0, 40.0, 8.0],
747                            "explanation": "extents 118 × 40 × 8 vs 120 × 40 × 8, shape distribution 94 % similar",
748                            "thumbnail_file_id": if state == "released" { json!(ME) } else { json!(null) },
749                        }] })
750            };
751            // a manager looking at an active member's lock: the reason form
752            let mut can_rev = can_all.clone();
753            can_rev["release_with_reason"] = json!(checked_out);
754            let html = render(
755                &env,
756                "revisions/show.html",
757                with_common(json!({
758                    "files_hint": files_hint(if state == "released" { "frozen" } else if checked_out { "upload" } else { "checkout" }),
759                    "rev": revision(state, checked_out), "item": item(), "revisions": [revision(state, checked_out)],
760                    "hidden": { "parents": 2, "incoming": 1, "changes": 1, "simulations": 0 },
761                    "is_latest": false, "latest_id": OTHER, "files": [file.clone(), native.clone(), unknown.clone()],
762                    "file_groups": [{ "files": [file.clone(), unknown.clone()], "collapsed": false },
763                                    { "files": [native.clone()], "collapsed": true, "count": 1, "families": "SolidWorks" }],
764                    "native_without_preview": state == "released", "lines": [bom_line.clone()],
765                    "where_used": [{ "line_id": ME, "parent_revision_id": OTHER, "parent_item_id": ME,
766                                     "parent_number": "ASM-000001", "parent_code": "A", "parent_name": "Assembly",
767                                     "parent_state": "released", "find_number": 10, "quantity": 2.0 }],
768                    "changes": [change("draft")], "open_change": change("draft"), "drafts": [change("draft")],
769                    "history": [audit_entry()], "projects": [project()], "units": units(),
770                    "references": references.clone(), "impact_groups": [impact_group()],
771                    "resolved_impacts": [impact(Some("acknowledged"))],
772                    "open_requests": [request("in_triage")], "similar": similar,
773                    "can": can_rev,
774                    "release_reason": { "min": 10, "max": 500 },
775                    "max_upload_mb": 512, "assistant_enabled": state == "released",
776                    "interchange": {
777                        "alternates": [linked("PRT-000003", false)],
778                        "alternate_for": [linked("PRT-000004", false)],
779                        "successor": linked("PRT-000002", false),
780                        "predecessors": [linked("PRT-000006", false)],
781                        "superseded": { "88888888-8888-4888-8888-888888888888": "PRT-000005" },
782                        "can_edit": checked_out,
783                    },
784                    "lifecycle": {
785                        "states": crate::domain::LifecycleState::ALL,
786                        "next": crate::domain::rules_from(crate::domain::LifecycleState::parse(state).unwrap()),
787                        "rules": crate::domain::LIFECYCLE_RULES,
788                    },
789                    "attribute_rows": [{ "key": "length", "label": "Length", "unit": "mm", "value": "12.5", "active": true },
790                                       { "key": "old", "label": "Old <code>", "unit": "", "value": "x", "active": false }],
791                    "classifications": [{ "value": "make", "label": "In-house" }, { "value": "purchased", "label": "Purchased" }],
792                })),
793            );
794            // preferred CAD program: the other program's file in a <details>
795            let (open, rest) = html
796                .split_once("<details class=\"other-formats\"")
797                .expect("collapsed group of other CAD formats");
798            assert!(open.contains("nozzle.step") && !open.contains(">nozzle.SLDPRT<"));
799            assert!(rest.contains("1 file in other CAD formats (SolidWorks)"));
800            assert!(rest.contains(">nozzle.SLDPRT<"));
801            assert_eq!(
802                html.contains("name=\"reason\" minlength=\"10\" maxlength=\"500\" required"),
803                checked_out,
804                "a manager releases an active member's lock with a reason"
805            );
806            assert!(
807                html.contains("aria-current=\"step\""),
808                "current lifecycle state is marked"
809            );
810            assert!(html.contains("<dd>12.5 mm</dd>") && html.contains("Old &lt;code&gt;"));
811            assert!(
812                html.contains("no longer in use"),
813                "inactive attributes are marked"
814            );
815            assert!(
816                html.contains("name=\"classification\""),
817                "classification in the master data"
818            );
819            for expected in [
820                "is superseded by",
821                "Superseded by PRT-000005",
822                "id=\"interchange\"",
823                "PRT-000003",
824                "may be replaced by",
825                "supersedes",
826                "second &lt;source&gt;",
827                "/where-used",
828            ] {
829                assert!(html.contains(expected), "revision page shows {expected}");
830            }
831            assert_eq!(
832                html.contains("Add alternate"),
833                checked_out,
834                "forms only for editors of the group"
835            );
836            assert!(html.contains("four-eyes principle"), "rules are listed");
837            if checked_out {
838                assert!(
839                    html.contains("Comparing the shape of nozzle.step"),
840                    "similar parts pending"
841                );
842            } else {
843                assert!(
844                    html.contains("PRT-000007/B")
845                        && html.contains("Nozzle &lt;i&gt;")
846                        && html.contains("shape distribution 94 % similar")
847                        && html.contains("value=\"91\""),
848                    "similar parts listed"
849                );
850            }
851            assert!(html.contains("Bracket &lt;b&gt;"), "names are escaped");
852            assert!(
853                html.contains("/files/") && html.contains("/restore"),
854                "rollback offered"
855            );
856            assert!(html.contains("Check in and release"), "check-in form");
857            assert!(
858                html.contains(&format!("/files/{OTHER}/preview"))
859                    && html.contains(&format!("/file-versions/{ME}/preview")),
860                "3D preview of the file and of its versions"
861            );
862            assert!(
863                html.contains("STEP (ISO 10303)")
864                    && html.contains("fmt fmt-exchange")
865                    && html.contains("SolidWorks part")
866                    && html.contains("fmt fmt-part"),
867                "format labels"
868            );
869            for expected in [
870                "Check needed:",
871                "/acknowledge",
872                "Drawing of",
873                "PRT-000009",
874                "released with",
875                "Welding spec",
876                "not in TeamCraft",
877                "Add to BOM",
878                "Hub.SLDDRW",
879                "Stage.SLDDRW references Stage.SLDASM",
880                "fit unchanged &lt;ok&gt;",
881                "Request change…",
882                "1 open change request on",
883                "file=nozzle.step",
884            ] {
885                assert!(html.contains(expected), "revision page shows {expected}");
886            }
887            assert!(
888                html.contains("x-unknown"),
889                "unknown formats show the content type"
890            );
891            assert_eq!(
892                html.contains("No 3D preview for native CAD files"),
893                state == "released",
894                "hint for native files without a neutral export"
895            );
896            // the sidebar: icon and drawer only when the assistant is enabled;
897            // the page declares where the user is (identifiers only)
898            assert_eq!(
899                html.contains("id=\"assistant-drawer\"")
900                    && html.contains("id=\"assistant-toggle\""),
901                state == "released",
902                "assistant sidebar only when enabled"
903            );
904            assert!(
905                html.contains("data-tc-kind=\"revision\"")
906                    && html.contains("data-tc-item=\"PRT-000001\"")
907                    && html.contains("data-tc-revision=\"B\""),
908                "the revision page declares its context"
909            );
910        }
911
912        // Simulations: basis links and results on the simulation, the
913        // simulations based on a part on the part
914        let basis = |out_of_date: Option<&str>| {
915            json!({ "id": ME, "revision_id": OTHER, "role": "geometry", "note": "fillet <r2>",
916                    "basis_item_id": OTHER, "basis_number": "PRT-000001", "basis_type": "part",
917                    "basis_revision_id": OTHER, "basis_code": "A", "basis_state": "released",
918                    "basis_name": "Bracket", "file_version_id": ME, "file_id": OTHER,
919                    "file_name": "bracket.step", "file_version": 2, "file_current_version": 3,
920                    "released_revision_id": ME, "released_code": "B", "created_at": TS,
921                    "out_of_date": out_of_date })
922        };
923        let sim_result = |name: &str, status: &str, upper: Option<f64>| {
924            json!({ "id": ME, "revision_id": OTHER, "position": 1, "name": name, "value": 182.5,
925                    "unit": "MPa", "lower_limit": null, "upper_limit": upper, "load_case": "LC1",
926                    "solver": "CalculiX", "solver_version": "2.21", "note": "", "updated_at": TS,
927                    "status": status })
928        };
929        let basis_roles: Vec<_> = crate::domain::BasisRole::ALL
930            .iter()
931            .map(|r| json!({ "value": r.as_str(), "label": r.label() }))
932            .collect();
933        for (state, checked_out) in [("in_work", false), ("released", false)] {
934            let mut rev = revision(state, checked_out);
935            rev["item_type"] = json!("simulation");
936            rev["item_number"] = json!("SIM-000001");
937            let mut sim_item = item();
938            sim_item["item_type"] = json!("simulation");
939            let editable = state == "in_work";
940            let html = render(
941                &env,
942                "revisions/show.html",
943                with_common(json!({
944                    "files_hint": files_hint(if editable { "upload" } else { "frozen" }),
945                    "rev": rev.clone(), "item": sim_item, "revisions": [rev.clone(), revision("released", false)],
946                    "hidden": { "parents": 0, "incoming": 0, "changes": 0, "simulations": 0 },
947                    "is_latest": true, "latest_id": OTHER, "files": [], "native_without_preview": false,
948                    "lines": [], "where_used": [], "changes": [], "open_change": null, "drafts": [],
949                    "history": [], "projects": [], "units": units(), "references": references.clone(),
950                    "impact_groups": [], "resolved_impacts": [],
951                    "simulation": {
952                        "bases": [basis(Some("PRT-000001/B was released (simulated: A)")), basis(None)],
953                        "results": [sim_result("Max. stress <vM>", "pass", Some(250.0)),
954                                    sim_result("Safety factor", "fail", None),
955                                    sim_result("Mass", "none", None)],
956                        "summary": { "total": 3, "pass": 1, "fail": 1, "without_limits": 1 },
957                        "out_of_date": 1, "roles": basis_roles.clone(),
958                        "views": [{ "id": ME, "filename": "beam <load>.vtu", "version": 2 }],
959                        "images": [{ "id": ME, "filename": "pressure <p>.png", "version": 1, "sha256": "ab" }],
960                        "can_decide": true,
961                        "proposals": [{ "id": OTHER, "revision_id": ME, "name": "Mass flow <p>", "value": 2.25, "unit": "kg/s",
962                                        "lower_limit": null, "upper_limit": 3.0, "load_case": "", "solver": "", "solver_version": "",
963                                        "source_file": "report <1>.pdf", "source_version": 2, "quote": "mass flow 2.25 kg/s",
964                                        "status": "pending", "proposed_by": ME, "proposed_by_name": "Erika", "created_at": TS }],
965                    },
966                    "based_simulations": [],
967                    "can": if editable { can_all.clone() } else { json!({}) }, "max_upload_mb": 512,
968                    "lifecycle": {
969                        "states": crate::domain::LifecycleState::ALL,
970                        "next": crate::domain::rules_from(crate::domain::LifecycleState::parse(state).unwrap()),
971                        "rules": crate::domain::LIFECYCLE_RULES,
972                    },
973                })),
974            );
975            for expected in [
976                "Based on",
977                "B was released (simulated: A)",
978                "bracket.step",
979                "fillet &lt;r2&gt;",
980                "Out of date",
981                "Up to date",
982                "Max. stress &lt;vM&gt;",
983                "badge badge-pass",
984                "badge badge-fail",
985                "1 failed",
986                "no limit",
987                "/simulation/compare",
988                "/simulation/results.csv",
989                "View result in 3D",
990                "beam &lt;load&gt;.vtu v2",
991                "class=\"sim-gallery\"",
992                "Proposed from reports",
993                "Mass flow &lt;p&gt;",
994                "report &lt;1&gt;.pdf",
995                "/simulation-proposals/",
996                "pressure &lt;p&gt;.png",
997            ] {
998                assert!(html.contains(expected), "simulation page shows {expected}");
999            }
1000            assert!(!html.contains("id=\"bom\""), "no BOM card for simulations");
1001            assert!(!html.contains("id=\"simulations\""));
1002            assert_eq!(
1003                html.contains("/simulation/results/import") && html.contains("/simulation/bases"),
1004                editable,
1005                "editing only while checked out"
1006            );
1007        }
1008        let html = render(
1009            &env,
1010            "revisions/show.html",
1011            with_common(json!({
1012                "files_hint": files_hint("hidden"),
1013                "rev": revision("released", false), "item": item(), "revisions": [revision("released", false)],
1014                "hidden": { "parents": 0, "incoming": 0, "changes": 0, "simulations": 1 },
1015                "is_latest": true, "latest_id": OTHER, "files": [], "native_without_preview": false,
1016                "lines": [], "where_used": [], "changes": [], "open_change": null, "drafts": [],
1017                "history": [], "projects": [], "units": units(), "references": references.clone(),
1018                "impact_groups": [], "resolved_impacts": [], "simulation": null,
1019                "based_simulations": [{
1020                    "simulation_item_id": OTHER, "simulation_number": "SIM-000001", "simulation_code": "A",
1021                    "simulation_state": "in_work", "simulation_name": "Bracket – static <LC1>",
1022                    "result_count": 3, "failed_count": 1, "open_impact_id": ME,
1023                    "basis": basis(Some("PRT-000001/B was released (simulated: A)")) }],
1024                "can": {}, "max_upload_mb": 512,
1025                "lifecycle": {
1026                    "states": crate::domain::LifecycleState::ALL,
1027                    "next": crate::domain::rules_from(crate::domain::LifecycleState::Released),
1028                    "rules": crate::domain::LIFECYCLE_RULES,
1029                },
1030            })),
1031        );
1032        for expected in [
1033            "id=\"simulations\"",
1034            "SIM-000001/A",
1035            "Bracket – static &lt;LC1&gt;",
1036            "1 of 3 failed",
1037            "check open",
1038            "Out of date",
1039        ] {
1040            assert!(html.contains(expected), "part page shows {expected}");
1041        }
1042        // As-built: build record and deviations of an as-built revision
1043        let lifecycle = |state: &str| {
1044            json!({
1045                "states": crate::domain::LifecycleState::ALL,
1046                "next": crate::domain::rules_from(crate::domain::LifecycleState::parse(state).unwrap()),
1047                "rules": crate::domain::LIFECYCLE_RULES,
1048            })
1049        };
1050        let kinds: Vec<_> = crate::domain::DeviationKind::ALL
1051            .iter()
1052            .map(|k| json!({ "value": k.as_str(), "label": k.label() }))
1053            .collect();
1054        let dispositions: Vec<_> = crate::domain::Disposition::ALL
1055            .iter()
1056            .map(|d| json!({ "value": d.as_str(), "label": d.label() }))
1057            .collect();
1058        let deviation = |feature: &str, disposition: &str| {
1059            json!({ "id": ME, "revision_id": OTHER, "position": 1, "kind": "dimension",
1060                    "feature": feature, "designed": "12.000 +0.018/0", "built": "12.035 <m>",
1061                    "disposition": disposition, "note": "", "created_by_name": "Erika",
1062                    "created_at": TS, "updated_at": TS })
1063        };
1064        for (state, restricted) in [("in_work", false), ("released", true)] {
1065            let mut rev = revision(state, false);
1066            rev["item_type"] = json!("as_built");
1067            rev["item_number"] = json!("AB-000001");
1068            let mut unit_item = item();
1069            unit_item["item_type"] = json!("as_built");
1070            let editable = state == "in_work";
1071            let html = render(
1072                &env,
1073                "revisions/show.html",
1074                with_common(json!({
1075                    "files_hint": files_hint(if editable { "upload" } else { "frozen" }),
1076                    "rev": rev.clone(), "item": unit_item, "revisions": [rev.clone()],
1077                    "hidden": { "parents": 0, "incoming": 0, "changes": 0, "simulations": 0, "units": 0 },
1078                    "is_latest": true, "latest_id": OTHER, "files": [], "native_without_preview": false,
1079                    "lines": [], "where_used": [], "changes": [], "open_change": null, "drafts": [],
1080                    "history": [], "projects": [], "units": units(), "references": references.clone(),
1081                    "impact_groups": [], "resolved_impacts": [], "simulation": null,
1082                    "based_simulations": [], "built_units": [], "can_be_built_to": false,
1083                    "as_built": {
1084                        "record": {
1085                            "revision_id": OTHER, "design_item_id": ME,
1086                            "design_number": if restricted { "restricted item" } else { "ASM-000003" },
1087                            "design_type": "assembly", "design_revision_id": ME, "design_code": "B",
1088                            "design_state": "released", "design_name": "Gearbox <g>",
1089                            "serial_number": "SN <0042>", "built_on": "2026-11-02", "note": "",
1090                            "updated_by_name": "Erika", "updated_at": TS, "released_code": "C",
1091                            "newer_design": if restricted { Value::Null } else { json!("ASM-000003/C is released (built to: B)") },
1092                            "restricted": restricted,
1093                        },
1094                        "deviations": [deviation("Bore <Ø12>", "open"), deviation("Flange", "scrap")],
1095                        "summary": { "total": 2, "open": 1, "use_as_is": 0, "rework": 0, "repair": 0, "scrap": 1 },
1096                        "kinds": kinds.clone(), "dispositions": dispositions.clone(),
1097                    },
1098                    "can": if editable { can_all.clone() } else { json!({}) }, "max_upload_mb": 512,
1099                    "lifecycle": lifecycle(state),
1100                })),
1101            );
1102            for expected in [
1103                "id=\"as-built\"",
1104                "Built to",
1105                "SN &lt;0042&gt;",
1106                "2026-11-02",
1107                "Deviations from the design",
1108                "1 open",
1109                "Bore &lt;Ø12&gt;",
1110                "12.035 &lt;m&gt;",
1111            ] {
1112                assert!(html.contains(expected), "as-built page shows {expected}");
1113            }
1114            assert_eq!(
1115                html.contains("ASM-000003/B") && html.contains("/bom/compare?with="),
1116                !restricted,
1117                "a hidden design is a placeholder"
1118            );
1119            assert_eq!(
1120                html.contains("/as-built/record") && html.contains("/as-built/deviations"),
1121                editable,
1122                "editing only while checked out"
1123            );
1124            assert!(!html.contains("id=\"built-units\""));
1125        }
1126        // the design side: units built to the item
1127        let html = render(
1128            &env,
1129            "revisions/show.html",
1130            with_common(json!({
1131                "files_hint": files_hint("frozen"),
1132                "rev": revision("released", false), "item": item(), "revisions": [revision("released", false)],
1133                "hidden": { "parents": 0, "incoming": 0, "changes": 0, "simulations": 0, "units": 2 },
1134                "is_latest": true, "latest_id": OTHER, "files": [], "native_without_preview": false,
1135                "lines": [{ "id": ME, "child_number": "PRT-000009", "child_latest_revision_id": OTHER, "child_name": "Screw", "child_code": "A" }], "where_used": [], "changes": [], "open_change": null, "drafts": [],
1136                "history": [], "projects": [{ "id": ME, "code": "ROCKET", "name": "Rocket" }],
1137                "units": units(), "references": references.clone(),
1138                "impact_groups": [], "resolved_impacts": [], "simulation": null, "as_built": null,
1139                "based_simulations": [], "can_be_built_to": true,
1140                "built_units": [{
1141                    "unit_item_id": OTHER, "unit_number": "AB-000001", "unit_revision_id": OTHER,
1142                    "unit_code": "A", "unit_state": "in_work", "unit_name": "Bracket – SN <7>",
1143                    "serial_number": "SN-7", "built_on": null, "design_revision_id": ME,
1144                    "design_code": "A", "deviation_count": 3, "open_count": 2,
1145                    "newer_design": "PRT-000001/B is released (built to: A)" }],
1146                "can": {}, "max_upload_mb": 512,
1147                "lifecycle": lifecycle("released"),
1148            })),
1149        );
1150        for expected in [
1151            "id=\"built-units\"",
1152            "AB-000001/A",
1153            "Bracket – SN &lt;7&gt;",
1154            "Older revision",
1155            "2 open",
1156            "+2 units in groups you cannot see",
1157            "Record a built unit",
1158            "Copy the BOM of B",
1159        ] {
1160            assert!(html.contains(expected), "part page shows {expected}");
1161        }
1162        let diff = |change: &str, before: Value, after: Value, delta: Value| {
1163            json!({ "change": change, "name": "Stress <max>", "load_case": "LC1", "unit": "MPa",
1164                    "before": before, "after": after, "delta": delta,
1165                    "delta_percent": if delta.is_null() { Value::Null } else { json!(-10.0) } })
1166        };
1167        let html = render(
1168            &env,
1169            "revisions/simulation_compare.html",
1170            with_common(json!({
1171                "rev": revision("in_work", false), "before": revision("released", false),
1172                "after": revision("in_work", false), "revisions": [revision("released", false)],
1173                "diffs": [diff("changed", sim_result("Stress", "fail", Some(150.0)),
1174                               sim_result("Stress", "pass", Some(250.0)), json!(-20.0)),
1175                          diff("added", Value::Null, sim_result("Mass", "none", None), Value::Null),
1176                          diff("removed", sim_result("Old", "pass", Some(1e9)), Value::Null, Value::Null)],
1177                "summary": { "added": 1, "removed": 1, "changed": 1, "unchanged": 0 },
1178            })),
1179        );
1180        assert!(html.contains("1 added · 1 removed · 1 changed · 0 unchanged"));
1181        assert!(html.contains("Stress &lt;max&gt;") && html.contains("-10 %"));
1182        assert!(html.contains("badge badge-fail") && html.contains("badge badge-pass"));
1183
1184        // 3D preview: the server delivers the mesh, the page only draws it
1185        let preview = |format: &str, is_current: bool| {
1186            let mut shown = version(1, "first <draft>");
1187            shown["id"] = json!(ME);
1188            with_common(json!({
1189                "file": file.clone(), "shown": shown, "is_current": is_current,
1190                "versions": [version(2, "wall 2.5 mm"), version(1, "first <draft>")],
1191                "rev": revision("released", false),
1192                "format": format, "is_brep": format == "step", "is_points": format == "las",
1193                "is_result": format == "vtk-unstructured",
1194            }))
1195        };
1196        let html = render(
1197            &env,
1198            "files/preview.html",
1199            preview("vtk-unstructured", true),
1200        );
1201        assert!(html.contains("coloured by a result field"), "result hint");
1202        let html = render(&env, "files/preview.html", preview("stl", true));
1203        assert!(html.contains(&format!("data-src=\"/file-versions/{ME}/mesh\"")));
1204        assert!(!html.contains("viewer-stl"), "no STL export of an STL file");
1205        assert!(html.contains("/static/shared/v/") && html.contains("/js/viewer.js\""));
1206        assert!(html.contains("first &lt;draft&gt;"), "comments are escaped");
1207        let html = render(&env, "files/preview.html", preview("step", false));
1208        assert!(html.contains("older version"));
1209        assert!(html.contains("tessellated"), "STEP hint");
1210        assert!(
1211            html.contains("id=\"viewer-stl\"") && html.contains("data-name=\"nozzle.step\""),
1212            "STL export of STEP models"
1213        );
1214        let html = render(&env, "files/preview.html", preview("las", true));
1215        assert!(
1216            !html.contains("viewer-stl"),
1217            "no STL export of a point cloud"
1218        );
1219        render(
1220            &env,
1221            "revisions/edit.html",
1222            with_common(
1223                json!({ "rev": revision("in_work", false), "error": null, "materials": [] }),
1224            ),
1225        );
1226        let html = render(
1227            &env,
1228            "revisions/edit.html",
1229            with_common(json!({
1230                "rev": revision("in_work", false), "error": null,
1231                "materials": [{ "name": "Alu <7075>", "label": "2810 kg/m³" }],
1232                "attribute_fields": [
1233                    { "key": "vendor", "label": "Vendor", "unit": "", "data_type": "choice",
1234                      "choices": ["Bosch", "SKF"], "value": "Old <Ltd>" },
1235                    { "key": "rohs", "label": "RoHS", "unit": "", "data_type": "boolean", "choices": [], "value": "yes" },
1236                    { "key": "length", "label": "Length", "unit": "mm", "data_type": "number", "choices": [], "value": "12.5" },
1237                ],
1238            })),
1239        );
1240        assert!(html.contains("name=\"attr.vendor\"") && html.contains("Length [mm]"));
1241        assert!(
1242            html.contains("<datalist id=\"material-options\"><option value=\"Alu &lt;7075&gt;\">2810 kg&#x2f;m³</option></datalist>")
1243                && html.contains("data-material-hint"),
1244            "material suggestions are escaped"
1245        );
1246        assert!(
1247            html.contains("Old &lt;Ltd&gt; (no longer a choice)"),
1248            "removed choices stay selectable"
1249        );
1250        assert!(html.contains("<option value=\"yes\" selected>"));
1251        render(
1252            &env,
1253            "revisions/edit.html",
1254            with_common(json!({
1255                "rev": revision("in_work", false), "error": "Mass: 'x' is not a number.", "mass_raw": "x", "cost_raw": "", "materials": []
1256            })),
1257        );
1258
1259        let node = json!({
1260            "line_id": ME, "level": 2, "find_number": 10, "quantity": 2.0, "notes": "", "item_id": OTHER,
1261            "item_number": "PRT-000002", "item_type": "part", "unit": "each",
1262            "revision": { "id": OTHER, "code": "A", "state": "released", "name": "Bolt", "mass_kg": 0.01, "unit_cost": 0.2 },
1263            "unit_mass_kg": 0.01, "total_mass_kg": 0.02, "unit_cost_total": 0.2, "total_cost": 0.4,
1264            "mass_complete": true, "cost_complete": false, "cycle": false, "children": []
1265        });
1266        let mut unresolved = node.clone();
1267        unresolved["revision"] = Value::Null;
1268        unresolved["level"] = json!(9);
1269        let child = |status: &str, label: &str| {
1270            json!({ "item_id": OTHER, "item_number": "PRT-000004", "item_name": "Bolt <M6>",
1271                    "quantity": 4.0, "quantity_text": "4", "bom_quantity_text": "2", "quantity_source": "cad_instances", "quantity_label": "CAD instances",
1272                    "via": "A.SLDASM → bolt.SLDPRT", "status": status, "status_label": label,
1273                    "bom_quantity": 2.0, "selected": status == "new" })
1274        };
1275        let from_refs = render(
1276            &env,
1277            "revisions/bom_from_references.html",
1278            with_common(json!({
1279                "rev": revision("in_work", false), "editable": true, "can_checkout": false, "differs": true,
1280                "plan": { "children": [child("new", "new line"), child("differs", "differs")],
1281                          "not_in_teamcraft": [{ "name": "ghost.SLDPRT", "via": "A.SLDASM" }],
1282                          "hidden": 2, "excluded": ["glue.SLDPRT"] },
1283            })),
1284        );
1285        assert!(from_refs.contains("Bolt &lt;M6&gt;") && from_refs.contains("BOM 2, CAD 4"));
1286        assert!(from_refs.contains("Not in TeamCraft") && from_refs.contains("2 hidden item(s)"));
1287        assert!(from_refs.contains("Add the ticked lines"));
1288        let not_out = render(
1289            &env,
1290            "revisions/bom_from_references.html",
1291            with_common(json!({
1292                "rev": revision("in_work", false), "editable": false, "can_checkout": true, "differs": false,
1293                "plan": { "children": [child("new", "new line")], "not_in_teamcraft": [], "hidden": 0, "excluded": [] },
1294            })),
1295        );
1296        assert!(not_out.contains("Check out and create"));
1297        let bom_html = render(
1298            &env,
1299            "revisions/bom.html",
1300            with_common(json!({
1301                "rev": revision("released", false), "rule": "released",
1302                "tree": { "total_mass_kg": 1.5, "total_cost": 10.0, "mass_complete": false, "cost_complete": true,
1303                          "line_count": 2, "unresolved_count": 1, "restricted_lines": 1,
1304                          "rollup_incomplete": true },
1305                "rows": [
1306                    { "level": 2, "indent": "\u{2003}", "has_children": false, "node": node },
1307                    { "level": 9, "indent": "", "has_children": false, "node": unresolved }
1308                ],
1309            })),
1310        );
1311        assert!(
1312            bom_html.contains("/package.zip?rule=released")
1313                && bom_html.contains("Pack and Go (ZIP)"),
1314            "Pack and Go with the selected rule"
1315        );
1316
1317        render(
1318            &env,
1319            "changes/list.html",
1320            with_common(json!({
1321                "changes": [change("in_review")], "status": "in_review",
1322                "statuses": [{ "value": "draft", "label": "Draft" }], "pagination": page(),
1323            })),
1324        );
1325        render(
1326            &env,
1327            "changes/new.html",
1328            with_common(json!({
1329                "form": { "title": "", "description": "", "priority": "normal", "revision_id": OTHER },
1330                "error": null, "priorities": ["low", "normal"], "revision": revision("in_work", false),
1331            })),
1332        );
1333        for status in ["draft", "in_review", "rejected", "released"] {
1334            let html = render(
1335                &env,
1336                "changes/show.html",
1337                with_common(json!({
1338                    "change": change(status), "status_label": "Draft",
1339                    "hidden_dependents": 1,
1340                    "implements": [request("accepted")],
1341                    "items": [{ "revision_id": OTHER, "item_id": ME, "item_number": "PRT-000001", "code": "A",
1342                                "name": "Bracket", "state": "in_work", "checked_out_by_name": "Erika" }],
1343                    "reviews": [{ "reviewer_id": OTHER, "reviewer_username": "erika", "reviewer_name": "Erika",
1344                                  "decision": "approved", "comment": "ok", "decided_at": TS, "absent": null,
1345                                  "sign_off_method": "password", "sign_off_meaning": "approved as <owner>" },
1346                                 { "reviewer_id": ME, "reviewer_username": "gone", "reviewer_name": "Gone <G>",
1347                                  "decision": "pending", "comment": "", "decided_at": null, "absent": "deactivated" }],
1348                    "replacements": [user()], "review_round": 2,
1349                    "earlier_rounds": [{ "round": 1, "reviewer_id": OTHER, "reviewer_username": "erika", "reviewer_name": "Erika",
1350                                         "decision": "rejected", "comment": "<too thin>", "decided_at": TS, "closed_at": TS }],
1351                    "candidates": [user()], "history": [audit_entry()], "priorities": ["low", "normal"],
1352                    "suggested": [{ "user_id": OTHER, "username": "max", "display_name": "Max <M>", "role": "editor",
1353                                    "score": 7, "reasons": ["edited PRT-000001 3 times in the last 90 days",
1354                                                            "manager of ROVER"] },
1355                                  { "user_id": ME, "username": "erika", "display_name": "Erika", "role": "editor",
1356                                    "score": 5, "cannot_review": true, "reasons": ["edited PRT-000001 once in the last 90 days"] }],
1357                    "impact": [{ "root_item_id": ME, "level": 1, "item_id": OTHER, "item_number": "ASM-000001",
1358                                 "item_name": "Stage", "revision_id": OTHER, "revision_code": "A",
1359                                 "revision_state": "released", "relation": "bom", "via_number": "PRT-000001",
1360                                 "in_change": false }],
1361                    "can": { "modify": true, "edit_text": true, "submit": true, "withdraw": true, "reopen": true,
1362                             "cancel": true, "review": true, "replace_reviewer": true, "take_over": true },
1363                    "sign_off": { "reauth": "release", "rejections_too": false, "sso": false,
1364                                  "reauthenticated": false, "window_minutes": 10 },
1365                })),
1366            );
1367            assert!(
1368                html.contains("name=\"password\"") && html.contains("name=\"meaning\""),
1369                "{status}: a fresh sign-in is asked for"
1370            );
1371            assert!(
1372                html.contains("signed off with password")
1373                    && html.contains("approved as &lt;owner&gt;"),
1374                "{status}: the sign-off of a decision"
1375            );
1376            assert!(
1377                html.contains("Earlier rounds")
1378                    && html.contains("Cannot decide: deactivated")
1379                    && html.contains("&lt;too thin&gt;")
1380                    && html.contains("/reviewers/"),
1381                "{status}: rounds and absent reviewers"
1382            );
1383            assert!(
1384                html.contains("/take-over\""),
1385                "{status}: a manager takes over a deactivated author's change"
1386            );
1387            if status == "in_review" {
1388                let mut ctx = json!({
1389                    "change": change(status), "status_label": "In review",
1390                    "reviews": [{ "reviewer_id": ME, "reviewer_username": "gone", "reviewer_name": "Gone <G>",
1391                                  "decision": "pending", "comment": "", "decided_at": null, "absent": "deactivated" }],
1392                    "replacements": [user()], "review_round": 1, "earlier_rounds": [],
1393                    "items": [], "candidates": [], "history": [], "priorities": ["low", "normal"],
1394                    "suggested": [], "impact": [],
1395                    "can": { "modify": false, "review": false, "replace_reviewer": true },
1396                });
1397                let html = render(&env, "changes/show.html", with_common(ctx.take()));
1398                assert!(
1399                    html.contains("/replace") && html.contains("Substitute for"),
1400                    "the replace form of an absent reviewer"
1401                );
1402            }
1403            assert!(
1404                html.contains("Impact analysis") && html.contains("uses PRT-000001 in its BOM"),
1405                "impact analysis on the change page"
1406            );
1407            assert!(
1408                html.contains("Implements") && html.contains("ECR-000001"),
1409                "the change page names the request it implements"
1410            );
1411            assert!(
1412                html.contains("Suggested reviewers")
1413                    && html.contains("Add Max &lt;M&gt;")
1414                    && html.contains("name=\"username\" value=\"max\"")
1415                    && html.contains(
1416                        "edited PRT-000001 3 times in the last 90 days; manager of ROVER"
1417                    ),
1418                "suggested reviewers with their reasons"
1419            );
1420        }
1421
1422        // change requests (ECR)
1423        let html = render(
1424            &env,
1425            "requests/list.html",
1426            with_common(json!({
1427                "requests": [request("new"), request("implemented")],
1428                "filter": { "status": "open", "scope": "mine", "item": "PRT-000001" },
1429                "statuses": crate::domain::RequestStatus::ALL.iter()
1430                    .map(|s| json!({ "value": s.as_str(), "label": s.label() })).collect::<Vec<_>>(),
1431                "base_query": "status=open&scope=mine&item=PRT-000001", "pagination": page(),
1432            })),
1433        );
1434        assert!(html.contains("ECR-000001") && html.contains("Crack &lt;at&gt; the weld"));
1435        assert!(html.contains("value=\"mine\" selected") && html.contains("In Triage"));
1436        let reasons = json!(crate::domain::RequestReason::ALL
1437            .iter()
1438            .map(|r| json!({ "value": r.as_str(), "label": r.label() }))
1439            .collect::<Vec<_>>());
1440        let html = render(
1441            &env,
1442            "requests/new.html",
1443            with_common(json!({
1444                "form": { "title": "", "description": "Found in nozzle.step:\n\n", "reason": "defect",
1445                          "priority": "normal", "due_date": "", "item_number": "", "revision_id": OTHER,
1446                          "note": "File: nozzle.step" },
1447                "error": "Title must not be empty.", "priorities": ["low", "normal"], "reasons": reasons,
1448                "revision": revision("released", false),
1449            })),
1450        );
1451        assert!(html.contains("PRT-000001/B") && html.contains("File: nozzle.step"));
1452        assert!(html.contains("value=\"defect\" selected") && html.contains("Raise request"));
1453        let request_item = json!({
1454            "item_id": ME, "item_number": "PRT-000001", "item_type": "part", "project_id": ROCKET,
1455            "project_code": "ROCKET", "revision_id": OTHER, "revision_code": "B", "revision_state": "released",
1456            "name": "Bracket <b>", "latest_revision_id": OTHER, "latest_code": "C", "latest_state": "in_work",
1457            "note": "weld seam" });
1458        let attachment = |ct: &str, name: &str| {
1459            json!({ "id": OTHER, "request_id": ME, "filename": name, "content_type": ct, "size_bytes": 2048,
1460                    "sha256": "ab".repeat(32), "uploaded_by": ME, "uploaded_by_name": "Max", "uploaded_at": TS })
1461        };
1462        let can_all = json!({ "edit": true, "start_triage": true, "decide": true, "assign": true, "reopen": true,
1463                              "withdraw": true, "implement": true, "comment": true, "attach": true });
1464        for status in [
1465            "new",
1466            "in_triage",
1467            "accepted",
1468            "rejected",
1469            "deferred",
1470            "implemented",
1471            "withdrawn",
1472        ] {
1473            let html = render(
1474                &env,
1475                "requests/show.html",
1476                with_common(json!({
1477                    "request": request(status), "status_label": "New", "reason_label": "Defect / error",
1478                    "hidden_changes": 1,
1479                    "items": [request_item.clone()], "in_work": [request_item.clone()],
1480                    "comments": [{ "id": OTHER, "author_id": OTHER, "author_name": "Erika",
1481                                   "body": "Seen on <three> parts", "created_at": TS }],
1482                    "attachments": [attachment("image/png", "crack.png"), attachment("application/pdf", "report.pdf")],
1483                    "images": [attachment("image/png", "crack.png")],
1484                    "changes": [change("draft")], "open_changes": [change("draft")], "candidates": [user()],
1485                    "history": [audit_entry()], "watching": false, "can": can_all.clone(),
1486                    "priorities": ["low", "normal"], "reasons": reasons.clone(), "max_attachment_mb": 10,
1487                })),
1488            );
1489            for expected in [
1490                "Crack &lt;at&gt; the weld",
1491                "Seen on &lt;three&gt; parts",
1492                "Create change order",
1493                "PRT-000001/C",
1494                "Link an open change order",
1495                "name=\"decision\" value=\"accept\"",
1496                "/request-attachments/",
1497                "?inline=1",
1498                "enctype=\"multipart/form-data\"",
1499                "CHG-000001",
1500                "weld seam",
1501            ] {
1502                assert!(
1503                    html.contains(expected),
1504                    "request page ({status}) shows {expected}"
1505                );
1506            }
1507            // deferred → deferred is no transition: no Defer button then
1508            assert_eq!(
1509                html.contains("name=\"decision\" value=\"defer\""),
1510                status != "deferred",
1511                "request page ({status}): Defer button"
1512            );
1513        }
1514
1515        let html = render(
1516            &env,
1517            "projects/list.html",
1518            with_common(json!({
1519                "projects": [project()], "my_projects": [ROCKET], "review_due": [],
1520                "manager_gaps": [
1521                    { "project_id": ROCKET, "code": "ROCKET", "name": "Sounding <rocket>", "kind": "none",
1522                      "active_managers": 0, "last_active_at": null },
1523                    { "project_id": OTHER, "code": "ROVER", "name": "Rover", "kind": "stale",
1524                      "active_managers": 2, "last_active_at": TS },
1525                ],
1526                "manager_gap_ids": [ROCKET, OTHER], "stale_days": 90,
1527            })),
1528        );
1529        assert!(html.contains("Groups without an active manager"));
1530        assert!(html.contains("Sounding &lt;rocket&gt; –") && html.contains("no active manager"));
1531        assert!(html.contains("2 active managers, none seen for 90 days"));
1532        assert!(html.contains("href=\"#manager-gaps\""), "the row is marked");
1533        let html = render(
1534            &env,
1535            "projects/list.html",
1536            with_common(json!({
1537                "projects": [project()], "my_projects": [ROCKET], "review_due": [],
1538                "manager_gaps": [], "manager_gap_ids": [], "stale_days": 90,
1539            })),
1540        );
1541        assert!(!html.contains("manager-gaps"));
1542        let html = render(
1543            &env,
1544            "projects/access_review.html",
1545            with_common(json!({
1546                "project_id": OTHER, "max_note": 1000,
1547                "report": { "project_code": "ROVER", "project_name": "Rover <x>", "generated_at": TS,
1548                    "admin_read": "with_reason", "administrators_outside": 2, "stale_days": 90,
1549                    "members": [{ "username": "erika", "display_name": "Erika", "role": "editor", "manager": true,
1550                                  "source": "oidc", "active": true, "added_at": TS, "last_login_at": null, "stale": true,
1551                                  "conditions_met": false }],
1552                    "conditions": { "required_claims": [{ "claim": "site", "values": ["a", "b"] }],
1553                                    "allowed_networks": [], "max_signin_age_hours": null },
1554                    "elevations": [{ "id": OTHER, "project_id": OTHER, "user_id": OTHER, "username": "root", "reason": "audit <b>",
1555                                    "started_at": TS, "expires_at": TS, "ended_at": null, "active": false }],
1556                    "reviews": [{ "id": OTHER, "username": "root", "note": "ok", "reviewed_at": TS,
1557                                  "admin_read": "none", "member_count": 1 }],
1558                    "schedule": { "interval_days": 90, "last_review_at": TS, "next_review_at": TS, "due": true } },
1559            })),
1560        );
1561        assert!(html.contains("no sign-in for 90 days") && html.contains("audit &lt;b&gt;"));
1562        assert!(html.contains("review of this group is due") && html.contains("every 90 days"));
1563        assert!(html.contains("is one of a, b") && html.contains("not met"));
1564        let entry = json!({ "id": OTHER, "at": TS, "user_id": OTHER, "username": "erika",
1565                            "channel": "assistant", "kind": "view", "object_type": "item",
1566                            "object_id": OTHER, "label": "PRT-1 <x>", "client_address": "192.0.2.4",
1567                            "detail": "get_bom" });
1568        let html = render(
1569            &env,
1570            "projects/access_log.html",
1571            with_common(json!({
1572                "project": project(), "entries": [entry],
1573                "query": { "user": "erika", "kind": "view", "channel": "assistant", "object": null,
1574                           "since": "2026-11-01", "until": null, "limit": null, "before": null },
1575                "next_link": "/projects/x/access-log?user=erika&before=y", "first_page_link": null,
1576                "filtered": true, "read_log": true, "error": null, "collapse_minutes": 5,
1577                "kinds": [{ "value": "view", "label": "View" }],
1578                "channels": [{ "value": "assistant", "label": "Assistant" }],
1579            })),
1580        );
1581        assert!(html.contains("PRT-1 &lt;x&gt;") && html.contains("get_bom"));
1582        assert!(html.contains("Older entries") && !html.contains("Newest entries"));
1583        assert!(html.contains("value=\"assistant\" selected"));
1584        let html = render(
1585            &env,
1586            "projects/access_log.html",
1587            with_common(json!({
1588                "project": project(), "entries": [], "query": {}, "next_link": null,
1589                "first_page_link": "/projects/x/access-log", "filtered": false, "read_log": false,
1590                "error": "since must be a date", "collapse_minutes": 5, "kinds": [], "channels": [],
1591            })),
1592        );
1593        assert!(
1594            html.contains("the log of this group is off") && html.contains("since must be a date")
1595        );
1596        let html = render(
1597            &env,
1598            "projects/show.html",
1599            with_common(json!({
1600                "project": project(),
1601                "members": [{ "user_id": OTHER, "username": "erika", "display_name": "Erika", "role": "editor",
1602                              "active": true, "source": "oidc", "added_at": TS, "manager": true, "checkouts": 0 },
1603                            { "user_id": "33333333-3333-4333-8333-333333333333", "username": "lena", "display_name": "Lena <gone>", "role": "editor",
1604                              "active": false, "source": "oidc", "added_at": TS, "manager": false, "checkouts": 40 }],
1605                "former_holders": [{ "user_id": OTHER, "username": "tom", "display_name": "Tom <left>",
1606                                     "active": true, "checkouts": 3 }],
1607                "candidates": [user()], "is_member": true, "can_edit": true, "oidc_enabled": true,
1608                "can_manage": true,
1609                "result_templates": [{ "id": OTHER, "project_id": OTHER, "name": "Pressure <drop>", "file_pattern": "*.log",
1610                                       "method": "regex", "pattern": "dp:\\s*([0-9.]+)", "csv_column": "", "csv_key_column": "",
1611                                       "csv_key_value": "", "pick": "last", "unit": "Pa", "lower_limit": null,
1612                                       "upper_limit": 500.0, "load_case": "", "solver": "", "enabled": true }],
1613                "numbering": { "scheme": "{PROJECT}-{TYPE}-{YYYY}-{SEQ:4}", "is_default": false,
1614                               "next": [{ "item_type": "part", "label": "Part", "number": "ROCKET-PRT-2026-0001" }] },
1615                "scheme_input": "{PROJECT}-{TYPE}-{YYYY}-{SEQ:4}", "previewing": true,
1616                "scheme_error": "Invalid numbering scheme 'x': <bad>", "default_scheme": "{TYPE}-{SEQ:6}",
1617            })),
1618        );
1619        assert!(html.contains("CAD editor"));
1620        assert!(html.contains("via IdP group"));
1621        assert!(html.contains("Pressure &lt;drop&gt;") && html.contains("/result-templates/"));
1622        assert!(html.contains("Add template"), "managers add templates");
1623        assert!(html.contains("manager"), "project managers are marked");
1624        assert!(html.contains("Add member"), "managers add members");
1625        assert!(html.contains("/demote\""), "managers demote managers");
1626        assert!(
1627            html.contains("/season\""),
1628            "managers find the season handover"
1629        );
1630        let season = render(
1631            &env,
1632            "projects/season.html",
1633            with_common(json!({
1634                "project": project(),
1635                "members": [
1636                    { "user_id": OTHER, "username": "erika", "display_name": "Erika", "role": "editor",
1637                      "active": true, "source": "oidc", "manager": true, "checkouts": 0,
1638                      "last_active_at": TS, "expires_at": null, "expired": false },
1639                    { "user_id": ME, "username": "lena", "display_name": "Lena <gone>", "role": "editor",
1640                      "active": false, "source": "manual", "manager": false, "checkouts": 40,
1641                      "last_active_at": null, "expires_at": "2026-07-31", "expired": true },
1642                ],
1643                "chosen": [ME], "inactive_since": "2026-08-01",
1644                "release_reason": { "min": 10, "max": 500 }, "max_members": 500,
1645            })),
1646        );
1647        assert!(season.contains("Lena &lt;gone&gt;") && season.contains("expired"));
1648        assert!(season.contains(&format!("name=\"release\" value=\"{ME}\"")));
1649        assert!(
1650            season.contains(&format!(
1651                "name=\"remove\" value=\"{ME}\" aria-label=\"Remove lena\" checked"
1652            )),
1653            "a member whose membership expired is ticked"
1654        );
1655        assert!(
1656            !season.contains(&format!(
1657                "name=\"remove\" value=\"{OTHER}\" aria-label=\"Remove erika\" checked"
1658            )),
1659            "an active member is not"
1660        );
1661        assert!(season.contains("value=\"2026-08-01\""));
1662        assert!(
1663            html.contains("Release 40 check-outs") && html.contains("Lena &lt;gone&gt;"),
1664            "a deactivated member's check-outs can be released"
1665        );
1666        assert!(
1667            html.contains("/members/33333333-3333-4333-8333-333333333333/remove\""),
1668            "a deactivated member's IdP membership can be removed"
1669        );
1670        assert!(
1671            !html.contains(&format!("/members/{OTHER}/remove\"")),
1672            "an active member's IdP membership cannot"
1673        );
1674        assert!(
1675            html.contains("Former members still holding") && html.contains("Release 3 check-outs"),
1676            "former holders are listed"
1677        );
1678        assert!(
1679            html.contains("ROCKET-PRT-2026-0001"),
1680            "next numbers are shown"
1681        );
1682        assert!(html.contains("preview – not saved"));
1683        assert!(html.contains("value=\"{PROJECT}-{TYPE}-{YYYY}-{SEQ:4}\""));
1684        assert!(html.contains("&lt;bad&gt;"), "scheme errors are escaped");
1685        assert!(html.contains("/numbering\""), "managers edit the scheme");
1686        let html = render(
1687            &env,
1688            "projects/show.html",
1689            with_common(json!({
1690                "project": project(), "members": [], "candidates": [], "is_member": true,
1691                "can_edit": true, "oidc_enabled": false, "can_manage": true, "readable": true,
1692                "result_templates": [],
1693                "policy": { "admin_read": "implicit", "access": { "read_log": true, "log_retention_days": 90,
1694                    "review_interval_days": 120,
1695                    "interfaces": { "api_tokens": true, "mcp": false, "assistant": true, "webhooks": true, "packages": true } },
1696                    "conditions": { "required_claims": [{ "claim": "site", "values": ["main-office"] }],
1697                                    "allowed_networks": ["10.0.0.0/8", "192.168.1.0/24"], "max_signin_age_hours": 12 } },
1698                "review_schedule": { "interval_days": 120, "last_review_at": null, "next_review_at": TS, "due": true },
1699                "claim_lines": "site = main-office, <x>", "my_address": "10.1.2.3",
1700                "admin_modes": [{ "value": "implicit", "label": "Implicit" }],
1701                "interface_rows": [{ "name": "mcp", "label": "MCP <server>", "allowed": false }],
1702                "access_entries": [{ "id": OTHER, "at": TS, "username": "erika", "channel": "api", "kind": "download",
1703                    "label": "<b>secret.step</b>", "client_address": "10.0.0.1", "detail": "" }],
1704                "numbering": { "scheme": "{TYPE}-{SEQ:6}", "is_default": true, "next": [] },
1705                "scheme_input": "", "previewing": false, "scheme_error": null, "default_scheme": "{TYPE}-{SEQ:6}",
1706            })),
1707        );
1708        assert!(
1709            html.contains("/access\""),
1710            "managers edit the interfaces and the log"
1711        );
1712        assert!(html.contains("MCP &lt;server&gt;"));
1713        assert!(
1714            html.contains("&lt;b&gt;secret.step"),
1715            "log labels are escaped"
1716        );
1717        assert!(html.contains("access review due") && html.contains("value=\"120\""));
1718        assert!(html.contains("/access-log\""), "the whole log is linked");
1719        assert!(html.contains("/conditions\"") && html.contains("main-office, &lt;x&gt;"));
1720        assert!(html.contains("10.1.2.3") && html.contains("value=\"12\""));
1721        let html = render(
1722            &env,
1723            "admin/users.html",
1724            with_common(json!({
1725                "users": [user()], "roles": roles(),
1726                "oidc": { "admin_group": "a", "editor_group": "e", "viewer_group": null },
1727                "idle_sso_days": 90,
1728                "idle_sso": [{
1729                    "user_id": ME, "username": "lena", "display_name": "Lena <L>",
1730                    "last_login_at": null, "last_active_at": TS, "idp_logout_at": TS,
1731                    "memberships": 2, "tokens": 1, "checkouts": 40,
1732                }],
1733            })),
1734        );
1735        assert!(html.contains("SSO users without sign-in") && html.contains("90 days"));
1736        assert!(html.contains("Lena &lt;L&gt;"), "names are escaped");
1737        assert!(html.contains(&format!("/users/{ME}/holdings\"")));
1738        assert!(html.contains(">never<") && html.contains(">40<"));
1739        let html = render(
1740            &env,
1741            "admin/user_edit.html",
1742            with_common(json!({
1743                "user": user(), "roles": roles(), "oidc_enabled": false, "memberships": [project()],
1744                "handover_targets": [user()], "held_checkouts": 40, "sole_manager_of": ["CHASSIS"],
1745                "tokens": [{ "id": ME, "name": "ci", "token_prefix": "tc_pat_abc123", "created_at": TS,
1746                             "last_used_at": null, "expires_at": TS, "scope": "full", "idle_days": null },
1747                           { "id": ME, "name": "desktop", "token_prefix": "tc_pat_def456", "created_at": TS,
1748                             "last_used_at": TS, "expires_at": TS, "scope": "read_only", "idle_days": 30 }],
1749            })),
1750        );
1751        assert!(html.contains("/offboard\"") && html.contains("only active manager of CHASSIS"));
1752        assert!(html.contains("name=\"confirm_no_manager\"") && html.contains("API tokens (2)"));
1753        let html = render(
1754            &env,
1755            "admin/holdings.html",
1756            with_common(json!({
1757                "nothing": false,
1758                "h": {
1759                    "user_id": OTHER, "username": "lena", "display_name": "Lena <left>", "active": false,
1760                    "last_login_at": null, "scope": "all",
1761                    "checkouts": { "total": 40, "shown": [{ "revision_id": OTHER, "item_number": "PRT-000007",
1762                        "code": "B", "name": "Upright <x>", "project_code": "CHASSIS", "checked_out_at": TS }] },
1763                    "hidden_checkouts": [{ "project_code": "NTK", "count": 2 }],
1764                    "authored_changes": { "total": 1, "shown": [{ "id": OTHER, "number": "CO-0031",
1765                        "title": "Stiffer upright", "status": "rejected" }] },
1766                    "pending_reviews": { "total": 0, "shown": [] },
1767                    "assigned_requests": { "total": 1, "shown": [{ "id": OTHER, "number": "CR-0004",
1768                        "title": "Crack", "status": "in_triage" }] },
1769                    "raised_requests": { "total": 0, "shown": [] },
1770                    "owned_items": { "total": 1, "shown": [{ "id": OTHER, "number": "PRT-000007",
1771                        "name": "Upright", "project_code": null }] },
1772                    "memberships": [{ "project_id": OTHER, "project_code": "CHASSIS", "project_name": "Chassis",
1773                        "source": "oidc", "manager": true, "only_active_manager": true }],
1774                    "tokens": [{ "id": ME, "name": "desktop", "token_prefix": "tc_pat_def456", "created_at": TS,
1775                        "last_used_at": null, "expires_at": TS, "scope": "full", "idle_days": 30 }],
1776                },
1777            })),
1778        );
1779        assert!(html.contains("Lena &lt;left&gt;") && html.contains("Upright &lt;x&gt;"));
1780        assert!(html.contains("The first 1 of 40") && html.contains("the only active manager"));
1781        assert!(html.contains("2 check-outs in") && html.contains("CO-0031"));
1782        let html = render(
1783            &env,
1784            "admin/holdings.html",
1785            with_common(json!({
1786                "nothing": true,
1787                "h": {
1788                    "user_id": OTHER, "username": "tom", "display_name": "Tom", "active": true,
1789                    "last_login_at": TS, "scope": "managed",
1790                    "checkouts": { "total": 0, "shown": [] }, "hidden_checkouts": [],
1791                    "authored_changes": { "total": 0, "shown": [] },
1792                    "pending_reviews": { "total": 0, "shown": [] },
1793                    "assigned_requests": { "total": 0, "shown": [] },
1794                    "raised_requests": { "total": 0, "shown": [] },
1795                    "owned_items": { "total": 0, "shown": [] },
1796                    "memberships": [], "tokens": null,
1797                },
1798            })),
1799        );
1800        assert!(html.contains("holds nothing that blocks") && !html.contains("API tokens"));
1801        assert!(html.contains("Only what lies in the project groups you manage"));
1802        render(
1803            &env,
1804            "admin/audit.html",
1805            with_common(json!({
1806                "entries": [audit_entry()], "filter": { "entity_type": "item", "username": null, "action": null },
1807                "base_query": "entity_type=item", "pagination": page(), "per_page": 50,
1808            })),
1809        );
1810        // mass properties: a full report, editable and read-only settings
1811        let mass_line = |source: &str, warnings: Value| {
1812            json!({ "level": 1, "find_number": 10, "item_number": "PRT-000002",
1813                    "revision_id": OTHER, "revision_code": "A", "name": "Fin <x>", "quantity": 4.0,
1814                    "factor": 1.0, "source": source, "source_label": source,
1815                    "detail": "fin.stl (mm) × 2810 kg/m³ (Aluminium 7075-T6)",
1816                    "unit_mass_kg": 0.0425, "total_mass_kg": 0.17, "cg_m": [1.2, 0.0, 1e-9],
1817                    "warnings": warnings })
1818        };
1819        let report = json!({
1820            "rule": "latest", "root_revision_id": ME, "root_label": "ASM-000001/A", "root_name": "Vehicle",
1821            "root_source": "assembly", "root_detail": "", "reference_m": [0.0, 0.0, 0.0],
1822            "mass_kg": 12.5, "placed_mass_kg": 12.4, "unplaced_mass_kg": 0.1,
1823            "cg_m": [1.234567, 0.0001, -0.002], "inertia_cg": [0.1, 5.2, 5.3, 1e-6, 0.0, -2e-4],
1824            "inertia_ref": [0.1, 24.0, 24.1, 1e-6, 0.0, -2e-4], "principal_moments": [5.3, 5.2, 0.1],
1825            "lines": [mass_line("computed", json!([])), mass_line("missing", json!(["no density <x>"])),
1826                      mass_line("restricted", json!([]))],
1827            "line_count": 3, "restricted_lines": 1, "missing_lines": 1, "complete": false,
1828            "warnings": ["1 restricted line left out."], "lines_with_warnings": 1,
1829        });
1830        let geometry_file = json!({ "id": OTHER, "revision_id": ME, "filename": "fin.stl", "sha256": "ab",
1831                                    "format": "stl", "length_unit": null, "instances": 4 });
1832        for (editable, measured) in [(true, true), (false, false)] {
1833            let settings = json!({
1834                "settings": { "revision_id": ME, "density_kg_m3": if measured { json!(2810.0) } else { Value::Null },
1835                              "geometry_file_id": OTHER,
1836                              "measured_mass_kg": if measured { json!(1.5) } else { Value::Null },
1837                              "measured_cg_m": if measured { json!([1.0, 0.0, 0.0]) } else { Value::Null },
1838                              "measured_inertia_kg_m2": null, "measured_note": "scale <A>" },
1839                "files": [geometry_file.clone()], "geometry_file_id": OTHER,
1840                "material": if measured { json!({ "id": OTHER, "name": "AlMg3", "density_kg_m3": 2660.0,
1841                                                  "notes": "", "created_at": TS, "updated_at": TS }) } else { Value::Null },
1842            });
1843            let html = render(
1844                &env,
1845                "revisions/mass.html",
1846                with_common(json!({
1847                    "rev": revision("in_work", editable), "rule": "latest", "report": report,
1848                    "reference": "0,0,0", "reference_error": if editable { Value::Null } else { json!("bad point") },
1849                    "settings": settings, "chosen": geometry_file, "chosen_unit": "mm",
1850                    "units": [{ "value": "mm" }, { "value": "m" }, { "value": "in" }],
1851                    "measured_cg": if measured { json!(["1", "0", "0"]) } else { json!([]) },
1852                    "measured_inertia": [], "editable": editable, "is_admin": false,
1853                })),
1854            );
1855            assert!(html.contains("Fin &lt;x&gt;") && html.contains("no density &lt;x&gt;"));
1856            assert!(html.contains("1.23457") && html.contains("mass.csv?rule=latest"));
1857            assert_eq!(html.contains("Save mass settings"), editable);
1858        }
1859        let empty_report = json!({
1860            "rule": "latest", "root_revision_id": ME, "root_label": "PRT-000001/B", "root_name": "Bracket",
1861            "root_source": "missing", "root_detail": "", "reference_m": [0.0, 0.0, 0.0],
1862            "mass_kg": 0.0, "placed_mass_kg": 0.0, "unplaced_mass_kg": 0.0, "cg_m": null,
1863            "inertia_cg": null, "inertia_ref": null, "principal_moments": null, "lines": [],
1864            "line_count": 0, "restricted_lines": 0, "missing_lines": 0, "complete": false,
1865            "warnings": [], "lines_with_warnings": 0,
1866        });
1867        let html = render(
1868            &env,
1869            "revisions/mass.html",
1870            with_common(json!({
1871                "rev": revision("released", false), "rule": "released", "report": empty_report,
1872                "reference": "0,0,0", "reference_error": null,
1873                "settings": { "settings": { "revision_id": ME, "density_kg_m3": null, "geometry_file_id": null,
1874                                            "measured_mass_kg": null, "measured_cg_m": null,
1875                                            "measured_inertia_kg_m2": null, "measured_note": "" },
1876                              "files": [], "geometry_file_id": null, "material": null },
1877                "chosen": null, "chosen_unit": null, "units": [], "measured_cg": [], "measured_inertia": [],
1878                "editable": false, "is_admin": false,
1879            })),
1880        );
1881        assert!(html.contains("No placed mass"));
1882        // files of several parts: the warning, the one-click choice (only
1883        // when editable) and the grouped selector
1884        for editable in [true, false] {
1885            let candidate = |id: &str, name: &str, likely: bool| json!({ "file_id": id, "filename": name, "format": "jt", "likely": likely, "used": false });
1886            let geometry = json!({
1887                "choice": "ambiguous", "file": null, "file_id": null, "other_formats": 0,
1888                "models": 2, "files": 3, "likely_file": "asm <1>.jt", "likely_file_id": OTHER,
1889                "candidates": [
1890                    { "model": "asm <1>", "files": [candidate(OTHER, "asm <1>.jt", true)] },
1891                    { "model": "fin", "files": [candidate(ME, "fin.jt", false)] },
1892                ],
1893            });
1894            let html = render(
1895                &env,
1896                "revisions/mass.html",
1897                with_common(json!({
1898                    "rev": revision("in_work", editable), "rule": "latest", "report": empty_report,
1899                    "reference": "0,0,0", "reference_error": null,
1900                    "settings": { "settings": { "revision_id": ME, "density_kg_m3": null, "geometry_file_id": null,
1901                                                "measured_mass_kg": null, "measured_cg_m": null,
1902                                                "measured_inertia_kg_m2": null, "measured_note": "" },
1903                                  "files": [], "geometry_file_id": null, "geometry": geometry,
1904                                  "material": null },
1905                    "chosen": null, "chosen_unit": null, "units": [], "measured_cg": [], "measured_inertia": [],
1906                    "editable": editable, "is_admin": false,
1907                })),
1908            );
1909            assert!(html.contains("Geometry ambiguous") && html.contains("asm &lt;1&gt;.jt"));
1910            assert_eq!(html.contains("/mass/geometry"), editable);
1911            assert_eq!(html.contains("<optgroup label=\"fin\">"), editable);
1912        }
1913        for is_admin in [true, false] {
1914            let html = render(
1915                &env,
1916                "materials.html",
1917                with_common(json!({
1918                    "materials": [{ "id": OTHER, "name": "Aluminium <7075>", "density_kg_m3": 2810.0,
1919                                    "notes": "handbook", "created_at": TS, "updated_at": TS }],
1920                    "is_admin": is_admin,
1921                })),
1922            );
1923            assert!(html.contains("Aluminium &lt;7075&gt;"));
1924            assert_eq!(html.contains("Add material"), is_admin);
1925        }
1926        render(
1927            &env,
1928            "materials.html",
1929            with_common(json!({ "materials": [], "is_admin": false })),
1930        );
1931        let attr_def = json!({
1932            "id": ME, "key": "vendor", "label": "Vendor <Lieferant>", "data_type": "choice",
1933            "unit": "", "choices": ["Bosch", "SKF"], "item_types": ["part"], "position": 10,
1934            "active": true, "created_at": TS,
1935        });
1936        let html = render(
1937            &env,
1938            "admin/attributes.html",
1939            with_common(json!({
1940                "rows": [{ "def": attr_def, "type_label": "Choice list" }],
1941                "data_types": [{ "value": "text", "label": "Text" }],
1942                "item_types": [{ "value": "part", "label": "Part", "checked": false }],
1943                "next_position": 20,
1944            })),
1945        );
1946        assert!(html.contains("Vendor &lt;Lieferant&gt;") && html.contains("2 choices"));
1947        let html = render(
1948            &env,
1949            "admin/attribute_edit.html",
1950            with_common(json!({
1951                "def": attr_def, "type_label": "Choice list", "choices_text": "Bosch\nSKF",
1952                "item_types": [{ "value": "part", "label": "Part", "checked": true }], "in_use": 3,
1953            })),
1954        );
1955        assert!(html.contains("3 revisions") && html.contains("Bosch\nSKF"));
1956        assert!(html.contains("value=\"part\" checked"));
1957        let webhook = json!({
1958            "id": ME, "name": "ERP <export>", "url": "https://erp.example.org/in?token=x",
1959            "secret_hint": "tc_whsec_…a1b2", "events": ["revision.released", "change.released"],
1960            "project_id": OTHER, "project_code": "ROVER", "active": true, "created_by": ME,
1961            "created_by_name": "Max", "created_at": TS, "updated_at": TS, "secret_rotated_at": TS,
1962            "pending": 2, "failed_recently": 1, "last_status": "failed", "last_delivery_at": TS,
1963            "host": "erp.example.org",
1964        });
1965        let events = json!(crate::domain::WebhookEvent::ALL
1966            .iter()
1967            .map(|e| json!({ "value": e.as_str(), "label": e.label(),
1968                             "on": *e == crate::domain::WebhookEvent::ChangeReleased }))
1969            .collect::<Vec<_>>());
1970        let projects = json!([{ "id": OTHER, "code": "ROVER", "name": "Planetary rover" }]);
1971        let html = render(
1972            &env,
1973            "admin/webhooks.html",
1974            with_common(json!({
1975                "webhooks": [webhook.clone()], "events": events.clone(), "projects": projects.clone(),
1976                "targets": { "allowed_hosts": [], "allow_private": false },
1977            })),
1978        );
1979        for expected in [
1980            "ERP &lt;export&gt;",
1981            "badge badge-failed",
1982            "1 failed in 7 days",
1983            "value=\"simulation.result_added\"",
1984            "TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS",
1985        ] {
1986            assert!(html.contains(expected), "webhook list shows {expected}");
1987        }
1988        assert!(!html.contains("token=x"), "the list shows the host only");
1989        let delivery = |status: &str, attempts: i32, code: Option<i32>, error: &str| {
1990            json!({
1991                "id": OTHER, "webhook_id": ME, "event_id": ME, "event": "change.released",
1992                "payload": {}, "payload_text": "{\n  \"event\": \"change.released\" <x>\n}",
1993                "status": status, "attempts": attempts, "next_attempt_at": TS,
1994                "last_status_code": code, "last_error": error, "created_at": TS, "updated_at": TS,
1995                "delivered_at": if status == "sent" { json!(TS) } else { json!(null) },
1996            })
1997        };
1998        let html = render(
1999            &env,
2000            "admin/branding.html",
2001            with_common(json!({
2002                "slots": [
2003                    { "kind": "wide", "label": "Wide logo", "custom": "aaaabbbbcccc", "hint": "h" },
2004                    { "kind": "square", "label": "Square logo", "custom": null, "hint": "h" },
2005                ],
2006                "max_kib": 512, "max_pixels": 4096,
2007            })),
2008        );
2009        assert!(
2010            html.contains("/branding/wide?v=aaaabbbbcccc"),
2011            "custom wide logo in the header"
2012        );
2013        assert!(
2014            html.contains("/admin/branding/wide/reset"),
2015            "reset offered for a custom logo"
2016        );
2017        assert!(
2018            !html.contains("/admin/branding/square/reset"),
2019            "no reset for the built-in logo"
2020        );
2021        // Admin → AI in every mode: provider and model shown, the key never
2022        let company_ai = crate::config::AssistantConfig {
2023            provider: crate::config::AssistantProvider::Anthropic,
2024            base_url: "https://api.anthropic.com/v1".into(),
2025            api_key: Some("sk-ant-never-shown".into()),
2026            model: "claude-opus-5-5".into(),
2027            max_steps: 8,
2028            max_tokens: 4096,
2029            request_timeout: std::time::Duration::from_secs(60),
2030            run_timeout: std::time::Duration::from_secs(180),
2031            max_concurrent: 4,
2032            retention_days: 30,
2033            internal_urls: Vec::new(),
2034        };
2035        use crate::config::LocalAgents;
2036        // the notice, and what the desktop app's Agent view runs on
2037        for (agents, assistant, says, desktop) in [
2038            (
2039                LocalAgents::Off,
2040                Some(&company_ai),
2041                "Company AI only",
2042                "company AI (no local option)",
2043            ),
2044            (
2045                LocalAgents::Off,
2046                None,
2047                "users have no AI in TeamCraft",
2048                "a notice that AI is switched off",
2049            ),
2050            (
2051                LocalAgents::Allowed,
2052                Some(&company_ai),
2053                "TEAMCRAFT_LOCAL_AGENTS=off",
2054                "the user chooses: company AI or local agent",
2055            ),
2056            (
2057                LocalAgents::Allowed,
2058                None,
2059                "No assistant is configured",
2060                "<dd>local agent</dd>",
2061            ),
2062        ] {
2063            let html = render(
2064                &env,
2065                "admin/ai.html",
2066                with_common(crate::services::assistant::admin_overview(
2067                    agents, assistant,
2068                )),
2069            );
2070            assert!(html.contains(says), "{agents:?}: {says}");
2071            assert!(html.contains(desktop), "{agents:?}: {desktop}");
2072            assert!(!html.contains("sk-ant-never-shown"), "the key leaked");
2073            if assistant.is_some() {
2074                assert!(html.contains("claude-opus-5-5"), "model shown");
2075                assert!(html.contains("api.anthropic.com"), "host shown");
2076                assert!(html.contains("set (not shown)"));
2077            }
2078        }
2079        let html = render(
2080            &env,
2081            "admin/webhook_edit.html",
2082            with_common(json!({
2083                "webhook": webhook, "host": "erp.example.org", "secret": "tc_whsec_0123",
2084                "events": events, "projects": projects, "max_attempts": 8, "retention_days": 30,
2085                "targets": { "allowed_hosts": ["erp.example.org"], "allow_private": false },
2086                "deliveries": [
2087                    delivery("sent", 1, Some(200), ""),
2088                    delivery("pending", 2, Some(503), "HTTP 503"),
2089                    delivery("failed", 8, None, "connection failed: refused"),
2090                ],
2091            })),
2092        );
2093        for expected in [
2094            "tc_whsec_0123",
2095            "data-copy=\"webhook-secret\"",
2096            "tc_whsec_…a1b2",
2097            "badge badge-retrying",
2098            "badge badge-failed",
2099            "connection failed: refused",
2100            "&lt;x&gt;",
2101            "/deliveries/",
2102            "value=\"change.released\" checked",
2103            "selected>ROVER",
2104        ] {
2105            assert!(html.contains(expected), "webhook page shows {expected}");
2106        }
2107        assert!(
2108            !html.contains("HTTP 503 – HTTP 503"),
2109            "the status code once"
2110        );
2111        let html = render(
2112            &env,
2113            "desktop/authorize.html",
2114            with_common(json!({
2115                "req": { "port": 53682, "state": "abcdefghijklmnop", "challenge": "c".repeat(43),
2116                         "device": "Leo's <MacBook>" },
2117                "token_days": 30,
2118            })),
2119        );
2120        assert!(
2121            html.contains("Leo&#x27;s &lt;MacBook&gt;"),
2122            "device name is escaped"
2123        );
2124        assert!(html.contains("name=\"decision\" value=\"allow\""));
2125        let html = render(
2126            &env,
2127            "account.html",
2128            with_common(json!({
2129                "user": user(),
2130                "tokens": [{ "id": ME, "name": "assistant", "token_prefix": "tc_pat_abc123", "created_at": TS,
2131                             "last_used_at": null, "expires_at": null, "scope": "mcp_only", "idle_days": null }],
2132                "new_token": { "name": "ci", "value": "tc_pat_secret", "scope": "read_only" },
2133                "api_base": "http://localhost:8080/api/v1",
2134                "skins": crate::domain::SKINS,
2135                "cad_families": crate::cadformat::families().iter()
2136                    .map(|s| json!({ "id": s.id, "short": s.short, "name": s.name }))
2137                    .collect::<Vec<_>>(),
2138                "notify": {
2139                    "settings": { "email": true, "email_address": "max@example.org", "mattermost": false,
2140                                  "mattermost_username": null, "muted": ["item_update"] },
2141                    "kinds": crate::domain::NotificationKind::MUTABLE.iter().map(|k| json!({
2142                        "value": k.as_str(), "label": k.label(), "on": *k != crate::domain::NotificationKind::ItemUpdate
2143                    })).collect::<Vec<_>>(),
2144                    "email_enabled": true, "mattermost_enabled": false, "mattermost_direct": false,
2145                },
2146                "unread_notifications": 3,
2147            })),
2148        );
2149        assert!(html.contains("tc_pat_secret"));
2150        assert!(
2151            html.contains("action=\"/account/preferred-cad\"")
2152                && html.contains("value=\"nx\"")
2153                && html.contains("Siemens NX"),
2154            "preferred CAD program choice"
2155        );
2156        assert!(
2157            html.contains("“ci” (read-only)")
2158                && html.contains("MCP only")
2159                && html.contains("name=\"scope\""),
2160            "token scopes"
2161        );
2162        assert!(
2163            html.contains("value=\"review_requested\" checked")
2164                && html.contains("value=\"item_update\" >")
2165                && html.contains("max@example.org")
2166                && html.contains("Mattermost is not configured"),
2167            "notification settings"
2168        );
2169        assert!(
2170            html.contains("class=\"bell has-unread\"")
2171                && html.contains("<span class=\"bell-count\">3</span>"),
2172            "bell with the unread count"
2173        );
2174        let notes = render(
2175            &env,
2176            "notifications.html",
2177            with_common(json!({
2178                "notifications": [
2179                    { "id": ME, "kind": "review_requested", "title": "Review requested: CHG-000004 <x>",
2180                      "body": "Erika asks you to review PRT-000003/B.", "link": "/changes/1", "subject_type": "change",
2181                      "subject_ref": "CHG-000004", "actor_name": "Erika", "created_at": TS, "read_at": null,
2182                      "email_state": "sent", "chat_state": "failed", "chat_error": "Mattermost user \"x\" not found" },
2183                    { "id": OTHER, "kind": "impact", "title": "Check needed: ASM-000001", "body": "",
2184                      "link": "/revisions/1", "subject_type": "revision", "subject_ref": "ASM-000001/A",
2185                      "actor_name": "Rolf", "created_at": TS, "read_at": TS, "email_state": "none", "chat_state": "none" }],
2186                "watched": [{ "entity_type": "item", "entity_id": ME, "number": "PRT-000003", "name": "Bracket",
2187                              "state": "released", "link": "/revisions/1", "revision_code": "B" },
2188                            { "entity_type": "change", "entity_id": OTHER, "number": "CHG-000004", "name": "Wall",
2189                              "state": "in_review", "link": "/changes/1", "revision_code": null }],
2190                "email_enabled": true, "mattermost_enabled": true, "unread_notifications": 1,
2191            })),
2192        );
2193        for expected in [
2194            "Review requested: CHG-000004 &lt;x&gt;",
2195            "class=\"unread\"",
2196            "e-mailed",
2197            "Mattermost failed",
2198            &format!("/notifications/{ME}/open"),
2199            "Mark all as read",
2200            &format!("/items/{ME}/watch"),
2201            &format!("/changes/{OTHER}/watch"),
2202        ] {
2203            assert!(
2204                notes.contains(expected),
2205                "notifications page shows {expected}"
2206            );
2207        }
2208
2209        let upload = render(
2210            &env,
2211            "imports/upload.html",
2212            with_common(json!({
2213                "target": null,
2214                "projects": [{ "id": ME, "code": "ROCKET", "name": "Rocket <stage>" }],
2215                "max_mib": 20,
2216            })),
2217        );
2218        assert!(
2219            upload.contains("enctype=\"multipart/form-data\"")
2220                && upload.contains("Rocket &lt;stage&gt;")
2221                && upload.contains("name=\"match_existing_sent\"")
2222                && upload.contains("name=\"project_id\""),
2223            "import upload form"
2224        );
2225        let into = render(
2226            &env,
2227            "imports/upload.html",
2228            with_common(json!({
2229                "target": { "id": ME, "item_number": "ASM-000001", "code": "A", "name": "Pump",
2230                            "project_code": "ROCKET" },
2231                "projects": [], "max_mib": 20,
2232            })),
2233        );
2234        assert!(
2235            into.contains(&format!("name=\"into\" value=\"{ME}\""))
2236                && !into.contains("name=\"project_id\""),
2237            "import into a checked-out revision"
2238        );
2239        let preview = render(
2240            &env,
2241            "imports/preview.html",
2242            with_common(json!({
2243                "id": OTHER,
2244                "plan": {
2245                    "filename": "pump <bom>.csv", "target": null, "root_label": "Pump",
2246                    "root_number": "ASM-PUMP", "root_name": "Pump", "project_code": "ROCKET",
2247                    "new_items": 2, "existing_items": 1, "lines": [{}, {}, {}],
2248                    "warnings": ["Row 4: <screw> appears again"],
2249                    "columns": [{ "header": "Part Number", "field": "number", "label": "Part number" }],
2250                    "attribute_columns": [{ "header": "Lieferant", "key": "vendor", "label": "Vendor" }],
2251                    "unused_columns": ["Cost <Center>"],
2252                },
2253                "rows": [
2254                    { "row": 2, "level": 1, "indent": "", "find_number": 1, "file_number": "HOUSING",
2255                      "number": "HOUSING", "existing": null, "type": "Assembly", "name": "Housing",
2256                      "quantity": 1.0, "unit": "each", "material": "AlMg3", "mass_kg": 0.8 },
2257                    { "row": 3, "level": 2, "indent": "indent-2", "find_number": 10,
2258                      "file_number": "ISO 4762 M6", "number": null, "existing": null, "type": "Part",
2259                      "name": "Screw", "quantity": 6.0, "unit": "each", "material": "", "mass_kg": null,
2260                      "classification": "Standard part", "attributes": [{ "key": "vendor", "label": "Vendor", "value": "Würth <GmbH>" }] },
2261                    { "row": 5, "level": 1, "indent": "", "find_number": 2, "file_number": "PRT-000001",
2262                      "number": "PRT-000001", "existing": "PRT-000001/B", "type": "Part",
2263                      "name": "Bracket", "quantity": 2.0, "unit": "each", "material": "", "mass_kg": null },
2264                ],
2265            })),
2266        );
2267        for expected in [
2268            "pump &lt;bom&gt;.csv",
2269            "<span class=\"mono\">ASM-PUMP</span>",
2270            &format!("/import/{OTHER}/run"),
2271            &format!("/import/{OTHER}/discard"),
2272            "Row 4: &lt;screw&gt; appears again",
2273            "indent-2",
2274            "new assembly",
2275            "generated",
2276            "PRT-000001&#x2f;B",
2277            "badge-released\">existing",
2278            "Attribute “Vendor”",
2279            "Cost &lt;Center&gt;",
2280            "standard part</span>",
2281            "Vendor: Würth &lt;GmbH&gt;",
2282            "<td>Part number</td>",
2283        ] {
2284            assert!(
2285                preview.contains(expected),
2286                "import preview shows {expected}"
2287            );
2288        }
2289        assert!(html.contains("<html lang=\"en\" data-skin=\"arch\">"));
2290        assert!(
2291            html.contains("data-skin=\"ubuntu\""),
2292            "skin picker lists every skin"
2293        );
2294        assert!(
2295            html.contains("skin-card selected"),
2296            "current skin is marked"
2297        );
2298
2299        // the assistant: dashboard quick action, change briefing, answer page
2300        let dashboard = |enabled: bool| {
2301            let mut data = with_common(json!({
2302                "stats": { "items": 0, "revisions_in_work": 0, "revisions_in_review": 0, "revisions_released": 0,
2303                           "open_changes": 0, "files": 0, "stored_bytes": 0 },
2304                "checkouts": [], "reviews": [], "my_changes": [], "activity": [], "impact_groups": [],
2305            }));
2306            data["assistant_enabled"] = json!(enabled);
2307            render(&env, "dashboard.html", data)
2308        };
2309        let html = dashboard(true);
2310        for expected in [
2311            "id=\"assistant-toggle\"",
2312            "aria-controls=\"assistant-drawer\"",
2313            "id=\"assistant-drawer\"",
2314            "data-module=\"/static/shared/v/",
2315            "/js/assistant.js\"",
2316            "/static/shared/css/assistant.css?v=",
2317            "data-can-edit=\"1\"",
2318            "data-tc-kind=\"dashboard\"",
2319        ] {
2320            assert!(html.contains(expected), "the sidebar markup has {expected}");
2321        }
2322        let disabled = dashboard(false);
2323        assert!(
2324            !disabled.contains("assistant-drawer")
2325                && !disabled.contains("assistant-toggle")
2326                && !disabled.contains("assistant.css"),
2327            "hidden when disabled"
2328        );
2329        assert!(
2330            disabled.contains("data-tc-kind=\"dashboard\""),
2331            "the page context is declared either way"
2332        );
2333
2334        let mut data = with_common(json!({
2335            "change": change("in_review"), "status_label": "In review", "items": [], "reviews": [],
2336            "candidates": [], "history": [], "priorities": ["low"], "impact": [], "hidden_dependents": 0,
2337            "can": { "modify": false, "edit_text": false, "submit": false, "withdraw": false, "reopen": false,
2338                     "cancel": false, "review": true },
2339        }));
2340        data["assistant_enabled"] = json!(true);
2341        let html = render(&env, "changes/show.html", data);
2342        assert!(
2343            html.contains("data-tc-kind=\"change\"")
2344                && html.contains("data-tc-change=\"CHG-000001\""),
2345            "a change order declares its number"
2346        );
2347
2348        let answer = crate::assistant::render_markdown("## Scope\n- PRT-000001 <b>");
2349        // "Open 3D preview" links: checked by open_links, label escaped
2350        let links = crate::assistant::open_links(
2351            &[
2352                json!({ "url": "http://localhost:8080/files/0b9c3a3e-5d1f-4c9a-9e8b-1234567890ab/preview",
2353                        "item": "PRT-000001", "revision": "A", "file": "<script>x</script>.stl" }),
2354                json!({ "url": "https://evil.example/files/0b9c3a3e-5d1f-4c9a-9e8b-1234567890ab/preview",
2355                        "item": "PRT-000002", "revision": "A", "file": "evil.stl" }),
2356            ],
2357            "http://localhost:8080",
2358        );
2359        assert_eq!(links.len(), 1);
2360        let html = render(
2361            &env,
2362            "assistant.html",
2363            with_common(json!({
2364                "actions": [["review_brief", "Brief me for this review"]],
2365                "form": { "question": "Is it <ready>?", "item": "", "revision": "", "change": "CHG-000001" },
2366                "back": "/changes/x", "error": null,
2367                "run": { "label": "Brief me for this review", "html": answer, "text": "x", "truncated": true,
2368                         "tools": [{ "name": "get_change", "ok": true }, { "name": "bom_health", "ok": false }],
2369                         "steps": 3, "model": "claude-opus-5-5", "allow_drafts": false,
2370                         "links": links },
2371            })),
2372        );
2373        assert!(
2374            !html.contains("<script>x") && !html.contains("evil"),
2375            "the link is escaped and only to this server"
2376        );
2377        for expected in [
2378            "<a class=\"button small view-3d\" href=\"&#x2f;files&#x2f;0b9c3a3e-5d1f-4c9a-9e8b-1234567890ab&#x2f;preview\">Open 3D preview: PRT-000001&#x2f;A · &lt;script&gt;x&lt;&#x2f;script&gt;.stl</a>",
2379            "<h3>Scope</h3>",
2380            "<a href=\"/i/PRT-000001\">PRT-000001</a> &lt;b&gt;",
2381            "Is it &lt;ready&gt;?",
2382            "get_change",
2383            "badge badge-rejected",
2384            "3 steps",
2385            "read-only",
2386            "cut off",
2387            "changes&#x2f;x\" data-back>Back</a>",
2388        ] {
2389            assert!(html.contains(expected), "assistant page shows {expected}");
2390        }
2391        let html = render(
2392            &env,
2393            "assistant.html",
2394            with_common(json!({
2395                "actions": [["attention", "What needs my attention"]],
2396                "form": { "question": "", "item": "", "revision": "", "change": "" },
2397                "back": "/", "error": "Type a question first.", "run": null,
2398            })),
2399        );
2400        assert!(
2401            html.contains("Type a question first.") && html.contains("What needs my attention")
2402        );
2403    }
2404
2405    fn units() -> Value {
2406        json!(crate::domain::COMMON_UNITS)
2407    }
2408
2409    /// Every link to an embedded asset carries the asset version, so browsers
2410    /// never keep an outdated stylesheet, script or logo after an update:
2411    /// `?v=` or, for shared scripts, the versioned path (src/assets.rs).
2412    #[test]
2413    fn static_links_carry_the_asset_version() {
2414        for (name, source) in TEMPLATES {
2415            for (i, _) in source.match_indices("\"/static/") {
2416                let link = &source[i + 1..];
2417                let link = &link[..link.find('"').unwrap_or(link.len())];
2418                let versioned = link.starts_with("/static/shared/v/{{ assets }}/js/");
2419                assert!(
2420                    link.contains("?v={{ assets }}") || versioned,
2421                    "{name}: {link} has no ?v={{{{ assets }}}}"
2422                );
2423            }
2424        }
2425    }
2426
2427    #[test]
2428    fn filters() {
2429        assert_eq!(
2430            filter_dt(Some("2026-11-03T14:05:59.123Z".into())),
2431            "2026-11-03 14:05 UTC"
2432        );
2433        assert_eq!(filter_dt(None), "—");
2434        assert_eq!(filter_num(Some(1.23456), None), "1.235");
2435        assert_eq!(filter_num(Some(2.0), Some(2)), "2");
2436        assert_eq!(filter_num(None, None), "—");
2437        assert_eq!(filter_sig(Some(12.345678)), "12.3457");
2438        assert_eq!(filter_sig(Some(0.0425)), "0.0425");
2439        assert_eq!(filter_sig(Some(-1234.5)), "-1234.5");
2440        assert_eq!(filter_sig(Some(2.5e-7)), "2.50000e-7");
2441        assert_eq!(filter_sig(Some(0.0)), "0");
2442        assert_eq!(filter_sig(Some(f64::NAN)), "—");
2443        assert_eq!(filter_sig(None), "—");
2444        assert_eq!(filter_fixed(Some(41.0), None), "41.00");
2445        assert_eq!(filter_fixed(Some(0.2), Some(3)), "0.200");
2446        assert_eq!(filter_fixed(None, Some(3)), "—");
2447        assert_eq!(filter_label(Some("in_work".into())), "WIP");
2448        assert_eq!(filter_label(Some("in_review".into())), "In Review");
2449        assert_eq!(filter_label(Some("released".into())), "Released");
2450    }
2451}