1use std::env;
2use std::sync::{Mutex, MutexGuard};
3
4#[cfg(feature = "macros")]
6pub use tpt_env_mocker_macros::tpt_env;
7
8static ENV_MUTEX: Mutex<()> = Mutex::new(());
13
14#[derive(Default)]
29pub struct MockEnv {
30 ops: Vec<Op>,
31}
32
33#[derive(Clone)]
34enum Op {
35 Set(String, String),
36 Remove(String),
37}
38
39impl MockEnv {
40 pub fn new() -> Self {
42 Self::default()
43 }
44
45 pub fn set(mut self, key: &str, value: &str) -> Self {
47 self.ops.push(Op::Set(key.to_owned(), value.to_owned()));
48 self
49 }
50
51 pub fn remove(mut self, key: &str) -> Self {
53 self.ops.push(Op::Remove(key.to_owned()));
54 self
55 }
56
57 pub fn lock(self) -> EnvGuard {
65 let lock = ENV_MUTEX
68 .lock()
69 .unwrap_or_else(|poisoned| poisoned.into_inner());
70
71 let original_values: Vec<(String, Option<String>)> = self
73 .ops
74 .iter()
75 .map(|op| {
76 let key = match op {
77 Op::Set(k, _) | Op::Remove(k) => k.clone(),
78 };
79 let original = env::var(&key).ok();
80 (key, original)
81 })
82 .collect();
83
84 for op in self.ops {
86 match op {
87 Op::Set(k, v) => {
88 unsafe { env::set_var(&k, &v) };
91 }
92 Op::Remove(k) => {
93 unsafe { env::remove_var(&k) };
94 }
95 }
96 }
97
98 EnvGuard {
99 _lock: lock,
100 original_values,
101 }
102 }
103
104 pub fn recover_poison() {
108 let _unused = ENV_MUTEX.lock().unwrap_or_else(|p| p.into_inner());
109 }
110}
111
112pub struct EnvGuard {
118 _lock: MutexGuard<'static, ()>,
119 original_values: Vec<(String, Option<String>)>,
120}
121
122impl Drop for EnvGuard {
123 fn drop(&mut self) {
124 for (key, original) in &self.original_values {
125 match original {
126 Some(val) => unsafe { env::set_var(key, val) },
127 None => unsafe { env::remove_var(key) },
128 }
129 }
130 }
131}
132
133#[cfg(test)]
134mod tests {
135 use super::*;
136
137 #[test]
138 fn sets_and_restores_env_var() {
139 let key = "TPT_TEST_VAR_RESTORE";
140 env::remove_var(key);
141 {
142 let _g = MockEnv::new().set(key, "hello").lock();
143 assert_eq!(env::var(key).unwrap(), "hello");
144 }
145 assert!(env::var(key).is_err(), "should be restored (removed)");
146 }
147
148 #[test]
149 fn restores_original_value() {
150 let key = "TPT_TEST_VAR_ORIGINAL";
151 unsafe { env::set_var(key, "original") };
152 {
153 let _g = MockEnv::new().set(key, "overridden").lock();
154 assert_eq!(env::var(key).unwrap(), "overridden");
155 }
156 assert_eq!(env::var(key).unwrap(), "original");
157 }
158
159 #[test]
160 fn remove_op() {
161 let key = "TPT_TEST_VAR_REMOVE";
162 unsafe { env::set_var(key, "present") };
163 {
164 let _g = MockEnv::new().remove(key).lock();
165 assert!(env::var(key).is_err());
166 }
167 assert_eq!(env::var(key).unwrap(), "present");
168 }
169
170 #[test]
171 fn multiple_vars() {
172 let k1 = "TPT_MULTI_A";
173 let k2 = "TPT_MULTI_B";
174 {
175 let _g = MockEnv::new().set(k1, "a").set(k2, "b").lock();
176 assert_eq!(env::var(k1).unwrap(), "a");
177 assert_eq!(env::var(k2).unwrap(), "b");
178 }
179 assert!(env::var(k1).is_err());
180 assert!(env::var(k2).is_err());
181 }
182}