14316676040

Committed 07 Apr 2025 06:27PM UTC coverage: 74.417% (-0.9%) from 75.283%

Build # 14316676040

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1202 from Blightmud/dependabot/cargo/rustls-0.23.25

build(deps): bump rustls from 0.23.23 to 0.23.25

Run Details

7089 of 9526 relevant lines covered (74.42%)

431.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.52

/src/tools/patch.rs

use {
    crate::{
        event::Event,
        fs,
        io::SaveData,
        model::{Connection, Servers, Settings},
        tts::TTSSettings,
        DATA_DIR,
    },
    lazy_static::lazy_static,
    serde::{Deserialize, Serialize},
    std::{collections::HashMap, path::PathBuf, sync::mpsc::Sender},
};

#[cfg(not(test))]
lazy_static! {
    pub static ref V2_SERVERS_PATH: PathBuf = DATA_DIR.join("data/servers.ron");
    pub static ref V2_SETTINGS_PATH: PathBuf = DATA_DIR.join("config/settings.ron");
    pub static ref V2_TTS_SETTINGS_PATH: PathBuf = DATA_DIR.join("data/tts_settings.ron");
}

/// Migrates settings.ron and servers.ron from DATA_DIR to CONFIG_DIR.
/// This happened in the v3.0.0 release.
/// See https://github.com/LiquidityC/Blightmud/pull/202
pub fn migrate_v2_settings_and_servers(main_writer: Sender<Event>) {
    macro_rules! send_error {
        ($msg:expr) => { main_writer.send(Event::Error($msg.into())).unwrap(); };
        ($fmt:literal, $($args:expr,)+) => { send_error!(format!($fmt, $($args,)+)) };
        ($fmt:literal, $($args:expr),+) => { send_error!(format!($fmt, $($args,)+)) };
    }

    macro_rules! send_info {
        ($msg:expr) => { main_writer.send(Event::Info($msg.into())).unwrap(); };
        ($fmt:literal, $($args:expr,)+) => { send_info!(format!($fmt, $($args,)+)) };
        ($fmt:literal, $($args:expr),+) => { send_info!(format!($fmt, $($args,)+)) };
    }

    #[derive(Debug, Clone, Serialize, Deserialize, Default)]
    struct V2Settings {
        settings: HashMap<String, bool>,
    }

    impl SaveData for V2Settings {
        fn relative_path() -> PathBuf {
            V2_SETTINGS_PATH.clone()
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize, Default)]
    struct V2Connection {
        host: String,
        port: u16,
        tls: Option<bool>,
    }

    impl From<V2Connection> for Connection {
        fn from(v2: V2Connection) -> Connection {
            Connection {
                host: v2.host,
                port: v2.port,
                tls: v2.tls.unwrap_or_default(),
                verify_cert: false,
            }
        }
    }

    #[derive(Debug, Clone, Serialize, Deserialize, Default)]
    #[serde(transparent)]
    struct V2Servers {
        servers: HashMap<String, V2Connection>,
    }

    impl SaveData for V2Servers {
        fn relative_path() -> PathBuf {
            V2_SERVERS_PATH.clone()
        }
    }

    impl From<V2Servers> for Servers {
        fn from(v2: V2Servers) -> Servers {
            let mut servers = HashMap::new();
            for (k, v) in v2.servers {
                servers.insert(k, v.into());
            }
            servers
        }
    }

    if V2_SERVERS_PATH.exists() {
        if Servers::relative_path().exists() {
            send_error!("Can't migrate servers.ron:");
            send_error!(
                "servers.ron already exists at {:?}",
                Servers::relative_path()
            );
        } else {
            let old_servers = V2Servers::load();
            let new_servers: Servers = old_servers.into();
            new_servers.save();
            let _ = fs::remove_file(&*V2_SERVERS_PATH);
            send_info!(
                "Migrated servers.ron from {:?} to {:?}",
                *V2_SERVERS_PATH,
                Servers::relative_path()
            );
        }
    }

    if V2_SETTINGS_PATH.exists() {
        if Settings::relative_path().exists() {
            send_error!("Can't migrate settings.ron:");
            send_error!(
                "settings.ron already exists at {:?}",
                Settings::relative_path()
            );
        } else {
            let old_settings = V2Settings::load();
            let new_settings = Settings::from(old_settings.settings);
            new_settings.save();
            let _ = fs::remove_file(&*V2_SETTINGS_PATH);
            send_info!(
                "Migrated settings.ron from {:?} to {:?}",
                *V2_SETTINGS_PATH,
                Settings::relative_path()
            );
        }
    }

    if V2_TTS_SETTINGS_PATH.exists() {
        if TTSSettings::relative_path().exists() {
            send_error!(
                "tts_settings.ron already exists at {:?}",
                TTSSettings::relative_path()
            );
        } else {
            TTSSettings::relative_path()
                .parent()
                .map(fs::create_dir_all);
            fs::rename(&*V2_TTS_SETTINGS_PATH, TTSSettings::relative_path()).unwrap();
            send_info!(
                "Migrated tts_settings.ron from {:?} to {:?}",
                *V2_TTS_SETTINGS_PATH,
                TTSSettings::relative_path(),
            );
        }
    }
}

