496 строк · 23 КиБ
code/crates/chl-wine/src/save_backup.rs
| 1 | //! Бэкап сохранений одной игры — то, что реально попросил владелец: «бекап |
| 2 | //! игровых сейвов … чтобы автоматом по базе тянулся у какой игры где сейвы |
| 3 | //! лежат … но тоже с возможностью указать свою директорию». |
| 4 | //! |
| 5 | //! Собирает вместе три вещи: |
| 6 | //! - [`crate::save_manifest`] — база ludusavi о том, где какая игра хранит |
| 7 | //! сохранения; |
| 8 | //! - [`crate::save_resolver`] — разворот её шаблонов пути в реальные |
| 9 | //! каталоги для конкретной установки этой игры; |
| 10 | //! - [`crate::snapshot`] (через [`crate::snapshot::create_any`]) — сам |
| 11 | //! механизм версионного бэкапа, уже проверенный на снимках префикса. |
| 12 | //! |
| 13 | //! **Откуда берутся корни для разворота.** Библиотека этого лаунчера |
| 14 | //! (`chl_core::library::Game`) не хранит для Steam-игр никакого «своего» |
| 15 | //! префикса — их фактически запускает сам Steam через собственный Proton |
| 16 | //! (см. doc-комментарий `Game::is_steam`), и `exe` у такой записи — это уже |
| 17 | //! каталог установки (`.../steamapps/common/<Игра>`), а не исполняемый |
| 18 | //! файл. Отсюда и разбор на два непохожих случая: |
| 19 | //! |
| 20 | //! - **Steam-игра** (`steam_appid` задан): `<base>` = `exe` напрямую, |
| 21 | //! `<root>` — библиотека Steam, которой он принадлежит (родитель |
| 22 | //! `steamapps`), Windows-профиль — `steamapps/compatdata/<appid>/pfx`, |
| 23 | //! если он есть (Proton-игра); нет — значит игра нативная, и |
| 24 | //! `<win...>`-плейсхолдеры просто не разворачиваются, а `<home>`/`<xdgData>` |
| 25 | //! отлично работают и для неё. |
| 26 | //! - **Своя игра** (добавлена вручную, `chl-wine` сам ведёт префикс): |
| 27 | //! Windows-профиль — `drive_c/users/steamuser` в префиксе, на который |
| 28 | //! указывает `Game::prefix`. `<base>`/`<root>` не определены — у ручных |
| 29 | //! игр в этой библиотеке нет установочного каталога в смысле Steam, и |
| 30 | //! врать про него незачем. |
| 31 | //! |
| 32 | //! Честно про охват: авто-поиск работает только для игр, у которых |
| 33 | //! ludusavi-manifest вообще что-то знает, и только если хотя бы один из его |
| 34 | //! путей действительно существует на этой машине. Для всего остального — |
| 35 | //! ручной override (`chl_core::backups::BackupSettings`), который всегда в |
| 36 | //! приоритете и никогда не перезаписывается автопоиском. |
| 37 | |
| 38 | use std::path::{Path, PathBuf}; |
| 39 | |
| 40 | use anyhow::{Context, Result, bail}; |
| 41 | use chl_core::library::Game; |
| 42 | use chl_core::paths::Dirs; |
| 43 | |
| 44 | use crate::save_manifest::Manifest; |
| 45 | use crate::save_resolver::{self, Roots}; |
| 46 | pub use crate::snapshot::{Created, Snapshot}; |
| 47 | |
| 48 | /// Куда лаунчер по умолчанию складывает бэкапы сохранений, если для игры |
| 49 | /// не задан свой каталог назначения. |
| 50 | /// |
| 51 | /// В данных (`Dirs::data`), не в кэше: то же рассуждение, что и у |
| 52 | /// библиотеки игр — потеря должна быть последствием, а не побочным |
| 53 | /// эффектом очистки кэша. |
| 54 | pub fn default_backup_dir(dirs: &Dirs, game: &str) -> PathBuf { |
| 55 | dirs.data.join("save_backups").join(slug(game)) |
| 56 | } |
| 57 | |
| 58 | fn slug(name: &str) -> String { |
| 59 | let s: String = name |
| 60 | .chars() |
| 61 | .map(|c| if c.is_alphanumeric() { c } else { '_' }) |
| 62 | .collect(); |
| 63 | let s = s.trim_matches('_'); |
| 64 | if s.is_empty() { "игра".to_string() } else { s.to_string() } |
| 65 | } |
| 66 | |
| 67 | /// Основной Steam — где лежит `userdata` и (для этой библиотеки) обычно и |
| 68 | /// `steamapps/compatdata`. `~/.steam/steam` — символическая ссылка, которую |
| 69 | /// ставит сам клиент Steam; `~/.local/share/Steam` — путь для установок |
| 70 | /// без Steam Runtime старого образца. Первый найденный и есть основной. |
| 71 | pub fn primary_steam_root(home: &Path) -> Option<PathBuf> { |
| 72 | [home.join(".steam/steam"), home.join(".local/share/Steam")] |
| 73 | .into_iter() |
| 74 | .find(|p| p.join("steamapps").is_dir()) |
| 75 | } |
| 76 | |
| 77 | /// Единственный аккаунт в `userdata/` — источник `<storeUserId>`. |
| 78 | /// |
| 79 | /// Если аккаунтов несколько (общий компьютер, несколько профилей), гадать, |
| 80 | /// какой из них — тот самый, нечестно, и лучше вернуть `None`, чем |
| 81 | /// подставить чужой ID. |
| 82 | pub fn steam_user_id(steam_root: &Path) -> Option<String> { |
| 83 | let mut entries = std::fs::read_dir(steam_root.join("userdata")) |
| 84 | .ok()? |
| 85 | .flatten() |
| 86 | .filter(|e| e.path().is_dir()) |
| 87 | .map(|e| e.file_name().to_string_lossy().into_owned()); |
| 88 | let first = entries.next()?; |
| 89 | if entries.next().is_some() { |
| 90 | return None; |
| 91 | } |
| 92 | Some(first) |
| 93 | } |
| 94 | |
| 95 | /// Библиотека Steam, которой принадлежит уже установленная игра — ищется |
| 96 | /// по пути `exe`, а не предполагается основной: у большой библиотеки игры |
| 97 | /// нередко стоят на второстепенном диске. |
| 98 | /// |
| 99 | /// `exe` вида `.../<library>/steamapps/common/<Игра>[/остальное]` — |
| 100 | /// возвращается `<library>`. |
| 101 | pub fn steam_library_root(exe: &Path) -> Option<PathBuf> { |
| 102 | exe.ancestors().find_map(|a| { |
| 103 | if a.file_name()?.to_str()? != "common" { |
| 104 | return None; |
| 105 | } |
| 106 | let steamapps = a.parent()?; |
| 107 | if steamapps.file_name()?.to_str()? != "steamapps" { |
| 108 | return None; |
| 109 | } |
| 110 | steamapps.parent().map(Path::to_path_buf) |
| 111 | }) |
| 112 | } |
| 113 | |
| 114 | /// Корни для разворота шаблонов манифеста под конкретную игру. |
| 115 | /// |
| 116 | /// `chimera_root` — установка `chl-wine` (`StartWineInstall::root`), нужна |
| 117 | /// только для игр не из Steam, у которых есть свой префикс. |
| 118 | pub fn roots_for_game(game: &Game, chimera_root: Option<&Path>) -> Roots { |
| 119 | let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_else(|| PathBuf::from("/")); |
| 120 | let xdg_data = std::env::var_os("XDG_DATA_HOME") |
| 121 | .map(PathBuf::from) |
| 122 | .unwrap_or_else(|| home.join(".local/share")); |
| 123 | let xdg_config = std::env::var_os("XDG_CONFIG_HOME") |
| 124 | .map(PathBuf::from) |
| 125 | .unwrap_or_else(|| home.join(".config")); |
| 126 | let os_user_name = std::env::var("USER").unwrap_or_default(); |
| 127 | |
| 128 | let mut roots = Roots { |
| 129 | home, |
| 130 | xdg_data, |
| 131 | xdg_config, |
| 132 | os_user_name, |
| 133 | ..Default::default() |
| 134 | }; |
| 135 | |
| 136 | if game.is_steam() { |
| 137 | // <base> — сам каталог установки, который Steam уже сообщил |
| 138 | // библиотеке как exe (см. doc-комментарий модуля). |
| 139 | roots.base = Some(game.exe.clone()); |
| 140 | if let Some(library) = steam_library_root(&game.exe) { |
| 141 | // compatdata лежит в той же библиотеке, что и сама игра — не |
| 142 | // обязательно в основной установке Steam. |
| 143 | if let Some(appid) = game.steam_appid { |
| 144 | let pfx = library.join(format!("steamapps/compatdata/{appid}/pfx")); |
| 145 | if pfx.join("drive_c").is_dir() { |
| 146 | roots.windows_user = Some(pfx.join("drive_c/users/steamuser")); |
| 147 | } |
| 148 | } |
| 149 | roots.root = Some(library); |
| 150 | } |
| 151 | if let Some(main) = primary_steam_root(&roots.home) { |
| 152 | roots.steam_user_id = steam_user_id(&main); |
| 153 | // <root> для userdata-шаблонов — именно основной Steam, а не |
| 154 | // второстепенная библиотека: userdata существует только там. |
| 155 | if roots.root.is_none() { |
| 156 | roots.root = Some(main); |
| 157 | } |
| 158 | } |
| 159 | } else if let Some(chimera_root) = chimera_root { |
| 160 | let pfx = chimera_root.join("data/pfx").join(&game.prefix); |
| 161 | if pfx.join("drive_c").is_dir() { |
| 162 | roots.windows_user = Some(pfx.join("drive_c/users/steamuser")); |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | roots |
| 167 | } |
| 168 | |
| 169 | /// Ищет запись манифеста для игры: сперва по `steam_appid` (надёжнее |
| 170 | /// всего — не зависит от разночтений в названии), потом по точному имени, |
| 171 | /// потом по нормализованному. |
| 172 | pub fn lookup_entry<'m>(manifest: &'m Manifest, name: &str, game: &Game) -> Option<&'m crate::save_manifest::ManifestEntry> { |
| 173 | if let Some(appid) = game.steam_appid |
| 174 | && let Some(e) = manifest.by_steam_id(appid) |
| 175 | { |
| 176 | return Some(e); |
| 177 | } |
| 178 | manifest |
| 179 | .by_exact_name(name) |
| 180 | .or_else(|| manifest.by_normalized_name(name)) |
| 181 | } |
| 182 | |
| 183 | /// Автоопределённый каталог с сохранениями игры — `None`, если в манифесте |
| 184 | /// нет записи или ни один из её путей не существует на этой машине. |
| 185 | pub fn auto_detect(manifest: &Manifest, name: &str, game: &Game, chimera_root: Option<&Path>) -> Option<PathBuf> { |
| 186 | let entry = lookup_entry(manifest, name, game)?; |
| 187 | let roots = roots_for_game(game, chimera_root); |
| 188 | save_resolver::best_save_dir(entry, &roots) |
| 189 | } |
| 190 | |
| 191 | /// Делает бэкап каталога с сохранениями. `save_dir` должен существовать и |
| 192 | /// быть каталогом — по любой другой причине (игра не найдена в манифесте, |
| 193 | /// override не задан) решение уже должно быть принято вызывающей стороной. |
| 194 | pub fn backup_now(save_dir: &Path, backup_dest: &Path, game: &str) -> Result<Created> { |
| 195 | if !save_dir.is_dir() { |
| 196 | bail!("{} не каталог — бэкапить нечего", save_dir.display()); |
| 197 | } |
| 198 | crate::snapshot::create_any( |
| 199 | save_dir, |
| 200 | backup_dest, |
| 201 | "бэкап", |
| 202 | &format!("бэкап сохранений «{game}»"), |
| 203 | ) |
| 204 | } |
| 205 | |
| 206 | /// Метка автоматического бэкапа — по ней снимок считается автоматическим |
| 207 | /// (`chl_core::state::AUTOMATIC_LABEL_PREFIXES`) и подпадает под уборку по |
| 208 | /// числу поколений. Бэкап с кнопки остаётся ручным и не удаляется. |
| 209 | pub const AUTO_LABEL: &str = "автобэкап сохранений"; |
| 210 | |
| 211 | /// Каталог с сохранениями игры: ручной путь, если задан, иначе автопоиск |
| 212 | /// по базе ludusavi. Одно правило для страницы «Бэкапы» и `chl run`. |
| 213 | pub fn effective_save_dir( |
| 214 | name: &str, |
| 215 | game: &Game, |
| 216 | manifest: Option<&Manifest>, |
| 217 | chimera_root: Option<&Path>, |
| 218 | overrides: &chl_core::backups::BackupSettings, |
| 219 | ) -> Option<PathBuf> { |
| 220 | if let Some(dir) = overrides.get(name).and_then(|o| o.save_dir.clone()) { |
| 221 | return Some(dir); |
| 222 | } |
| 223 | auto_detect(manifest?, name, game, chimera_root) |
| 224 | } |
| 225 | |
| 226 | /// Куда складывать бэкапы игры: ручной путь, если задан, иначе по умолчанию. |
| 227 | pub fn effective_backup_dir(dirs: &Dirs, name: &str, overrides: &chl_core::backups::BackupSettings) -> PathBuf { |
| 228 | overrides |
| 229 | .get(name) |
| 230 | .and_then(|o| o.backup_dir.clone()) |
| 231 | .unwrap_or_else(|| default_backup_dir(dirs, name)) |
| 232 | } |
| 233 | |
| 234 | /// Нужен ли автобэкап сейчас: `period_days` = 0 — после каждого выхода, |
| 235 | /// иначе не чаще раза в столько дней от последнего автоматического. |
| 236 | pub fn auto_backup_due(last_auto: Option<u64>, now: u64, period_days: u64) -> bool { |
| 237 | period_days == 0 || last_auto.is_none_or(|t| now.saturating_sub(t) >= period_days * 86_400) |
| 238 | } |
| 239 | |
| 240 | /// Итог автобэкапа. |
| 241 | #[derive(Debug)] |
| 242 | pub enum AutoBackup { |
| 243 | /// Каталога с сохранениями не нашлось — ни ручного пути, ни записи в базе. |
| 244 | NoSaveDir, |
| 245 | /// Последний автобэкап ещё свежий. |
| 246 | NotDue, |
| 247 | Done { created: Created, removed: usize, kept: usize }, |
| 248 | } |
| 249 | |
| 250 | /// Бэкап сохранений после выхода из игры, с уборкой лишних поколений. |
| 251 | /// |
| 252 | /// База ludusavi — только из кэша: выход из игры не должен ждать сеть. |
| 253 | pub fn auto_backup( |
| 254 | dirs: &Dirs, |
| 255 | name: &str, |
| 256 | game: &Game, |
| 257 | chimera_root: Option<&Path>, |
| 258 | period_days: u64, |
| 259 | keep: usize, |
| 260 | ) -> Result<AutoBackup> { |
| 261 | let manifest = crate::save_manifest::load_cached(&dirs.cache).ok().flatten(); |
| 262 | let overrides = chl_core::backups::BackupSettings::load(&dirs.backup_settings()); |
| 263 | let Some(save_dir) = effective_save_dir(name, game, manifest.as_ref(), chimera_root, &overrides) else { |
| 264 | return Ok(AutoBackup::NoSaveDir); |
| 265 | }; |
| 266 | if !save_dir.is_dir() { |
| 267 | return Ok(AutoBackup::NoSaveDir); |
| 268 | } |
| 269 | let dest = effective_backup_dir(dirs, name, &overrides); |
| 270 | let now = std::time::SystemTime::now() |
| 271 | .duration_since(std::time::UNIX_EPOCH) |
| 272 | .map(|d| d.as_secs()) |
| 273 | .unwrap_or(0); |
| 274 | let last_auto = crate::snapshot::list(&dest) |
| 275 | .iter() |
| 276 | .filter(|s| s.origin == crate::snapshot::Origin::Automatic) |
| 277 | .map(|s| s.taken_at) |
| 278 | .max(); |
| 279 | if !auto_backup_due(last_auto, now, period_days) { |
| 280 | return Ok(AutoBackup::NotDue); |
| 281 | } |
| 282 | let created = crate::snapshot::create_any(&save_dir, &dest, AUTO_LABEL, &format!("{AUTO_LABEL} «{name}»"))?; |
| 283 | let removed = crate::snapshot::prune(&dest, &crate::snapshot::Policy { keep: keep.max(1), days: 0 }, now).len(); |
| 284 | let kept = crate::snapshot::list(&dest).iter().filter(|s| s.origin == crate::snapshot::Origin::Automatic).count(); |
| 285 | Ok(AutoBackup::Done { created, removed, kept }) |
| 286 | } |
| 287 | |
| 288 | /// Все бэкапы игры, новые первыми — как есть у снимков префикса. |
| 289 | pub fn list_backups(backup_dest: &Path) -> Vec<Snapshot> { |
| 290 | crate::snapshot::list(backup_dest) |
| 291 | } |
| 292 | |
| 293 | /// Восстанавливает каталог с сохранениями из бэкапа. |
| 294 | pub fn restore_backup(snapshot: &Snapshot, save_dir: &Path) -> Result<()> { |
| 295 | crate::snapshot::restore_any(snapshot, save_dir) |
| 296 | .with_context(|| format!("не восстанавливается {}", save_dir.display())) |
| 297 | } |
| 298 | |
| 299 | #[cfg(test)] |
| 300 | mod tests { |
| 301 | use super::*; |
| 302 | use chl_core::library::Source; |
| 303 | |
| 304 | fn tmp(name: &str) -> PathBuf { |
| 305 | let d = std::env::temp_dir().join(format!("chl-test-save-backup-{name}")); |
| 306 | std::fs::remove_dir_all(&d).ok(); |
| 307 | std::fs::create_dir_all(&d).unwrap(); |
| 308 | d |
| 309 | } |
| 310 | |
| 311 | fn game(exe: &Path, prefix: &str, steam_appid: Option<u32>) -> Game { |
| 312 | Game { |
| 313 | exe: exe.to_path_buf(), |
| 314 | prefix: prefix.to_string(), |
| 315 | source: if steam_appid.is_some() { Source::Store } else { Source::Manual }, |
| 316 | steam_appid, |
| 317 | cover: None, |
| 318 | hero: None, |
| 319 | hidden: false, |
| 320 | kind: chl_core::library::GameKind::default(), |
| 321 | } |
| 322 | } |
| 323 | |
| 324 | #[test] |
| 325 | fn steam_library_root_находит_библиотеку_по_common() { |
| 326 | let exe = PathBuf::from("/home/игрок/.steam/steam/steamapps/common/Portal"); |
| 327 | assert_eq!( |
| 328 | steam_library_root(&exe), |
| 329 | Some(PathBuf::from("/home/игрок/.steam/steam")) |
| 330 | ); |
| 331 | } |
| 332 | |
| 333 | #[test] |
| 334 | fn steam_library_root_работает_и_для_вторичной_библиотеки() { |
| 335 | let exe = PathBuf::from("/mnt/ssd2/SteamLibrary/steamapps/common/Игра/game.exe"); |
| 336 | assert_eq!( |
| 337 | steam_library_root(&exe), |
| 338 | Some(PathBuf::from("/mnt/ssd2/SteamLibrary")) |
| 339 | ); |
| 340 | } |
| 341 | |
| 342 | #[test] |
| 343 | fn steam_library_root_none_для_не_steam_пути() { |
| 344 | assert_eq!(steam_library_root(Path::new("/home/игрок/Games/RF/game.exe")), None); |
| 345 | } |
| 346 | |
| 347 | #[test] |
| 348 | fn steam_user_id_единственный_аккаунт_находится() { |
| 349 | let root = tmp("userdata-one"); |
| 350 | std::fs::create_dir_all(root.join("userdata/12345")).unwrap(); |
| 351 | assert_eq!(steam_user_id(&root), Some("12345".to_string())); |
| 352 | std::fs::remove_dir_all(&root).ok(); |
| 353 | } |
| 354 | |
| 355 | #[test] |
| 356 | fn steam_user_id_несколько_аккаунтов_не_угадывается() { |
| 357 | let root = tmp("userdata-many"); |
| 358 | std::fs::create_dir_all(root.join("userdata/111")).unwrap(); |
| 359 | std::fs::create_dir_all(root.join("userdata/222")).unwrap(); |
| 360 | assert_eq!(steam_user_id(&root), None); |
| 361 | std::fs::remove_dir_all(&root).ok(); |
| 362 | } |
| 363 | |
| 364 | #[test] |
| 365 | fn roots_for_game_steam_без_compatdata_считается_нативной() { |
| 366 | let root = tmp("steam-native"); |
| 367 | let steamapps = root.join("steam/steamapps"); |
| 368 | std::fs::create_dir_all(steamapps.join("common/Portal")).unwrap(); |
| 369 | let exe = steamapps.join("common/Portal"); |
| 370 | let g = game(&exe, "pfx_default", Some(400)); |
| 371 | |
| 372 | let roots = roots_for_game(&g, None); |
| 373 | assert_eq!(roots.base, Some(exe)); |
| 374 | assert_eq!(roots.windows_user, None, "compatdata нет — не Proton"); |
| 375 | std::fs::remove_dir_all(&root).ok(); |
| 376 | } |
| 377 | |
| 378 | #[test] |
| 379 | fn roots_for_game_steam_с_compatdata_даёт_windows_профиль() { |
| 380 | let root = tmp("steam-proton"); |
| 381 | let steamapps = root.join("steam/steamapps"); |
| 382 | std::fs::create_dir_all(steamapps.join("common/Игра")).unwrap(); |
| 383 | std::fs::create_dir_all(steamapps.join("compatdata/12345/pfx/drive_c/users/steamuser")) |
| 384 | .unwrap(); |
| 385 | let exe = steamapps.join("common/Игра"); |
| 386 | let g = game(&exe, "pfx_default", Some(12345)); |
| 387 | |
| 388 | let roots = roots_for_game(&g, None); |
| 389 | assert_eq!( |
| 390 | roots.windows_user, |
| 391 | Some(steamapps.join("compatdata/12345/pfx/drive_c/users/steamuser")) |
| 392 | ); |
| 393 | std::fs::remove_dir_all(&root).ok(); |
| 394 | } |
| 395 | |
| 396 | #[test] |
| 397 | fn roots_for_game_своя_игра_берёт_профиль_из_префикса_chl_wine() { |
| 398 | let root = tmp("own-prefix"); |
| 399 | let chimera = root.join("chimera"); |
| 400 | std::fs::create_dir_all(chimera.join("data/pfx/pfx_default/drive_c/users/steamuser")) |
| 401 | .unwrap(); |
| 402 | let exe = root.join("Games/RF/game.exe"); |
| 403 | let g = game(&exe, "pfx_default", None); |
| 404 | |
| 405 | let roots = roots_for_game(&g, Some(&chimera)); |
| 406 | assert_eq!( |
| 407 | roots.windows_user, |
| 408 | Some(chimera.join("data/pfx/pfx_default/drive_c/users/steamuser")) |
| 409 | ); |
| 410 | assert_eq!(roots.base, None, "у ручных игр нет каталога установки Steam"); |
| 411 | std::fs::remove_dir_all(&root).ok(); |
| 412 | } |
| 413 | |
| 414 | #[test] |
| 415 | fn backup_now_отказывает_на_несуществующем_каталоге() { |
| 416 | let root = tmp("no-save-dir"); |
| 417 | let err = backup_now(&root.join("нет"), &root.join("dest"), "Игра") |
| 418 | .unwrap_err() |
| 419 | .to_string(); |
| 420 | assert!(err.contains("бэкапить нечего"), "{err}"); |
| 421 | std::fs::remove_dir_all(&root).ok(); |
| 422 | } |
| 423 | |
| 424 | #[test] |
| 425 | fn backup_now_и_list_backups_работают_вместе() { |
| 426 | let root = tmp("roundtrip"); |
| 427 | let save = root.join("save"); |
| 428 | std::fs::create_dir_all(&save).unwrap(); |
| 429 | std::fs::write(save.join("слот.dat"), "прогресс").unwrap(); |
| 430 | |
| 431 | let dest = default_backup_dir( |
| 432 | &Dirs { config: root.join("config"), data: root.clone(), cache: root.join("cache"), state: root.join("state") }, |
| 433 | "Моя Игра", |
| 434 | ); |
| 435 | let created = backup_now(&save, &dest, "Моя Игра").unwrap(); |
| 436 | assert!(created.snapshot.path.join("слот.dat").is_file()); |
| 437 | |
| 438 | let listed = list_backups(&dest); |
| 439 | assert_eq!(listed.len(), 1); |
| 440 | std::fs::remove_dir_all(&root).ok(); |
| 441 | } |
| 442 | |
| 443 | #[test] |
| 444 | fn lookup_entry_предпочитает_steam_appid_имени() { |
| 445 | let manifest_yaml = r#" |
| 446 | "Игра А": |
| 447 | steam: |
| 448 | id: 1 |
| 449 | files: |
| 450 | "<base>/save": { tags: [save] } |
| 451 | "Игра Б": |
| 452 | files: |
| 453 | "<base>/иное": { tags: [save] } |
| 454 | "#; |
| 455 | let m = crate::save_manifest::parse(manifest_yaml).unwrap(); |
| 456 | // В библиотеке игра называется иначе, чем в манифесте, но appid тот же. |
| 457 | let g = game(Path::new("/base"), "pfx_default", Some(1)); |
| 458 | let found = lookup_entry(&m, "Совсем другое имя", &g).unwrap(); |
| 459 | assert!(found.files.iter().any(|f| f.template.ends_with("/save"))); |
| 460 | } |
| 461 | |
| 462 | #[test] |
| 463 | fn default_backup_dir_превращает_имя_игры_в_безопасный_путь() { |
| 464 | let dirs = Dirs { |
| 465 | config: PathBuf::from("/c"), |
| 466 | data: PathBuf::from("/d"), |
| 467 | cache: PathBuf::from("/ch"), |
| 468 | state: PathBuf::from("/s"), |
| 469 | }; |
| 470 | let p = default_backup_dir(&dirs, "A Plague Tale: Innocence"); |
| 471 | assert_eq!(p, PathBuf::from("/d/save_backups/A_Plague_Tale__Innocence")); |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | #[cfg(test)] |
| 476 | mod auto_tests { |
| 477 | use super::*; |
| 478 | |
| 479 | #[test] |
| 480 | fn после_каждого_выхода_или_раз_в_n_дней() { |
| 481 | let day = 86_400; |
| 482 | assert!(auto_backup_due(Some(100), 101, 0)); |
| 483 | assert!(auto_backup_due(None, 5, 3)); |
| 484 | assert!(!auto_backup_due(Some(10 * day), 12 * day, 3)); |
| 485 | assert!(auto_backup_due(Some(10 * day), 13 * day, 3)); |
| 486 | } |
| 487 | |
| 488 | #[test] |
| 489 | fn автобэкап_и_снимок_перед_пакетами_считаются_автоматическими() { |
| 490 | assert!(chl_core::state::is_automatic_label(AUTO_LABEL)); |
| 491 | assert!(chl_core::state::is_automatic_label("до установки пакетов")); |
| 492 | assert!(!chl_core::state::is_automatic_label("бэкап")); |
| 493 | } |
| 494 | } |
| 495 | |
| 496 |