Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/tests/cfg_resolve.rs

9.8 KiB, 2 runs

created by r1870400018:75199, 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//! Every reference form a configuration value may hold, as Steel accepted them
2//! before its private copy of the resolver was removed (26 Oct 2026, D-20261026-02).
3//! `fe2o3_jdat::cfg` is now the one resolver, so each form is held here.
4
5use oxedyne_fe2o3_core::prelude::*;
6use oxedyne_fe2o3_jdat::cfg;
7
8use std::path::{
9 Path,
10 PathBuf,
11};
12
13
14fn scratch(name: &str) -> Outcome<PathBuf> {
15 let dir = Path::new(env!("CARGO_TARGET_TMPDIR")).join("cfg_resolve").join(name);
16 let _ = std::fs::remove_dir_all(&dir);
17 res!(std::fs::create_dir_all(&dir));
18 Ok(dir)
19}
20
21enum Want {
22 Is(String), // resolves to exactly this
23 Fails, // refused
24}
25
26#[test]
27fn every_form_steel_accepts_resolves_as_before() -> Outcome<()> {
28 let root = res!(scratch("forms"));
29 res!(std::fs::write(root.join("present.key"), "s3cret\n"));
30 res!(std::fs::write(root.join("notdir"), "x"));
31 res!(std::fs::create_dir_all(root.join("sub")));
32 res!(std::fs::write(root.join("sub").join("nested.key"), " inner \n"));
33 let abs = root.join("present.key");
34 let abs = abs.to_string_lossy();
35
36 std::env::set_var("FE2O3_CFG_RESOLVE_SET", "value");
37 std::env::set_var("FE2O3_CFG_RESOLVE_KEY", "present.key");
38 std::env::set_var("FE2O3_CFG_RESOLVE_DIR", "sub");
39 std::env::set_var("FE2O3_CFG_RESOLVE_EMPTY", "");
40 std::env::remove_var("FE2O3_CFG_RESOLVE_UNSET");
41
42 let table: Vec<(String, Want)> = vec![
43 // Plain text.
44 (fmt!("plain"), Want::Is(fmt!("plain"))),
45 (fmt!(""), Want::Is(fmt!(""))),
46 // Environment.
47 (fmt!("{{env:FE2O3_CFG_RESOLVE_SET}}"), Want::Is(fmt!("value"))),
48 (fmt!("a {{env:FE2O3_CFG_RESOLVE_SET}} b"), Want::Is(fmt!("a value b"))),
49 (fmt!("{{env:FE2O3_CFG_RESOLVE_UNSET:dflt}}"), Want::Is(fmt!("dflt"))),
50 (fmt!("{{env:FE2O3_CFG_RESOLVE_UNSET:}}"), Want::Is(fmt!(""))),
51 (fmt!("{{env:FE2O3_CFG_RESOLVE_UNSET:a:b}}"), Want::Is(fmt!("a:b"))),
52 (fmt!("{{env:FE2O3_CFG_RESOLVE_EMPTY:dflt}}"), Want::Is(fmt!("dflt"))),
53 (fmt!("{{env:FE2O3_CFG_RESOLVE_SET:dflt}}"), Want::Is(fmt!("value"))),
54 (fmt!("{{env:FE2O3_CFG_RESOLVE_UNSET}}"), Want::Fails),
55 (fmt!("{{env:FE2O3_CFG_RESOLVE_EMPTY}}"), Want::Fails),
56 (fmt!("{{env:unclosed"), Want::Fails),
57 // Files, relative to the root and trimmed.
58 (fmt!("{{file:present.key}}"), Want::Is(fmt!("s3cret"))),
59 (fmt!("{{file:sub/nested.key}}"), Want::Is(fmt!("inner"))),
60 (fmt!("Bearer {{file:present.key}}"), Want::Is(fmt!("Bearer s3cret"))),
61 (fmt!("{{file:absent.key}}"), Want::Fails),
62 (fmt!("{{file:unclosed"), Want::Fails),
63 // An absolute path replaces the root.
64 (fmt!("{{file:{}}}", abs), Want::Is(fmt!("s3cret"))),
65 // The optional form: absent is empty, any other failure still fails.
66 (fmt!("{{file?:present.key}}"), Want::Is(fmt!("s3cret"))),
67 (fmt!("{{file?:absent.key}}"), Want::Is(fmt!(""))),
68 (fmt!("{{file?:notdir/child}}"), Want::Fails),
69 (fmt!("{{file?:unclosed"), Want::Fails),
70 (fmt!("a{{file?:absent.key}}b{{file:present.key}}c"), Want::Is(fmt!("abs3cretc"))),
71 (fmt!("{{file:present.key}}{{file?:absent.key}}"), Want::Is(fmt!("s3cret"))),
72 // The environment inside a file reference.
73 (fmt!("{{file:{{env:FE2O3_CFG_RESOLVE_KEY}}}}"), Want::Is(fmt!("s3cret"))),
74 (fmt!("{{file:{{env:FE2O3_CFG_RESOLVE_DIR}}/nested.key}}"), Want::Is(fmt!("inner"))),
75 (fmt!("{{file:{{env:FE2O3_CFG_RESOLVE_UNSET:present.key}}}}"), Want::Is(fmt!("s3cret"))),
76 (fmt!("{{file?:{{env:FE2O3_CFG_RESOLVE_UNSET:absent.key}}}}"), Want::Is(fmt!(""))),
77 (fmt!("{{file:{{env:FE2O3_CFG_RESOLVE_UNSET}}}}"), Want::Fails),
78 ];
79
80 for (value, want) in &table {
81 let got = cfg::resolve(value, &root);
82 match (want, got) {
83 (Want::Is(w), Ok(g)) => assert_eq!(&g, w, "{:?}", value),
84 (Want::Is(w), Err(e)) => panic!("{:?} should resolve to {:?}, failed: {}", value, w, e),
85 (Want::Fails, Ok(g)) => panic!("{:?} should be refused, resolved to {:?}", value, g),
86 (Want::Fails, Err(_)) => (),
87 }
88 }
89
90 // A present file the process may not read is refused by the optional form too.
91 #[cfg(unix)]
92 {
93 use std::os::unix::fs::PermissionsExt;
94 let locked = root.join("locked.key");
95 res!(std::fs::write(&locked, "nope\n"));
96 res!(std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o000)));
97 if std::fs::read_to_string(&locked).is_err() { // root reads mode 000
98 assert!(cfg::resolve("{file?:locked.key}", &root).is_err());
99 }
100 let _ = std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o600));
101 }
102
103 let _ = std::fs::remove_dir_all(&root);
104 Ok(())
105}
106
107#[test]
108fn file_refs_names_every_file_after_env_and_reads_none() -> Outcome<()> {
109 let root = Path::new("/nonexistent/root");
110 std::env::set_var("FE2O3_CFG_RESOLVE_REFS", "from_env.key");
111 let got = res!(cfg::file_refs(
112 "a{file:one.key}b{file?:{env:FE2O3_CFG_RESOLVE_REFS}}c{file:/abs/three.key}", root));
113 assert_eq!(got, vec![
114 root.join("one.key"),
115 root.join("from_env.key"),
116 PathBuf::from("/abs/three.key"),
117 ]);
118 assert!(cfg::file_refs("{file:unclosed", root).is_err());
119 assert_eq!(res!(cfg::file_refs("plain", root)), Vec::<PathBuf>::new());
120 Ok(())
121}
122
123#[test]
124fn the_app_root_rule_resolves_every_spec() -> Outcome<()> {
125 let cwd = res!(std::env::current_dir());
126 for spec in ["current", "here", "auto", "."] {
127 assert_eq!(res!(cfg::resolve_root(spec, "FE2O3_CFG_ROOT_UNUSED")), cwd, "{}", spec);
128 }
129 std::env::set_var("FE2O3_CFG_ROOT_SET", "/srv/app");
130 assert_eq!(res!(cfg::resolve_root("env", "FE2O3_CFG_ROOT_SET")), PathBuf::from("/srv/app"));
131 std::env::remove_var("FE2O3_CFG_ROOT_UNSET");
132 assert!(cfg::resolve_root("env", "FE2O3_CFG_ROOT_UNSET").is_err());
133 let home = res!(std::env::var("HOME"));
134 assert_eq!(res!(cfg::resolve_root("~/apps/x", "V")), PathBuf::from(fmt!("{}/apps/x", home)));
135 assert_eq!(res!(cfg::resolve_root("./apps/x", "V")), cwd.join("apps/x"));
136 assert_eq!(res!(cfg::resolve_root("/abs/x", "V")), PathBuf::from("/abs/x"));
137 assert_eq!(res!(cfg::resolve_root("rel/x", "V")), PathBuf::from("rel/x"));
138 Ok(())
139}
140
141#[test]
142fn a_file_is_inserted_verbatim_and_never_rescanned() -> Outcome<()> {
143 let root = res!(scratch("verbatim"));
144 let held = "a{file:/etc/passwd}b{env:FE2O3_CFG_RESOLVE_INNER}c{file?:x}{file:unclosed";
145 res!(std::fs::write(root.join("held.key"), fmt!("{}\n", held)));
146 res!(std::fs::write(root.join("self.key"), "{file:self.key}"));
147 std::env::set_var("FE2O3_CFG_RESOLVE_INNER", "expanded");
148 assert_eq!(res!(cfg::resolve("{file:held.key}", &root)), held);
149 assert_eq!(res!(cfg::resolve("[{file?:held.key}]", &root)), fmt!("[{}]", held));
150 // A file naming itself would loop if its contents were scanned again.
151 assert_eq!(res!(cfg::resolve("{file:self.key}-{file:self.key}", &root)),
152 "{file:self.key}-{file:self.key}");
153 let _ = std::fs::remove_dir_all(&root);
154 Ok(())
155}
156
157// QA gwmain P3-3: an environment value is inserted verbatim, as a file's contents are, and the
158// scan goes on after it. A value naming its own variable used to hang start-up, and a value
159// holding `{file:...}` was then read as a key file that no path check saw.
160#[test]
161fn an_env_value_is_inserted_verbatim_and_never_rescanned() -> Outcome<()> {
162 let root = res!(scratch("env_verbatim"));
163 res!(std::fs::write(root.join("probe.key"), "read"));
164 std::env::set_var("FE2O3_CFG_RESOLVE_SELF", "{env:FE2O3_CFG_RESOLVE_SELF}");
165 std::env::set_var("FE2O3_CFG_RESOLVE_HOLDS_FILE", "x{file:probe.key}y");
166 std::env::set_var("FE2O3_CFG_RESOLVE_HOLDS_ENV", "{env:FE2O3_CFG_RESOLVE_SET2}");
167 std::env::set_var("FE2O3_CFG_RESOLVE_SET2", "inner");
168 std::env::set_var("FE2O3_CFG_RESOLVE_BRACE", "pro}be.key");
169 let (tx, rx) = std::sync::mpsc::channel();
170 let r = root.clone();
171 std::thread::spawn(move || {
172 let _ = tx.send((
173 cfg::resolve_env("a{env:FE2O3_CFG_RESOLVE_SELF}b").map_err(|e| fmt!("{}", e)),
174 cfg::resolve("<{env:FE2O3_CFG_RESOLVE_SELF}>", &r).map_err(|e| fmt!("{}", e)),
175 ));
176 });
177 let (env_only, whole) = match rx.recv_timeout(std::time::Duration::from_secs(5)) {
178 Ok(v) => v,
179 Err(_) => panic!("a self-referring environment value hangs the resolver"),
180 };
181 assert_eq!(env_only, Ok(fmt!("a{{env:FE2O3_CFG_RESOLVE_SELF}}b")));
182 assert_eq!(whole, Ok(fmt!("<{{env:FE2O3_CFG_RESOLVE_SELF}}>")));
183 assert_eq!(res!(cfg::resolve_env("{env:FE2O3_CFG_RESOLVE_HOLDS_ENV}")), "{env:FE2O3_CFG_RESOLVE_SET2}");
184 // A {file:} inside an environment value is text, not a reference: nothing is read.
185 assert_eq!(res!(cfg::resolve("{env:FE2O3_CFG_RESOLVE_HOLDS_FILE}", &root)), "x{file:probe.key}y");
186 assert!(res!(cfg::file_refs("{env:FE2O3_CFG_RESOLVE_HOLDS_FILE}", &root)).is_empty());
187 // A brace in a variable naming a file does not end the reference early.
188 res!(std::fs::write(root.join("pro}be.key"), "braced"));
189 assert_eq!(res!(cfg::resolve("{file:{env:FE2O3_CFG_RESOLVE_BRACE}}", &root)), "braced");
190 assert_eq!(res!(cfg::file_refs("{file:{env:FE2O3_CFG_RESOLVE_BRACE}}", &root)), vec![root.join("pro}be.key")]);
191 let _ = std::fs::remove_dir_all(&root);
192 Ok(())
193}