oxedyne/fe2o3/fe2o3_jdat/tests/cfg_roots.rs
4.9 KiB, 3 runs
created by r1870400018:76020, 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::Roots`, an app's code, state and secret roots, each chosen by `resolve_root` and each |
| 2 | //! placing its values by `path_at` (SRV-LAYOUT G1, 30 Oct 2026). |
| 3 | |
| 4 | use oxedyne_fe2o3_core::prelude::*; |
| 5 | use oxedyne_fe2o3_jdat::{ |
| 6 | prelude::*, |
| 7 | cfg::{ |
| 8 | self, |
| 9 | Roots, |
| 10 | }, |
| 11 | }; |
| 12 | |
| 13 | use std::path::{ |
| 14 | Path, |
| 15 | PathBuf, |
| 16 | }; |
| 17 | |
| 18 | |
| 19 | #[test] |
| 20 | fn roots_state_and_secret_default_to_app() -> Outcome<()> { |
| 21 | let roots = res!(Roots::resolve("/srv/app", "", "", "FE2O3_ROOTS_T1")); |
| 22 | assert_eq!(roots.app_root(), Path::new("/srv/app")); |
| 23 | assert_eq!(roots.state_root(), Path::new("/srv/app")); |
| 24 | assert_eq!(roots.secret_root(), Path::new("/srv/app")); |
| 25 | // An unsplit app places every value exactly as path_at under its one root does. |
| 26 | for value in ["o3db", "./logs", "/var/log/x", "a/../b"] { |
| 27 | let one = res!(cfg::path_at(value, Path::new("/srv/app"), None)); |
| 28 | assert_eq!(res!(roots.app(value)), one, "{}", value); |
| 29 | assert_eq!(res!(roots.state(value)), one, "{}", value); |
| 30 | assert_eq!(res!(roots.secret(value)), one, "{}", value); |
| 31 | } |
| 32 | Ok(()) |
| 33 | } |
| 34 | |
| 35 | #[test] |
| 36 | fn roots_split_places_each_value_under_its_own_root() -> Outcome<()> { |
| 37 | let roots = res!(Roots::resolve( |
| 38 | "/srv/app", "/var/lib/app", "/etc/oxedyne/app", "FE2O3_ROOTS_T2")); |
| 39 | assert_eq!(res!(roots.app("www")), PathBuf::from("/srv/app/www")); |
| 40 | assert_eq!(res!(roots.state("./o3db")), PathBuf::from("/var/lib/app/o3db")); |
| 41 | assert_eq!(res!(roots.secret("ctl.token")), PathBuf::from("/etc/oxedyne/app/ctl.token")); |
| 42 | // An absolute value is used as written whichever root it is asked of. |
| 43 | assert_eq!(res!(roots.state("/run/app/ctl.sock")), PathBuf::from("/run/app/ctl.sock")); |
| 44 | Ok(()) |
| 45 | } |
| 46 | |
| 47 | #[test] |
| 48 | fn roots_each_spec_is_a_resolve_root_spec_with_its_own_env_var() -> Outcome<()> { |
| 49 | std::env::set_var("FE2O3_ROOTS_T3_APP_ROOT", "/srv/a"); |
| 50 | std::env::set_var("FE2O3_ROOTS_T3_STATE_ROOT", "/var/lib/a"); |
| 51 | std::env::set_var("FE2O3_ROOTS_T3_SECRET_ROOT", "/etc/a"); |
| 52 | let roots = res!(Roots::resolve("env", "env", "env", "FE2O3_ROOTS_T3")); |
| 53 | assert_eq!(roots.app_root(), Path::new("/srv/a")); |
| 54 | assert_eq!(roots.state_root(), Path::new("/var/lib/a")); |
| 55 | assert_eq!(roots.secret_root(), Path::new("/etc/a")); |
| 56 | |
| 57 | let cwd = res!(std::env::current_dir()); |
| 58 | let home = PathBuf::from(res!(std::env::var("HOME"))); |
| 59 | let roots = res!(Roots::resolve(".", "./state", "~/keys", "FE2O3_ROOTS_T3")); |
| 60 | assert_eq!(roots.app_root(), cwd.as_path()); |
| 61 | assert_eq!(roots.state_root(), cwd.join("state").as_path()); |
| 62 | assert_eq!(roots.secret_root(), home.join("keys").as_path()); |
| 63 | |
| 64 | std::env::remove_var("FE2O3_ROOTS_T3B_STATE_ROOT"); |
| 65 | let e = match Roots::resolve("/srv/a", "env", "", "FE2O3_ROOTS_T3B") { |
| 66 | Ok(r) => return Err(err!("An unset state env var resolved to {:?}.", r; Test)), |
| 67 | Err(e) => e, |
| 68 | }; |
| 69 | assert!(fmt!("{}", e).contains("FE2O3_ROOTS_T3B_STATE_ROOT"), "{}", e); |
| 70 | Ok(()) |
| 71 | } |
| 72 | |
| 73 | #[test] |
| 74 | fn roots_refuse_a_relative_root_and_keep_path_at_checks() -> Outcome<()> { |
| 75 | // resolve_root takes "rel/x" as written, so a relative root is refused here, by name. |
| 76 | for (app, state, secret, which) in [ |
| 77 | ("rel/app", "", "", "app"), |
| 78 | ("", "", "", "app"), |
| 79 | ("/srv/a", "rel/state", "", "state"), |
| 80 | ("/srv/a", "", "rel/sec", "secret"), |
| 81 | ] { |
| 82 | match Roots::resolve(app, state, secret, "FE2O3_ROOTS_T4") { |
| 83 | Ok(r) => return Err(err!("{:?} resolved with a relative root: {:?}.", |
| 84 | (app, state, secret), r; Test)), |
| 85 | Err(e) => assert!(fmt!("{}", e).contains(which), "{}: {}", which, e), |
| 86 | } |
| 87 | } |
| 88 | let roots = res!(Roots::resolve("/srv/a", "/var/lib/a", "/etc/a", "FE2O3_ROOTS_T4")); |
| 89 | for value in ["../etc", "", "x\0y", "{env:X}", "{file:k}"] { |
| 90 | assert!(roots.state(value).is_err(), "state {:?}", value); |
| 91 | assert!(roots.secret(value).is_err(), "secret {:?}", value); |
| 92 | } |
| 93 | // '~/' needs a home, given or from HOME; one given replaces it. |
| 94 | let roots = roots.with_home(Some(PathBuf::from("/home/runner"))); |
| 95 | assert_eq!(res!(roots.state("~/x")), PathBuf::from("/home/runner/x")); |
| 96 | let roots = roots.with_home(None); |
| 97 | assert!(roots.state("~/x").is_err()); |
| 98 | Ok(()) |
| 99 | } |
| 100 | |
| 101 | #[test] |
| 102 | fn roots_resolve_file_references_under_the_secret_root() -> Outcome<()> { |
| 103 | let base = std::env::temp_dir().join(fmt!("fe2o3_cfg_roots_{}", std::process::id())); |
| 104 | let secret = base.join("secret"); |
| 105 | res!(std::fs::create_dir_all(&secret)); |
| 106 | res!(std::fs::write(secret.join("api.key"), "s3cret\n")); |
| 107 | let roots = res!(Roots::resolve( |
| 108 | &base.join("app").to_string_lossy(), "", &secret.to_string_lossy(), "FE2O3_ROOTS_T5")); |
| 109 | let dat = Dat::List(vec![Dat::Str(fmt!("{{file:api.key}}")), Dat::U8(7)]); |
| 110 | assert_eq!(res!(roots.resolve_secrets(&dat)), |
| 111 | Dat::List(vec![Dat::Str(fmt!("s3cret")), Dat::U8(7)])); |
| 112 | res!(std::fs::remove_dir_all(&base)); |
| 113 | Ok(()) |
| 114 | } |