#[cfg(test)]
lazy_static! {
    pub static ref V2_SERVERS_PATH: PathBuf = DATA_DIR.join("v2_servers.ron");
    pub static ref V2_SETTINGS_PATH: PathBuf = DATA_DIR.join("v2_settings.ron");
    pub static ref V2_TTS_SETTINGS_PATH: PathBuf = DATA_DIR.join("v2_tts_settings.ron");
}

#[cfg(test)]
#[allow(dead_code)]
mod patch_test {
    use {
        super::*,
        crate::model::*,
        std::{io::Write, panic, sync::mpsc},
    };

    fn setup() {
        let paths = [
            TTSSettings::relative_path(),
            Settings::relative_path(),
            Servers::relative_path(),
            DATA_DIR.join("test"),
        ];
        for path in paths.iter() {
            path.parent().map(|dir| fs::create_dir_all(&dir));
        }
    }

    fn cleanup() {
        let _ = fs::remove_dir_all(PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(".run/test"));
    }

    fn create_v2_settings_file() {
        let v2_settings = r#"(settings:{"tts_enabled":true,"logging_enabled":true,"save_history":false,"confirm_quit":false,"mouse_enabled":true})"#;
        let mut file = fs::File::create(&*V2_SETTINGS_PATH).unwrap();
        file.write_all(v2_settings.as_bytes()).unwrap();
    }

    fn create_v2_tts_settings_file() {
        let v2_tts_settings = r#"(echo_keys:true,rate:5)"#;
        let mut file = fs::File::create(&*V2_TTS_SETTINGS_PATH).unwrap();
        file.write_all(v2_tts_settings.as_bytes()).unwrap();
    }

    fn create_v2_servers_file() {
        let v2_servers = r#"{"lotr":(host:"lotr-mud.com",port:5555,tls:Some(true)),"starwars":(host:"starwars.mud.com",port:1212,tls:Some(false)),"mymud2":(host:"mud2",port:1234,tls:Some(false)),"mymud":(host:"mud",port:6789,tls:Some(false))}"#;
        let mut file = fs::File::create(&*V2_SERVERS_PATH).unwrap();
        file.write_all(v2_servers.as_bytes()).unwrap();
    }

    macro_rules! assert_event {
        ($event:expr, $event_type:pat) => {{
            if !matches!($event, $event_type) {
                println!("{:?}", $event);
            }
            assert!(matches!($event, $event_type));
        }};
    }

    #[test]
    fn test_v2_migrator() {
        let orig_hook = panic::take_hook();
        panic::set_hook(Box::new(move |info| {
            cleanup();
            orig_hook(info);
        }));

        let tests = [
            test_migrate_v2_servers,
            test_migrate_v2_settings,
            test_migrate_v2_tts_settings,
            test_doesnt_migrate_over_existing_settings_file,
            test_doesnt_migrate_over_existing_tts_settings_file,
            test_doesnt_migrate_over_existing_servers_file,
        ];

        for test in tests.iter() {
            setup();
            test();
            cleanup();
        }
    }

