//! The game client is a separate object: detected read-only, with targeted updates to //! `realmlist.wtf` (backed up first) and the `Interface/AddOns/CoABotUI` folder (backed up when it differs). //! The selected realm in WTF/Config.wtf is synchronized while the client is closed. //! Cache, other addons and the executable are never modified. use std::collections::BTreeMap; use std::fs; use std::path::{Path, PathBuf}; use std::process::Command; use serde::{Deserialize, Serialize}; use crate::error::{Error, Result}; use crate::fsx; pub use crate::glue_config; pub const ADDON_NAME: &str = "CoABotUI"; // CoA Custom Races V2 ships its own client (CoACustomRace.exe) next to Ascension.exe and must be started instead. const EXECUTABLES: [&str; 4] = ["CoACustomRace.exe", "Ascension.exe", "Wow.exe", "WoW.exe"]; pub fn is_running(client: &Path) -> bool { if crate::platform::flavor() == crate::platform::Flavor::Docker { return crate::wine::is_running(client, &EXECUTABLES); } EXECUTABLES.iter().any(|exe| { let path = client.join(exe); let path = dunce::canonicalize(&path).unwrap_or(path); !crate::process::find_by_exe(&path).is_empty() }) } fn realm_config(old: &[u8], realm: &str) -> Vec { let eol: &[u8] = if old.windows(2).any(|w| w == b"\r\n") { b"\r\n" } else { b"\n" }; let mut out = Vec::new(); let mut replaced = false; for line in old.split_inclusive(|b| *b == b'\n') { let body = line.strip_prefix(b"\xef\xbb\xbf").unwrap_or(line); let mut words = body .split(|b| b.is_ascii_whitespace()) .filter(|w| !w.is_empty()); let matches = words.next().is_some_and(|w| w.eq_ignore_ascii_case(b"SET")) && words .next() .is_some_and(|w| w.eq_ignore_ascii_case(b"realmName")); if matches { if line.starts_with(b"\xef\xbb\xbf") { out.extend_from_slice(b"\xef\xbb\xbf"); } out.extend_from_slice(format!("SET realmName \"{realm}\"").as_bytes()); if line.ends_with(b"\r\n") { out.extend_from_slice(b"\r\n"); } else if line.ends_with(b"\n") { out.push(b'\n'); } replaced = true; } else { out.extend_from_slice(line); } } if !replaced { if !out.is_empty() && !out.ends_with(b"\n") { out.extend_from_slice(eol); } out.extend_from_slice(format!("SET realmName \"{realm}\"").as_bytes()); out.extend_from_slice(eol); } out } pub fn sync_realm(client: &Path, meta: &Path, mode: crate::realms::Mode) -> Result { let realm = match mode { crate::realms::Mode::Coa => "Conquest of Azeroth", crate::realms::Mode::Wildcard => "Wildcard", crate::realms::Mode::Reborn => "Warcraft Reborn", }; sync_realm_when_closed(client, meta, realm, is_running(client)) } /// [`sync_realm`] with the realm's name as the server shows it (the owner may have renamed it). pub fn sync_realm_named(client: &Path, meta: &Path, realm: &str) -> Result { sync_realm_when_closed(client, meta, realm, is_running(client)) } fn sync_realm_when_closed( client: &Path, meta: &Path, realm: &str, running: bool, ) -> Result { if running { return Ok(false); } let file = client.join("WTF/Config.wtf"); let old = match fs::read(&file) { Ok(bytes) => bytes, Err(e) if e.kind() == std::io::ErrorKind::NotFound => Vec::new(), Err(e) => return Err(e.into()), }; let new = realm_config(&old, realm); if new == old { return Ok(true); } if file.exists() { let saved = backup_dir(meta).join(format!("config-realm-{}.wtf", uuid::Uuid::new_v4())); fsx::atomic_write(&saved, &old)?; } fsx::atomic_write(&file, &new)?; Ok(true) } #[derive(Debug, Clone, Serialize)] pub struct Realmlist { pub path: String, pub host: Option, } #[derive(Debug, Clone, Serialize)] pub struct AddonState { pub installed: bool, pub version: Option, /// Some(true) when the installed files equal the package's; None when there is no package to compare with. pub up_to_date: Option, } #[derive(Debug, Clone, Serialize)] pub struct ClientInfo { pub path: String, pub executable: String, pub realmlists: Vec, pub addon: AddonState, pub other_addons: usize, } fn find_exe(dir: &Path) -> Option<&'static str> { EXECUTABLES.iter().copied().find(|e| dir.join(e).is_file()) } /// `Data//realmlist.wtf` files (a client may have several locales). pub fn realmlist_files(client: &Path) -> Vec { let mut v: Vec = fs::read_dir(client.join("Data")) .map(|rd| { rd.flatten() .map(|e| e.path().join("realmlist.wtf")) .filter(|p| p.is_file()) .collect() }) .unwrap_or_default(); v.sort(); v } fn parse_host(text: &str) -> Option { text.lines().find_map(|l| { let l = l.trim(); let rest = l .get(..3) .filter(|p| p.eq_ignore_ascii_case("set")) .and_then(|_| { l[3..] .trim_start() .get(..9) .filter(|w| w.eq_ignore_ascii_case("realmlist")) .map(|_| l[3..].trim_start()[9..].trim()) })?; Some(rest.trim_matches('"').to_string()) }) } fn toc_version(toc: &Path) -> Option { fs::read_to_string(toc) .ok()? .lines() .find_map(|l| l.strip_prefix("## Version:").map(|v| v.trim().to_string())) } fn tree_hashes(dir: &Path) -> BTreeMap { fn walk(root: &Path, dir: &Path, out: &mut BTreeMap) { let Ok(rd) = fs::read_dir(dir) else { return }; for e in rd.flatten() { let p = e.path(); if p.is_dir() { walk(root, &p, out); } else if let (Ok(rel), Ok(h)) = (p.strip_prefix(root), fsx::sha256_file(&p)) { out.insert(rel.to_string_lossy().replace('\\', "/"), h); } } } let mut out = BTreeMap::new(); walk(dir, dir, &mut out); out } /// Where a server package ships the addon, relative to the server folder. pub fn addon_source(server_root: &Path) -> Option { let p = server_root.join("Extras").join(ADDON_NAME); p.join(format!("{ADDON_NAME}.toc")).is_file().then_some(p) } pub fn addon_state(client: &Path, source: Option<&Path>) -> AddonState { let dir = client.join("Interface/AddOns").join(ADDON_NAME); let toc = dir.join(format!("{ADDON_NAME}.toc")); let installed = toc.is_file(); AddonState { installed, version: installed.then(|| toc_version(&toc)).flatten(), up_to_date: source.filter(|_| installed).map(|s| { let (want, have) = (tree_hashes(s), tree_hashes(&dir)); want.iter().all(|(k, v)| have.get(k) == Some(v)) }), } } /// Read-only look at a folder; None if it is not a game client. pub fn detect(path: &Path, addon_package: Option<&Path>) -> Option { if !path.join("Data").is_dir() { return None; } let exe = find_exe(path)?; let realmlists = realmlist_files(path) .into_iter() .map(|p| Realmlist { host: fs::read_to_string(&p).ok().and_then(|t| parse_host(&t)), path: p.to_string_lossy().into_owned(), }) .collect(); let other = fs::read_dir(path.join("Interface/AddOns")) .map(|rd| { rd.flatten() .filter(|e| e.path().is_dir() && e.file_name() != ADDON_NAME) .count() }) .unwrap_or(0); Some(ClientInfo { path: path.to_string_lossy().into_owned(), executable: exe.into(), realmlists, addon: addon_state(path, addon_package), other_addons: other, }) } fn backup_dir(meta: &Path) -> PathBuf { meta.join("backups").join("client") } pub fn host_ok(h: &str) -> bool { !h.is_empty() && h.len() <= 253 && h.chars() .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | ':')) && !h.starts_with('-') } /// Locales a client has game data for (`Data//locale-.MPQ`), e.g. `enUS`. fn installed_locales(client: &Path) -> Vec { let mut v: Vec = fs::read_dir(client.join("Data")) .map(|rd| { rd.flatten() .filter(|e| e.path().is_dir()) .filter_map(|e| e.file_name().into_string().ok()) .filter(|n| { n.len() == 4 && n[..2].bytes().all(|b| b.is_ascii_lowercase()) && n[2..].bytes().all(|b| b.is_ascii_uppercase()) }) .filter(|n| { client .join("Data") .join(n) .join(format!("locale-{n}.MPQ")) .is_file() }) .collect() }) .unwrap_or_default(); v.sort(); v } /// Point every locale's realmlist at `host`. Each changed file is copied to the backup folder first. /// A freshly downloaded client has no realmlist yet; one is created for each installed locale. pub fn set_realmlist(client: &Path, meta: &Path, host: &str) -> Result> { if !host_ok(host) { return Err(Error::Invalid("That address is not valid.".into())); } let mut changed = Vec::new(); if realmlist_files(client).is_empty() { for loc in installed_locales(client) { let file = client.join("Data").join(&loc).join("realmlist.wtf"); fsx::atomic_write( &file, format!( "set realmlist {host} " ) .as_bytes(), )?; changed.push(file.to_string_lossy().into_owned()); } if !changed.is_empty() { return Ok(changed); } } let stamp = chrono::Utc::now().format("%Y%m%d-%H%M%S").to_string(); for file in realmlist_files(client) { let old = fs::read(&file)?; let text = String::from_utf8(old.clone()) .map_err(|_| Error::Invalid("realmlist.wtf is not text".into()))?; if parse_host(&text).as_deref() == Some(host) { continue; } let eol = if text.contains("\r\n") { "\r\n" } else { "\n" }; let mut replaced = false; let mut lines: Vec = text .lines() .map(|l| { if !replaced && parse_host(l).is_some() { replaced = true; format!("set realmlist {host}") } else { l.to_string() } }) .collect(); if !replaced { lines.push(format!("set realmlist {host}")); } let new = lines.join(eol) + eol; let locale = file .parent() .and_then(|p| p.file_name()) .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_default(); let saved = backup_dir(meta).join(format!("realmlist-{locale}-{stamp}.wtf")); fsx::atomic_write(&saved, &old)?; fsx::atomic_write(&file, new.as_bytes())?; changed.push(file.to_string_lossy().into_owned()); } Ok(changed) } /// Replace the text of every locale's realmlist with `content` (a named realmlist chosen by the player). Each changed file /// is saved to the backup folder first; files that already hold the same lines are left alone. A client without one gets a /// file for each installed locale. Returns the files that changed. pub fn write_realmlist(client: &Path, meta: &Path, content: &str) -> Result> { let compact = |t: &str| { t.lines() .map(|l| l.trim().to_ascii_lowercase()) .filter(|l| !l.is_empty()) .collect::>() .join("\n") }; let mut files = realmlist_files(client); if files.is_empty() { files = installed_locales(client) .into_iter() .map(|loc| client.join("Data").join(loc).join("realmlist.wtf")) .collect(); } let stamp = chrono::Utc::now().format("%Y%m%d-%H%M%S").to_string(); let mut changed = Vec::new(); for file in files { let old = fs::read(&file).ok(); if let Some(old) = &old { if compact(&String::from_utf8_lossy(old)) == compact(content) { continue; } let locale = file .parent() .and_then(|p| p.file_name()) .map(|n| n.to_string_lossy().into_owned()) .unwrap_or_default(); fsx::atomic_write( &backup_dir(meta).join(format!("realmlist-{locale}-{stamp}.wtf")), old, )?; } fsx::atomic_write(&file, content.as_bytes())?; changed.push(file.to_string_lossy().into_owned()); } Ok(changed) } /// Copy the addon into the client. If a different version is there, that one folder is backed up first; /// files in it that the package does not contain are left alone. pub fn install_addon(client: &Path, meta: &Path, source: &Path) -> Result<()> { if !source.join(format!("{ADDON_NAME}.toc")).is_file() { return Err(Error::Invalid("The addon package is incomplete.".into())); } let dest = fsx::ensure_within(client, &client.join("Interface/AddOns").join(ADDON_NAME))?; let want = tree_hashes(source); if dest.is_dir() { let have = tree_hashes(&dest); if want.iter().all(|(k, v)| have.get(k) == Some(v)) { return Ok(()); } let keep = backup_dir(meta).join(format!( "{ADDON_NAME}-{}", chrono::Utc::now().format("%Y%m%d-%H%M%S") )); for rel in have.keys() { let to = fsx::safe_join(&keep, rel)?; fs::create_dir_all(to.parent().unwrap())?; fs::copy(fsx::safe_join(&dest, rel)?, to)?; } } for rel in want.keys() { let target = fsx::safe_join(&dest, rel)?; fsx::atomic_write(&target, &fs::read(fsx::safe_join(source, rel)?)?)?; } Ok(()) } /// Start the game client. The caller is responsible for making sure the server is ready first. pub fn launch(client: &Path) -> Result { let exe = find_exe(client).ok_or_else(|| Error::Invalid("The game client was not found.".into()))?; if crate::platform::flavor() == crate::platform::Flavor::Docker { return crate::wine::launch(client, exe); } let executable = client.join(exe); let spawn = || { Command::new(&executable) .current_dir(client) .spawn() .map(|child| child.id()) }; #[cfg(windows)] { launch_with_elevation_fallback(spawn, || launch_elevated(&executable, client)) .map_err(Into::into) } #[cfg(not(windows))] { spawn().map_err(Into::into) } } /// Start normally first; ask Windows for elevation only when the client requires it (ERROR_ELEVATION_REQUIRED, 740). /// Any other error, including the player declining the prompt (1223), is returned unchanged. #[cfg(windows)] fn launch_with_elevation_fallback( spawn: impl FnOnce() -> std::io::Result, elevate: impl FnOnce() -> std::io::Result, ) -> std::io::Result { match spawn() { Err(error) if error.raw_os_error() == Some(740) => elevate(), result => result, } } /// Start only the game with the normal Windows permission prompt; the Manager itself stays unelevated. #[cfg(windows)] fn launch_elevated(executable: &Path, directory: &Path) -> std::io::Result { use std::os::windows::ffi::OsStrExt; use windows_sys::Win32::Foundation::CloseHandle; use windows_sys::Win32::System::Threading::GetProcessId; use windows_sys::Win32::UI::Shell::{ ShellExecuteExW, SEE_MASK_NOASYNC, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOW, }; use windows_sys::Win32::UI::WindowsAndMessaging::SW_SHOWNORMAL; let file: Vec = executable .as_os_str() .encode_wide() .chain(Some(0)) .collect(); let cwd: Vec = directory.as_os_str().encode_wide().chain(Some(0)).collect(); let verb: Vec = "runas".encode_utf16().chain(Some(0)).collect(); let mut info = SHELLEXECUTEINFOW { cbSize: std::mem::size_of::() as u32, fMask: SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NOASYNC, lpVerb: verb.as_ptr(), lpFile: file.as_ptr(), lpDirectory: cwd.as_ptr(), nShow: SW_SHOWNORMAL, ..Default::default() }; if unsafe { ShellExecuteExW(&mut info) } == 0 { return Err(std::io::Error::last_os_error()); } if info.hProcess.is_null() { return Err(std::io::Error::other( "Windows did not return the game process handle.", )); } let pid = unsafe { GetProcessId(info.hProcess) }; let error = std::io::Error::last_os_error(); unsafe { CloseHandle(info.hProcess); } if pid == 0 { return Err(error); } Ok(pid) } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] pub struct RealmlistOverrideEntry { pub file_path: PathBuf, pub original_bytes: Option>, } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] pub struct RealmlistOverrideJournal { pub client_path: PathBuf, pub target_host: String, pub entries: Vec, pub created_at: i64, } pub fn journal_path(meta: &Path) -> PathBuf { meta.join("realmlist_override_journal.json") } /// Begins a crash-safe temporary realmlist redirection for PLAY. /// The exact original bytes (or absence) of every realmlist file are journaled atomically before any file is touched. pub fn begin_realmlist_override( client: &Path, meta: &Path, host: &str, ) -> Result { if !host_ok(host) { return Err(Error::Invalid("That address is not valid.".into())); } let jpath = journal_path(meta); let mut files = realmlist_files(client); if files.is_empty() { files = installed_locales(client) .into_iter() .map(|loc| client.join("Data").join(loc).join("realmlist.wtf")) .collect(); } let mut entries = Vec::new(); for file in &files { let original_bytes = fs::read(file).ok(); entries.push(RealmlistOverrideEntry { file_path: file.clone(), original_bytes, }); } let journal = RealmlistOverrideJournal { client_path: client.to_path_buf(), target_host: host.to_string(), entries, created_at: chrono::Utc::now().timestamp(), }; if !jpath.exists() { let json = serde_json::to_vec_pretty(&journal) .map_err(|e| Error::Invalid(format!("Failed to serialize override journal: {e}")))?; fsx::atomic_write(&jpath, &json)?; } for file in &files { let dir = file .parent() .ok_or_else(|| Error::Invalid("file has no parent".into()))?; fs::create_dir_all(dir)?; let content = format!("set realmlist {host}\r\n"); fsx::atomic_write(file, content.as_bytes())?; } Ok(journal) } /// Restores the client's original realmlist bytes or absence from the journal. /// Removes the journal upon clean completion. Returns true if an override was recovered/reverted. pub fn revert_realmlist_override(meta: &Path) -> Result { let jpath = journal_path(meta); if !jpath.exists() { return Ok(false); } let bytes = match fs::read(&jpath) { Ok(b) => b, Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(false), Err(e) => return Err(e.into()), }; let journal: RealmlistOverrideJournal = serde_json::from_slice(&bytes) .map_err(|e| Error::Invalid(format!("Corrupt override journal: {e}")))?; for entry in &journal.entries { match &entry.original_bytes { Some(orig) => { let _ = fsx::atomic_write(&entry.file_path, orig); } None => { if entry.file_path.exists() { let _ = fs::remove_file(&entry.file_path); } } } } let _ = fs::remove_file(&jpath); Ok(true) } /// Recovers any unfinished realmlist overrides across known client metadata folders. pub fn recover_all_realmlist_overrides(meta_roots: &[PathBuf]) -> usize { let mut recovered = 0; for meta in meta_roots { if revert_realmlist_override(meta).unwrap_or(false) { recovered += 1; } } recovered } #[cfg(test)] mod tests { use super::*; #[cfg(windows)] #[test] fn elevation_is_requested_only_when_windows_requires_it() { assert_eq!( launch_with_elevation_fallback(|| Ok(17), || panic!("unneeded elevation")).unwrap(), 17 ); assert_eq!( launch_with_elevation_fallback( || Err(std::io::Error::from_raw_os_error(740)), || Ok(23) ) .unwrap(), 23 ); let error = launch_with_elevation_fallback( || Err(std::io::Error::from_raw_os_error(2)), || panic!("wrong error elevated"), ) .unwrap_err(); assert_eq!(error.raw_os_error(), Some(2)); let cancelled = launch_with_elevation_fallback( || Err(std::io::Error::from_raw_os_error(740)), || Err(std::io::Error::from_raw_os_error(1223)), ) .unwrap_err(); assert_eq!(cancelled.raw_os_error(), Some(1223)); } #[test] fn realm_selection_preserves_other_settings_bytes_and_line_endings() { let old = b"\xef\xbb\xbfSET realmName \"Wildcard\"\r\nSET accountName \"\xff\"\r\nset REALMNAME \"old\"\r\nSET realmList \"127.0.0.1\""; let expected = b"\xef\xbb\xbfSET realmName \"Conquest of Azeroth\"\r\nSET accountName \"\xff\"\r\nSET realmName \"Conquest of Azeroth\"\r\nSET realmList \"127.0.0.1\""; assert_eq!(realm_config(old, "Conquest of Azeroth"), expected); assert_eq!( realm_config(b"SET sound 1", "Wildcard"), b"SET sound 1\nSET realmName \"Wildcard\"\n" ); } #[test] fn realm_sync_backs_up_config_and_is_idempotent() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let meta = d.path().join("meta"); let original = b"SET sound 1\r\nSET realmName \"Wildcard\"\r\n"; fs::write(c.join("WTF/Config.wtf"), original).unwrap(); assert!(sync_realm(&c, &meta, crate::realms::Mode::Coa).unwrap()); let backups: Vec<_> = fs::read_dir(backup_dir(&meta)).unwrap().flatten().collect(); assert_eq!(backups.len(), 1); assert_eq!(fs::read(backups[0].path()).unwrap(), original); assert!(sync_realm(&c, &meta, crate::realms::Mode::Coa).unwrap()); assert_eq!(fs::read_dir(backup_dir(&meta)).unwrap().count(), 1); assert!(sync_realm(&c, &meta, crate::realms::Mode::Wildcard).unwrap()); assert_eq!(fs::read(c.join("WTF/Config.wtf")).unwrap(), original); assert!(sync_realm(&c, &meta, crate::realms::Mode::Reborn).unwrap()); assert_eq!( fs::read(c.join("WTF/Config.wtf")).unwrap(), b"SET sound 1\r\nSET realmName \"Warcraft Reborn\"\r\n" ); } #[test] fn running_client_defers_realm_update_until_closed() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let meta = d.path().join("meta"); let original = b"SET realmName \"Wildcard\"\n"; fs::write(c.join("WTF/Config.wtf"), original).unwrap(); assert!(!sync_realm_when_closed(&c, &meta, "Conquest of Azeroth", true).unwrap()); assert_eq!(fs::read(c.join("WTF/Config.wtf")).unwrap(), original); assert!(!backup_dir(&meta).exists()); assert!(sync_realm_when_closed(&c, &meta, "Conquest of Azeroth", false).unwrap()); assert_eq!( fs::read(c.join("WTF/Config.wtf")).unwrap(), b"SET realmName \"Conquest of Azeroth\"\n" ); } fn fake_client(d: &Path) -> PathBuf { let c = d.join("wow"); fs::create_dir_all(c.join("Data/enUS")).unwrap(); fs::create_dir_all(c.join("Data/ruRU")).unwrap(); fs::create_dir_all(c.join("Interface/AddOns/ElvUI")).unwrap(); fs::create_dir_all(c.join("WTF")).unwrap(); fs::write(c.join("Ascension.exe"), b"exe").unwrap(); fs::write( c.join("Data/enUS/realmlist.wtf"), "set realmlist old.example.com\r\nset patchlist x\r\n", ) .unwrap(); fs::write( c.join("Data/ruRU/realmlist.wtf"), "set realmlist 127.0.0.1\n", ) .unwrap(); fs::write(c.join("WTF/Config.wtf"), "SET x 1").unwrap(); fs::write(c.join("Interface/AddOns/ElvUI/ElvUI.toc"), "## Title: Elv").unwrap(); c } fn package(d: &Path, version: &str) -> PathBuf { let p = d.join("pkg").join(ADDON_NAME); fs::create_dir_all(&p).unwrap(); fs::write( p.join("CoABotUI.toc"), format!("## Version: {version}\nCoABotUI.lua\n"), ) .unwrap(); fs::write(p.join("CoABotUI.lua"), format!("-- v{version}")).unwrap(); p } fn snapshot(root: &Path) -> BTreeMap { tree_hashes(root) } #[test] fn detects_only_real_clients_and_reads_realmlists() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let info = detect(&c, None).unwrap(); assert_eq!(info.executable, "Ascension.exe"); assert_eq!(info.realmlists.len(), 2); assert_eq!(info.realmlists[0].host.as_deref(), Some("old.example.com")); assert_eq!(info.other_addons, 1); assert!(!info.addon.installed); assert!( detect(d.path(), None).is_none(), "a plain folder is not a client" ); fs::create_dir_all(d.path().join("srv/Data")).unwrap(); assert!( detect(&d.path().join("srv"), None).is_none(), "Data without an executable is not a client" ); } #[test] fn realmlist_change_is_backed_up_minimal_and_idempotent() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let meta = d.path().join("meta"); let before = snapshot(&c); let changed = set_realmlist(&c, &meta, "192.168.0.5").unwrap(); assert_eq!(changed.len(), 2); assert_eq!( fs::read_to_string(c.join("Data/enUS/realmlist.wtf")).unwrap(), "set realmlist 192.168.0.5\r\nset patchlist x\r\n", "other lines and line endings preserved" ); assert_eq!( fs::read_to_string(c.join("Data/ruRU/realmlist.wtf")).unwrap(), "set realmlist 192.168.0.5\n" ); let saved: Vec<_> = fs::read_dir(meta.join("backups/client")) .unwrap() .flatten() .collect(); assert_eq!(saved.len(), 2, "each changed file was backed up"); assert_eq!( fs::read_to_string( saved .iter() .find(|e| e.file_name().to_string_lossy().contains("enUS")) .unwrap() .path() ) .unwrap(), "set realmlist old.example.com\r\nset patchlist x\r\n" ); // nothing else in the client changed let after = snapshot(&c); let diff: Vec<_> = after .iter() .filter(|(k, v)| before.get(*k) != Some(*v)) .map(|(k, _)| k.clone()) .collect(); assert_eq!( diff, ["Data/ruRU/realmlist.wtf", "Data/enUS/realmlist.wtf"] .iter() .map(|s| s.to_string()) .collect::>() .into_iter() .collect::>() ); assert!( set_realmlist(&c, &meta, "192.168.0.5").unwrap().is_empty(), "already set: no write, no new backup" ); assert!(set_realmlist(&c, &meta, "bad host; rm -rf").is_err()); } #[test] fn a_fresh_client_gets_a_realmlist_for_each_installed_locale() { let d = tempfile::tempdir().unwrap(); let c = d.path().join("fresh"); fs::create_dir_all(c.join("Data/enUS")).unwrap(); fs::create_dir_all(c.join("Data/Content")).unwrap(); fs::write(c.join("Data/enUS/locale-enUS.MPQ"), b"x").unwrap(); fs::write(c.join("Ascension.exe"), b"exe").unwrap(); let changed = set_realmlist(&c, &d.path().join("meta"), "127.0.0.1").unwrap(); assert_eq!(changed.len(), 1); assert_eq!( fs::read_to_string(c.join("Data/enUS/realmlist.wtf")).unwrap(), "set realmlist 127.0.0.1 " ); assert!(!c.join("Data/Content/realmlist.wtf").exists()); assert_eq!( detect(&c, None).unwrap().realmlists[0].host.as_deref(), Some("127.0.0.1") ); } #[test] fn addon_install_touches_only_its_own_folder_and_backs_up_a_different_version() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let meta = d.path().join("meta"); let v1 = package(d.path(), "1"); install_addon(&c, &meta, &v1).unwrap(); assert_eq!(addon_state(&c, Some(&v1)).up_to_date, Some(true)); assert!( !meta.join("backups/client").exists() || fs::read_dir(meta.join("backups/client")) .unwrap() .next() .is_none(), "first install has nothing to back up" ); let before = snapshot(&c); install_addon(&c, &meta, &v1).unwrap(); assert_eq!(snapshot(&c), before, "same version: no change at all"); // user tweaks their copy, then a newer package arrives fs::write(c.join("Interface/AddOns/CoABotUI/notes.txt"), "mine").unwrap(); let v2 = package(d.path(), "2"); let outside_before: BTreeMap<_, _> = snapshot(&c) .into_iter() .filter(|(k, _)| !k.starts_with("Interface/AddOns/CoABotUI")) .collect(); install_addon(&c, &meta, &v2).unwrap(); assert_eq!(addon_state(&c, Some(&v2)).version.as_deref(), Some("2")); assert_eq!( fs::read_to_string(c.join("Interface/AddOns/CoABotUI/notes.txt")).unwrap(), "mine", "the user's extra file survives" ); let outside_after: BTreeMap<_, _> = snapshot(&c) .into_iter() .filter(|(k, _)| !k.starts_with("Interface/AddOns/CoABotUI")) .collect(); assert_eq!( outside_before, outside_after, "other addons, WTF, Data untouched" ); let kept = fs::read_dir(meta.join("backups/client")) .unwrap() .flatten() .find(|e| e.file_name().to_string_lossy().starts_with(ADDON_NAME)) .unwrap() .path(); assert_eq!( fs::read_to_string(kept.join("CoABotUI.lua")).unwrap(), "-- v1", "the previous version and the user's copy are backed up" ); assert!(kept.join("notes.txt").is_file()); } #[test] fn incomplete_addon_package_and_missing_client_are_refused() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let empty = d.path().join("emptypkg"); fs::create_dir_all(&empty).unwrap(); assert!(install_addon(&c, &d.path().join("meta"), &empty).is_err()); assert!(launch(d.path()).is_err()); } #[test] fn realmlist_override_crash_safety_and_byte_for_byte_recovery() { let d = tempfile::tempdir().unwrap(); let c = fake_client(d.path()); let meta = d.path().join("meta"); fs::create_dir_all(&meta).unwrap(); let orig_bytes = b"set realmlist custom-auth.game.org\nset patchlist patch.game.org\r\n"; let target_file = c.join("Data/enUS/realmlist.wtf"); fs::write(&target_file, orig_bytes).unwrap(); let journal = begin_realmlist_override(&c, &meta, "198.51.100.1").unwrap(); assert_eq!(journal.target_host, "198.51.100.1"); assert_eq!( fs::read_to_string(&target_file).unwrap(), "set realmlist 198.51.100.1\r\n" ); assert!( journal_path(&meta).exists(), "journal file must exist while playing" ); let recovered = revert_realmlist_override(&meta).unwrap(); assert!(recovered, "must report successful recovery"); assert!( !journal_path(&meta).exists(), "journal must be deleted after recovery" ); let restored_bytes = fs::read(&target_file).unwrap(); assert_eq!( restored_bytes, orig_bytes, "Must restore exact original bytes" ); } #[test] fn realmlist_override_restores_absence_if_file_did_not_exist() { let d = tempfile::tempdir().unwrap(); let c = d.path().join("wow_fresh"); fs::create_dir_all(c.join("Data/enUS")).unwrap(); fs::write(c.join("Data/enUS/locale-enUS.MPQ"), b"x").unwrap(); let meta = d.path().join("meta"); fs::create_dir_all(&meta).unwrap(); let target_file = c.join("Data/enUS/realmlist.wtf"); assert!(!target_file.exists()); begin_realmlist_override(&c, &meta, "198.51.100.1").unwrap(); assert!(target_file.exists()); revert_realmlist_override(&meta).unwrap(); assert!( !target_file.exists(), "Originally absent file must be deleted upon reversion" ); } }