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 | |
| 5 | use oxedyne_fe2o3_core::prelude::*; |
| 6 | use oxedyne_fe2o3_jdat::cfg; |
| 7 | |
| 8 | use std::path::{ |
| 9 | Path, |
| 10 | PathBuf, |
| 11 | }; |
| 12 | |
| 13 | |
| 14 | fn 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 | |
| 21 | enum Want { |
| 22 | Is(String), // resolves to exactly this |
| 23 | Fails, // refused |
| 24 | } |
| 25 | |
| 26 | #[test] |
| 27 | fn 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] |
| 108 | fn 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] |
| 124 | fn 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] |
| 142 | fn 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] |
| 161 | fn 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 | } |