    fn test_migrate_v2_settings() {
        create_v2_settings_file();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let info = rx.recv().unwrap();
        assert_event!(info, Event::Info(..));

        let settings = Settings::try_load().unwrap();
        assert!(settings.get(LOGGING_ENABLED).unwrap());
        assert!(settings.get(TTS_ENABLED).unwrap());
        assert!(settings.get(MOUSE_ENABLED).unwrap());
        assert!(!settings.get(SAVE_HISTORY).unwrap());
        assert!(!settings.get(CONFIRM_QUIT).unwrap());
    }

    fn test_migrate_v2_tts_settings() {
        create_v2_tts_settings_file();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let info = rx.recv().unwrap();
        assert_event!(info, Event::Info(..));

        let settings = TTSSettings::try_load().unwrap();
        assert!(settings.echo_keys);
        assert_eq!(5.0, settings.rate);
    }

    fn test_migrate_v2_servers() {
        create_v2_servers_file();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let info = rx.recv().unwrap();
        assert_event!(info, Event::Info(..));

        let servers = Servers::try_load().unwrap();
        let lotr = servers.get("lotr").unwrap();
        assert!(lotr.tls);
        assert_eq!(5555, lotr.port);
        assert_eq!(false, servers.get("mymud").unwrap().tls);
        assert_eq!(1234, servers.get("mymud2").unwrap().port);
    }

    fn test_doesnt_migrate_over_existing_settings_file() {
        create_v2_settings_file();
        let mut file = fs::File::create(&Settings::relative_path()).unwrap();
        file.write_all(b"").unwrap();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let event = rx.recv().unwrap();
        assert_event!(event, Event::Error(..));
    }

    fn test_doesnt_migrate_over_existing_tts_settings_file() {
        create_v2_tts_settings_file();
        let mut file = fs::File::create(&TTSSettings::relative_path()).unwrap();
        file.write_all(b"").unwrap();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let event = rx.recv().unwrap();
        assert_event!(event, Event::Error(..));
    }

    fn test_doesnt_migrate_over_existing_servers_file() {
        create_v2_servers_file();
        let mut file = fs::File::create(&Servers::relative_path()).unwrap();
        file.write_all(b"").unwrap();

        let (tx, rx) = mpsc::channel();
        migrate_v2_settings_and_servers(tx);

        let event = rx.recv().unwrap();
        assert_event!(event, Event::Error(..));
    }
}

