Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/tests/cfg_template.rs

6.3 KiB, 1 run

created by r1870400018:76339, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! `cfg::fill_from_template`, an installed configuration's missing optional keys read from the
2//! release's embedded template (CFG-COMPAT, 31 Oct 2026).
3
4use oxedyne_fe2o3_core::prelude::*;
5use oxedyne_fe2o3_jdat::{
6 prelude::*,
7 cfg,
8};
9
10
11const TEMPLATE: &str = r#"{
12 "name": "shipped",
13 "run": {
14 "pool": 4,
15 "queue": 8,
16 },
17 "os": {
18 "slice": "app.slice",
19 },
20}"#;
21
22fn map_of(text: &str) -> Outcome<DaticleMap> {
23 cfg::template_map(text)
24}
25
26fn get<'a>(map: &'a DaticleMap, sec: &str, key: &str) -> Option<&'a Dat> {
27 match map.get(&Dat::Str(fmt!("{}", sec))) {
28 Some(Dat::Map(m)) => m.get(&Dat::Str(fmt!("{}", key))),
29 _ => None,
30 }
31}
32
33#[test]
34fn an_absent_key_reads_the_template() -> Outcome<()> {
35 let mut map = res!(map_of(r#"{ "run": { "pool": 4 }, "os": { "slice": "app.slice" } }"#));
36 res!(cfg::fill_from_template(&mut map, TEMPLATE, &["run", "os"]));
37 assert_eq!(get(&map, "run", "queue"), Some(&Dat::U8(8)));
38 Ok(())
39}
40
41#[test]
42fn an_installed_key_is_kept() -> Outcome<()> {
43 let mut map = res!(map_of(r#"{ "run": { "pool": 2 } }"#));
44 res!(cfg::fill_from_template(&mut map, TEMPLATE, &["run"]));
45 assert_eq!(get(&map, "run", "pool"), Some(&Dat::U8(2)));
46 assert_eq!(get(&map, "run", "queue"), Some(&Dat::U8(8)));
47 Ok(())
48}
49
50#[test]
51fn an_absent_section_is_taken_whole() -> Outcome<()> {
52 let mut map = res!(map_of(r#"{ "run": {} }"#));
53 res!(cfg::fill_from_template(&mut map, TEMPLATE, &["run", "os"]));
54 assert_eq!(get(&map, "os", "slice"), Some(&Dat::Str(fmt!("app.slice"))));
55 Ok(())
56}
57
58#[test]
59fn a_key_outside_the_sections_stays_required() -> Outcome<()> {
60 let mut map = res!(map_of(r#"{ "run": {} }"#));
61 res!(cfg::fill_from_template(&mut map, TEMPLATE, &["run"]));
62 assert!(map.get(&Dat::Str(fmt!("name"))).is_none(), "a top-level key is never filled");
63 assert!(map.get(&Dat::Str(fmt!("os"))).is_none(), "an unnamed section is never filled");
64 Ok(())
65}
66
67#[test]
68fn a_template_that_fails_to_decode_is_refused() {
69 let broken = r#"{ "run": { "pool": "#;
70 assert!(cfg::template_map(broken).is_err(), "a broken template is never an empty map");
71 let mut map = DaticleMap::new();
72 let r = cfg::fill_from_template(&mut map, broken, &["run"]);
73 assert!(r.is_err(), "a broken template is never read as an empty one");
74 assert!(map.is_empty());
75 assert!(cfg::template_map("[1, 2]").is_err(), "a template that is no map is refused");
76}
77
78#[test]
79fn a_section_the_template_lacks_is_refused_by_name() {
80 let mut map = DaticleMap::new();
81 match cfg::fill_from_template(&mut map, TEMPLATE, &["net"]) {
82 Err(e) => assert!(fmt!("{}", e).contains("'net'"), "{}", e),
83 Ok(()) => panic!("a section the template lacks was accepted"),
84 }
85}
86
87#[test]
88fn an_installed_section_that_is_no_map_is_refused_by_name() -> Outcome<()> {
89 let mut map = res!(map_of(r#"{ "run": 5 }"#));
90 match cfg::fill_from_template(&mut map, TEMPLATE, &["run"]) {
91 Err(e) => assert!(fmt!("{}", e).contains("'run'"), "{}", e),
92 Ok(()) => panic!("a section that is no map was accepted"),
93 }
94 Ok(())
95}
96
97// `cfg::fill_keys_from_template`, the key-level fill: only the named keys are read from the
98// template, for a section whose other keys stay required (Kimberlite's `owner`, 1 Nov 2026).
99
100const KEYED: &str = r#"{
101 "owner": {
102 "home": "~/",
103 "agent": "~/.local/state/app/agent",
104 },
105}"#;
106
107#[test]
108fn a_named_key_the_file_lacks_reads_the_template() -> Outcome<()> {
109 let mut map = res!(map_of(r#"{ "owner": { "home": "/srv" } }"#));
110 res!(cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent")]));
111 assert_eq!(get(&map, "owner", "agent"), Some(&Dat::Str(fmt!("~/.local/state/app/agent"))));
112 assert_eq!(get(&map, "owner", "home"), Some(&Dat::Str(fmt!("/srv"))));
113 Ok(())
114}
115
116#[test]
117fn a_named_key_the_file_sets_is_kept() -> Outcome<()> {
118 let mut map = res!(map_of(r#"{ "owner": { "home": "/srv", "agent": "/run/agent" } }"#));
119 res!(cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent")]));
120 assert_eq!(get(&map, "owner", "agent"), Some(&Dat::Str(fmt!("/run/agent"))));
121 Ok(())
122}
123
124#[test]
125fn an_unnamed_key_in_the_section_stays_required() -> Outcome<()> {
126 let mut map = res!(map_of(r#"{ "owner": {} }"#));
127 res!(cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent")]));
128 assert!(get(&map, "owner", "home").is_none(), "only the named key is filled");
129 assert!(get(&map, "owner", "agent").is_some());
130 Ok(())
131}
132
133#[test]
134fn a_named_key_the_template_lacks_is_refused_by_name() -> Outcome<()> {
135 let mut map = res!(map_of(r#"{ "owner": {} }"#));
136 match cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "socket")]) {
137 Err(e) => assert!(fmt!("{}", e).contains("'owner.socket'"), "{}", e),
138 Ok(()) => panic!("a key the template lacks was accepted"),
139 }
140 match cfg::fill_keys_from_template(&mut map, KEYED, &[("net", "agent")]) {
141 Err(e) => assert!(fmt!("{}", e).contains("'net'"), "{}", e),
142 Ok(()) => panic!("a section the template lacks was accepted"),
143 }
144 assert_eq!(map, res!(map_of(r#"{ "owner": {} }"#)), "a refused fill changes nothing");
145 Ok(())
146}
147
148#[test]
149fn a_refused_key_leaves_the_earlier_ones_unfilled() -> Outcome<()> {
150 let mut map = res!(map_of(r#"{ "owner": {} }"#));
151 let r = cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent"), ("owner", "x")]);
152 assert!(r.is_err());
153 assert!(get(&map, "owner", "agent").is_none(), "every key is checked before any is filled");
154 Ok(())
155}
156
157#[test]
158fn an_installed_section_that_is_no_map_is_refused_for_a_key() -> Outcome<()> {
159 let mut map = res!(map_of(r#"{ "owner": 5 }"#));
160 match cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent")]) {
161 Err(e) => assert!(fmt!("{}", e).contains("'owner'"), "{}", e),
162 Ok(()) => panic!("a section that is no map was accepted"),
163 }
164 Ok(())
165}
166
167#[test]
168fn an_absent_section_is_left_absent() -> Outcome<()> {
169 let mut map = res!(map_of(r#"{ "run": {} }"#));
170 res!(cfg::fill_keys_from_template(&mut map, KEYED, &[("owner", "agent")]));
171 assert!(map.get(&Dat::Str(fmt!("owner"))).is_none(),
172 "a section the file lacks is not made, so its required keys are still reported missing");
173 Ok(())
174}