Skip to main content

smplx_test_test/
config.rs

1use std::fs;
2use std::fs::OpenOptions;
3use std::io::Read;
4use std::io::Write;
5use std::path::Path;
6
7use serde::{Deserialize, Serialize};
8
9use smplx_regtest::RegtestConfig;
10use smplx_sdk::global::Verbosity;
11
12use super::error::TestError;
13
14pub const TEST_ENV_NAME: &str = "SIMPLEX_TEST_ENV";
15pub const DEFAULT_TEST_MNEMONIC: &str = "exist carry drive collect lend cereal occur much tiger just involve mean";
16pub const DEFAULT_BITCOINS: u64 = 10_000_000;
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(default)]
20pub struct TestConfig {
21    pub mnemonic: String,
22    pub bitcoins: u64,
23    pub esplora: Option<EsploraConfig>,
24    pub rpc: Option<RpcConfig>,
25    pub verbosity: Verbosity,
26}
27
28#[derive(Debug, Default, Clone, Serialize, Deserialize)]
29pub struct EsploraConfig {
30    pub url: String,
31    pub network: String,
32}
33
34#[derive(Debug, Default, Clone, Serialize, Deserialize)]
35pub struct RpcConfig {
36    pub url: String,
37    pub username: String,
38    pub password: String,
39}
40
41impl TestConfig {
42    pub fn from_file(path: impl AsRef<Path>) -> Result<Self, TestError> {
43        let mut content = String::new();
44        let mut file = OpenOptions::new().read(true).open(path)?;
45
46        file.read_to_string(&mut content)?;
47
48        Ok(toml::from_str(&content)?)
49    }
50
51    pub fn to_regtest_config(&self) -> RegtestConfig {
52        RegtestConfig {
53            mnemonic: self.mnemonic.clone(),
54            bitcoins: self.bitcoins,
55            rpc_port: None,
56            esplora_port: None,
57            rpc_user: None,
58            rpc_password: None,
59        }
60    }
61
62    pub fn to_file(&self, path: &impl AsRef<Path>) -> Result<(), TestError> {
63        if let Some(parent_dir) = path.as_ref().parent() {
64            fs::create_dir_all(parent_dir)?;
65        }
66
67        let mut file = OpenOptions::new().create(true).write(true).truncate(true).open(path)?;
68
69        file.write_all(toml::to_string_pretty(&self).unwrap().as_bytes())?;
70        file.flush()?;
71
72        Ok(())
73    }
74}
75
76impl Default for TestConfig {
77    fn default() -> Self {
78        Self {
79            mnemonic: DEFAULT_TEST_MNEMONIC.to_string(),
80            bitcoins: DEFAULT_BITCOINS,
81            esplora: None,
82            rpc: None,
83            verbosity: Verbosity::None,
84        }
85    }
86}
87
88#[cfg(test)]
89mod tests {
90    use super::*;
91
92    #[test]
93    fn config_round_trips_and_converts_to_regtest() {
94        let path = std::env::temp_dir().join(format!("smplx-test-config-{}.toml", std::process::id()));
95        let config = TestConfig {
96            mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
97                .into(),
98            bitcoins: 42,
99            verbosity: Verbosity::Trace,
100            esplora: Some(EsploraConfig {
101                url: "http://localhost:3000".into(),
102                network: "ElementsRegtest".into(),
103            }),
104            rpc: Some(RpcConfig {
105                url: "http://localhost:18443".into(),
106                username: "user".into(),
107                password: "password".into(),
108            }),
109        };
110
111        config.to_file(&path).expect("test config should be written");
112        let loaded = TestConfig::from_file(&path).expect("test config should be loaded");
113        let regtest = loaded.to_regtest_config();
114
115        assert_eq!(loaded.mnemonic, config.mnemonic);
116        assert_eq!(loaded.bitcoins, config.bitcoins);
117        assert_eq!(loaded.verbosity, Verbosity::Trace);
118        let esplora = loaded.esplora.as_ref().unwrap();
119        assert_eq!(esplora.url, "http://localhost:3000");
120        assert_eq!(esplora.network, "ElementsRegtest");
121        let rpc = loaded.rpc.as_ref().unwrap();
122        assert_eq!(rpc.url, "http://localhost:18443");
123        assert_eq!(rpc.username, "user");
124        assert_eq!(rpc.password, "password");
125        assert_eq!(regtest.mnemonic, config.mnemonic);
126        assert_eq!(regtest.bitcoins, config.bitcoins);
127        assert!(regtest.rpc_port.is_none());
128        assert!(regtest.esplora_port.is_none());
129        assert!(regtest.rpc_user.is_none());
130        assert!(regtest.rpc_password.is_none());
131        let _ = std::fs::remove_file(path);
132    }
133}