1	use {
2	crate::{
3	event::Event,
4	fs,
5	io::SaveData,
6	model::{Connection, Servers, Settings},
7	tts::TTSSettings,
8	DATA_DIR,
9	},
10	lazy_static::lazy_static,
11	serde::{Deserialize, Serialize},
12	std::{collections::HashMap, path::PathBuf, sync::mpsc::Sender},
13	};
14
15	#[cfg(not(test))]
16	lazy_static! {
17	pub static ref V2_SERVERS_PATH: PathBuf = DATA_DIR.join("data/servers.ron");
18	pub static ref V2_SETTINGS_PATH: PathBuf = DATA_DIR.join("config/settings.ron");
19	pub static ref V2_TTS_SETTINGS_PATH: PathBuf = DATA_DIR.join("data/tts_settings.ron");
20	}
21
22	/// Migrates settings.ron and servers.ron from DATA_DIR to CONFIG_DIR.
23	/// This happened in the v3.0.0 release.
24	/// See https://github.com/LiquidityC/Blightmud/pull/202
25	pub fn migrate_v2_settings_and_servers(main_writer: Sender<Event>) {	6✔
26	macro_rules! send_error {
27	($msg:expr) => { main_writer.send(Event::Error($msg.into())).unwrap(); };
28	($fmt:literal, $($args:expr,)+) => { send_error!(format!($fmt, $($args,)+)) };
29	($fmt:literal, $($args:expr),+) => { send_error!(format!($fmt, $($args,)+)) };
30	}
31
32	macro_rules! send_info {
33	($msg:expr) => { main_writer.send(Event::Info($msg.into())).unwrap(); };
34	($fmt:literal, $($args:expr,)+) => { send_info!(format!($fmt, $($args,)+)) };
35	($fmt:literal, $($args:expr),+) => { send_info!(format!($fmt, $($args,)+)) };
36	}
37
38	#[derive(Debug, Clone, Serialize, Deserialize, Default)]
39	struct V2Settings {
40	settings: HashMap<String, bool>,
41	}
42
43	impl SaveData for V2Settings {
44	fn relative_path() -> PathBuf {	1✔
45	V2_SETTINGS_PATH.clone()	1✔
46	}	1✔
47	}
48
49	#[derive(Debug, Clone, Serialize, Deserialize, Default)]
50	struct V2Connection {
51	host: String,
52	port: u16,
53	tls: Option<bool>,
54	}
55
56	impl From<V2Connection> for Connection {
57	fn from(v2: V2Connection) -> Connection {	4✔
58	Connection {	4✔
59	host: v2.host,	4✔
60	port: v2.port,	4✔
61	tls: v2.tls.unwrap_or_default(),	4✔
62	verify_cert: false,	4✔
63	}	4✔
64	}	4✔
65	}
66
67	#[derive(Debug, Clone, Serialize, Deserialize, Default)]	1✔
68	#[serde(transparent)]
69	struct V2Servers {
70	servers: HashMap<String, V2Connection>,
71	}
72
73	impl SaveData for V2Servers {
74	fn relative_path() -> PathBuf {	1✔
75	V2_SERVERS_PATH.clone()	1✔
76	}	1✔
77	}
78
79	impl From<V2Servers> for Servers {
80	fn from(v2: V2Servers) -> Servers {	1✔
81	let mut servers = HashMap::new();	1✔
82	for (k, v) in v2.servers {	5✔
83	servers.insert(k, v.into());	4✔
84	}	4✔
85	servers	1✔
86	}	1✔
87	}
88
89	if V2_SERVERS_PATH.exists() {	6✔
90	if Servers::relative_path().exists() {	2✔
91	send_error!("Can't migrate servers.ron:");	1✔
92	send_error!(	1✔
93	"servers.ron already exists at {:?}",	1✔
94	Servers::relative_path()	1✔
95	);	1✔
96	} else {	1✔
97	let old_servers = V2Servers::load();	1✔
98	let new_servers: Servers = old_servers.into();	1✔
99	new_servers.save();	1✔
100	let _ = fs::remove_file(&*V2_SERVERS_PATH);	1✔
101	send_info!(	1✔
102	"Migrated servers.ron from {:?} to {:?}",	1✔
103	*V2_SERVERS_PATH,	1✔
104	Servers::relative_path()	1✔
105	);	1✔
106	}	1✔
107	}	4✔
108
109	if V2_SETTINGS_PATH.exists() {	6✔
110	if Settings::relative_path().exists() {	2✔
111	send_error!("Can't migrate settings.ron:");	1✔
112	send_error!(	1✔
113	"settings.ron already exists at {:?}",	1✔
114	Settings::relative_path()	1✔
115	);	1✔
116	} else {	1✔
117	let old_settings = V2Settings::load();	1✔
118	let new_settings = Settings::from(old_settings.settings);	1✔
119	new_settings.save();	1✔
120	let _ = fs::remove_file(&*V2_SETTINGS_PATH);	1✔
121	send_info!(	1✔
122	"Migrated settings.ron from {:?} to {:?}",	1✔
123	*V2_SETTINGS_PATH,	1✔
124	Settings::relative_path()	1✔
125	);	1✔
126	}	1✔
127	}	4✔
128
129	if V2_TTS_SETTINGS_PATH.exists() {	6✔
130	if TTSSettings::relative_path().exists() {	2✔
131	send_error!(	1✔
132	"tts_settings.ron already exists at {:?}",	1✔
133	TTSSettings::relative_path()	1✔
134	);	1✔
135	} else {	1✔
136	TTSSettings::relative_path()	1✔
137	.parent()	1✔
138	.map(fs::create_dir_all);	1✔
139	fs::rename(&*V2_TTS_SETTINGS_PATH, TTSSettings::relative_path()).unwrap();	1✔
140	send_info!(	1✔
141	"Migrated tts_settings.ron from {:?} to {:?}",	1✔
142	*V2_TTS_SETTINGS_PATH,	1✔
143	TTSSettings::relative_path(),	1✔
144	);	1✔
145	}	1✔
146	}	4✔
147	}	6✔
148
149	#[cfg(test)]
150	lazy_static! {
151	pub static ref V2_SERVERS_PATH: PathBuf = DATA_DIR.join("v2_servers.ron");
152	pub static ref V2_SETTINGS_PATH: PathBuf = DATA_DIR.join("v2_settings.ron");
153	pub static ref V2_TTS_SETTINGS_PATH: PathBuf = DATA_DIR.join("v2_tts_settings.ron");
154	}
155
156	#[cfg(test)]
157	#[allow(dead_code)]
158	mod patch_test {
159	use {
160	super::*,
161	crate::model::*,
162	std::{io::Write, panic, sync::mpsc},
163	};
164
165	fn setup() {	6✔
166	let paths = [	6✔
167	TTSSettings::relative_path(),	6✔
168	Settings::relative_path(),	6✔
169	Servers::relative_path(),	6✔
170	DATA_DIR.join("test"),	6✔
171	];	6✔
172	for path in paths.iter() {	24✔
173	path.parent().map(\|dir\| fs::create_dir_all(&dir));	24✔
174	}
175	}	6✔
176
177	fn cleanup() {	6✔
178	let _ = fs::remove_dir_all(PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(".run/test"));	6✔
179	}	6✔
180
181	fn create_v2_settings_file() {	2✔
182	let v2_settings = r#"(settings:{"tts_enabled":true,"logging_enabled":true,"save_history":false,"confirm_quit":false,"mouse_enabled":true})"#;	2✔
183	let mut file = fs::File::create(&*V2_SETTINGS_PATH).unwrap();	2✔
184	file.write_all(v2_settings.as_bytes()).unwrap();	2✔
185	}	2✔
186
187	fn create_v2_tts_settings_file() {	2✔
188	let v2_tts_settings = r#"(echo_keys:true,rate:5)"#;	2✔
189	let mut file = fs::File::create(&*V2_TTS_SETTINGS_PATH).unwrap();	2✔
190	file.write_all(v2_tts_settings.as_bytes()).unwrap();	2✔
191	}	2✔
192
193	fn create_v2_servers_file() {	2✔
194	let v2_servers = r#"{"lotr":(host:"lotr-mud.com",port:5555,tls:Some(true)),"starwars":(host:"starwars.mud.com",port:1212,tls:Some(false)),"mymud2":(host:"mud2",port:1234,tls:Some(false)),"mymud":(host:"mud",port:6789,tls:Some(false))}"#;	2✔
195	let mut file = fs::File::create(&*V2_SERVERS_PATH).unwrap();	2✔
196	file.write_all(v2_servers.as_bytes()).unwrap();	2✔
197	}	2✔
198
199	macro_rules! assert_event {
200	($event:expr, $event_type:pat) => {{
201	if !matches!($event, $event_type) {
202	println!("{:?}", $event);
203	}
204	assert!(matches!($event, $event_type));
205	}};
206	}
207
208	#[test]
209	fn test_v2_migrator() {	1✔
210	let orig_hook = panic::take_hook();	1✔
211	panic::set_hook(Box::new(move \|info\| {	1✔
212	cleanup();	×
213	orig_hook(info);	×
214	}));	×
215
216	let tests = [	1✔
217	test_migrate_v2_servers,	1✔
218	test_migrate_v2_settings,	1✔
219	test_migrate_v2_tts_settings,	1✔
220	test_doesnt_migrate_over_existing_settings_file,	1✔
221	test_doesnt_migrate_over_existing_tts_settings_file,	1✔
222	test_doesnt_migrate_over_existing_servers_file,	1✔
223	];	1✔
224
225	for test in tests.iter() {	6✔
226	setup();	6✔
227	test();	6✔
228	cleanup();	6✔
229	}	6✔
230	}	1✔
231
232	fn test_migrate_v2_settings() {	1✔
233	create_v2_settings_file();	1✔
234		1✔
235	let (tx, rx) = mpsc::channel();	1✔
236	migrate_v2_settings_and_servers(tx);	1✔
237		1✔
238	let info = rx.recv().unwrap();	1✔
239	assert_event!(info, Event::Info(..));	1✔
240
241	let settings = Settings::try_load().unwrap();	1✔
242	assert!(settings.get(LOGGING_ENABLED).unwrap());	1✔
243	assert!(settings.get(TTS_ENABLED).unwrap());	1✔
244	assert!(settings.get(MOUSE_ENABLED).unwrap());	1✔
245	assert!(!settings.get(SAVE_HISTORY).unwrap());	1✔
246	assert!(!settings.get(CONFIRM_QUIT).unwrap());	1✔
247	}	1✔
248
249	fn test_migrate_v2_tts_settings() {	1✔
250	create_v2_tts_settings_file();	1✔
251		1✔
252	let (tx, rx) = mpsc::channel();	1✔
253	migrate_v2_settings_and_servers(tx);	1✔
254		1✔
255	let info = rx.recv().unwrap();	1✔
256	assert_event!(info, Event::Info(..));	1✔
257
258	let settings = TTSSettings::try_load().unwrap();	1✔
259	assert!(settings.echo_keys);	1✔
260	assert_eq!(5.0, settings.rate);	1✔
261	}	1✔
262
263	fn test_migrate_v2_servers() {	1✔
264	create_v2_servers_file();	1✔
265		1✔
266	let (tx, rx) = mpsc::channel();	1✔
267	migrate_v2_settings_and_servers(tx);	1✔
268		1✔
269	let info = rx.recv().unwrap();	1✔
270	assert_event!(info, Event::Info(..));	1✔
271
272	let servers = Servers::try_load().unwrap();	1✔
273	let lotr = servers.get("lotr").unwrap();	1✔
274	assert!(lotr.tls);	1✔
275	assert_eq!(5555, lotr.port);	1✔
276	assert_eq!(false, servers.get("mymud").unwrap().tls);	1✔
277	assert_eq!(1234, servers.get("mymud2").unwrap().port);	1✔
278	}	1✔
279
280	fn test_doesnt_migrate_over_existing_settings_file() {	1✔
281	create_v2_settings_file();	1✔
282	let mut file = fs::File::create(&Settings::relative_path()).unwrap();	1✔
283	file.write_all(b"").unwrap();	1✔
284		1✔
285	let (tx, rx) = mpsc::channel();	1✔
286	migrate_v2_settings_and_servers(tx);	1✔
287		1✔
288	let event = rx.recv().unwrap();	1✔
289	assert_event!(event, Event::Error(..));	1✔
290	}	1✔
291
292	fn test_doesnt_migrate_over_existing_tts_settings_file() {	1✔
293	create_v2_tts_settings_file();	1✔
294	let mut file = fs::File::create(&TTSSettings::relative_path()).unwrap();	1✔
295	file.write_all(b"").unwrap();	1✔
296		1✔
297	let (tx, rx) = mpsc::channel();	1✔
298	migrate_v2_settings_and_servers(tx);	1✔
299		1✔
300	let event = rx.recv().unwrap();	1✔
301	assert_event!(event, Event::Error(..));	1✔
302	}	1✔
303
304	fn test_doesnt_migrate_over_existing_servers_file() {	1✔
305	create_v2_servers_file();	1✔
306	let mut file = fs::File::create(&Servers::relative_path()).unwrap();	1✔
307	file.write_all(b"").unwrap();	1✔
308		1✔
309	let (tx, rx) = mpsc::channel();	1✔
310	migrate_v2_settings_and_servers(tx);	1✔
311		1✔
312	let event = rx.recv().unwrap();	1✔
313	assert_event!(event, Event::Error(..));	1✔
314	}	1✔
315	}

Blightmud / Blightmud / 14316676040

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous