Oregami
Repositories/oxedyne/fe2o3

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
4use oxedyne_fe2o3_core::prelude::*;
5use oxedyne_fe2o3_jdat::{
6 prelude::*,
7 cfg::{
8 self,
9 Roots,
10 },
11};
12
13use std::path::{
14 Path,
15 PathBuf,
16};
17
18
19#[test]
20fn 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]
36fn 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]
48fn 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]
74fn 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]
102fn 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}